/* LIBGIMP - The GIMP Library * Copyright (C) 1995-2003 Peter Mattis and Spencer Kimball * * gimpimage_pdb.c * * This library is free software: you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 3 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library. If not, see * . */ /* NOTE: This file is auto-generated by pdbgen.pl */ #include "config.h" #include "gimp.h" /** * SECTION: gimpimage * @title: gimpimage * @short_description: Operations on complete images. * * Operations on complete images: creation, resizing/rescaling, and * operations involving multiple layers. **/ /** * gimp_image_id_is_valid: * @image_id: The image ID to check. * * Returns TRUE if the image ID is valid. * * This procedure checks if the given image ID is valid and refers to * an existing image. * * Returns: Whether the image ID is valid. * * Since: 3.0 **/ gboolean gimp_image_id_is_valid (gint image_id) { GimpValueArray *args; GimpValueArray *return_vals; gboolean valid = FALSE; args = gimp_value_array_new_from_types (NULL, G_TYPE_INT, image_id, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-id-is-valid", args); gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) valid = GIMP_VALUES_GET_BOOLEAN (return_vals, 1); gimp_value_array_unref (return_vals); return valid; } /** * gimp_get_images: * @num_images: (out): The number of images currently open. * * Returns the list of images currently open. * * This procedure returns the list of images currently open in GIMP. * * Returns: (array length=num_images) (element-type GimpImage) (transfer container): * The list of images currently open. * The returned value must be freed with g_free(). **/ GimpImage ** gimp_get_images (gint *num_images) { GimpValueArray *args; GimpValueArray *return_vals; GimpImage **images = NULL; args = gimp_value_array_new_from_types (NULL, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-get-images", args); gimp_value_array_unref (args); *num_images = 0; if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) { *num_images = GIMP_VALUES_GET_INT (return_vals, 1); { GimpObjectArray *a = g_value_get_boxed (gimp_value_array_index (return_vals, 2)); if (a) images = g_memdup (a->data, a->length * sizeof (gpointer)); }; } gimp_value_array_unref (return_vals); return images; } /** * gimp_image_new: * @width: The width of the image. * @height: The height of the image. * @type: The type of image. * * Creates a new image with the specified width, height, and type. * * Creates a new image, undisplayed, with the specified extents and * type. A layer should be created and added before this image is * displayed, or subsequent calls to gimp_display_new() with this image * as an argument will fail. Layers can be created using the * gimp_layer_new() commands. They can be added to an image using the * gimp_image_insert_layer() command. * * If your image's type if INDEXED, a colormap must also be added with * gimp_image_set_colormap(). An indexed image without a colormap will * output unexpected colors. * * Returns: (transfer none): The newly created image. **/ GimpImage * gimp_image_new (gint width, gint height, GimpImageBaseType type) { GimpValueArray *args; GimpValueArray *return_vals; GimpImage *image = NULL; args = gimp_value_array_new_from_types (NULL, G_TYPE_INT, width, G_TYPE_INT, height, GIMP_TYPE_IMAGE_BASE_TYPE, type, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-new", args); gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) image = GIMP_VALUES_GET_IMAGE (return_vals, 1); gimp_value_array_unref (return_vals); return image; } /** * gimp_image_new_with_precision: * @width: The width of the image. * @height: The height of the image. * @type: The type of image. * @precision: The precision. * * Creates a new image with the specified width, height, type and * precision. * * Creates a new image, undisplayed with the specified extents, type * and precision. Indexed images can only be created at * GIMP_PRECISION_U8_NON_LINEAR precision. See gimp_image_new() for * further details. * * Returns: (transfer none): The newly created image. * * Since: 2.10 **/ GimpImage * gimp_image_new_with_precision (gint width, gint height, GimpImageBaseType type, GimpPrecision precision) { GimpValueArray *args; GimpValueArray *return_vals; GimpImage *image = NULL; args = gimp_value_array_new_from_types (NULL, G_TYPE_INT, width, G_TYPE_INT, height, GIMP_TYPE_IMAGE_BASE_TYPE, type, GIMP_TYPE_PRECISION, precision, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-new-with-precision", args); gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) image = GIMP_VALUES_GET_IMAGE (return_vals, 1); gimp_value_array_unref (return_vals); return image; } /** * gimp_image_duplicate: * @image: The image. * * Duplicate the specified image * * This procedure duplicates the specified image, copying all layers, * channels, and image information. * * Returns: (transfer none): The new, duplicated image. **/ GimpImage * gimp_image_duplicate (GimpImage *image) { GimpValueArray *args; GimpValueArray *return_vals; GimpImage *new_image = NULL; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-duplicate", args); gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) new_image = GIMP_VALUES_GET_IMAGE (return_vals, 1); gimp_value_array_unref (return_vals); return new_image; } /** * gimp_image_delete: * @image: The image. * * Delete the specified image. * * If there are no displays associated with this image it will be * deleted. This means that you can not delete an image through the PDB * that was created by the user. If the associated display was however * created through the PDB and you know the display ID, you may delete * the display. Removal of the last associated display will then delete * the image. * * Returns: TRUE on success. **/ gboolean gimp_image_delete (GimpImage *image) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-delete", args); gimp_value_array_unref (args); success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS; gimp_value_array_unref (return_vals); return success; } /** * gimp_image_base_type: * @image: The image. * * Get the base type of the image. * * This procedure returns the image's base type. Layers in the image * must be of this subtype, but can have an optional alpha channel. * * Returns: The image's base type. **/ GimpImageBaseType gimp_image_base_type (GimpImage *image) { GimpValueArray *args; GimpValueArray *return_vals; GimpImageBaseType base_type = 0; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-base-type", args); gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) base_type = GIMP_VALUES_GET_ENUM (return_vals, 1); gimp_value_array_unref (return_vals); return base_type; } /** * gimp_image_get_precision: * @image: The image. * * Get the precision of the image. * * This procedure returns the image's precision. * * Returns: The image's precision. * * Since: 2.10 **/ GimpPrecision gimp_image_get_precision (GimpImage *image) { GimpValueArray *args; GimpValueArray *return_vals; GimpPrecision precision = 0; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-get-precision", args); gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) precision = GIMP_VALUES_GET_ENUM (return_vals, 1); gimp_value_array_unref (return_vals); return precision; } /** * gimp_image_get_default_new_layer_mode: * @image: The image. * * Get the default mode for newly created layers of this image. * * Returns the default mode for newly created layers of this image. * * Returns: The layer mode. * * Since: 2.10 **/ GimpLayerMode gimp_image_get_default_new_layer_mode (GimpImage *image) { GimpValueArray *args; GimpValueArray *return_vals; GimpLayerMode mode = 0; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-get-default-new-layer-mode", args); gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) mode = GIMP_VALUES_GET_ENUM (return_vals, 1); gimp_value_array_unref (return_vals); return mode; } /** * gimp_image_width: * @image: The image. * * Return the width of the image * * This procedure returns the image's width. This value is independent * of any of the layers in this image. This is the \"canvas\" width. * * Returns: The image's width. **/ gint gimp_image_width (GimpImage *image) { GimpValueArray *args; GimpValueArray *return_vals; gint width = 0; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-width", args); gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) width = GIMP_VALUES_GET_INT (return_vals, 1); gimp_value_array_unref (return_vals); return width; } /** * gimp_image_height: * @image: The image. * * Return the height of the image * * This procedure returns the image's height. This value is independent * of any of the layers in this image. This is the \"canvas\" height. * * Returns: The image's height. **/ gint gimp_image_height (GimpImage *image) { GimpValueArray *args; GimpValueArray *return_vals; gint height = 0; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-height", args); gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) height = GIMP_VALUES_GET_INT (return_vals, 1); gimp_value_array_unref (return_vals); return height; } /** * gimp_image_get_layers: * @image: The image. * @num_layers: (out): The number of layers contained in the image. * * Returns the list of layers contained in the specified image. * * This procedure returns the list of layers contained in the specified * image. The order of layers is from topmost to bottommost. * * Returns: (array length=num_layers) (element-type GimpLayer) (transfer container): * The list of layers contained in the image. * The returned value must be freed with g_free(). **/ GimpLayer ** gimp_image_get_layers (GimpImage *image, gint *num_layers) { GimpValueArray *args; GimpValueArray *return_vals; GimpLayer **layers = NULL; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-get-layers", args); gimp_value_array_unref (args); *num_layers = 0; if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) { *num_layers = GIMP_VALUES_GET_INT (return_vals, 1); { GimpObjectArray *a = g_value_get_boxed (gimp_value_array_index (return_vals, 2)); if (a) layers = g_memdup (a->data, a->length * sizeof (gpointer)); }; } gimp_value_array_unref (return_vals); return layers; } /** * gimp_image_get_channels: * @image: The image. * @num_channels: (out): The number of channels contained in the image. * * Returns the list of channels contained in the specified image. * * This procedure returns the list of channels contained in the * specified image. This does not include the selection mask, or layer * masks. The order is from topmost to bottommost. Note that * \"channels\" are custom channels and do not include the image's * color components. * * Returns: (array length=num_channels) (element-type GimpChannel) (transfer container): * The list of channels contained in the image. * The returned value must be freed with g_free(). **/ GimpChannel ** gimp_image_get_channels (GimpImage *image, gint *num_channels) { GimpValueArray *args; GimpValueArray *return_vals; GimpChannel **channels = NULL; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-get-channels", args); gimp_value_array_unref (args); *num_channels = 0; if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) { *num_channels = GIMP_VALUES_GET_INT (return_vals, 1); { GimpObjectArray *a = g_value_get_boxed (gimp_value_array_index (return_vals, 2)); if (a) channels = g_memdup (a->data, a->length * sizeof (gpointer)); }; } gimp_value_array_unref (return_vals); return channels; } /** * gimp_image_get_vectors: * @image: The image. * @num_vectors: (out): The number of vectors contained in the image. * * Returns the list of vectors contained in the specified image. * * This procedure returns the list of vectors contained in the * specified image. * * Returns: (array length=num_vectors) (element-type GimpVectors) (transfer container): * The list of vectors contained in the image. * The returned value must be freed with g_free(). * * Since: 2.4 **/ GimpVectors ** gimp_image_get_vectors (GimpImage *image, gint *num_vectors) { GimpValueArray *args; GimpValueArray *return_vals; GimpVectors **vectors = NULL; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-get-vectors", args); gimp_value_array_unref (args); *num_vectors = 0; if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) { *num_vectors = GIMP_VALUES_GET_INT (return_vals, 1); { GimpObjectArray *a = g_value_get_boxed (gimp_value_array_index (return_vals, 2)); if (a) vectors = g_memdup (a->data, a->length * sizeof (gpointer)); }; } gimp_value_array_unref (return_vals); return vectors; } /** * gimp_image_get_active_drawable: * @image: The image. * * Get the image's active drawable * * This procedure returns the ID of the image's active drawable. This * can be either a layer, a channel, or a layer mask. The active * drawable is specified by the active image channel. If that is -1, * then by the active image layer. If the active image layer has a * layer mask and the layer mask is in edit mode, then the layer mask * is the active drawable. * * Returns: (transfer none): The active drawable. **/ GimpDrawable * gimp_image_get_active_drawable (GimpImage *image) { GimpValueArray *args; GimpValueArray *return_vals; GimpDrawable *drawable = NULL; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-get-active-drawable", args); gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) drawable = GIMP_VALUES_GET_DRAWABLE (return_vals, 1); gimp_value_array_unref (return_vals); return drawable; } /** * gimp_image_unset_active_channel: * @image: The image. * * Unsets the active channel in the specified image. * * If an active channel exists, it is unset. There then exists no * active channel, and if desired, one can be set through a call to * 'Set Active Channel'. No error is returned in the case of no * existing active channel. * * Returns: TRUE on success. **/ gboolean gimp_image_unset_active_channel (GimpImage *image) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-unset-active-channel", args); gimp_value_array_unref (args); success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS; gimp_value_array_unref (return_vals); return success; } /** * gimp_image_get_floating_sel: * @image: The image. * * Return the floating selection of the image. * * This procedure returns the image's floating selection, if it exists. * If it doesn't exist, -1 is returned as the layer ID. * * Returns: (transfer none): The image's floating selection. **/ GimpLayer * gimp_image_get_floating_sel (GimpImage *image) { GimpValueArray *args; GimpValueArray *return_vals; GimpLayer *floating_sel = NULL; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-get-floating-sel", args); gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) floating_sel = GIMP_VALUES_GET_LAYER (return_vals, 1); gimp_value_array_unref (return_vals); return floating_sel; } /** * gimp_image_floating_sel_attached_to: * @image: The image. * * Return the drawable the floating selection is attached to. * * This procedure returns the drawable the image's floating selection * is attached to, if it exists. If it doesn't exist, -1 is returned as * the drawable ID. * * Returns: (transfer none): * The drawable the floating selection is attached to. **/ GimpDrawable * gimp_image_floating_sel_attached_to (GimpImage *image) { GimpValueArray *args; GimpValueArray *return_vals; GimpDrawable *drawable = NULL; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-floating-sel-attached-to", args); gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) drawable = GIMP_VALUES_GET_DRAWABLE (return_vals, 1); gimp_value_array_unref (return_vals); return drawable; } /** * gimp_image_pick_color: * @image: The image. * @drawable: (nullable): The drawable to pick from. * @x: x coordinate of upper-left corner of rectangle. * @y: y coordinate of upper-left corner of rectangle. * @sample_merged: Use the composite image, not the drawable. * @sample_average: Average the color of all the pixels in a specified radius. * @average_radius: The radius of pixels to average. * @color: (out caller-allocates): The return color. * * Determine the color at the given drawable coordinates * * This tool determines the color at the specified coordinates. The * returned color is an RGB triplet even for grayscale and indexed * drawables. If the coordinates lie outside of the extents of the * specified drawable, then an error is returned. If the drawable has * an alpha channel, the algorithm examines the alpha value of the * drawable at the coordinates. If the alpha value is completely * transparent (0), then an error is returned. If the sample_merged * parameter is TRUE, the data of the composite image will be used * instead of that for the specified drawable. This is equivalent to * sampling for colors after merging all visible layers. In the case of * a merged sampling, the supplied drawable is ignored. * * Returns: TRUE on success. **/ gboolean gimp_image_pick_color (GimpImage *image, GimpDrawable *drawable, gdouble x, gdouble y, gboolean sample_merged, gboolean sample_average, gdouble average_radius, GimpRGB *color) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, GIMP_TYPE_DRAWABLE, drawable, G_TYPE_DOUBLE, x, G_TYPE_DOUBLE, y, G_TYPE_BOOLEAN, sample_merged, G_TYPE_BOOLEAN, sample_average, G_TYPE_DOUBLE, average_radius, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-pick-color", args); gimp_value_array_unref (args); success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS; if (success) GIMP_VALUES_GET_RGB (return_vals, 1, &*color); gimp_value_array_unref (return_vals); return success; } /** * gimp_image_pick_correlate_layer: * @image: The image. * @x: The x coordinate for the pick. * @y: The y coordinate for the pick. * * Find the layer visible at the specified coordinates. * * This procedure finds the layer which is visible at the specified * coordinates. Layers which do not qualify are those whose extents do * not pass within the specified coordinates, or which are transparent * at the specified coordinates. This procedure will return -1 if no * layer is found. * * Returns: (transfer none): The layer found at the specified coordinates. **/ GimpLayer * gimp_image_pick_correlate_layer (GimpImage *image, gint x, gint y) { GimpValueArray *args; GimpValueArray *return_vals; GimpLayer *layer = NULL; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_INT, x, G_TYPE_INT, y, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-pick-correlate-layer", args); gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) layer = GIMP_VALUES_GET_LAYER (return_vals, 1); gimp_value_array_unref (return_vals); return layer; } /** * gimp_image_insert_layer: * @image: The image. * @layer: The layer. * @parent: (nullable): The parent layer. * @position: The layer position. * * Add the specified layer to the image. * * This procedure adds the specified layer to the image at the given * position. If the specified parent is a valid layer group (See * gimp_item_is_group() and gimp_layer_group_new()) then the layer is * added inside the group. If the parent is 0, the layer is added * inside the main stack, outside of any group. The position argument * specifies the location of the layer inside the stack (or the group, * if a valid parent was supplied), starting from the top (0) and * increasing. If the position is specified as -1 and the parent is * specified as 0, then the layer is inserted above the active layer, * or inside the group if the active layer is a layer group. The layer * type must be compatible with the image base type. * * Returns: TRUE on success. **/ gboolean gimp_image_insert_layer (GimpImage *image, GimpLayer *layer, GimpLayer *parent, gint position) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, GIMP_TYPE_LAYER, layer, GIMP_TYPE_LAYER, parent, G_TYPE_INT, position, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-insert-layer", args); gimp_value_array_unref (args); success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS; gimp_value_array_unref (return_vals); return success; } /** * gimp_image_remove_layer: * @image: The image. * @layer: The layer. * * Remove the specified layer from the image. * * This procedure removes the specified layer from the image. If the * layer doesn't exist, an error is returned. If there are no layers * left in the image, this call will fail. If this layer is the last * layer remaining, the image will become empty and have no active * layer. * * Returns: TRUE on success. **/ gboolean gimp_image_remove_layer (GimpImage *image, GimpLayer *layer) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, GIMP_TYPE_LAYER, layer, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-remove-layer", args); gimp_value_array_unref (args); success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS; gimp_value_array_unref (return_vals); return success; } /** * gimp_image_freeze_layers: * @image: The image. * * Freeze the image's layer list. * * This procedure freezes the layer list of the image, suppressing any * updates to the Layers dialog in response to changes to the image's * layers. This can significantly improve performance while applying * changes affecting the layer list. * * Each call to gimp_image_freeze_layers() should be matched by a * corresponding call to gimp_image_thaw_layers(), undoing its effects. * * Returns: TRUE on success. * * Since: 2.10.2 **/ gboolean gimp_image_freeze_layers (GimpImage *image) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-freeze-layers", args); gimp_value_array_unref (args); success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS; gimp_value_array_unref (return_vals); return success; } /** * gimp_image_thaw_layers: * @image: The image. * * Thaw the image's layer list. * * This procedure thaws the layer list of the image, re-enabling * updates to the Layers dialog. * * This procedure should match a corresponding call to * gimp_image_freeze_layers(). * * Returns: TRUE on success. * * Since: 2.10.2 **/ gboolean gimp_image_thaw_layers (GimpImage *image) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-thaw-layers", args); gimp_value_array_unref (args); success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS; gimp_value_array_unref (return_vals); return success; } /** * gimp_image_insert_channel: * @image: The image. * @channel: The channel. * @parent: (nullable): The parent channel. * @position: The channel position. * * Add the specified channel to the image. * * This procedure adds the specified channel to the image at the given * position. Since channel groups are not currently supported, the * parent argument must always be 0. The position argument specifies * the location of the channel inside the stack, starting from the top * (0) and increasing. If the position is specified as -1, then the * channel is inserted above the active channel. * * Returns: TRUE on success. **/ gboolean gimp_image_insert_channel (GimpImage *image, GimpChannel *channel, GimpChannel *parent, gint position) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, GIMP_TYPE_CHANNEL, channel, GIMP_TYPE_CHANNEL, parent, G_TYPE_INT, position, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-insert-channel", args); gimp_value_array_unref (args); success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS; gimp_value_array_unref (return_vals); return success; } /** * gimp_image_remove_channel: * @image: The image. * @channel: The channel. * * Remove the specified channel from the image. * * This procedure removes the specified channel from the image. If the * channel doesn't exist, an error is returned. * * Returns: TRUE on success. **/ gboolean gimp_image_remove_channel (GimpImage *image, GimpChannel *channel) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, GIMP_TYPE_CHANNEL, channel, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-remove-channel", args); gimp_value_array_unref (args); success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS; gimp_value_array_unref (return_vals); return success; } /** * gimp_image_freeze_channels: * @image: The image. * * Freeze the image's channel list. * * This procedure freezes the channel list of the image, suppressing * any updates to the Channels dialog in response to changes to the * image's channels. This can significantly improve performance while * applying changes affecting the channel list. * * Each call to gimp_image_freeze_channels() should be matched by a * corresponding call to gimp_image_thaw_channels(), undoing its * effects. * * Returns: TRUE on success. * * Since: 2.10.2 **/ gboolean gimp_image_freeze_channels (GimpImage *image) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-freeze-channels", args); gimp_value_array_unref (args); success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS; gimp_value_array_unref (return_vals); return success; } /** * gimp_image_thaw_channels: * @image: The image. * * Thaw the image's channel list. * * This procedure thaws the channel list of the image, re-enabling * updates to the Channels dialog. * * This procedure should match a corresponding call to * gimp_image_freeze_channels(). * * Returns: TRUE on success. * * Since: 2.10.2 **/ gboolean gimp_image_thaw_channels (GimpImage *image) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-thaw-channels", args); gimp_value_array_unref (args); success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS; gimp_value_array_unref (return_vals); return success; } /** * gimp_image_insert_vectors: * @image: The image. * @vectors: The vectors. * @parent: (nullable): The parent vectors. * @position: The vectors position. * * Add the specified vectors to the image. * * This procedure adds the specified vectors to the image at the given * position. Since vectors groups are not currently supported, the * parent argument must always be 0. The position argument specifies * the location of the vectors inside the stack, starting from the top * (0) and increasing. If the position is specified as -1, then the * vectors is inserted above the active vectors. * * Returns: TRUE on success. **/ gboolean gimp_image_insert_vectors (GimpImage *image, GimpVectors *vectors, GimpVectors *parent, gint position) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, GIMP_TYPE_VECTORS, vectors, GIMP_TYPE_VECTORS, parent, G_TYPE_INT, position, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-insert-vectors", args); gimp_value_array_unref (args); success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS; gimp_value_array_unref (return_vals); return success; } /** * gimp_image_remove_vectors: * @image: The image. * @vectors: The vectors object. * * Remove the specified path from the image. * * This procedure removes the specified path from the image. If the * path doesn't exist, an error is returned. * * Returns: TRUE on success. * * Since: 2.4 **/ gboolean gimp_image_remove_vectors (GimpImage *image, GimpVectors *vectors) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, GIMP_TYPE_VECTORS, vectors, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-remove-vectors", args); gimp_value_array_unref (args); success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS; gimp_value_array_unref (return_vals); return success; } /** * gimp_image_freeze_vectors: * @image: The image. * * Freeze the image's vectors list. * * This procedure freezes the vectors list of the image, suppressing * any updates to the Paths dialog in response to changes to the * image's vectors. This can significantly improve performance while * applying changes affecting the vectors list. * * Each call to gimp_image_freeze_vectors() should be matched by a * corresponding call to gimp_image_thaw_vectors(), undoing its * effects. * * Returns: TRUE on success. * * Since: 2.10.2 **/ gboolean gimp_image_freeze_vectors (GimpImage *image) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-freeze-vectors", args); gimp_value_array_unref (args); success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS; gimp_value_array_unref (return_vals); return success; } /** * gimp_image_thaw_vectors: * @image: The image. * * Thaw the image's vectors list. * * This procedure thaws the vectors list of the image, re-enabling * updates to the Paths dialog. * * This procedure should match a corresponding call to * gimp_image_freeze_vectors(). * * Returns: TRUE on success. * * Since: 2.10.2 **/ gboolean gimp_image_thaw_vectors (GimpImage *image) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-thaw-vectors", args); gimp_value_array_unref (args); success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS; gimp_value_array_unref (return_vals); return success; } /** * gimp_image_get_item_position: * @image: The image. * @item: The item. * * Returns the position of the item in its level of its item tree. * * This procedure determines the position of the specified item in its * level in its item tree in the image. If the item doesn't exist in * the image, or the item is not part of an item tree, an error is * returned. * * Returns: The position of the item in its level in the item tree. * * Since: 2.8 **/ gint gimp_image_get_item_position (GimpImage *image, GimpItem *item) { GimpValueArray *args; GimpValueArray *return_vals; gint position = 0; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, GIMP_TYPE_ITEM, item, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-get-item-position", args); gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) position = GIMP_VALUES_GET_INT (return_vals, 1); gimp_value_array_unref (return_vals); return position; } /** * gimp_image_raise_item: * @image: The image. * @item: The item to raise. * * Raise the specified item in its level in its item tree * * This procedure raises the specified item one step in the item tree. * The procedure call will fail if there is no item above it. * * Returns: TRUE on success. * * Since: 2.8 **/ gboolean gimp_image_raise_item (GimpImage *image, GimpItem *item) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, GIMP_TYPE_ITEM, item, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-raise-item", args); gimp_value_array_unref (args); success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS; gimp_value_array_unref (return_vals); return success; } /** * gimp_image_lower_item: * @image: The image. * @item: The item to lower. * * Lower the specified item in its level in its item tree * * This procedure lowers the specified item one step in the item tree. * The procedure call will fail if there is no item below it. * * Returns: TRUE on success. * * Since: 2.8 **/ gboolean gimp_image_lower_item (GimpImage *image, GimpItem *item) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, GIMP_TYPE_ITEM, item, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-lower-item", args); gimp_value_array_unref (args); success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS; gimp_value_array_unref (return_vals); return success; } /** * gimp_image_raise_item_to_top: * @image: The image. * @item: The item to raise to top. * * Raise the specified item to the top of its level in its item tree * * This procedure raises the specified item to top of its level in the * item tree. It will not move the item if there is no item above it. * * Returns: TRUE on success. * * Since: 2.8 **/ gboolean gimp_image_raise_item_to_top (GimpImage *image, GimpItem *item) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, GIMP_TYPE_ITEM, item, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-raise-item-to-top", args); gimp_value_array_unref (args); success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS; gimp_value_array_unref (return_vals); return success; } /** * gimp_image_lower_item_to_bottom: * @image: The image. * @item: The item to lower to bottom. * * Lower the specified item to the bottom of its level in its item tree * * This procedure lowers the specified item to bottom of its level in * the item tree. It will not move the layer if there is no layer below * it. * * Returns: TRUE on success. * * Since: 2.8 **/ gboolean gimp_image_lower_item_to_bottom (GimpImage *image, GimpItem *item) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, GIMP_TYPE_ITEM, item, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-lower-item-to-bottom", args); gimp_value_array_unref (args); success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS; gimp_value_array_unref (return_vals); return success; } /** * gimp_image_reorder_item: * @image: The image. * @item: The item to reorder. * @parent: (nullable): The new parent item. * @position: The new position of the item. * * Reorder the specified item within its item tree * * This procedure reorders the specified item within its item tree. * * Returns: TRUE on success. * * Since: 2.8 **/ gboolean gimp_image_reorder_item (GimpImage *image, GimpItem *item, GimpItem *parent, gint position) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, GIMP_TYPE_ITEM, item, GIMP_TYPE_ITEM, parent, G_TYPE_INT, position, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-reorder-item", args); gimp_value_array_unref (args); success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS; gimp_value_array_unref (return_vals); return success; } /** * gimp_image_flatten: * @image: The image. * * Flatten all visible layers into a single layer. Discard all * invisible layers. * * This procedure combines the visible layers in a manner analogous to * merging with the CLIP_TO_IMAGE merge type. Non-visible layers are * discarded, and the resulting image is stripped of its alpha channel. * * Returns: (transfer none): The resulting layer. **/ GimpLayer * gimp_image_flatten (GimpImage *image) { GimpValueArray *args; GimpValueArray *return_vals; GimpLayer *layer = NULL; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-flatten", args); gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) layer = GIMP_VALUES_GET_LAYER (return_vals, 1); gimp_value_array_unref (return_vals); return layer; } /** * gimp_image_merge_visible_layers: * @image: The image. * @merge_type: The type of merge. * * Merge the visible image layers into one. * * This procedure combines the visible layers into a single layer using * the specified merge type. A merge type of EXPAND_AS_NECESSARY * expands the final layer to encompass the areas of the visible * layers. A merge type of CLIP_TO_IMAGE clips the final layer to the * extents of the image. A merge type of CLIP_TO_BOTTOM_LAYER clips the * final layer to the size of the bottommost layer. * * Returns: (transfer none): The resulting layer. **/ GimpLayer * gimp_image_merge_visible_layers (GimpImage *image, GimpMergeType merge_type) { GimpValueArray *args; GimpValueArray *return_vals; GimpLayer *layer = NULL; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, GIMP_TYPE_MERGE_TYPE, merge_type, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-merge-visible-layers", args); gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) layer = GIMP_VALUES_GET_LAYER (return_vals, 1); gimp_value_array_unref (return_vals); return layer; } /** * gimp_image_merge_down: * @image: The image. * @merge_layer: The layer to merge down from. * @merge_type: The type of merge. * * Merge the layer passed and the first visible layer below. * * This procedure combines the passed layer and the first visible layer * below it using the specified merge type. A merge type of * EXPAND_AS_NECESSARY expands the final layer to encompass the areas * of the visible layers. A merge type of CLIP_TO_IMAGE clips the final * layer to the extents of the image. A merge type of * CLIP_TO_BOTTOM_LAYER clips the final layer to the size of the * bottommost layer. * * Returns: (transfer none): The resulting layer. **/ GimpLayer * gimp_image_merge_down (GimpImage *image, GimpLayer *merge_layer, GimpMergeType merge_type) { GimpValueArray *args; GimpValueArray *return_vals; GimpLayer *layer = NULL; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, GIMP_TYPE_LAYER, merge_layer, GIMP_TYPE_MERGE_TYPE, merge_type, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-merge-down", args); gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) layer = GIMP_VALUES_GET_LAYER (return_vals, 1); gimp_value_array_unref (return_vals); return layer; } /** * gimp_image_merge_layer_group: * @image: The image. * @layer_group: The layer group to merge. * * Merge the passed layer group's layers into one normal layer. * * This procedure combines the layers of the passed layer group into a * single normal layer, replacing the group. * * Returns: (transfer none): The resulting layer. * * Since: 2.10.14 **/ GimpLayer * gimp_image_merge_layer_group (GimpImage *image, GimpLayer *layer_group) { GimpValueArray *args; GimpValueArray *return_vals; GimpLayer *layer = NULL; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, GIMP_TYPE_LAYER, layer_group, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-merge-layer-group", args); gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) layer = GIMP_VALUES_GET_LAYER (return_vals, 1); gimp_value_array_unref (return_vals); return layer; } /** * _gimp_image_get_colormap: * @image: The image. * @num_bytes: (out): Number of bytes in the colormap array. * * Returns the image's colormap * * This procedure returns an actual pointer to the image's colormap, as * well as the number of bytes contained in the colormap. The actual * number of colors in the transmitted colormap will be 'num-bytes' / * 3. If the image is not in Indexed color mode, no colormap is * returned. * * Returns: (array length=num_bytes) (element-type guint8) (transfer full): * The image's colormap. * The returned value must be freed with g_free(). **/ guint8 * _gimp_image_get_colormap (GimpImage *image, gint *num_bytes) { GimpValueArray *args; GimpValueArray *return_vals; guint8 *colormap = NULL; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-get-colormap", args); gimp_value_array_unref (args); *num_bytes = 0; if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) { *num_bytes = GIMP_VALUES_GET_INT (return_vals, 1); colormap = GIMP_VALUES_DUP_UINT8_ARRAY (return_vals, 2); } gimp_value_array_unref (return_vals); return colormap; } /** * _gimp_image_set_colormap: * @image: The image. * @num_bytes: Number of bytes in the colormap array. * @colormap: (array length=num_bytes) (element-type guint8): The new colormap values. * * Sets the entries in the image's colormap. * * This procedure sets the entries in the specified image's colormap. * The number of entries is specified by the 'num-bytes' parameter and * corresponds to the number of INT8 triples that must be contained in * the 'colormap' array. The actual number of colors in the transmitted * colormap is 'num-bytes' / 3. * * Returns: TRUE on success. **/ gboolean _gimp_image_set_colormap (GimpImage *image, gint num_bytes, const guint8 *colormap) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_INT, num_bytes, GIMP_TYPE_UINT8_ARRAY, NULL, G_TYPE_NONE); gimp_value_set_uint8_array (gimp_value_array_index (args, 2), colormap, num_bytes); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-set-colormap", args); gimp_value_array_unref (args); success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS; gimp_value_array_unref (return_vals); return success; } /** * _gimp_image_get_metadata: * @image: The image. * * Returns the image's metadata. * * Returns exif/iptc/xmp metadata from the image. * * Returns: (transfer full): The exif/ptc/xmp metadata as a string. * The returned value must be freed with g_free(). **/ gchar * _gimp_image_get_metadata (GimpImage *image) { GimpValueArray *args; GimpValueArray *return_vals; gchar *metadata_string = NULL; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-get-metadata", args); gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) metadata_string = GIMP_VALUES_DUP_STRING (return_vals, 1); gimp_value_array_unref (return_vals); return metadata_string; } /** * _gimp_image_set_metadata: * @image: The image. * @metadata_string: The exif/ptc/xmp metadata as a string. * * Set the image's metadata. * * Sets exif/iptc/xmp metadata on the image. * * Returns: TRUE on success. **/ gboolean _gimp_image_set_metadata (GimpImage *image, const gchar *metadata_string) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_STRING, metadata_string, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-set-metadata", args); gimp_value_array_unref (args); success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS; gimp_value_array_unref (return_vals); return success; } /** * gimp_image_clean_all: * @image: The image. * * Set the image dirty count to 0. * * This procedure sets the specified image's dirty count to 0, allowing * operations to occur without having a 'dirtied' image. This is * especially useful for creating and loading images which should not * initially be considered dirty, even though layers must be created, * filled, and installed in the image. Note that save plug-ins must NOT * call this function themselves after saving the image. * * Returns: TRUE on success. **/ gboolean gimp_image_clean_all (GimpImage *image) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-clean-all", args); gimp_value_array_unref (args); success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS; gimp_value_array_unref (return_vals); return success; } /** * gimp_image_is_dirty: * @image: The image. * * Checks if the image has unsaved changes. * * This procedure checks the specified image's dirty count to see if it * needs to be saved. Note that saving the image does not automatically * set the dirty count to 0, you need to call gimp_image_clean_all() * after calling a save procedure to make the image clean. * * Returns: TRUE if the image has unsaved changes. **/ gboolean gimp_image_is_dirty (GimpImage *image) { GimpValueArray *args; GimpValueArray *return_vals; gboolean dirty = FALSE; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-is-dirty", args); gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) dirty = GIMP_VALUES_GET_BOOLEAN (return_vals, 1); gimp_value_array_unref (return_vals); return dirty; } /** * _gimp_image_thumbnail: * @image: The image. * @width: The requested thumbnail width. * @height: The requested thumbnail height. * @actual_width: (out): The previews width. * @actual_height: (out): The previews height. * @bpp: (out): The previews bpp. * @thumbnail_data_count: (out): The number of bytes in thumbnail data. * @thumbnail_data: (out) (array length=thumbnail_data_count) (element-type guint8) (transfer full): The thumbnail data. * * Get a thumbnail of an image. * * This function gets data from which a thumbnail of an image preview * can be created. Maximum x or y dimension is 1024 pixels. The pixels * are returned in RGB[A] or GRAY[A] format. The bpp return value gives * the number of bits per pixel in the image. * * Returns: TRUE on success. **/ gboolean _gimp_image_thumbnail (GimpImage *image, gint width, gint height, gint *actual_width, gint *actual_height, gint *bpp, gint *thumbnail_data_count, guint8 **thumbnail_data) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_INT, width, G_TYPE_INT, height, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-thumbnail", args); gimp_value_array_unref (args); *actual_width = 0; *actual_height = 0; *bpp = 0; *thumbnail_data_count = 0; *thumbnail_data = NULL; success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS; if (success) { *actual_width = GIMP_VALUES_GET_INT (return_vals, 1); *actual_height = GIMP_VALUES_GET_INT (return_vals, 2); *bpp = GIMP_VALUES_GET_INT (return_vals, 3); *thumbnail_data_count = GIMP_VALUES_GET_INT (return_vals, 4); *thumbnail_data = GIMP_VALUES_DUP_UINT8_ARRAY (return_vals, 5); } gimp_value_array_unref (return_vals); return success; } /** * gimp_image_get_active_layer: * @image: The image. * * Returns the specified image's active layer. * * If there is an active layer, its ID will be returned, otherwise, -1. * If a channel is currently active, then no layer will be. If a layer * mask is active, then this will return the associated layer. * * Returns: (transfer none): The active layer. **/ GimpLayer * gimp_image_get_active_layer (GimpImage *image) { GimpValueArray *args; GimpValueArray *return_vals; GimpLayer *active_layer = NULL; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-get-active-layer", args); gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) active_layer = GIMP_VALUES_GET_LAYER (return_vals, 1); gimp_value_array_unref (return_vals); return active_layer; } /** * gimp_image_set_active_layer: * @image: The image. * @active_layer: The new image active layer. * * Sets the specified image's active layer. * * If the layer exists, it is set as the active layer in the image. Any * previous active layer or channel is set to inactive. An exception is * a previously existing floating selection, in which case this * procedure will return an execution error. * * Returns: TRUE on success. **/ gboolean gimp_image_set_active_layer (GimpImage *image, GimpLayer *active_layer) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, GIMP_TYPE_LAYER, active_layer, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-set-active-layer", args); gimp_value_array_unref (args); success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS; gimp_value_array_unref (return_vals); return success; } /** * gimp_image_get_active_channel: * @image: The image. * * Returns the specified image's active channel. * * If there is an active channel, this will return the channel ID, * otherwise, -1. * * Returns: (transfer none): The active channel. **/ GimpChannel * gimp_image_get_active_channel (GimpImage *image) { GimpValueArray *args; GimpValueArray *return_vals; GimpChannel *active_channel = NULL; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-get-active-channel", args); gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) active_channel = GIMP_VALUES_GET_CHANNEL (return_vals, 1); gimp_value_array_unref (return_vals); return active_channel; } /** * gimp_image_set_active_channel: * @image: The image. * @active_channel: The new image active channel. * * Sets the specified image's active channel. * * If the channel exists, it is set as the active channel in the image. * Any previous active channel or layer is set to inactive. An * exception is a previously existing floating selection, in which case * this procedure will return an execution error. * * Returns: TRUE on success. **/ gboolean gimp_image_set_active_channel (GimpImage *image, GimpChannel *active_channel) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, GIMP_TYPE_CHANNEL, active_channel, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-set-active-channel", args); gimp_value_array_unref (args); success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS; gimp_value_array_unref (return_vals); return success; } /** * gimp_image_get_active_vectors: * @image: The image. * * Returns the specified image's active vectors. * * If there is an active path, its ID will be returned, otherwise, -1. * * Returns: (transfer none): The active vectors. **/ GimpVectors * gimp_image_get_active_vectors (GimpImage *image) { GimpValueArray *args; GimpValueArray *return_vals; GimpVectors *active_vectors = NULL; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-get-active-vectors", args); gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) active_vectors = GIMP_VALUES_GET_VECTORS (return_vals, 1); gimp_value_array_unref (return_vals); return active_vectors; } /** * gimp_image_set_active_vectors: * @image: The image. * @active_vectors: The new image active vectors. * * Sets the specified image's active vectors. * * If the path exists, it is set as the active path in the image. * * Returns: TRUE on success. **/ gboolean gimp_image_set_active_vectors (GimpImage *image, GimpVectors *active_vectors) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, GIMP_TYPE_VECTORS, active_vectors, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-set-active-vectors", args); gimp_value_array_unref (args); success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS; gimp_value_array_unref (return_vals); return success; } /** * gimp_image_get_selection: * @image: The image. * * Returns the specified image's selection. * * This will always return a valid ID for a selection -- which is * represented as a channel internally. * * Returns: (transfer none): The selection channel. **/ GimpSelection * gimp_image_get_selection (GimpImage *image) { GimpValueArray *args; GimpValueArray *return_vals; GimpSelection *selection = NULL; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-get-selection", args); gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) selection = GIMP_VALUES_GET_SELECTION (return_vals, 1); gimp_value_array_unref (return_vals); return selection; } /** * gimp_image_get_component_active: * @image: The image. * @component: The image component. * * Returns if the specified image's image component is active. * * This procedure returns if the specified image's image component * (i.e. Red, Green, Blue intensity channels in an RGB image) is active * or inactive -- whether or not it can be modified. If the specified * component is not valid for the image type, an error is returned. * * Returns: Component is active. **/ gboolean gimp_image_get_component_active (GimpImage *image, GimpChannelType component) { GimpValueArray *args; GimpValueArray *return_vals; gboolean active = FALSE; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, GIMP_TYPE_CHANNEL_TYPE, component, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-get-component-active", args); gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) active = GIMP_VALUES_GET_BOOLEAN (return_vals, 1); gimp_value_array_unref (return_vals); return active; } /** * gimp_image_set_component_active: * @image: The image. * @component: The image component. * @active: Component is active. * * Sets if the specified image's image component is active. * * This procedure sets if the specified image's image component (i.e. * Red, Green, Blue intensity channels in an RGB image) is active or * inactive -- whether or not it can be modified. If the specified * component is not valid for the image type, an error is returned. * * Returns: TRUE on success. **/ gboolean gimp_image_set_component_active (GimpImage *image, GimpChannelType component, gboolean active) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, GIMP_TYPE_CHANNEL_TYPE, component, G_TYPE_BOOLEAN, active, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-set-component-active", args); gimp_value_array_unref (args); success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS; gimp_value_array_unref (return_vals); return success; } /** * gimp_image_get_component_visible: * @image: The image. * @component: The image component. * * Returns if the specified image's image component is visible. * * This procedure returns if the specified image's image component * (i.e. Red, Green, Blue intensity channels in an RGB image) is * visible or invisible -- whether or not it can be seen. If the * specified component is not valid for the image type, an error is * returned. * * Returns: Component is visible. **/ gboolean gimp_image_get_component_visible (GimpImage *image, GimpChannelType component) { GimpValueArray *args; GimpValueArray *return_vals; gboolean visible = FALSE; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, GIMP_TYPE_CHANNEL_TYPE, component, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-get-component-visible", args); gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) visible = GIMP_VALUES_GET_BOOLEAN (return_vals, 1); gimp_value_array_unref (return_vals); return visible; } /** * gimp_image_set_component_visible: * @image: The image. * @component: The image component. * @visible: Component is visible. * * Sets if the specified image's image component is visible. * * This procedure sets if the specified image's image component (i.e. * Red, Green, Blue intensity channels in an RGB image) is visible or * invisible -- whether or not it can be seen. If the specified * component is not valid for the image type, an error is returned. * * Returns: TRUE on success. **/ gboolean gimp_image_set_component_visible (GimpImage *image, GimpChannelType component, gboolean visible) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, GIMP_TYPE_CHANNEL_TYPE, component, G_TYPE_BOOLEAN, visible, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-set-component-visible", args); gimp_value_array_unref (args); success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS; gimp_value_array_unref (return_vals); return success; } /** * gimp_image_get_file: * @image: The image. * * Returns the file for the specified image. * * This procedure returns the file associated with the specified image. * The image has a file only if it was loaded or imported from a file * or has since been saved or exported. Otherwise, this function * returns %NULL. See also gimp-image-get-imported-file to get the * current file if it was imported from a non-GIMP file format and not * yet saved, or gimp-image-get-exported-file if the image has been * exported to a non-GIMP file format. * * Returns: (transfer full): The file. * * Since: 2.8 **/ GFile * gimp_image_get_file (GimpImage *image) { GimpValueArray *args; GimpValueArray *return_vals; GFile *file = NULL; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-get-file", args); gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) file = GIMP_VALUES_DUP_FILE (return_vals, 1); gimp_value_array_unref (return_vals); return file; } /** * gimp_image_set_file: * @image: The image. * @file: The new image file. * * Sets the specified image's file. * * This procedure sets the specified image's file. * * Returns: TRUE on success. **/ gboolean gimp_image_set_file (GimpImage *image, GFile *file) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_FILE, file, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-set-file", args); gimp_value_array_unref (args); success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS; gimp_value_array_unref (return_vals); return success; } /** * gimp_image_get_xcf_file: * @image: The image. * * Returns the XCF file for the specified image. * * This procedure returns the XCF file associated with the image. If * there is no such file, this procedure returns %NULL. * * Returns: (transfer full): The imported XCF file. * * Since: 2.8 **/ GFile * gimp_image_get_xcf_file (GimpImage *image) { GimpValueArray *args; GimpValueArray *return_vals; GFile *file = NULL; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-get-xcf-file", args); gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) file = GIMP_VALUES_DUP_FILE (return_vals, 1); gimp_value_array_unref (return_vals); return file; } /** * gimp_image_get_imported_file: * @image: The image. * * Returns the imported file for the specified image. * * This procedure returns the file associated with the specified image * if the image was imported from a non-native Gimp format. If the * image was not imported, or has since been saved in the native Gimp * format, this procedure returns %NULL. * * Returns: (transfer full): The imported file. * * Since: 2.8 **/ GFile * gimp_image_get_imported_file (GimpImage *image) { GimpValueArray *args; GimpValueArray *return_vals; GFile *file = NULL; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-get-imported-file", args); gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) file = GIMP_VALUES_DUP_FILE (return_vals, 1); gimp_value_array_unref (return_vals); return file; } /** * gimp_image_get_exported_file: * @image: The image. * * Returns the exported file for the specified image. * * This procedure returns the file associated with the specified image * if the image was exported a non-native GIMP format. If the image was * not exported, this procedure returns %NULL. * * Returns: (transfer full): The exported file. * * Since: 2.8 **/ GFile * gimp_image_get_exported_file (GimpImage *image) { GimpValueArray *args; GimpValueArray *return_vals; GFile *file = NULL; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-get-exported-file", args); gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) file = GIMP_VALUES_DUP_FILE (return_vals, 1); gimp_value_array_unref (return_vals); return file; } /** * gimp_image_get_name: * @image: The image. * * Returns the specified image's name. * * This procedure returns the image's name. If the image has a filename * or an URI, then the returned name contains the filename's or URI's * base name (the last component of the path). Otherwise it is the * translated string \"Untitled\". The returned name is formatted like * the image name in the image window title, it may contain '[]', * '(imported)' etc. and should only be used to label user interface * elements. Never use it to construct filenames. * * Returns: (transfer full): The name. * The returned value must be freed with g_free(). **/ gchar * gimp_image_get_name (GimpImage *image) { GimpValueArray *args; GimpValueArray *return_vals; gchar *name = NULL; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-get-name", args); gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) name = GIMP_VALUES_DUP_STRING (return_vals, 1); gimp_value_array_unref (return_vals); return name; } /** * gimp_image_get_resolution: * @image: The image. * @xresolution: (out): The resolution in the x-axis, in dots per inch. * @yresolution: (out): The resolution in the y-axis, in dots per inch. * * Returns the specified image's resolution. * * This procedure returns the specified image's resolution in dots per * inch. This value is independent of any of the layers in this image. * * Returns: TRUE on success. **/ gboolean gimp_image_get_resolution (GimpImage *image, gdouble *xresolution, gdouble *yresolution) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-get-resolution", args); gimp_value_array_unref (args); *xresolution = 0.0; *yresolution = 0.0; success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS; if (success) { *xresolution = GIMP_VALUES_GET_DOUBLE (return_vals, 1); *yresolution = GIMP_VALUES_GET_DOUBLE (return_vals, 2); } gimp_value_array_unref (return_vals); return success; } /** * gimp_image_set_resolution: * @image: The image. * @xresolution: The new image resolution in the x-axis, in dots per inch. * @yresolution: The new image resolution in the y-axis, in dots per inch. * * Sets the specified image's resolution. * * This procedure sets the specified image's resolution in dots per * inch. This value is independent of any of the layers in this image. * No scaling or resizing is performed. * * Returns: TRUE on success. **/ gboolean gimp_image_set_resolution (GimpImage *image, gdouble xresolution, gdouble yresolution) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_DOUBLE, xresolution, G_TYPE_DOUBLE, yresolution, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-set-resolution", args); gimp_value_array_unref (args); success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS; gimp_value_array_unref (return_vals); return success; } /** * gimp_image_get_unit: * @image: The image. * * Returns the specified image's unit. * * This procedure returns the specified image's unit. This value is * independent of any of the layers in this image. See the * gimp_unit_*() procedure definitions for the valid range of unit IDs * and a description of the unit system. * * Returns: (transfer none): The unit. **/ GimpUnit gimp_image_get_unit (GimpImage *image) { GimpValueArray *args; GimpValueArray *return_vals; GimpUnit unit = GIMP_UNIT_PIXEL; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-get-unit", args); gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) unit = GIMP_VALUES_GET_INT (return_vals, 1); gimp_value_array_unref (return_vals); return unit; } /** * gimp_image_set_unit: * @image: The image. * @unit: The new image unit. * * Sets the specified image's unit. * * This procedure sets the specified image's unit. No scaling or * resizing is performed. This value is independent of any of the * layers in this image. See the gimp_unit_*() procedure definitions * for the valid range of unit IDs and a description of the unit * system. * * Returns: TRUE on success. **/ gboolean gimp_image_set_unit (GimpImage *image, GimpUnit unit) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, GIMP_TYPE_UNIT, unit, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-set-unit", args); gimp_value_array_unref (args); success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS; gimp_value_array_unref (return_vals); return success; } /** * gimp_image_get_tattoo_state: * @image: The image. * * Returns the tattoo state associated with the image. * * This procedure returns the tattoo state of the image. Use only by * save/load plug-ins that wish to preserve an images tattoo state. * Using this function at other times will produce unexpected results. * * Returns: The tattoo state. **/ guint gimp_image_get_tattoo_state (GimpImage *image) { GimpValueArray *args; GimpValueArray *return_vals; guint tattoo_state = 0; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-get-tattoo-state", args); gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) tattoo_state = GIMP_VALUES_GET_UINT (return_vals, 1); gimp_value_array_unref (return_vals); return tattoo_state; } /** * gimp_image_set_tattoo_state: * @image: The image. * @tattoo_state: The new image tattoo state. * * Set the tattoo state associated with the image. * * This procedure sets the tattoo state of the image. Use only by * save/load plug-ins that wish to preserve an images tattoo state. * Using this function at other times will produce unexpected results. * A full check of uniqueness of states in layers, channels and paths * will be performed by this procedure and a execution failure will be * returned if this fails. A failure will also be returned if the new * tattoo state value is less than the maximum tattoo value from all of * the tattoos from the paths, layers and channels. After the image * data has been loaded and all the tattoos have been set then this is * the last procedure that should be called. If effectively does a * status check on the tattoo values that have been set to make sure * that all is OK. * * Returns: TRUE on success. **/ gboolean gimp_image_set_tattoo_state (GimpImage *image, guint tattoo_state) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_UINT, tattoo_state, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-set-tattoo-state", args); gimp_value_array_unref (args); success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS; gimp_value_array_unref (return_vals); return success; } /** * gimp_image_get_layer_by_tattoo: * @image: The image. * @tattoo: The tattoo of the layer to find. * * Find a layer with a given tattoo in an image. * * This procedure returns the layer with the given tattoo in the * specified image. * * Returns: (transfer none): The layer with the specified tattoo. **/ GimpLayer * gimp_image_get_layer_by_tattoo (GimpImage *image, guint tattoo) { GimpValueArray *args; GimpValueArray *return_vals; GimpLayer *layer = NULL; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_UINT, tattoo, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-get-layer-by-tattoo", args); gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) layer = GIMP_VALUES_GET_LAYER (return_vals, 1); gimp_value_array_unref (return_vals); return layer; } /** * gimp_image_get_channel_by_tattoo: * @image: The image. * @tattoo: The tattoo of the channel to find. * * Find a channel with a given tattoo in an image. * * This procedure returns the channel with the given tattoo in the * specified image. * * Returns: (transfer none): The channel with the specified tattoo. **/ GimpChannel * gimp_image_get_channel_by_tattoo (GimpImage *image, guint tattoo) { GimpValueArray *args; GimpValueArray *return_vals; GimpChannel *channel = NULL; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_UINT, tattoo, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-get-channel-by-tattoo", args); gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) channel = GIMP_VALUES_GET_CHANNEL (return_vals, 1); gimp_value_array_unref (return_vals); return channel; } /** * gimp_image_get_vectors_by_tattoo: * @image: The image. * @tattoo: The tattoo of the vectors to find. * * Find a vectors with a given tattoo in an image. * * This procedure returns the vectors with the given tattoo in the * specified image. * * Returns: (transfer none): The vectors with the specified tattoo. * * Since: 2.6 **/ GimpVectors * gimp_image_get_vectors_by_tattoo (GimpImage *image, guint tattoo) { GimpValueArray *args; GimpValueArray *return_vals; GimpVectors *vectors = NULL; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_UINT, tattoo, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-get-vectors-by-tattoo", args); gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) vectors = GIMP_VALUES_GET_VECTORS (return_vals, 1); gimp_value_array_unref (return_vals); return vectors; } /** * gimp_image_get_layer_by_name: * @image: The image. * @name: The name of the layer to find. * * Find a layer with a given name in an image. * * This procedure returns the layer with the given name in the * specified image. * * Returns: (transfer none): The layer with the specified name. * * Since: 2.8 **/ GimpLayer * gimp_image_get_layer_by_name (GimpImage *image, const gchar *name) { GimpValueArray *args; GimpValueArray *return_vals; GimpLayer *layer = NULL; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_STRING, name, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-get-layer-by-name", args); gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) layer = GIMP_VALUES_GET_LAYER (return_vals, 1); gimp_value_array_unref (return_vals); return layer; } /** * gimp_image_get_channel_by_name: * @image: The image. * @name: The name of the channel to find. * * Find a channel with a given name in an image. * * This procedure returns the channel with the given name in the * specified image. * * Returns: (transfer none): The channel with the specified name. * * Since: 2.8 **/ GimpChannel * gimp_image_get_channel_by_name (GimpImage *image, const gchar *name) { GimpValueArray *args; GimpValueArray *return_vals; GimpChannel *channel = NULL; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_STRING, name, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-get-channel-by-name", args); gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) channel = GIMP_VALUES_GET_CHANNEL (return_vals, 1); gimp_value_array_unref (return_vals); return channel; } /** * gimp_image_get_vectors_by_name: * @image: The image. * @name: The name of the vectors to find. * * Find a vectors with a given name in an image. * * This procedure returns the vectors with the given name in the * specified image. * * Returns: (transfer none): The vectors with the specified name. * * Since: 2.8 **/ GimpVectors * gimp_image_get_vectors_by_name (GimpImage *image, const gchar *name) { GimpValueArray *args; GimpValueArray *return_vals; GimpVectors *vectors = NULL; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_STRING, name, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-get-vectors-by-name", args); gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) vectors = GIMP_VALUES_GET_VECTORS (return_vals, 1); gimp_value_array_unref (return_vals); return vectors; } /** * gimp_image_attach_parasite: * @image: The image. * @parasite: The parasite to attach to an image. * * Add a parasite to an image. * * This procedure attaches a parasite to an image. It has no return * values. * * Returns: TRUE on success. * * Since: 2.8 **/ gboolean gimp_image_attach_parasite (GimpImage *image, const GimpParasite *parasite) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, GIMP_TYPE_PARASITE, parasite, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-attach-parasite", args); gimp_value_array_unref (args); success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS; gimp_value_array_unref (return_vals); return success; } /** * gimp_image_detach_parasite: * @image: The image. * @name: The name of the parasite to detach from an image. * * Removes a parasite from an image. * * This procedure detaches a parasite from an image. It has no return * values. * * Returns: TRUE on success. * * Since: 2.8 **/ gboolean gimp_image_detach_parasite (GimpImage *image, const gchar *name) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_STRING, name, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-detach-parasite", args); gimp_value_array_unref (args); success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS; gimp_value_array_unref (return_vals); return success; } /** * gimp_image_get_parasite: * @image: The image. * @name: The name of the parasite to find. * * Look up a parasite in an image * * Finds and returns the parasite that was previously attached to an * image. * * Returns: (transfer full): The found parasite. * * Since: 2.8 **/ GimpParasite * gimp_image_get_parasite (GimpImage *image, const gchar *name) { GimpValueArray *args; GimpValueArray *return_vals; GimpParasite *parasite = NULL; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_STRING, name, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-get-parasite", args); gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) parasite = GIMP_VALUES_DUP_PARASITE (return_vals, 1); gimp_value_array_unref (return_vals); return parasite; } /** * gimp_image_get_parasite_list: * @image: The image. * @num_parasites: (out): The number of attached parasites. * * List all parasites. * * Returns a list of all currently attached parasites. * * Returns: (array length=num_parasites) (element-type gchar*) (transfer full): * The names of currently attached parasites. * The returned value must be freed with g_strfreev(). * * Since: 2.8 **/ gchar ** gimp_image_get_parasite_list (GimpImage *image, gint *num_parasites) { GimpValueArray *args; GimpValueArray *return_vals; gchar **parasites = NULL; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_NONE); return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-get-parasite-list", args); gimp_value_array_unref (args); *num_parasites = 0; if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) { *num_parasites = GIMP_VALUES_GET_INT (return_vals, 1); parasites = GIMP_VALUES_DUP_STRING_ARRAY (return_vals, 2); } gimp_value_array_unref (return_vals); return parasites; }