From 17a40b049f25517779dbb0c94a58bc0c4040a50b Mon Sep 17 00:00:00 2001 From: Jehan Date: Mon, 12 Aug 2019 14:44:07 +0200 Subject: [PATCH] libgimp: generate functions both for old and new GimpImage APIs. This way, it would still be possible to use the old API. WIP. --- libgimp/gimpchannel_pdb.c | 111 + libgimp/gimpchannel_pdb.h | 61 +- libgimp/gimpdisplay_pdb.c | 88 + libgimp/gimpdisplay_pdb.h | 19 +- libgimp/gimpedit_pdb.c | 182 +- libgimp/gimpedit_pdb.h | 41 +- libgimp/gimpfileops_pdb.c | 263 +- libgimp/gimpfileops_pdb.h | 22 + libgimp/gimpimage_pdb.c | 3707 ++++++++++++++++++++++++++- libgimp/gimpimage_pdb.h | 557 ++-- libgimp/gimpimagecolorprofile_pdb.c | 310 +++ libgimp/gimpimagecolorprofile_pdb.h | 60 +- libgimp/gimpimageconvert_pdb.c | 193 ++ libgimp/gimpimageconvert_pdb.h | 45 +- libgimp/gimpimagegrid_pdb.c | 463 ++++ libgimp/gimpimagegrid_pdb.h | 79 +- libgimp/gimpimageguides_pdb.c | 262 ++ libgimp/gimpimageguides_pdb.h | 42 +- libgimp/gimpimagesamplepoints_pdb.c | 193 ++ libgimp/gimpimagesamplepoints_pdb.h | 34 +- libgimp/gimpimageselect_pdb.c | 446 ++++ libgimp/gimpimageselect_pdb.h | 115 +- libgimp/gimpimagetransform_pdb.c | 284 ++ libgimp/gimpimagetransform_pdb.h | 60 +- libgimp/gimpimageundo_pdb.c | 304 +++ libgimp/gimpimageundo_pdb.h | 28 +- libgimp/gimpitem_pdb.c | 43 +- libgimp/gimpitem_pdb.h | 94 +- libgimp/gimplayer_pdb.c | 206 ++ libgimp/gimplayer_pdb.h | 17 + libgimp/gimpselection_pdb.c | 616 +++++ libgimp/gimpselection_pdb.h | 101 +- libgimp/gimptextlayer_pdb.c | 58 + libgimp/gimptextlayer_pdb.h | 108 +- libgimp/gimptexttool_pdb.c | 79 + libgimp/gimptexttool_pdb.h | 47 +- libgimp/gimpvectors_pdb.c | 317 +++ libgimp/gimpvectors_pdb.h | 238 +- pdb/lib.pl | 816 +++--- pdb/pdb.pl | 3 +- 40 files changed, 9732 insertions(+), 980 deletions(-) diff --git a/libgimp/gimpchannel_pdb.c b/libgimp/gimpchannel_pdb.c index 7780605e00..dad21df6ea 100644 --- a/libgimp/gimpchannel_pdb.c +++ b/libgimp/gimpchannel_pdb.c @@ -94,6 +94,66 @@ _gimp_channel_new (GimpImage *image, return channel_ID; } +/** + * __gimp_channel_new: (skip) + * @image_ID: The image to which to add the channel. + * @width: The channel width. + * @height: The channel height. + * @name: The channel name. + * @opacity: The channel opacity. + * @color: The channel compositing color. + * + * Create a new channel. + * + * This procedure creates a new channel with the specified width, + * height, name, opacity and color. + * The new channel still needs to be added to the image, as this is not + * automatic. Add the new channel with gimp_image_insert_channel(). + * Other attributes, such as channel visibility, should be set with + * explicit procedure calls. + * The channel's contents are undefined initially. + * + * Returns: The newly created channel. + **/ +gint32 +__gimp_channel_new (gint32 image_ID, + gint width, + gint height, + const gchar *name, + gdouble opacity, + const GimpRGB *color) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint32 channel_ID = -1; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_INT, width, + G_TYPE_INT, height, + G_TYPE_STRING, name, + G_TYPE_DOUBLE, opacity, + GIMP_TYPE_RGB, color, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-channel-new", + args); + else + return_vals = gimp_run_procedure_array ("gimp-channel-new", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + channel_ID = gimp_value_get_channel_id (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return channel_ID; +} + /** * gimp_channel_new_from_component: * @image: The image to which to add the channel. @@ -145,6 +205,57 @@ gimp_channel_new_from_component (GimpImage *image, return channel_ID; } +/** + * _gimp_channel_new_from_component: (skip) + * @image_ID: The image to which to add the channel. + * @component: The image component. + * @name: The channel name. + * + * Create a new channel from a color component + * + * This procedure creates a new channel from a color component. + * The new channel still needs to be added to the image, as this is not + * automatic. Add the new channel with gimp_image_insert_channel(). + * Other attributes, such as channel visibility, should be set with + * explicit procedure calls. + * + * Returns: The newly created channel. + * + * Since: 2.4 + **/ +gint32 +_gimp_channel_new_from_component (gint32 image_ID, + GimpChannelType component, + const gchar *name) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint32 channel_ID = -1; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + GIMP_TYPE_CHANNEL_TYPE, component, + G_TYPE_STRING, name, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-channel-new-from-component", + args); + else + return_vals = gimp_run_procedure_array ("gimp-channel-new-from-component", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + channel_ID = gimp_value_get_channel_id (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return channel_ID; +} + /** * gimp_channel_copy: * @channel_ID: The channel to copy. diff --git a/libgimp/gimpchannel_pdb.h b/libgimp/gimpchannel_pdb.h index 4e1cb8318a..1aa515de72 100644 --- a/libgimp/gimpchannel_pdb.h +++ b/libgimp/gimpchannel_pdb.h @@ -32,31 +32,42 @@ G_BEGIN_DECLS /* For information look into the C source or the html documentation */ -G_GNUC_INTERNAL gint32 _gimp_channel_new (GimpImage *image, - gint width, - gint height, - const gchar *name, - gdouble opacity, - const GimpRGB *color); -gint32 gimp_channel_new_from_component (GimpImage *image, - GimpChannelType component, - const gchar *name); -gint32 gimp_channel_copy (gint32 channel_ID); -gboolean gimp_channel_combine_masks (gint32 channel1_ID, - gint32 channel2_ID, - GimpChannelOps operation, - gint offx, - gint offy); -gboolean gimp_channel_get_show_masked (gint32 channel_ID); -gboolean gimp_channel_set_show_masked (gint32 channel_ID, - gboolean show_masked); -gdouble gimp_channel_get_opacity (gint32 channel_ID); -gboolean gimp_channel_set_opacity (gint32 channel_ID, - gdouble opacity); -gboolean gimp_channel_get_color (gint32 channel_ID, - GimpRGB *color); -gboolean gimp_channel_set_color (gint32 channel_ID, - const GimpRGB *color); +G_GNUC_INTERNAL gint32 _gimp_channel_new (GimpImage *image, + gint width, + gint height, + const gchar *name, + gdouble opacity, + const GimpRGB *color); +GIMP_DEPRECATED_FOR(_gimp_channel_new) +G_GNUC_INTERNAL gint32 __gimp_channel_new (gint32 image_ID, + gint width, + gint height, + const gchar *name, + gdouble opacity, + const GimpRGB *color); +gint32 gimp_channel_new_from_component (GimpImage *image, + GimpChannelType component, + const gchar *name); +GIMP_DEPRECATED_FOR(gimp_channel_new_from_component) +G_GNUC_INTERNAL gint32 _gimp_channel_new_from_component (gint32 image_ID, + GimpChannelType component, + const gchar *name); +gint32 gimp_channel_copy (gint32 channel_ID); +gboolean gimp_channel_combine_masks (gint32 channel1_ID, + gint32 channel2_ID, + GimpChannelOps operation, + gint offx, + gint offy); +gboolean gimp_channel_get_show_masked (gint32 channel_ID); +gboolean gimp_channel_set_show_masked (gint32 channel_ID, + gboolean show_masked); +gdouble gimp_channel_get_opacity (gint32 channel_ID); +gboolean gimp_channel_set_opacity (gint32 channel_ID, + gdouble opacity); +gboolean gimp_channel_get_color (gint32 channel_ID, + GimpRGB *color); +gboolean gimp_channel_set_color (gint32 channel_ID, + const GimpRGB *color); G_END_DECLS diff --git a/libgimp/gimpdisplay_pdb.c b/libgimp/gimpdisplay_pdb.c index f89655fead..1f88c8ad1c 100644 --- a/libgimp/gimpdisplay_pdb.c +++ b/libgimp/gimpdisplay_pdb.c @@ -120,6 +120,50 @@ gimp_display_new (GimpImage *image) return display_ID; } +/** + * _gimp_display_new: (skip) + * @image_ID: The image. + * + * Create a new display for the specified image. + * + * Creates a new display for the specified image. If the image already + * has a display, another is added. Multiple displays are handled + * transparently by GIMP. The newly created display is returned and can + * be subsequently destroyed with a call to gimp_display_delete(). This + * procedure only makes sense for use with the GIMP UI, and will result + * in an execution error if called when GIMP has no UI. + * + * Returns: The new display. + **/ +gint32 +_gimp_display_new (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint32 display_ID = -1; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-display-new", + args); + else + return_vals = gimp_run_procedure_array ("gimp-display-new", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + display_ID = gimp_value_get_display_id (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return display_ID; +} + /** * gimp_display_delete: * @display_ID: The display to delete. @@ -289,3 +333,47 @@ gimp_displays_reconnect (GimpImage *old_image, return success; } + +/** + * _gimp_displays_reconnect: (skip) + * @old_image_ID: The old image (must have at least one display). + * @new_image_ID: The new image (must not have a display). + * + * Reconnect displays from one image to another image. + * + * This procedure connects all displays of the old_image to the + * new_image. If the old_image has no display or new_image already has + * a display the reconnect is not performed and the procedure returns + * without success. You should rarely need to use this function. + * + * Returns: TRUE on success. + **/ +gboolean +_gimp_displays_reconnect (gint32 old_image_ID, + gint32 new_image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, old_image_ID, + GIMP_TYPE_IMAGE_ID, new_image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-displays-reconnect", + args); + else + return_vals = gimp_run_procedure_array ("gimp-displays-reconnect", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} diff --git a/libgimp/gimpdisplay_pdb.h b/libgimp/gimpdisplay_pdb.h index 94a1c00e1d..0feb8edd47 100644 --- a/libgimp/gimpdisplay_pdb.h +++ b/libgimp/gimpdisplay_pdb.h @@ -32,13 +32,18 @@ G_BEGIN_DECLS /* For information look into the C source or the html documentation */ -gboolean gimp_display_is_valid (gint32 display_ID); -gint32 gimp_display_new (GimpImage *image); -gboolean gimp_display_delete (gint32 display_ID); -gint gimp_display_get_window_handle (gint32 display_ID); -gboolean gimp_displays_flush (void); -gboolean gimp_displays_reconnect (GimpImage *old_image, - GimpImage *new_image); +gboolean gimp_display_is_valid (gint32 display_ID); +gint32 gimp_display_new (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_display_new) +G_GNUC_INTERNAL gint32 _gimp_display_new (gint32 image_ID); +gboolean gimp_display_delete (gint32 display_ID); +gint gimp_display_get_window_handle (gint32 display_ID); +gboolean gimp_displays_flush (void); +gboolean gimp_displays_reconnect (GimpImage *old_image, + GimpImage *new_image); +GIMP_DEPRECATED_FOR(gimp_displays_reconnect) +G_GNUC_INTERNAL gboolean _gimp_displays_reconnect (gint32 old_image_ID, + gint32 new_image_ID); G_END_DECLS diff --git a/libgimp/gimpedit_pdb.c b/libgimp/gimpedit_pdb.c index 7b59d6bb94..4d459445e1 100644 --- a/libgimp/gimpedit_pdb.c +++ b/libgimp/gimpedit_pdb.c @@ -172,6 +172,52 @@ gimp_edit_copy_visible (GimpImage *image) return non_empty; } +/** + * _gimp_edit_copy_visible: (skip) + * @image_ID: The image to copy from. + * + * Copy from the projection. + * + * If there is a selection in the image, then the area specified by the + * selection is copied from the projection and placed in an internal + * GIMP edit buffer. It can subsequently be retrieved using the + * gimp_edit_paste() command. If there is no selection, then the + * projection's contents will be stored in the internal GIMP edit + * buffer. + * + * Returns: TRUE if the copy was successful. + * + * Since: 2.2 + **/ +gboolean +_gimp_edit_copy_visible (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean non_empty = FALSE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-edit-copy-visible", + args); + else + return_vals = gimp_run_procedure_array ("gimp-edit-copy-visible", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + non_empty = g_value_get_boolean (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return non_empty; +} + /** * gimp_edit_paste: * @drawable_ID: The drawable to paste to. @@ -263,13 +309,55 @@ gimp_edit_paste_as_new_image (void) gimp_value_array_unref (args); if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) - image = gimp_image_new_by_id (g_value_get_int (gimp_value_array_index (return_vals, 1))); + image = gimp_image_new_by_id (gimp_value_get_image_id (gimp_value_array_index (return_vals, 1))); gimp_value_array_unref (return_vals); return image; } +/** + * _gimp_edit_paste_as_new_image: (skip) + * + * Paste buffer to a new image. + * + * This procedure pastes a copy of the internal GIMP edit buffer to a + * new image. The GIMP edit buffer will be empty unless a call was + * previously made to either gimp_edit_cut() or gimp_edit_copy(). This + * procedure returns the new image or -1 if the edit buffer was empty. + * + * Returns: The new image. + * + * Since: 2.10 + **/ +gint32 +_gimp_edit_paste_as_new_image (void) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint32 image_ID = -1; + + args = gimp_value_array_new_from_types (NULL, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-edit-paste-as-new-image", + args); + else + return_vals = gimp_run_procedure_array ("gimp-edit-paste-as-new-image", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + image_ID = gimp_value_get_image_id (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return image_ID; +} + /** * gimp_edit_named_cut: * @drawable_ID: The drawable to cut from. @@ -417,6 +505,54 @@ gimp_edit_named_copy_visible (GimpImage *image, return real_name; } +/** + * _gimp_edit_named_copy_visible: (skip) + * @image_ID: The image to copy from. + * @buffer_name: The name of the buffer to create. + * + * Copy from the projection into a named buffer. + * + * This procedure works like gimp_edit_copy_visible(), but additionally + * stores the copied buffer into a named buffer that will stay + * available for later pasting, regardless of any intermediate copy or + * cut operations. + * + * Returns: The real name given to the buffer, or NULL if the copy failed. + * The returned value must be freed with g_free(). + * + * Since: 2.4 + **/ +gchar * +_gimp_edit_named_copy_visible (gint32 image_ID, + const gchar *buffer_name) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gchar *real_name = NULL; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_STRING, buffer_name, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-edit-named-copy-visible", + args); + else + return_vals = gimp_run_procedure_array ("gimp-edit-named-copy-visible", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + real_name = g_value_dup_string (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return real_name; +} + /** * gimp_edit_named_paste: * @drawable_ID: The drawable to paste to. @@ -500,9 +636,51 @@ gimp_edit_named_paste_as_new_image (const gchar *buffer_name) gimp_value_array_unref (args); if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) - image = gimp_image_new_by_id (g_value_get_int (gimp_value_array_index (return_vals, 1))); + image = gimp_image_new_by_id (gimp_value_get_image_id (gimp_value_array_index (return_vals, 1))); gimp_value_array_unref (return_vals); return image; } + +/** + * _gimp_edit_named_paste_as_new_image: (skip) + * @buffer_name: The name of the buffer to paste. + * + * Paste named buffer to a new image. + * + * This procedure works like gimp_edit_paste_as_new_image() but pastes + * a named buffer instead of the global buffer. + * + * Returns: The new image. + * + * Since: 2.10 + **/ +gint32 +_gimp_edit_named_paste_as_new_image (const gchar *buffer_name) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint32 image_ID = -1; + + args = gimp_value_array_new_from_types (NULL, + G_TYPE_STRING, buffer_name, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-edit-named-paste-as-new-image", + args); + else + return_vals = gimp_run_procedure_array ("gimp-edit-named-paste-as-new-image", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + image_ID = gimp_value_get_image_id (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return image_ID; +} diff --git a/libgimp/gimpedit_pdb.h b/libgimp/gimpedit_pdb.h index 4092904f90..5e986004ca 100644 --- a/libgimp/gimpedit_pdb.h +++ b/libgimp/gimpedit_pdb.h @@ -32,22 +32,31 @@ G_BEGIN_DECLS /* For information look into the C source or the html documentation */ -gboolean gimp_edit_cut (gint32 drawable_ID); -gboolean gimp_edit_copy (gint32 drawable_ID); -gboolean gimp_edit_copy_visible (GimpImage *image); -gint32 gimp_edit_paste (gint32 drawable_ID, - gboolean paste_into); -GimpImage* gimp_edit_paste_as_new_image (void); -gchar* gimp_edit_named_cut (gint32 drawable_ID, - const gchar *buffer_name); -gchar* gimp_edit_named_copy (gint32 drawable_ID, - const gchar *buffer_name); -gchar* gimp_edit_named_copy_visible (GimpImage *image, - const gchar *buffer_name); -gint32 gimp_edit_named_paste (gint32 drawable_ID, - const gchar *buffer_name, - gboolean paste_into); -GimpImage* gimp_edit_named_paste_as_new_image (const gchar *buffer_name); +gboolean gimp_edit_cut (gint32 drawable_ID); +gboolean gimp_edit_copy (gint32 drawable_ID); +gboolean gimp_edit_copy_visible (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_edit_copy_visible) +G_GNUC_INTERNAL gboolean _gimp_edit_copy_visible (gint32 image_ID); +gint32 gimp_edit_paste (gint32 drawable_ID, + gboolean paste_into); +GimpImage* gimp_edit_paste_as_new_image (void); +GIMP_DEPRECATED_FOR(gimp_edit_paste_as_new_image) +G_GNUC_INTERNAL gint32 _gimp_edit_paste_as_new_image (void); +gchar* gimp_edit_named_cut (gint32 drawable_ID, + const gchar *buffer_name); +gchar* gimp_edit_named_copy (gint32 drawable_ID, + const gchar *buffer_name); +gchar* gimp_edit_named_copy_visible (GimpImage *image, + const gchar *buffer_name); +GIMP_DEPRECATED_FOR(gimp_edit_named_copy_visible) +G_GNUC_INTERNAL gchar* _gimp_edit_named_copy_visible (gint32 image_ID, + const gchar *buffer_name); +gint32 gimp_edit_named_paste (gint32 drawable_ID, + const gchar *buffer_name, + gboolean paste_into); +GimpImage* gimp_edit_named_paste_as_new_image (const gchar *buffer_name); +GIMP_DEPRECATED_FOR(gimp_edit_named_paste_as_new_image) +G_GNUC_INTERNAL gint32 _gimp_edit_named_paste_as_new_image (const gchar *buffer_name); G_END_DECLS diff --git a/libgimp/gimpfileops_pdb.c b/libgimp/gimpfileops_pdb.c index f6dc0ca92f..794da05541 100644 --- a/libgimp/gimpfileops_pdb.c +++ b/libgimp/gimpfileops_pdb.c @@ -78,13 +78,64 @@ gimp_file_load (GimpRunMode run_mode, gimp_value_array_unref (args); if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) - image = gimp_image_new_by_id (g_value_get_int (gimp_value_array_index (return_vals, 1))); + image = gimp_image_new_by_id (gimp_value_get_image_id (gimp_value_array_index (return_vals, 1))); gimp_value_array_unref (return_vals); return image; } +/** + * _gimp_file_load: (skip) + * @run_mode: The run mode. + * @filename: The name of the file to load. + * @raw_filename: The name as entered by the user. + * + * Loads an image file by invoking the right load handler. + * + * This procedure invokes the correct file load handler using magic if + * possible, and falling back on the file's extension and/or prefix if + * not. The name of the file to load is typically a full pathname, and + * the name entered is what the user actually typed before prepending a + * directory path. The reason for this is that if the user types + * https://www.gimp.org/foo.png he wants to fetch a URL, and the full + * pathname will not look like a URL. + * + * Returns: The output image. + **/ +gint32 +_gimp_file_load (GimpRunMode run_mode, + const gchar *filename, + const gchar *raw_filename) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint32 image_ID = -1; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_RUN_MODE, run_mode, + G_TYPE_STRING, filename, + G_TYPE_STRING, raw_filename, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-file-load", + args); + else + return_vals = gimp_run_procedure_array ("gimp-file-load", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + image_ID = gimp_value_get_image_id (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return image_ID; +} + /** * gimp_file_load_layer: * @run_mode: The run mode. @@ -135,6 +186,56 @@ gimp_file_load_layer (GimpRunMode run_mode, return layer_ID; } +/** + * _gimp_file_load_layer: (skip) + * @run_mode: The run mode. + * @image_ID: Destination image. + * @filename: The name of the file to load. + * + * Loads an image file as a layer for an existing image. + * + * This procedure behaves like the file-load procedure but opens the + * specified image as a layer for an existing image. The returned layer + * needs to be added to the existing image with + * gimp_image_insert_layer(). + * + * Returns: The layer created when loading the image file. + * + * Since: 2.4 + **/ +gint32 +_gimp_file_load_layer (GimpRunMode run_mode, + gint32 image_ID, + const gchar *filename) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint32 layer_ID = -1; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_RUN_MODE, run_mode, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_STRING, filename, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-file-load-layer", + args); + else + return_vals = gimp_run_procedure_array ("gimp-file-load-layer", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return layer_ID; +} + /** * gimp_file_load_layers: * @run_mode: The run mode. @@ -194,6 +295,64 @@ gimp_file_load_layers (GimpRunMode run_mode, return layer_ids; } +/** + * _gimp_file_load_layers: (skip) + * @run_mode: The run mode. + * @image_ID: Destination image. + * @filename: The name of the file to load. + * @num_layers: (out): The number of loaded layers. + * + * Loads an image file as layers for an existing image. + * + * This procedure behaves like the file-load procedure but opens the + * specified image as layers for an existing image. The returned layers + * needs to be added to the existing image with + * gimp_image_insert_layer(). + * + * Returns: (array length=num_layers): The list of loaded layers. + * The returned value must be freed with g_free(). + * + * Since: 2.4 + **/ +gint * +_gimp_file_load_layers (GimpRunMode run_mode, + gint32 image_ID, + const gchar *filename, + gint *num_layers) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint *layer_ids = NULL; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_RUN_MODE, run_mode, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_STRING, filename, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-file-load-layers", + args); + else + return_vals = gimp_run_procedure_array ("gimp-file-load-layers", + args); + gimp_value_array_unref (args); + + *num_layers = 0; + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + { + *num_layers = g_value_get_int (gimp_value_array_index (return_vals, 1)); + layer_ids = gimp_value_dup_int32_array (gimp_value_array_index (return_vals, 2)); + } + + gimp_value_array_unref (return_vals); + + return layer_ids; +} + /** * gimp_file_save: * @run_mode: The run mode. @@ -250,6 +409,62 @@ gimp_file_save (GimpRunMode run_mode, return success; } +/** + * _gimp_file_save: (skip) + * @run_mode: The run mode. + * @image_ID: Input image. + * @drawable_ID: Drawable to save. + * @filename: The name of the file to save the image in. + * @raw_filename: The name as entered by the user. + * + * Saves a file by extension. + * + * This procedure invokes the correct file save handler according to + * the file's extension and/or prefix. The name of the file to save is + * typically a full pathname, and the name entered is what the user + * actually typed before prepending a directory path. The reason for + * this is that if the user types https://www.gimp.org/foo.png she + * wants to fetch a URL, and the full pathname will not look like a + * URL. + * + * Returns: TRUE on success. + **/ +gboolean +_gimp_file_save (GimpRunMode run_mode, + gint32 image_ID, + gint32 drawable_ID, + const gchar *filename, + const gchar *raw_filename) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_RUN_MODE, run_mode, + GIMP_TYPE_IMAGE_ID, image_ID, + GIMP_TYPE_DRAWABLE_ID, drawable_ID, + G_TYPE_STRING, filename, + G_TYPE_STRING, raw_filename, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-file-save", + args); + else + return_vals = gimp_run_procedure_array ("gimp-file-save", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_file_save_thumbnail: * @image: The image. @@ -296,6 +511,52 @@ gimp_file_save_thumbnail (GimpImage *image, return success; } +/** + * _gimp_file_save_thumbnail: (skip) + * @image_ID: The image. + * @filename: The name of the file the thumbnail belongs to. + * + * Saves a thumbnail for the given image + * + * This procedure saves a thumbnail for the given image according to + * the Free Desktop Thumbnail Managing Standard. The thumbnail is saved + * so that it belongs to the file with the given filename. This means + * you have to save the image under this name first, otherwise this + * procedure will fail. This procedure may become useful if you want to + * explicitly save a thumbnail with a file. + * + * Returns: TRUE on success. + **/ +gboolean +_gimp_file_save_thumbnail (gint32 image_ID, + const gchar *filename) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_STRING, filename, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-file-save-thumbnail", + args); + else + return_vals = gimp_run_procedure_array ("gimp-file-save-thumbnail", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * _gimp_register_magic_load_handler: * @procedure_name: The name of the procedure to be used for loading. diff --git a/libgimp/gimpfileops_pdb.h b/libgimp/gimpfileops_pdb.h index 69b11dacae..c0c0ec1a53 100644 --- a/libgimp/gimpfileops_pdb.h +++ b/libgimp/gimpfileops_pdb.h @@ -35,20 +35,42 @@ G_BEGIN_DECLS GimpImage* gimp_file_load (GimpRunMode run_mode, const gchar *filename, const gchar *raw_filename); +GIMP_DEPRECATED_FOR(gimp_file_load) +G_GNUC_INTERNAL gint32 _gimp_file_load (GimpRunMode run_mode, + const gchar *filename, + const gchar *raw_filename); gint32 gimp_file_load_layer (GimpRunMode run_mode, GimpImage *image, const gchar *filename); +GIMP_DEPRECATED_FOR(gimp_file_load_layer) +G_GNUC_INTERNAL gint32 _gimp_file_load_layer (GimpRunMode run_mode, + gint32 image_ID, + const gchar *filename); gint* gimp_file_load_layers (GimpRunMode run_mode, GimpImage *image, const gchar *filename, gint *num_layers); +GIMP_DEPRECATED_FOR(gimp_file_load_layers) +G_GNUC_INTERNAL gint* _gimp_file_load_layers (GimpRunMode run_mode, + gint32 image_ID, + const gchar *filename, + gint *num_layers); gboolean gimp_file_save (GimpRunMode run_mode, GimpImage *image, gint32 drawable_ID, const gchar *filename, const gchar *raw_filename); +GIMP_DEPRECATED_FOR(gimp_file_save) +G_GNUC_INTERNAL gboolean _gimp_file_save (GimpRunMode run_mode, + gint32 image_ID, + gint32 drawable_ID, + const gchar *filename, + const gchar *raw_filename); gboolean gimp_file_save_thumbnail (GimpImage *image, const gchar *filename); +GIMP_DEPRECATED_FOR(gimp_file_save_thumbnail) +G_GNUC_INTERNAL gboolean _gimp_file_save_thumbnail (gint32 image_ID, + const gchar *filename); G_GNUC_INTERNAL gboolean _gimp_register_magic_load_handler (const gchar *procedure_name, const gchar *extensions, const gchar *prefixes, diff --git a/libgimp/gimpimage_pdb.c b/libgimp/gimpimage_pdb.c index 3b9dc85723..b3970d9e77 100644 --- a/libgimp/gimpimage_pdb.c +++ b/libgimp/gimpimage_pdb.c @@ -77,6 +77,48 @@ gimp_image_is_valid (GimpImage *image) return valid; } +/** + * _gimp_image_is_valid: (skip) + * @image_ID: The image to check. + * + * Returns TRUE if the image is valid. + * + * This procedure checks if the given image is valid and refers to an + * existing image. + * + * Returns: Whether the image is valid. + * + * Since: 2.4 + **/ +gboolean +_gimp_image_is_valid (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean valid = FALSE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-is-valid", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-is-valid", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + valid = g_value_get_boolean (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return valid; +} + /** * gimp_image_list: * @num_images: (out): The number of images currently open. @@ -169,13 +211,67 @@ gimp_image_new (gint width, gimp_value_array_unref (args); if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) - image = gimp_image_new_by_id (g_value_get_int (gimp_value_array_index (return_vals, 1))); + image = gimp_image_new_by_id (gimp_value_get_image_id (gimp_value_array_index (return_vals, 1))); gimp_value_array_unref (return_vals); return image; } +/** + * _gimp_image_new: (skip) + * @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: The newly created image. + **/ +gint32 +_gimp_image_new (gint width, + gint height, + GimpImageBaseType type) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint32 image_ID = -1; + + 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); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-new", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-new", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + image_ID = gimp_value_get_image_id (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return image_ID; +} + /** * gimp_image_new_with_precision: * @width: The width of the image. @@ -223,13 +319,67 @@ gimp_image_new_with_precision (gint width, gimp_value_array_unref (args); if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) - image = gimp_image_new_by_id (g_value_get_int (gimp_value_array_index (return_vals, 1))); + image = gimp_image_new_by_id (gimp_value_get_image_id (gimp_value_array_index (return_vals, 1))); gimp_value_array_unref (return_vals); return image; } +/** + * _gimp_image_new_with_precision: (skip) + * @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: The newly created image. + * + * Since: 2.10 + **/ +gint32 +_gimp_image_new_with_precision (gint width, + gint height, + GimpImageBaseType type, + GimpPrecision precision) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint32 image_ID = -1; + + 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); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-new-with-precision", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-new-with-precision", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + image_ID = gimp_value_get_image_id (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return image_ID; +} + /** * gimp_image_duplicate: * @image: The image. @@ -263,13 +413,53 @@ gimp_image_duplicate (GimpImage *image) gimp_value_array_unref (args); if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) - new_image = gimp_image_new_by_id (g_value_get_int (gimp_value_array_index (return_vals, 1))); + new_image = gimp_image_new_by_id (gimp_value_get_image_id (gimp_value_array_index (return_vals, 1))); gimp_value_array_unref (return_vals); return new_image; } +/** + * _gimp_image_duplicate: (skip) + * @image_ID: The image. + * + * Duplicate the specified image + * + * This procedure duplicates the specified image, copying all layers, + * channels, and image information. + * + * Returns: The new, duplicated image. + **/ +gint32 +_gimp_image_duplicate (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint32 new_image_ID = -1; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-duplicate", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-duplicate", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + new_image_ID = gimp_value_get_image_id (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return new_image_ID; +} + /** * gimp_image_delete: * @image: The image. @@ -313,6 +503,49 @@ gimp_image_delete (GimpImage *image) return success; } +/** + * _gimp_image_delete: (skip) + * @image_ID: 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 (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-delete", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-delete", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_base_type: * @image: The image. @@ -353,6 +586,46 @@ gimp_image_base_type (GimpImage *image) return base_type; } +/** + * _gimp_image_base_type: (skip) + * @image_ID: 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 (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + GimpImageBaseType base_type = 0; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-base-type", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-base-type", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + base_type = g_value_get_enum (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return base_type; +} + /** * gimp_image_get_precision: * @image: The image. @@ -394,6 +667,47 @@ gimp_image_get_precision (GimpImage *image) return precision; } +/** + * _gimp_image_get_precision: (skip) + * @image_ID: 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 (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + GimpPrecision precision = 0; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-get-precision", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-get-precision", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + precision = g_value_get_enum (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return precision; +} + /** * gimp_image_get_default_new_layer_mode: * @image: The image. @@ -435,6 +749,47 @@ gimp_image_get_default_new_layer_mode (GimpImage *image) return mode; } +/** + * _gimp_image_get_default_new_layer_mode: (skip) + * @image_ID: 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 (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + GimpLayerMode mode = 0; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-get-default-new-layer-mode", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-get-default-new-layer-mode", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + mode = g_value_get_enum (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return mode; +} + /** * gimp_image_width: * @image: The image. @@ -475,6 +830,46 @@ gimp_image_width (GimpImage *image) return width; } +/** + * _gimp_image_width: (skip) + * @image_ID: 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 (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint width = 0; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-width", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-width", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + width = g_value_get_int (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return width; +} + /** * gimp_image_height: * @image: The image. @@ -515,6 +910,46 @@ gimp_image_height (GimpImage *image) return height; } +/** + * _gimp_image_height: (skip) + * @image_ID: 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 (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint height = 0; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-height", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-height", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + height = g_value_get_int (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return height; +} + /** * gimp_image_get_layers: * @image: The image. @@ -564,6 +999,55 @@ gimp_image_get_layers (GimpImage *image, return layer_ids; } +/** + * _gimp_image_get_layers: (skip) + * @image_ID: 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): + * The list of layers contained in the image. + * The returned value must be freed with g_free(). + **/ +gint * +_gimp_image_get_layers (gint32 image_ID, + gint *num_layers) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint *layer_ids = NULL; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-get-layers", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-get-layers", + args); + gimp_value_array_unref (args); + + *num_layers = 0; + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + { + *num_layers = g_value_get_int (gimp_value_array_index (return_vals, 1)); + layer_ids = gimp_value_dup_int32_array (gimp_value_array_index (return_vals, 2)); + } + + gimp_value_array_unref (return_vals); + + return layer_ids; +} + /** * gimp_image_get_channels: * @image: The image. @@ -616,6 +1100,58 @@ gimp_image_get_channels (GimpImage *image, return channel_ids; } +/** + * _gimp_image_get_channels: (skip) + * @image_ID: 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): + * The list of channels contained in the image. + * The returned value must be freed with g_free(). + **/ +gint * +_gimp_image_get_channels (gint32 image_ID, + gint *num_channels) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint *channel_ids = NULL; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-get-channels", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-get-channels", + args); + gimp_value_array_unref (args); + + *num_channels = 0; + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + { + *num_channels = g_value_get_int (gimp_value_array_index (return_vals, 1)); + channel_ids = gimp_value_dup_int32_array (gimp_value_array_index (return_vals, 2)); + } + + gimp_value_array_unref (return_vals); + + return channel_ids; +} + /** * gimp_image_get_vectors: * @image: The image. @@ -667,6 +1203,57 @@ gimp_image_get_vectors (GimpImage *image, return vector_ids; } +/** + * _gimp_image_get_vectors: (skip) + * @image_ID: 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): + * The list of vectors contained in the image. + * The returned value must be freed with g_free(). + * + * Since: 2.4 + **/ +gint * +_gimp_image_get_vectors (gint32 image_ID, + gint *num_vectors) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint *vector_ids = NULL; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-get-vectors", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-get-vectors", + args); + gimp_value_array_unref (args); + + *num_vectors = 0; + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + { + *num_vectors = g_value_get_int (gimp_value_array_index (return_vals, 1)); + vector_ids = gimp_value_dup_int32_array (gimp_value_array_index (return_vals, 2)); + } + + gimp_value_array_unref (return_vals); + + return vector_ids; +} + /** * gimp_image_get_active_drawable: * @image: The image. @@ -711,6 +1298,50 @@ gimp_image_get_active_drawable (GimpImage *image) return drawable_ID; } +/** + * _gimp_image_get_active_drawable: (skip) + * @image_ID: 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: The active drawable. + **/ +gint32 +_gimp_image_get_active_drawable (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint32 drawable_ID = -1; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-get-active-drawable", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-get-active-drawable", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + drawable_ID = gimp_value_get_drawable_id (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return drawable_ID; +} + /** * gimp_image_unset_active_channel: * @image: The image. @@ -752,6 +1383,47 @@ gimp_image_unset_active_channel (GimpImage *image) return success; } +/** + * _gimp_image_unset_active_channel: (skip) + * @image_ID: 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 (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-unset-active-channel", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-unset-active-channel", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_get_floating_sel: * @image: The image. @@ -792,6 +1464,46 @@ gimp_image_get_floating_sel (GimpImage *image) return floating_sel_ID; } +/** + * _gimp_image_get_floating_sel: (skip) + * @image_ID: 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: The image's floating selection. + **/ +gint32 +_gimp_image_get_floating_sel (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint32 floating_sel_ID = -1; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-get-floating-sel", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-get-floating-sel", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + floating_sel_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return floating_sel_ID; +} + /** * gimp_image_floating_sel_attached_to: * @image: The image. @@ -833,6 +1545,47 @@ gimp_image_floating_sel_attached_to (GimpImage *image) return drawable_ID; } +/** + * _gimp_image_floating_sel_attached_to: (skip) + * @image_ID: 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: The drawable the floating selection is attached to. + **/ +gint32 +_gimp_image_floating_sel_attached_to (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint32 drawable_ID = -1; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-floating-sel-attached-to", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-floating-sel-attached-to", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + drawable_ID = gimp_value_get_drawable_id (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return drawable_ID; +} + /** * gimp_image_pick_color: * @image: The image. @@ -904,6 +1657,77 @@ gimp_image_pick_color (GimpImage *image, return success; } +/** + * _gimp_image_pick_color: (skip) + * @image_ID: The image. + * @drawable_ID: 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 (gint32 image_ID, + gint32 drawable_ID, + gdouble x, + gdouble y, + gboolean sample_merged, + gboolean sample_average, + gdouble average_radius, + GimpRGB *color) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + GIMP_TYPE_DRAWABLE_ID, drawable_ID, + 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); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-pick-color", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-pick-color", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + if (success) + gimp_value_get_rgb (gimp_value_array_index (return_vals, 1), &*color); + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_pick_correlate_layer: * @image: The image. @@ -953,6 +1777,55 @@ gimp_image_pick_correlate_layer (GimpImage *image, return layer_ID; } +/** + * _gimp_image_pick_correlate_layer: (skip) + * @image_ID: 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: The layer found at the specified coordinates. + **/ +gint32 +_gimp_image_pick_correlate_layer (gint32 image_ID, + gint x, + gint y) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint32 layer_ID = -1; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_INT, x, + G_TYPE_INT, y, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-pick-correlate-layer", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-pick-correlate-layer", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return layer_ID; +} + /** * gimp_image_insert_layer: * @image: The image. @@ -1010,6 +1883,63 @@ gimp_image_insert_layer (GimpImage *image, return success; } +/** + * _gimp_image_insert_layer: (skip) + * @image_ID: The image. + * @layer_ID: The layer. + * @parent_ID: 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 (gint32 image_ID, + gint32 layer_ID, + gint32 parent_ID, + gint position) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + GIMP_TYPE_LAYER_ID, layer_ID, + GIMP_TYPE_LAYER_ID, parent_ID, + G_TYPE_INT, position, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-insert-layer", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-insert-layer", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_remove_layer: * @image: The image. @@ -1055,6 +1985,51 @@ gimp_image_remove_layer (GimpImage *image, return success; } +/** + * _gimp_image_remove_layer: (skip) + * @image_ID: The image. + * @layer_ID: 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 (gint32 image_ID, + gint32 layer_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + GIMP_TYPE_LAYER_ID, layer_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-remove-layer", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-remove-layer", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_freeze_layers: * @image: The image. @@ -1101,6 +2076,52 @@ gimp_image_freeze_layers (GimpImage *image) return success; } +/** + * _gimp_image_freeze_layers: (skip) + * @image_ID: 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 (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-freeze-layers", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-freeze-layers", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_thaw_layers: * @image: The image. @@ -1145,6 +2166,50 @@ gimp_image_thaw_layers (GimpImage *image) return success; } +/** + * _gimp_image_thaw_layers: (skip) + * @image_ID: 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 (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-thaw-layers", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-thaw-layers", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_insert_channel: * @image: The image. @@ -1197,6 +2262,58 @@ gimp_image_insert_channel (GimpImage *image, return success; } +/** + * _gimp_image_insert_channel: (skip) + * @image_ID: The image. + * @channel_ID: The channel. + * @parent_ID: 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 (gint32 image_ID, + gint32 channel_ID, + gint32 parent_ID, + gint position) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + GIMP_TYPE_CHANNEL_ID, channel_ID, + GIMP_TYPE_CHANNEL_ID, parent_ID, + G_TYPE_INT, position, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-insert-channel", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-insert-channel", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_remove_channel: * @image: The image. @@ -1239,6 +2356,48 @@ gimp_image_remove_channel (GimpImage *image, return success; } +/** + * _gimp_image_remove_channel: (skip) + * @image_ID: The image. + * @channel_ID: 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 (gint32 image_ID, + gint32 channel_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + GIMP_TYPE_CHANNEL_ID, channel_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-remove-channel", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-remove-channel", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_freeze_channels: * @image: The image. @@ -1286,6 +2445,53 @@ gimp_image_freeze_channels (GimpImage *image) return success; } +/** + * _gimp_image_freeze_channels: (skip) + * @image_ID: 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 (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-freeze-channels", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-freeze-channels", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_thaw_channels: * @image: The image. @@ -1330,6 +2536,50 @@ gimp_image_thaw_channels (GimpImage *image) return success; } +/** + * _gimp_image_thaw_channels: (skip) + * @image_ID: 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 (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-thaw-channels", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-thaw-channels", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_insert_vectors: * @image: The image. @@ -1382,6 +2632,58 @@ gimp_image_insert_vectors (GimpImage *image, return success; } +/** + * _gimp_image_insert_vectors: (skip) + * @image_ID: The image. + * @vectors_ID: The vectors. + * @parent_ID: 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 (gint32 image_ID, + gint32 vectors_ID, + gint32 parent_ID, + gint position) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + GIMP_TYPE_VECTORS_ID, vectors_ID, + GIMP_TYPE_VECTORS_ID, parent_ID, + G_TYPE_INT, position, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-insert-vectors", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-insert-vectors", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_remove_vectors: * @image: The image. @@ -1426,6 +2728,50 @@ gimp_image_remove_vectors (GimpImage *image, return success; } +/** + * _gimp_image_remove_vectors: (skip) + * @image_ID: The image. + * @vectors_ID: 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 (gint32 image_ID, + gint32 vectors_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + GIMP_TYPE_VECTORS_ID, vectors_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-remove-vectors", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-remove-vectors", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_freeze_vectors: * @image: The image. @@ -1473,6 +2819,53 @@ gimp_image_freeze_vectors (GimpImage *image) return success; } +/** + * _gimp_image_freeze_vectors: (skip) + * @image_ID: 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 (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-freeze-vectors", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-freeze-vectors", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_thaw_vectors: * @image: The image. @@ -1517,6 +2910,50 @@ gimp_image_thaw_vectors (GimpImage *image) return success; } +/** + * _gimp_image_thaw_vectors: (skip) + * @image_ID: 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 (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-thaw-vectors", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-thaw-vectors", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_get_item_position: * @image: The image. @@ -1564,6 +3001,53 @@ gimp_image_get_item_position (GimpImage *image, return position; } +/** + * _gimp_image_get_item_position: (skip) + * @image_ID: The image. + * @item_ID: 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 (gint32 image_ID, + gint32 item_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint position = 0; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + GIMP_TYPE_ITEM_ID, item_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-get-item-position", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-get-item-position", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + position = g_value_get_int (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return position; +} + /** * gimp_image_raise_item: * @image: The image. @@ -1608,6 +3092,50 @@ gimp_image_raise_item (GimpImage *image, return success; } +/** + * _gimp_image_raise_item: (skip) + * @image_ID: The image. + * @item_ID: 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 (gint32 image_ID, + gint32 item_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + GIMP_TYPE_ITEM_ID, item_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-raise-item", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-raise-item", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_lower_item: * @image: The image. @@ -1652,6 +3180,50 @@ gimp_image_lower_item (GimpImage *image, return success; } +/** + * _gimp_image_lower_item: (skip) + * @image_ID: The image. + * @item_ID: 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 (gint32 image_ID, + gint32 item_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + GIMP_TYPE_ITEM_ID, item_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-lower-item", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-lower-item", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_raise_item_to_top: * @image: The image. @@ -1696,6 +3268,50 @@ gimp_image_raise_item_to_top (GimpImage *image, return success; } +/** + * _gimp_image_raise_item_to_top: (skip) + * @image_ID: The image. + * @item_ID: 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 (gint32 image_ID, + gint32 item_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + GIMP_TYPE_ITEM_ID, item_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-raise-item-to-top", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-raise-item-to-top", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_lower_item_to_bottom: * @image: The image. @@ -1741,6 +3357,51 @@ gimp_image_lower_item_to_bottom (GimpImage *image, return success; } +/** + * _gimp_image_lower_item_to_bottom: (skip) + * @image_ID: The image. + * @item_ID: 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 (gint32 image_ID, + gint32 item_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + GIMP_TYPE_ITEM_ID, item_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-lower-item-to-bottom", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-lower-item-to-bottom", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_reorder_item: * @image: The image. @@ -1790,6 +3451,55 @@ gimp_image_reorder_item (GimpImage *image, return success; } +/** + * _gimp_image_reorder_item: (skip) + * @image_ID: The image. + * @item_ID: The item to reorder. + * @parent_ID: 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 (gint32 image_ID, + gint32 item_ID, + gint32 parent_ID, + gint position) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + GIMP_TYPE_ITEM_ID, item_ID, + GIMP_TYPE_ITEM_ID, parent_ID, + G_TYPE_INT, position, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-reorder-item", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-reorder-item", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_flatten: * @image: The image. @@ -1832,6 +3542,48 @@ gimp_image_flatten (GimpImage *image) return layer_ID; } +/** + * _gimp_image_flatten: (skip) + * @image_ID: 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: The resulting layer. + **/ +gint32 +_gimp_image_flatten (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint32 layer_ID = -1; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-flatten", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-flatten", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return layer_ID; +} + /** * gimp_image_merge_visible_layers: * @image: The image. @@ -1879,6 +3631,53 @@ gimp_image_merge_visible_layers (GimpImage *image, return layer_ID; } +/** + * _gimp_image_merge_visible_layers: (skip) + * @image_ID: 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: The resulting layer. + **/ +gint32 +_gimp_image_merge_visible_layers (gint32 image_ID, + GimpMergeType merge_type) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint32 layer_ID = -1; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + GIMP_TYPE_MERGE_TYPE, merge_type, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-merge-visible-layers", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-merge-visible-layers", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return layer_ID; +} + /** * gimp_image_merge_down: * @image: The image. @@ -1930,6 +3729,57 @@ gimp_image_merge_down (GimpImage *image, return layer_ID; } +/** + * _gimp_image_merge_down: (skip) + * @image_ID: The image. + * @merge_layer_ID: 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: The resulting layer. + **/ +gint32 +_gimp_image_merge_down (gint32 image_ID, + gint32 merge_layer_ID, + GimpMergeType merge_type) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint32 layer_ID = -1; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + GIMP_TYPE_LAYER_ID, merge_layer_ID, + GIMP_TYPE_MERGE_TYPE, merge_type, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-merge-down", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-merge-down", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return layer_ID; +} + /** * _gimp_image_get_colormap: * @image: The image. @@ -1982,6 +3832,57 @@ _gimp_image_get_colormap (GimpImage *image, return colormap; } +/** + * __gimp_image_get_colormap: (skip) + * @image_ID: 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): The image's colormap. + * The returned value must be freed with g_free(). + **/ +guint8 * +__gimp_image_get_colormap (gint32 image_ID, + gint *num_bytes) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + guint8 *colormap = NULL; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-get-colormap", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-get-colormap", + args); + gimp_value_array_unref (args); + + *num_bytes = 0; + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + { + *num_bytes = g_value_get_int (gimp_value_array_index (return_vals, 1)); + colormap = gimp_value_dup_uint8_array (gimp_value_array_index (return_vals, 2)); + } + + gimp_value_array_unref (return_vals); + + return colormap; +} + /** * _gimp_image_set_colormap: * @image: The image. @@ -2031,6 +3932,55 @@ _gimp_image_set_colormap (GimpImage *image, return success; } +/** + * __gimp_image_set_colormap: (skip) + * @image_ID: 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 (gint32 image_ID, + gint num_bytes, + const guint8 *colormap) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + 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); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-set-colormap", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-set-colormap", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * _gimp_image_get_metadata: * @image: The image. @@ -2071,6 +4021,46 @@ _gimp_image_get_metadata (GimpImage *image) return metadata_string; } +/** + * __gimp_image_get_metadata: (skip) + * @image_ID: The image. + * + * Returns the image's metadata. + * + * Returns exif/iptc/xmp metadata from the image. + * + * Returns: The exif/ptc/xmp metadata as a string. + * The returned value must be freed with g_free(). + **/ +gchar * +__gimp_image_get_metadata (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gchar *metadata_string = NULL; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-get-metadata", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-get-metadata", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + metadata_string = g_value_dup_string (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return metadata_string; +} + /** * _gimp_image_set_metadata: * @image: The image. @@ -2112,6 +4102,47 @@ _gimp_image_set_metadata (GimpImage *image, return success; } +/** + * __gimp_image_set_metadata: (skip) + * @image_ID: 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 (gint32 image_ID, + const gchar *metadata_string) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_STRING, metadata_string, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-set-metadata", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-set-metadata", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_clean_all: * @image: The image. @@ -2155,6 +4186,49 @@ gimp_image_clean_all (GimpImage *image) return success; } +/** + * _gimp_image_clean_all: (skip) + * @image_ID: 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 (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-clean-all", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-clean-all", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_is_dirty: * @image: The image. @@ -2197,6 +4271,48 @@ gimp_image_is_dirty (GimpImage *image) return dirty; } +/** + * _gimp_image_is_dirty: (skip) + * @image_ID: 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 (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean dirty = FALSE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-is-dirty", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-is-dirty", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + dirty = g_value_get_boolean (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return dirty; +} + /** * _gimp_image_thumbnail: * @image: The image. @@ -2269,6 +4385,78 @@ _gimp_image_thumbnail (GimpImage *image, return success; } +/** + * __gimp_image_thumbnail: (skip) + * @image_ID: 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): 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 (gint32 image_ID, + gint width, + gint height, + gint *actual_width, + gint *actual_height, + gint *bpp, + gint *thumbnail_data_count, + guint8 **thumbnail_data) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_INT, width, + G_TYPE_INT, height, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-thumbnail", + args); + else + return_vals = gimp_run_procedure_array ("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 = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + if (success) + { + *actual_width = g_value_get_int (gimp_value_array_index (return_vals, 1)); + *actual_height = g_value_get_int (gimp_value_array_index (return_vals, 2)); + *bpp = g_value_get_int (gimp_value_array_index (return_vals, 3)); + *thumbnail_data_count = g_value_get_int (gimp_value_array_index (return_vals, 4)); + *thumbnail_data = gimp_value_dup_uint8_array (gimp_value_array_index (return_vals, 5)); + } + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_get_active_layer: * @image: The image. @@ -2310,6 +4498,47 @@ gimp_image_get_active_layer (GimpImage *image) return active_layer_ID; } +/** + * _gimp_image_get_active_layer: (skip) + * @image_ID: 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: The active layer. + **/ +gint32 +_gimp_image_get_active_layer (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint32 active_layer_ID = -1; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-get-active-layer", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-get-active-layer", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + active_layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return active_layer_ID; +} + /** * gimp_image_set_active_layer: * @image: The image. @@ -2354,6 +4583,50 @@ gimp_image_set_active_layer (GimpImage *image, return success; } +/** + * _gimp_image_set_active_layer: (skip) + * @image_ID: The image. + * @active_layer_ID: 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 (gint32 image_ID, + gint32 active_layer_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + GIMP_TYPE_LAYER_ID, active_layer_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-set-active-layer", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-set-active-layer", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_get_active_channel: * @image: The image. @@ -2394,6 +4667,46 @@ gimp_image_get_active_channel (GimpImage *image) return active_channel_ID; } +/** + * _gimp_image_get_active_channel: (skip) + * @image_ID: The image. + * + * Returns the specified image's active channel. + * + * If there is an active channel, this will return the channel ID, + * otherwise, -1. + * + * Returns: The active channel. + **/ +gint32 +_gimp_image_get_active_channel (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint32 active_channel_ID = -1; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-get-active-channel", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-get-active-channel", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + active_channel_ID = gimp_value_get_channel_id (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return active_channel_ID; +} + /** * gimp_image_set_active_channel: * @image: The image. @@ -2438,6 +4751,50 @@ gimp_image_set_active_channel (GimpImage *image, return success; } +/** + * _gimp_image_set_active_channel: (skip) + * @image_ID: The image. + * @active_channel_ID: 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 (gint32 image_ID, + gint32 active_channel_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + GIMP_TYPE_CHANNEL_ID, active_channel_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-set-active-channel", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-set-active-channel", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_get_active_vectors: * @image: The image. @@ -2477,6 +4834,45 @@ gimp_image_get_active_vectors (GimpImage *image) return active_vectors_ID; } +/** + * _gimp_image_get_active_vectors: (skip) + * @image_ID: The image. + * + * Returns the specified image's active vectors. + * + * If there is an active path, its ID will be returned, otherwise, -1. + * + * Returns: The active vectors. + **/ +gint32 +_gimp_image_get_active_vectors (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint32 active_vectors_ID = -1; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-get-active-vectors", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-get-active-vectors", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + active_vectors_ID = gimp_value_get_vectors_id (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return active_vectors_ID; +} + /** * gimp_image_set_active_vectors: * @image: The image. @@ -2518,6 +4914,47 @@ gimp_image_set_active_vectors (GimpImage *image, return success; } +/** + * _gimp_image_set_active_vectors: (skip) + * @image_ID: The image. + * @active_vectors_ID: 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 (gint32 image_ID, + gint32 active_vectors_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + GIMP_TYPE_VECTORS_ID, active_vectors_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-set-active-vectors", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-set-active-vectors", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_get_selection: * @image: The image. @@ -2558,6 +4995,46 @@ gimp_image_get_selection (GimpImage *image) return selection_ID; } +/** + * _gimp_image_get_selection: (skip) + * @image_ID: 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: The selection channel. + **/ +gint32 +_gimp_image_get_selection (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint32 selection_ID = -1; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-get-selection", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-get-selection", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + selection_ID = gimp_value_get_selection_id (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return selection_ID; +} + /** * gimp_image_get_component_active: * @image: The image. @@ -2603,6 +5080,51 @@ gimp_image_get_component_active (GimpImage *image, return active; } +/** + * _gimp_image_get_component_active: (skip) + * @image_ID: 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 (gint32 image_ID, + GimpChannelType component) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean active = FALSE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + GIMP_TYPE_CHANNEL_TYPE, component, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-get-component-active", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-get-component-active", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + active = g_value_get_boolean (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return active; +} + /** * gimp_image_set_component_active: * @image: The image. @@ -2650,6 +5172,53 @@ gimp_image_set_component_active (GimpImage *image, return success; } +/** + * _gimp_image_set_component_active: (skip) + * @image_ID: 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 (gint32 image_ID, + GimpChannelType component, + gboolean active) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + GIMP_TYPE_CHANNEL_TYPE, component, + G_TYPE_BOOLEAN, active, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-set-component-active", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-set-component-active", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_get_component_visible: * @image: The image. @@ -2696,6 +5265,52 @@ gimp_image_get_component_visible (GimpImage *image, return visible; } +/** + * _gimp_image_get_component_visible: (skip) + * @image_ID: 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 (gint32 image_ID, + GimpChannelType component) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean visible = FALSE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + GIMP_TYPE_CHANNEL_TYPE, component, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-get-component-visible", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-get-component-visible", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + visible = g_value_get_boolean (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return visible; +} + /** * gimp_image_set_component_visible: * @image: The image. @@ -2743,6 +5358,53 @@ gimp_image_set_component_visible (GimpImage *image, return success; } +/** + * _gimp_image_set_component_visible: (skip) + * @image_ID: 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 (gint32 image_ID, + GimpChannelType component, + gboolean visible) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + GIMP_TYPE_CHANNEL_TYPE, component, + G_TYPE_BOOLEAN, visible, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-set-component-visible", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-set-component-visible", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_get_filename: * @image: The image. @@ -2787,6 +5449,50 @@ gimp_image_get_filename (GimpImage *image) return filename; } +/** + * _gimp_image_get_filename: (skip) + * @image_ID: The image. + * + * Returns the specified image's filename. + * + * This procedure returns the specified image's filename in the + * filesystem encoding. The image has a filename 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_uri(). + * + * Returns: The filename. + * The returned value must be freed with g_free(). + **/ +gchar * +_gimp_image_get_filename (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gchar *filename = NULL; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-get-filename", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-get-filename", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + filename = g_value_dup_string (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return filename; +} + /** * gimp_image_set_filename: * @image: The image. @@ -2829,6 +5535,48 @@ gimp_image_set_filename (GimpImage *image, return success; } +/** + * _gimp_image_set_filename: (skip) + * @image_ID: The image. + * @filename: The new image filename. + * + * Sets the specified image's filename. + * + * This procedure sets the specified image's filename. The filename + * should be in the filesystem encoding. + * + * Returns: TRUE on success. + **/ +gboolean +_gimp_image_set_filename (gint32 image_ID, + const gchar *filename) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_STRING, filename, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-set-filename", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-set-filename", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_get_uri: * @image: The image. @@ -2877,6 +5625,54 @@ gimp_image_get_uri (GimpImage *image) return uri; } +/** + * _gimp_image_get_uri: (skip) + * @image_ID: The image. + * + * Returns the URI for the specified image. + * + * This procedure returns the URI associated with the specified image. + * The image has an URI 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-uri to get the URI + * of the current file if it was imported from a non-GIMP file format + * and not yet saved, or gimp-image-get-exported-uri if the image has + * been exported to a non-GIMP file format. + * + * Returns: The URI. + * The returned value must be freed with g_free(). + * + * Since: 2.8 + **/ +gchar * +_gimp_image_get_uri (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gchar *uri = NULL; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-get-uri", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-get-uri", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + uri = g_value_dup_string (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return uri; +} + /** * gimp_image_get_xcf_uri: * @image: The image. @@ -2920,6 +5716,49 @@ gimp_image_get_xcf_uri (GimpImage *image) return uri; } +/** + * _gimp_image_get_xcf_uri: (skip) + * @image_ID: The image. + * + * Returns the XCF URI for the specified image. + * + * This procedure returns the XCF URI associated with the image. If + * there is no such URI, this procedure returns %NULL. + * + * Returns: The imported URI. + * The returned value must be freed with g_free(). + * + * Since: 2.8 + **/ +gchar * +_gimp_image_get_xcf_uri (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gchar *uri = NULL; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-get-xcf-uri", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-get-xcf-uri", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + uri = g_value_dup_string (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return uri; +} + /** * gimp_image_get_imported_uri: * @image: The image. @@ -2965,6 +5804,51 @@ gimp_image_get_imported_uri (GimpImage *image) return uri; } +/** + * _gimp_image_get_imported_uri: (skip) + * @image_ID: The image. + * + * Returns the imported URI for the specified image. + * + * This procedure returns the URI 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: The imported URI. + * The returned value must be freed with g_free(). + * + * Since: 2.8 + **/ +gchar * +_gimp_image_get_imported_uri (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gchar *uri = NULL; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-get-imported-uri", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-get-imported-uri", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + uri = g_value_dup_string (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return uri; +} + /** * gimp_image_get_exported_uri: * @image: The image. @@ -3009,6 +5893,50 @@ gimp_image_get_exported_uri (GimpImage *image) return uri; } +/** + * _gimp_image_get_exported_uri: (skip) + * @image_ID: The image. + * + * Returns the exported URI for the specified image. + * + * This procedure returns the URI 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: The exported URI. + * The returned value must be freed with g_free(). + * + * Since: 2.8 + **/ +gchar * +_gimp_image_get_exported_uri (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gchar *uri = NULL; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-get-exported-uri", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-get-exported-uri", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + uri = g_value_dup_string (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return uri; +} + /** * gimp_image_get_name: * @image: The image. @@ -3055,6 +5983,52 @@ gimp_image_get_name (GimpImage *image) return name; } +/** + * _gimp_image_get_name: (skip) + * @image_ID: 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: The name. + * The returned value must be freed with g_free(). + **/ +gchar * +_gimp_image_get_name (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gchar *name = NULL; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-get-name", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-get-name", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + name = g_value_dup_string (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return name; +} + /** * gimp_image_get_resolution: * @image: The image. @@ -3107,6 +6081,58 @@ gimp_image_get_resolution (GimpImage *image, return success; } +/** + * _gimp_image_get_resolution: (skip) + * @image_ID: 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 (gint32 image_ID, + gdouble *xresolution, + gdouble *yresolution) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-get-resolution", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-get-resolution", + args); + gimp_value_array_unref (args); + + *xresolution = 0.0; + *yresolution = 0.0; + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + if (success) + { + *xresolution = g_value_get_double (gimp_value_array_index (return_vals, 1)); + *yresolution = g_value_get_double (gimp_value_array_index (return_vals, 2)); + } + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_set_resolution: * @image: The image. @@ -3153,6 +6179,52 @@ gimp_image_set_resolution (GimpImage *image, return success; } +/** + * _gimp_image_set_resolution: (skip) + * @image_ID: 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 (gint32 image_ID, + gdouble xresolution, + gdouble yresolution) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_DOUBLE, xresolution, + G_TYPE_DOUBLE, yresolution, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-set-resolution", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-set-resolution", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_get_unit: * @image: The image. @@ -3195,6 +6267,48 @@ gimp_image_get_unit (GimpImage *image) return unit; } +/** + * _gimp_image_get_unit: (skip) + * @image_ID: 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: The unit. + **/ +GimpUnit +_gimp_image_get_unit (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + GimpUnit unit = GIMP_UNIT_PIXEL; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-get-unit", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-get-unit", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + unit = g_value_get_int (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return unit; +} + /** * gimp_image_set_unit: * @image: The image. @@ -3240,6 +6354,51 @@ gimp_image_set_unit (GimpImage *image, return success; } +/** + * _gimp_image_set_unit: (skip) + * @image_ID: 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 (gint32 image_ID, + GimpUnit unit) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + GIMP_TYPE_UNIT, unit, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-set-unit", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-set-unit", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_get_tattoo_state: * @image: The image. @@ -3281,6 +6440,47 @@ gimp_image_get_tattoo_state (GimpImage *image) return tattoo_state; } +/** + * _gimp_image_get_tattoo_state: (skip) + * @image_ID: 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 (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + guint tattoo_state = 0; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-get-tattoo-state", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-get-tattoo-state", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + tattoo_state = g_value_get_uint (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return tattoo_state; +} + /** * gimp_image_set_tattoo_state: * @image: The image. @@ -3333,6 +6533,58 @@ gimp_image_set_tattoo_state (GimpImage *image, return success; } +/** + * _gimp_image_set_tattoo_state: (skip) + * @image_ID: 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 (gint32 image_ID, + guint tattoo_state) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_UINT, tattoo_state, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-set-tattoo-state", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-set-tattoo-state", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_get_layer_by_tattoo: * @image: The image. @@ -3376,6 +6628,49 @@ gimp_image_get_layer_by_tattoo (GimpImage *image, return layer_ID; } +/** + * _gimp_image_get_layer_by_tattoo: (skip) + * @image_ID: 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: The layer with the specified tattoo. + **/ +gint32 +_gimp_image_get_layer_by_tattoo (gint32 image_ID, + guint tattoo) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint32 layer_ID = -1; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_UINT, tattoo, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-get-layer-by-tattoo", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-get-layer-by-tattoo", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return layer_ID; +} + /** * gimp_image_get_channel_by_tattoo: * @image: The image. @@ -3419,6 +6714,49 @@ gimp_image_get_channel_by_tattoo (GimpImage *image, return channel_ID; } +/** + * _gimp_image_get_channel_by_tattoo: (skip) + * @image_ID: 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: The channel with the specified tattoo. + **/ +gint32 +_gimp_image_get_channel_by_tattoo (gint32 image_ID, + guint tattoo) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint32 channel_ID = -1; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_UINT, tattoo, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-get-channel-by-tattoo", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-get-channel-by-tattoo", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + channel_ID = gimp_value_get_channel_id (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return channel_ID; +} + /** * gimp_image_get_vectors_by_tattoo: * @image: The image. @@ -3464,6 +6802,51 @@ gimp_image_get_vectors_by_tattoo (GimpImage *image, return vectors_ID; } +/** + * _gimp_image_get_vectors_by_tattoo: (skip) + * @image_ID: 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: The vectors with the specified tattoo. + * + * Since: 2.6 + **/ +gint32 +_gimp_image_get_vectors_by_tattoo (gint32 image_ID, + guint tattoo) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint32 vectors_ID = -1; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_UINT, tattoo, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-get-vectors-by-tattoo", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-get-vectors-by-tattoo", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + vectors_ID = gimp_value_get_vectors_id (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return vectors_ID; +} + /** * gimp_image_get_layer_by_name: * @image: The image. @@ -3509,6 +6892,51 @@ gimp_image_get_layer_by_name (GimpImage *image, return layer_ID; } +/** + * _gimp_image_get_layer_by_name: (skip) + * @image_ID: 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: The layer with the specified name. + * + * Since: 2.8 + **/ +gint32 +_gimp_image_get_layer_by_name (gint32 image_ID, + const gchar *name) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint32 layer_ID = -1; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_STRING, name, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-get-layer-by-name", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-get-layer-by-name", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return layer_ID; +} + /** * gimp_image_get_channel_by_name: * @image: The image. @@ -3554,6 +6982,51 @@ gimp_image_get_channel_by_name (GimpImage *image, return channel_ID; } +/** + * _gimp_image_get_channel_by_name: (skip) + * @image_ID: 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: The channel with the specified name. + * + * Since: 2.8 + **/ +gint32 +_gimp_image_get_channel_by_name (gint32 image_ID, + const gchar *name) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint32 channel_ID = -1; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_STRING, name, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-get-channel-by-name", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-get-channel-by-name", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + channel_ID = gimp_value_get_channel_id (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return channel_ID; +} + /** * gimp_image_get_vectors_by_name: * @image: The image. @@ -3599,6 +7072,51 @@ gimp_image_get_vectors_by_name (GimpImage *image, return vectors_ID; } +/** + * _gimp_image_get_vectors_by_name: (skip) + * @image_ID: 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: The vectors with the specified name. + * + * Since: 2.8 + **/ +gint32 +_gimp_image_get_vectors_by_name (gint32 image_ID, + const gchar *name) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint32 vectors_ID = -1; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_STRING, name, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-get-vectors-by-name", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-get-vectors-by-name", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + vectors_ID = gimp_value_get_vectors_id (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return vectors_ID; +} + /** * gimp_image_attach_parasite: * @image: The image. @@ -3643,6 +7161,50 @@ gimp_image_attach_parasite (GimpImage *image, return success; } +/** + * _gimp_image_attach_parasite: (skip) + * @image_ID: 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 (gint32 image_ID, + const GimpParasite *parasite) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + GIMP_TYPE_PARASITE, parasite, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-attach-parasite", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-attach-parasite", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_detach_parasite: * @image: The image. @@ -3687,6 +7249,50 @@ gimp_image_detach_parasite (GimpImage *image, return success; } +/** + * _gimp_image_detach_parasite: (skip) + * @image_ID: 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 (gint32 image_ID, + const gchar *name) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_STRING, name, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-detach-parasite", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-detach-parasite", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_get_parasite: * @image: The image. @@ -3732,6 +7338,51 @@ gimp_image_get_parasite (GimpImage *image, return parasite; } +/** + * _gimp_image_get_parasite: (skip) + * @image_ID: 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: The found parasite. + * + * Since: 2.8 + **/ +GimpParasite * +_gimp_image_get_parasite (gint32 image_ID, + const gchar *name) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + GimpParasite *parasite = NULL; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_STRING, name, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-get-parasite", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-get-parasite", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + parasite = g_value_dup_boxed (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return parasite; +} + /** * gimp_image_get_parasite_list: * @image: The image. @@ -3781,3 +7432,53 @@ gimp_image_get_parasite_list (GimpImage *image, return parasites; } + +/** + * _gimp_image_get_parasite_list: (skip) + * @image_ID: 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): + * The names of currently attached parasites. + * The returned value must be freed with g_strfreev(). + * + * Since: 2.8 + **/ +gchar ** +_gimp_image_get_parasite_list (gint32 image_ID, + gint *num_parasites) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gchar **parasites = NULL; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-get-parasite-list", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-get-parasite-list", + args); + gimp_value_array_unref (args); + + *num_parasites = 0; + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + { + *num_parasites = g_value_get_int (gimp_value_array_index (return_vals, 1)); + parasites = gimp_value_dup_string_array (gimp_value_array_index (return_vals, 2)); + } + + gimp_value_array_unref (return_vals); + + return parasites; +} diff --git a/libgimp/gimpimage_pdb.h b/libgimp/gimpimage_pdb.h index b7ad5ea4e6..c6a59a1aea 100644 --- a/libgimp/gimpimage_pdb.h +++ b/libgimp/gimpimage_pdb.h @@ -32,165 +32,404 @@ G_BEGIN_DECLS /* For information look into the C source or the html documentation */ -gboolean gimp_image_is_valid (GimpImage *image); -gint* gimp_image_list (gint *num_images); -GimpImage* gimp_image_new (gint width, - gint height, - GimpImageBaseType type); -GimpImage* gimp_image_new_with_precision (gint width, - gint height, - GimpImageBaseType type, - GimpPrecision precision); -GimpImage* gimp_image_duplicate (GimpImage *image); -gboolean gimp_image_delete (GimpImage *image); -GimpImageBaseType gimp_image_base_type (GimpImage *image); -GimpPrecision gimp_image_get_precision (GimpImage *image); -GimpLayerMode gimp_image_get_default_new_layer_mode (GimpImage *image); -gint gimp_image_width (GimpImage *image); -gint gimp_image_height (GimpImage *image); -gint* gimp_image_get_layers (GimpImage *image, - gint *num_layers); -gint* gimp_image_get_channels (GimpImage *image, - gint *num_channels); -gint* gimp_image_get_vectors (GimpImage *image, - gint *num_vectors); -gint32 gimp_image_get_active_drawable (GimpImage *image); -gboolean gimp_image_unset_active_channel (GimpImage *image); -gint32 gimp_image_get_floating_sel (GimpImage *image); -gint32 gimp_image_floating_sel_attached_to (GimpImage *image); -gboolean gimp_image_pick_color (GimpImage *image, - gint32 drawable_ID, - gdouble x, - gdouble y, - gboolean sample_merged, - gboolean sample_average, - gdouble average_radius, - GimpRGB *color); -gint32 gimp_image_pick_correlate_layer (GimpImage *image, - gint x, - gint y); -gboolean gimp_image_insert_layer (GimpImage *image, - gint32 layer_ID, - gint32 parent_ID, - gint position); -gboolean gimp_image_remove_layer (GimpImage *image, - gint32 layer_ID); -gboolean gimp_image_freeze_layers (GimpImage *image); -gboolean gimp_image_thaw_layers (GimpImage *image); -gboolean gimp_image_insert_channel (GimpImage *image, - gint32 channel_ID, - gint32 parent_ID, - gint position); -gboolean gimp_image_remove_channel (GimpImage *image, - gint32 channel_ID); -gboolean gimp_image_freeze_channels (GimpImage *image); -gboolean gimp_image_thaw_channels (GimpImage *image); -gboolean gimp_image_insert_vectors (GimpImage *image, - gint32 vectors_ID, - gint32 parent_ID, - gint position); -gboolean gimp_image_remove_vectors (GimpImage *image, - gint32 vectors_ID); -gboolean gimp_image_freeze_vectors (GimpImage *image); -gboolean gimp_image_thaw_vectors (GimpImage *image); -gint gimp_image_get_item_position (GimpImage *image, - gint32 item_ID); -gboolean gimp_image_raise_item (GimpImage *image, - gint32 item_ID); -gboolean gimp_image_lower_item (GimpImage *image, - gint32 item_ID); -gboolean gimp_image_raise_item_to_top (GimpImage *image, - gint32 item_ID); -gboolean gimp_image_lower_item_to_bottom (GimpImage *image, - gint32 item_ID); -gboolean gimp_image_reorder_item (GimpImage *image, - gint32 item_ID, - gint32 parent_ID, - gint position); -gint32 gimp_image_flatten (GimpImage *image); -gint32 gimp_image_merge_visible_layers (GimpImage *image, - GimpMergeType merge_type); -gint32 gimp_image_merge_down (GimpImage *image, - gint32 merge_layer_ID, - GimpMergeType merge_type); -G_GNUC_INTERNAL guint8* _gimp_image_get_colormap (GimpImage *image, - gint *num_bytes); -G_GNUC_INTERNAL gboolean _gimp_image_set_colormap (GimpImage *image, - gint num_bytes, - const guint8 *colormap); -G_GNUC_INTERNAL gchar* _gimp_image_get_metadata (GimpImage *image); -G_GNUC_INTERNAL gboolean _gimp_image_set_metadata (GimpImage *image, - const gchar *metadata_string); -gboolean gimp_image_clean_all (GimpImage *image); -gboolean gimp_image_is_dirty (GimpImage *image); -G_GNUC_INTERNAL 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); -gint32 gimp_image_get_active_layer (GimpImage *image); -gboolean gimp_image_set_active_layer (GimpImage *image, - gint32 active_layer_ID); -gint32 gimp_image_get_active_channel (GimpImage *image); -gboolean gimp_image_set_active_channel (GimpImage *image, - gint32 active_channel_ID); -gint32 gimp_image_get_active_vectors (GimpImage *image); -gboolean gimp_image_set_active_vectors (GimpImage *image, - gint32 active_vectors_ID); -gint32 gimp_image_get_selection (GimpImage *image); -gboolean gimp_image_get_component_active (GimpImage *image, - GimpChannelType component); -gboolean gimp_image_set_component_active (GimpImage *image, - GimpChannelType component, - gboolean active); -gboolean gimp_image_get_component_visible (GimpImage *image, - GimpChannelType component); -gboolean gimp_image_set_component_visible (GimpImage *image, - GimpChannelType component, - gboolean visible); -gchar* gimp_image_get_filename (GimpImage *image); -gboolean gimp_image_set_filename (GimpImage *image, - const gchar *filename); -gchar* gimp_image_get_uri (GimpImage *image); -gchar* gimp_image_get_xcf_uri (GimpImage *image); -gchar* gimp_image_get_imported_uri (GimpImage *image); -gchar* gimp_image_get_exported_uri (GimpImage *image); -gchar* gimp_image_get_name (GimpImage *image); -gboolean gimp_image_get_resolution (GimpImage *image, - gdouble *xresolution, - gdouble *yresolution); -gboolean gimp_image_set_resolution (GimpImage *image, - gdouble xresolution, - gdouble yresolution); -GimpUnit gimp_image_get_unit (GimpImage *image); -gboolean gimp_image_set_unit (GimpImage *image, - GimpUnit unit); -guint gimp_image_get_tattoo_state (GimpImage *image); -gboolean gimp_image_set_tattoo_state (GimpImage *image, - guint tattoo_state); -gint32 gimp_image_get_layer_by_tattoo (GimpImage *image, - guint tattoo); -gint32 gimp_image_get_channel_by_tattoo (GimpImage *image, - guint tattoo); -gint32 gimp_image_get_vectors_by_tattoo (GimpImage *image, - guint tattoo); -gint32 gimp_image_get_layer_by_name (GimpImage *image, - const gchar *name); -gint32 gimp_image_get_channel_by_name (GimpImage *image, - const gchar *name); -gint32 gimp_image_get_vectors_by_name (GimpImage *image, - const gchar *name); -gboolean gimp_image_attach_parasite (GimpImage *image, - const GimpParasite *parasite); -gboolean gimp_image_detach_parasite (GimpImage *image, - const gchar *name); -GimpParasite* gimp_image_get_parasite (GimpImage *image, - const gchar *name); -gchar** gimp_image_get_parasite_list (GimpImage *image, - gint *num_parasites); +gboolean gimp_image_is_valid (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_image_is_valid) +G_GNUC_INTERNAL gboolean _gimp_image_is_valid (gint32 image_ID); +gint* gimp_image_list (gint *num_images); +GimpImage* gimp_image_new (gint width, + gint height, + GimpImageBaseType type); +GIMP_DEPRECATED_FOR(gimp_image_new) +G_GNUC_INTERNAL gint32 _gimp_image_new (gint width, + gint height, + GimpImageBaseType type); +GimpImage* gimp_image_new_with_precision (gint width, + gint height, + GimpImageBaseType type, + GimpPrecision precision); +GIMP_DEPRECATED_FOR(gimp_image_new_with_precision) +G_GNUC_INTERNAL gint32 _gimp_image_new_with_precision (gint width, + gint height, + GimpImageBaseType type, + GimpPrecision precision); +GimpImage* gimp_image_duplicate (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_image_duplicate) +G_GNUC_INTERNAL gint32 _gimp_image_duplicate (gint32 image_ID); +gboolean gimp_image_delete (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_image_delete) +G_GNUC_INTERNAL gboolean _gimp_image_delete (gint32 image_ID); +GimpImageBaseType gimp_image_base_type (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_image_base_type) +G_GNUC_INTERNAL GimpImageBaseType _gimp_image_base_type (gint32 image_ID); +GimpPrecision gimp_image_get_precision (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_image_get_precision) +G_GNUC_INTERNAL GimpPrecision _gimp_image_get_precision (gint32 image_ID); +GimpLayerMode gimp_image_get_default_new_layer_mode (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_image_get_default_new_layer_mode) +G_GNUC_INTERNAL GimpLayerMode _gimp_image_get_default_new_layer_mode (gint32 image_ID); +gint gimp_image_width (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_image_width) +G_GNUC_INTERNAL gint _gimp_image_width (gint32 image_ID); +gint gimp_image_height (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_image_height) +G_GNUC_INTERNAL gint _gimp_image_height (gint32 image_ID); +gint* gimp_image_get_layers (GimpImage *image, + gint *num_layers); +GIMP_DEPRECATED_FOR(gimp_image_get_layers) +G_GNUC_INTERNAL gint* _gimp_image_get_layers (gint32 image_ID, + gint *num_layers); +gint* gimp_image_get_channels (GimpImage *image, + gint *num_channels); +GIMP_DEPRECATED_FOR(gimp_image_get_channels) +G_GNUC_INTERNAL gint* _gimp_image_get_channels (gint32 image_ID, + gint *num_channels); +gint* gimp_image_get_vectors (GimpImage *image, + gint *num_vectors); +GIMP_DEPRECATED_FOR(gimp_image_get_vectors) +G_GNUC_INTERNAL gint* _gimp_image_get_vectors (gint32 image_ID, + gint *num_vectors); +gint32 gimp_image_get_active_drawable (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_image_get_active_drawable) +G_GNUC_INTERNAL gint32 _gimp_image_get_active_drawable (gint32 image_ID); +gboolean gimp_image_unset_active_channel (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_image_unset_active_channel) +G_GNUC_INTERNAL gboolean _gimp_image_unset_active_channel (gint32 image_ID); +gint32 gimp_image_get_floating_sel (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_image_get_floating_sel) +G_GNUC_INTERNAL gint32 _gimp_image_get_floating_sel (gint32 image_ID); +gint32 gimp_image_floating_sel_attached_to (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_image_floating_sel_attached_to) +G_GNUC_INTERNAL gint32 _gimp_image_floating_sel_attached_to (gint32 image_ID); +gboolean gimp_image_pick_color (GimpImage *image, + gint32 drawable_ID, + gdouble x, + gdouble y, + gboolean sample_merged, + gboolean sample_average, + gdouble average_radius, + GimpRGB *color); +GIMP_DEPRECATED_FOR(gimp_image_pick_color) +G_GNUC_INTERNAL gboolean _gimp_image_pick_color (gint32 image_ID, + gint32 drawable_ID, + gdouble x, + gdouble y, + gboolean sample_merged, + gboolean sample_average, + gdouble average_radius, + GimpRGB *color); +gint32 gimp_image_pick_correlate_layer (GimpImage *image, + gint x, + gint y); +GIMP_DEPRECATED_FOR(gimp_image_pick_correlate_layer) +G_GNUC_INTERNAL gint32 _gimp_image_pick_correlate_layer (gint32 image_ID, + gint x, + gint y); +gboolean gimp_image_insert_layer (GimpImage *image, + gint32 layer_ID, + gint32 parent_ID, + gint position); +GIMP_DEPRECATED_FOR(gimp_image_insert_layer) +G_GNUC_INTERNAL gboolean _gimp_image_insert_layer (gint32 image_ID, + gint32 layer_ID, + gint32 parent_ID, + gint position); +gboolean gimp_image_remove_layer (GimpImage *image, + gint32 layer_ID); +GIMP_DEPRECATED_FOR(gimp_image_remove_layer) +G_GNUC_INTERNAL gboolean _gimp_image_remove_layer (gint32 image_ID, + gint32 layer_ID); +gboolean gimp_image_freeze_layers (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_image_freeze_layers) +G_GNUC_INTERNAL gboolean _gimp_image_freeze_layers (gint32 image_ID); +gboolean gimp_image_thaw_layers (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_image_thaw_layers) +G_GNUC_INTERNAL gboolean _gimp_image_thaw_layers (gint32 image_ID); +gboolean gimp_image_insert_channel (GimpImage *image, + gint32 channel_ID, + gint32 parent_ID, + gint position); +GIMP_DEPRECATED_FOR(gimp_image_insert_channel) +G_GNUC_INTERNAL gboolean _gimp_image_insert_channel (gint32 image_ID, + gint32 channel_ID, + gint32 parent_ID, + gint position); +gboolean gimp_image_remove_channel (GimpImage *image, + gint32 channel_ID); +GIMP_DEPRECATED_FOR(gimp_image_remove_channel) +G_GNUC_INTERNAL gboolean _gimp_image_remove_channel (gint32 image_ID, + gint32 channel_ID); +gboolean gimp_image_freeze_channels (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_image_freeze_channels) +G_GNUC_INTERNAL gboolean _gimp_image_freeze_channels (gint32 image_ID); +gboolean gimp_image_thaw_channels (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_image_thaw_channels) +G_GNUC_INTERNAL gboolean _gimp_image_thaw_channels (gint32 image_ID); +gboolean gimp_image_insert_vectors (GimpImage *image, + gint32 vectors_ID, + gint32 parent_ID, + gint position); +GIMP_DEPRECATED_FOR(gimp_image_insert_vectors) +G_GNUC_INTERNAL gboolean _gimp_image_insert_vectors (gint32 image_ID, + gint32 vectors_ID, + gint32 parent_ID, + gint position); +gboolean gimp_image_remove_vectors (GimpImage *image, + gint32 vectors_ID); +GIMP_DEPRECATED_FOR(gimp_image_remove_vectors) +G_GNUC_INTERNAL gboolean _gimp_image_remove_vectors (gint32 image_ID, + gint32 vectors_ID); +gboolean gimp_image_freeze_vectors (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_image_freeze_vectors) +G_GNUC_INTERNAL gboolean _gimp_image_freeze_vectors (gint32 image_ID); +gboolean gimp_image_thaw_vectors (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_image_thaw_vectors) +G_GNUC_INTERNAL gboolean _gimp_image_thaw_vectors (gint32 image_ID); +gint gimp_image_get_item_position (GimpImage *image, + gint32 item_ID); +GIMP_DEPRECATED_FOR(gimp_image_get_item_position) +G_GNUC_INTERNAL gint _gimp_image_get_item_position (gint32 image_ID, + gint32 item_ID); +gboolean gimp_image_raise_item (GimpImage *image, + gint32 item_ID); +GIMP_DEPRECATED_FOR(gimp_image_raise_item) +G_GNUC_INTERNAL gboolean _gimp_image_raise_item (gint32 image_ID, + gint32 item_ID); +gboolean gimp_image_lower_item (GimpImage *image, + gint32 item_ID); +GIMP_DEPRECATED_FOR(gimp_image_lower_item) +G_GNUC_INTERNAL gboolean _gimp_image_lower_item (gint32 image_ID, + gint32 item_ID); +gboolean gimp_image_raise_item_to_top (GimpImage *image, + gint32 item_ID); +GIMP_DEPRECATED_FOR(gimp_image_raise_item_to_top) +G_GNUC_INTERNAL gboolean _gimp_image_raise_item_to_top (gint32 image_ID, + gint32 item_ID); +gboolean gimp_image_lower_item_to_bottom (GimpImage *image, + gint32 item_ID); +GIMP_DEPRECATED_FOR(gimp_image_lower_item_to_bottom) +G_GNUC_INTERNAL gboolean _gimp_image_lower_item_to_bottom (gint32 image_ID, + gint32 item_ID); +gboolean gimp_image_reorder_item (GimpImage *image, + gint32 item_ID, + gint32 parent_ID, + gint position); +GIMP_DEPRECATED_FOR(gimp_image_reorder_item) +G_GNUC_INTERNAL gboolean _gimp_image_reorder_item (gint32 image_ID, + gint32 item_ID, + gint32 parent_ID, + gint position); +gint32 gimp_image_flatten (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_image_flatten) +G_GNUC_INTERNAL gint32 _gimp_image_flatten (gint32 image_ID); +gint32 gimp_image_merge_visible_layers (GimpImage *image, + GimpMergeType merge_type); +GIMP_DEPRECATED_FOR(gimp_image_merge_visible_layers) +G_GNUC_INTERNAL gint32 _gimp_image_merge_visible_layers (gint32 image_ID, + GimpMergeType merge_type); +gint32 gimp_image_merge_down (GimpImage *image, + gint32 merge_layer_ID, + GimpMergeType merge_type); +GIMP_DEPRECATED_FOR(gimp_image_merge_down) +G_GNUC_INTERNAL gint32 _gimp_image_merge_down (gint32 image_ID, + gint32 merge_layer_ID, + GimpMergeType merge_type); +G_GNUC_INTERNAL guint8* _gimp_image_get_colormap (GimpImage *image, + gint *num_bytes); +GIMP_DEPRECATED_FOR(_gimp_image_get_colormap) +G_GNUC_INTERNAL guint8* __gimp_image_get_colormap (gint32 image_ID, + gint *num_bytes); +G_GNUC_INTERNAL gboolean _gimp_image_set_colormap (GimpImage *image, + gint num_bytes, + const guint8 *colormap); +GIMP_DEPRECATED_FOR(_gimp_image_set_colormap) +G_GNUC_INTERNAL gboolean __gimp_image_set_colormap (gint32 image_ID, + gint num_bytes, + const guint8 *colormap); +G_GNUC_INTERNAL gchar* _gimp_image_get_metadata (GimpImage *image); +GIMP_DEPRECATED_FOR(_gimp_image_get_metadata) +G_GNUC_INTERNAL gchar* __gimp_image_get_metadata (gint32 image_ID); +G_GNUC_INTERNAL gboolean _gimp_image_set_metadata (GimpImage *image, + const gchar *metadata_string); +GIMP_DEPRECATED_FOR(_gimp_image_set_metadata) +G_GNUC_INTERNAL gboolean __gimp_image_set_metadata (gint32 image_ID, + const gchar *metadata_string); +gboolean gimp_image_clean_all (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_image_clean_all) +G_GNUC_INTERNAL gboolean _gimp_image_clean_all (gint32 image_ID); +gboolean gimp_image_is_dirty (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_image_is_dirty) +G_GNUC_INTERNAL gboolean _gimp_image_is_dirty (gint32 image_ID); +G_GNUC_INTERNAL 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); +GIMP_DEPRECATED_FOR(_gimp_image_thumbnail) +G_GNUC_INTERNAL gboolean __gimp_image_thumbnail (gint32 image_ID, + gint width, + gint height, + gint *actual_width, + gint *actual_height, + gint *bpp, + gint *thumbnail_data_count, + guint8 **thumbnail_data); +gint32 gimp_image_get_active_layer (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_image_get_active_layer) +G_GNUC_INTERNAL gint32 _gimp_image_get_active_layer (gint32 image_ID); +gboolean gimp_image_set_active_layer (GimpImage *image, + gint32 active_layer_ID); +GIMP_DEPRECATED_FOR(gimp_image_set_active_layer) +G_GNUC_INTERNAL gboolean _gimp_image_set_active_layer (gint32 image_ID, + gint32 active_layer_ID); +gint32 gimp_image_get_active_channel (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_image_get_active_channel) +G_GNUC_INTERNAL gint32 _gimp_image_get_active_channel (gint32 image_ID); +gboolean gimp_image_set_active_channel (GimpImage *image, + gint32 active_channel_ID); +GIMP_DEPRECATED_FOR(gimp_image_set_active_channel) +G_GNUC_INTERNAL gboolean _gimp_image_set_active_channel (gint32 image_ID, + gint32 active_channel_ID); +gint32 gimp_image_get_active_vectors (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_image_get_active_vectors) +G_GNUC_INTERNAL gint32 _gimp_image_get_active_vectors (gint32 image_ID); +gboolean gimp_image_set_active_vectors (GimpImage *image, + gint32 active_vectors_ID); +GIMP_DEPRECATED_FOR(gimp_image_set_active_vectors) +G_GNUC_INTERNAL gboolean _gimp_image_set_active_vectors (gint32 image_ID, + gint32 active_vectors_ID); +gint32 gimp_image_get_selection (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_image_get_selection) +G_GNUC_INTERNAL gint32 _gimp_image_get_selection (gint32 image_ID); +gboolean gimp_image_get_component_active (GimpImage *image, + GimpChannelType component); +GIMP_DEPRECATED_FOR(gimp_image_get_component_active) +G_GNUC_INTERNAL gboolean _gimp_image_get_component_active (gint32 image_ID, + GimpChannelType component); +gboolean gimp_image_set_component_active (GimpImage *image, + GimpChannelType component, + gboolean active); +GIMP_DEPRECATED_FOR(gimp_image_set_component_active) +G_GNUC_INTERNAL gboolean _gimp_image_set_component_active (gint32 image_ID, + GimpChannelType component, + gboolean active); +gboolean gimp_image_get_component_visible (GimpImage *image, + GimpChannelType component); +GIMP_DEPRECATED_FOR(gimp_image_get_component_visible) +G_GNUC_INTERNAL gboolean _gimp_image_get_component_visible (gint32 image_ID, + GimpChannelType component); +gboolean gimp_image_set_component_visible (GimpImage *image, + GimpChannelType component, + gboolean visible); +GIMP_DEPRECATED_FOR(gimp_image_set_component_visible) +G_GNUC_INTERNAL gboolean _gimp_image_set_component_visible (gint32 image_ID, + GimpChannelType component, + gboolean visible); +gchar* gimp_image_get_filename (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_image_get_filename) +G_GNUC_INTERNAL gchar* _gimp_image_get_filename (gint32 image_ID); +gboolean gimp_image_set_filename (GimpImage *image, + const gchar *filename); +GIMP_DEPRECATED_FOR(gimp_image_set_filename) +G_GNUC_INTERNAL gboolean _gimp_image_set_filename (gint32 image_ID, + const gchar *filename); +gchar* gimp_image_get_uri (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_image_get_uri) +G_GNUC_INTERNAL gchar* _gimp_image_get_uri (gint32 image_ID); +gchar* gimp_image_get_xcf_uri (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_image_get_xcf_uri) +G_GNUC_INTERNAL gchar* _gimp_image_get_xcf_uri (gint32 image_ID); +gchar* gimp_image_get_imported_uri (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_image_get_imported_uri) +G_GNUC_INTERNAL gchar* _gimp_image_get_imported_uri (gint32 image_ID); +gchar* gimp_image_get_exported_uri (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_image_get_exported_uri) +G_GNUC_INTERNAL gchar* _gimp_image_get_exported_uri (gint32 image_ID); +gchar* gimp_image_get_name (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_image_get_name) +G_GNUC_INTERNAL gchar* _gimp_image_get_name (gint32 image_ID); +gboolean gimp_image_get_resolution (GimpImage *image, + gdouble *xresolution, + gdouble *yresolution); +GIMP_DEPRECATED_FOR(gimp_image_get_resolution) +G_GNUC_INTERNAL gboolean _gimp_image_get_resolution (gint32 image_ID, + gdouble *xresolution, + gdouble *yresolution); +gboolean gimp_image_set_resolution (GimpImage *image, + gdouble xresolution, + gdouble yresolution); +GIMP_DEPRECATED_FOR(gimp_image_set_resolution) +G_GNUC_INTERNAL gboolean _gimp_image_set_resolution (gint32 image_ID, + gdouble xresolution, + gdouble yresolution); +GimpUnit gimp_image_get_unit (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_image_get_unit) +G_GNUC_INTERNAL GimpUnit _gimp_image_get_unit (gint32 image_ID); +gboolean gimp_image_set_unit (GimpImage *image, + GimpUnit unit); +GIMP_DEPRECATED_FOR(gimp_image_set_unit) +G_GNUC_INTERNAL gboolean _gimp_image_set_unit (gint32 image_ID, + GimpUnit unit); +guint gimp_image_get_tattoo_state (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_image_get_tattoo_state) +G_GNUC_INTERNAL guint _gimp_image_get_tattoo_state (gint32 image_ID); +gboolean gimp_image_set_tattoo_state (GimpImage *image, + guint tattoo_state); +GIMP_DEPRECATED_FOR(gimp_image_set_tattoo_state) +G_GNUC_INTERNAL gboolean _gimp_image_set_tattoo_state (gint32 image_ID, + guint tattoo_state); +gint32 gimp_image_get_layer_by_tattoo (GimpImage *image, + guint tattoo); +GIMP_DEPRECATED_FOR(gimp_image_get_layer_by_tattoo) +G_GNUC_INTERNAL gint32 _gimp_image_get_layer_by_tattoo (gint32 image_ID, + guint tattoo); +gint32 gimp_image_get_channel_by_tattoo (GimpImage *image, + guint tattoo); +GIMP_DEPRECATED_FOR(gimp_image_get_channel_by_tattoo) +G_GNUC_INTERNAL gint32 _gimp_image_get_channel_by_tattoo (gint32 image_ID, + guint tattoo); +gint32 gimp_image_get_vectors_by_tattoo (GimpImage *image, + guint tattoo); +GIMP_DEPRECATED_FOR(gimp_image_get_vectors_by_tattoo) +G_GNUC_INTERNAL gint32 _gimp_image_get_vectors_by_tattoo (gint32 image_ID, + guint tattoo); +gint32 gimp_image_get_layer_by_name (GimpImage *image, + const gchar *name); +GIMP_DEPRECATED_FOR(gimp_image_get_layer_by_name) +G_GNUC_INTERNAL gint32 _gimp_image_get_layer_by_name (gint32 image_ID, + const gchar *name); +gint32 gimp_image_get_channel_by_name (GimpImage *image, + const gchar *name); +GIMP_DEPRECATED_FOR(gimp_image_get_channel_by_name) +G_GNUC_INTERNAL gint32 _gimp_image_get_channel_by_name (gint32 image_ID, + const gchar *name); +gint32 gimp_image_get_vectors_by_name (GimpImage *image, + const gchar *name); +GIMP_DEPRECATED_FOR(gimp_image_get_vectors_by_name) +G_GNUC_INTERNAL gint32 _gimp_image_get_vectors_by_name (gint32 image_ID, + const gchar *name); +gboolean gimp_image_attach_parasite (GimpImage *image, + const GimpParasite *parasite); +GIMP_DEPRECATED_FOR(gimp_image_attach_parasite) +G_GNUC_INTERNAL gboolean _gimp_image_attach_parasite (gint32 image_ID, + const GimpParasite *parasite); +gboolean gimp_image_detach_parasite (GimpImage *image, + const gchar *name); +GIMP_DEPRECATED_FOR(gimp_image_detach_parasite) +G_GNUC_INTERNAL gboolean _gimp_image_detach_parasite (gint32 image_ID, + const gchar *name); +GimpParasite* gimp_image_get_parasite (GimpImage *image, + const gchar *name); +GIMP_DEPRECATED_FOR(gimp_image_get_parasite) +G_GNUC_INTERNAL GimpParasite* _gimp_image_get_parasite (gint32 image_ID, + const gchar *name); +gchar** gimp_image_get_parasite_list (GimpImage *image, + gint *num_parasites); +GIMP_DEPRECATED_FOR(gimp_image_get_parasite_list) +G_GNUC_INTERNAL gchar** _gimp_image_get_parasite_list (gint32 image_ID, + gint *num_parasites); G_END_DECLS diff --git a/libgimp/gimpimagecolorprofile_pdb.c b/libgimp/gimpimagecolorprofile_pdb.c index 170972c7ba..921cac6cc2 100644 --- a/libgimp/gimpimagecolorprofile_pdb.c +++ b/libgimp/gimpimagecolorprofile_pdb.c @@ -85,6 +85,56 @@ _gimp_image_get_color_profile (GimpImage *image, return profile_data; } +/** + * __gimp_image_get_color_profile: (skip) + * @image_ID: The image. + * @num_bytes: (out): Number of bytes in the color_profile array. + * + * Returns the image's color profile + * + * This procedure returns the image's color profile, or NULL if the + * image has no color profile assigned. + * + * Returns: (array length=num_bytes): The image's serialized color profile. + * The returned value must be freed with g_free(). + * + * Since: 2.10 + **/ +guint8 * +__gimp_image_get_color_profile (gint32 image_ID, + gint *num_bytes) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + guint8 *profile_data = NULL; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-get-color-profile", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-get-color-profile", + args); + gimp_value_array_unref (args); + + *num_bytes = 0; + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + { + *num_bytes = g_value_get_int (gimp_value_array_index (return_vals, 1)); + profile_data = gimp_value_dup_uint8_array (gimp_value_array_index (return_vals, 2)); + } + + gimp_value_array_unref (return_vals); + + return profile_data; +} + /** * _gimp_image_get_effective_color_profile: * @image: The image. @@ -139,6 +189,59 @@ _gimp_image_get_effective_color_profile (GimpImage *image, return profile_data; } +/** + * __gimp_image_get_effective_color_profile: (skip) + * @image_ID: The image. + * @num_bytes: (out): Number of bytes in the color_profile array. + * + * Returns the color profile that is used for the image + * + * This procedure returns the color profile that is actually used for + * this image, which is the profile returned by + * gimp_image_get_color_profile() if the image has a profile assigned, + * or a generated default RGB or grayscale profile, according to the + * image's type. + * + * Returns: (array length=num_bytes): The image's serialized color profile. + * The returned value must be freed with g_free(). + * + * Since: 2.10 + **/ +guint8 * +__gimp_image_get_effective_color_profile (gint32 image_ID, + gint *num_bytes) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + guint8 *profile_data = NULL; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-get-effective-color-profile", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-get-effective-color-profile", + args); + gimp_value_array_unref (args); + + *num_bytes = 0; + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + { + *num_bytes = g_value_get_int (gimp_value_array_index (return_vals, 1)); + profile_data = gimp_value_dup_uint8_array (gimp_value_array_index (return_vals, 2)); + } + + gimp_value_array_unref (return_vals); + + return profile_data; +} + /** * _gimp_image_set_color_profile: * @image: The image. @@ -190,6 +293,57 @@ _gimp_image_set_color_profile (GimpImage *image, return success; } +/** + * __gimp_image_set_color_profile: (skip) + * @image_ID: The image. + * @num_bytes: Number of bytes in the color_profile array. + * @color_profile: (array length=num_bytes) (element-type guint8): The new serialized color profile. + * + * Sets the image's color profile + * + * This procedure sets the image's color profile, or unsets it if NULL + * is passed as 'color_profile'. This procedure does no color + * conversion. However, it will change the pixel format of all layers + * to contain the babl space matching the profile. You must call this + * procedure before adding layers to the image. + * + * Returns: TRUE on success. + * + * Since: 2.10 + **/ +gboolean +__gimp_image_set_color_profile (gint32 image_ID, + gint num_bytes, + const guint8 *color_profile) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_INT, num_bytes, + GIMP_TYPE_UINT8_ARRAY, NULL, + G_TYPE_NONE); + gimp_value_set_uint8_array (gimp_value_array_index (args, 2), color_profile, num_bytes); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-set-color-profile", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-set-color-profile", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_set_color_profile_from_file: * @image: The image. @@ -238,6 +392,54 @@ gimp_image_set_color_profile_from_file (GimpImage *image, return success; } +/** + * _gimp_image_set_color_profile_from_file: (skip) + * @image_ID: The image. + * @uri: The URI of the file containing the new color profile. + * + * Sets the image's color profile from an ICC file + * + * This procedure sets the image's color profile from a file containing + * an ICC profile, or unsets it if NULL is passed as 'uri'. This + * procedure does no color conversion. However, it will change the + * pixel format of all layers to contain the babl space matching the + * profile. You must call this procedure before adding layers to the + * image. + * + * Returns: TRUE on success. + * + * Since: 2.10 + **/ +gboolean +_gimp_image_set_color_profile_from_file (gint32 image_ID, + const gchar *uri) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_STRING, uri, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-set-color-profile-from-file", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-set-color-profile-from-file", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * _gimp_image_convert_color_profile: * @image: The image. @@ -294,6 +496,62 @@ _gimp_image_convert_color_profile (GimpImage *image, return success; } +/** + * __gimp_image_convert_color_profile: (skip) + * @image_ID: The image. + * @num_bytes: Number of bytes in the color_profile array. + * @color_profile: (array length=num_bytes) (element-type guint8): The serialized color profile. + * @intent: Rendering intent. + * @bpc: Black point compensation. + * + * Convert the image's layers to a color profile + * + * This procedure converts from the image's color profile (or the + * default RGB or grayscale profile if none is set) to the given color + * profile. Only RGB and grayscale color profiles are accepted, + * according to the image's type. + * + * Returns: TRUE on success. + * + * Since: 2.10 + **/ +gboolean +__gimp_image_convert_color_profile (gint32 image_ID, + gint num_bytes, + const guint8 *color_profile, + GimpColorRenderingIntent intent, + gboolean bpc) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_INT, num_bytes, + GIMP_TYPE_UINT8_ARRAY, NULL, + GIMP_TYPE_COLOR_RENDERING_INTENT, intent, + G_TYPE_BOOLEAN, bpc, + G_TYPE_NONE); + gimp_value_set_uint8_array (gimp_value_array_index (args, 2), color_profile, num_bytes); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-convert-color-profile", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-convert-color-profile", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_convert_color_profile_from_file: * @image: The image. @@ -345,3 +603,55 @@ gimp_image_convert_color_profile_from_file (GimpImage *image, return success; } + +/** + * _gimp_image_convert_color_profile_from_file: (skip) + * @image_ID: The image. + * @uri: The URI of the file containing the new color profile. + * @intent: Rendering intent. + * @bpc: Black point compensation. + * + * Convert the image's layers to a color profile + * + * This procedure converts from the image's color profile (or the + * default RGB or grayscale profile if none is set) to an ICC profile + * specified by 'uri'. Only RGB and grayscale color profiles are + * accepted, according to the image's type. + * + * Returns: TRUE on success. + * + * Since: 2.10 + **/ +gboolean +_gimp_image_convert_color_profile_from_file (gint32 image_ID, + const gchar *uri, + GimpColorRenderingIntent intent, + gboolean bpc) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_STRING, uri, + GIMP_TYPE_COLOR_RENDERING_INTENT, intent, + G_TYPE_BOOLEAN, bpc, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-convert-color-profile-from-file", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-convert-color-profile-from-file", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} diff --git a/libgimp/gimpimagecolorprofile_pdb.h b/libgimp/gimpimagecolorprofile_pdb.h index 454a837bfe..ded795b2e4 100644 --- a/libgimp/gimpimagecolorprofile_pdb.h +++ b/libgimp/gimpimagecolorprofile_pdb.h @@ -32,24 +32,48 @@ G_BEGIN_DECLS /* For information look into the C source or the html documentation */ -G_GNUC_INTERNAL guint8* _gimp_image_get_color_profile (GimpImage *image, - gint *num_bytes); -G_GNUC_INTERNAL guint8* _gimp_image_get_effective_color_profile (GimpImage *image, - gint *num_bytes); -G_GNUC_INTERNAL gboolean _gimp_image_set_color_profile (GimpImage *image, - gint num_bytes, - const guint8 *color_profile); -gboolean gimp_image_set_color_profile_from_file (GimpImage *image, - const gchar *uri); -G_GNUC_INTERNAL gboolean _gimp_image_convert_color_profile (GimpImage *image, - gint num_bytes, - const guint8 *color_profile, - GimpColorRenderingIntent intent, - gboolean bpc); -gboolean gimp_image_convert_color_profile_from_file (GimpImage *image, - const gchar *uri, - GimpColorRenderingIntent intent, - gboolean bpc); +G_GNUC_INTERNAL guint8* _gimp_image_get_color_profile (GimpImage *image, + gint *num_bytes); +GIMP_DEPRECATED_FOR(_gimp_image_get_color_profile) +G_GNUC_INTERNAL guint8* __gimp_image_get_color_profile (gint32 image_ID, + gint *num_bytes); +G_GNUC_INTERNAL guint8* _gimp_image_get_effective_color_profile (GimpImage *image, + gint *num_bytes); +GIMP_DEPRECATED_FOR(_gimp_image_get_effective_color_profile) +G_GNUC_INTERNAL guint8* __gimp_image_get_effective_color_profile (gint32 image_ID, + gint *num_bytes); +G_GNUC_INTERNAL gboolean _gimp_image_set_color_profile (GimpImage *image, + gint num_bytes, + const guint8 *color_profile); +GIMP_DEPRECATED_FOR(_gimp_image_set_color_profile) +G_GNUC_INTERNAL gboolean __gimp_image_set_color_profile (gint32 image_ID, + gint num_bytes, + const guint8 *color_profile); +gboolean gimp_image_set_color_profile_from_file (GimpImage *image, + const gchar *uri); +GIMP_DEPRECATED_FOR(gimp_image_set_color_profile_from_file) +G_GNUC_INTERNAL gboolean _gimp_image_set_color_profile_from_file (gint32 image_ID, + const gchar *uri); +G_GNUC_INTERNAL gboolean _gimp_image_convert_color_profile (GimpImage *image, + gint num_bytes, + const guint8 *color_profile, + GimpColorRenderingIntent intent, + gboolean bpc); +GIMP_DEPRECATED_FOR(_gimp_image_convert_color_profile) +G_GNUC_INTERNAL gboolean __gimp_image_convert_color_profile (gint32 image_ID, + gint num_bytes, + const guint8 *color_profile, + GimpColorRenderingIntent intent, + gboolean bpc); +gboolean gimp_image_convert_color_profile_from_file (GimpImage *image, + const gchar *uri, + GimpColorRenderingIntent intent, + gboolean bpc); +GIMP_DEPRECATED_FOR(gimp_image_convert_color_profile_from_file) +G_GNUC_INTERNAL gboolean _gimp_image_convert_color_profile_from_file (gint32 image_ID, + const gchar *uri, + GimpColorRenderingIntent intent, + gboolean bpc); G_END_DECLS diff --git a/libgimp/gimpimageconvert_pdb.c b/libgimp/gimpimageconvert_pdb.c index 2033e89c22..ed49b3ec9d 100644 --- a/libgimp/gimpimageconvert_pdb.c +++ b/libgimp/gimpimageconvert_pdb.c @@ -75,6 +75,47 @@ gimp_image_convert_rgb (GimpImage *image) return success; } +/** + * _gimp_image_convert_rgb: (skip) + * @image_ID: The image. + * + * Convert specified image to RGB color + * + * This procedure converts the specified image to RGB color. This + * process requires an image in Grayscale or Indexed color mode. No + * image content is lost in this process aside from the colormap for an + * indexed image. + * + * Returns: TRUE on success. + **/ +gboolean +_gimp_image_convert_rgb (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-convert-rgb", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-convert-rgb", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_convert_grayscale: * @image: The image. @@ -114,6 +155,45 @@ gimp_image_convert_grayscale (GimpImage *image) return success; } +/** + * _gimp_image_convert_grayscale: (skip) + * @image_ID: The image. + * + * Convert specified image to grayscale + * + * This procedure converts the specified image to grayscale. This + * process requires an image in RGB or Indexed color mode. + * + * Returns: TRUE on success. + **/ +gboolean +_gimp_image_convert_grayscale (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-convert-grayscale", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-convert-grayscale", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_convert_indexed: * @image: The image. @@ -182,6 +262,74 @@ gimp_image_convert_indexed (GimpImage *image, return success; } +/** + * _gimp_image_convert_indexed: (skip) + * @image_ID: The image. + * @dither_type: The dither type to use. + * @palette_type: The type of palette to use. + * @num_cols: The number of colors to quantize to, ignored unless (palette_type == GIMP_CONVERT_PALETTE_GENERATE). + * @alpha_dither: Dither transparency to fake partial opacity. + * @remove_unused: Remove unused or duplicate color entries from final palette, ignored if (palette_type == GIMP_CONVERT_PALETTE_GENERATE). + * @palette: The name of the custom palette to use, ignored unless (palette_type == GIMP_CONVERT_PALETTE_CUSTOM). + * + * Convert specified image to and Indexed image + * + * This procedure converts the specified image to 'indexed' color. This + * process requires an image in RGB or Grayscale mode. The + * 'palette_type' specifies what kind of palette to use, A type of '0' + * means to use an optimal palette of 'num_cols' generated from the + * colors in the image. A type of '1' means to re-use the previous + * palette (not currently implemented). A type of '2' means to use the + * so-called WWW-optimized palette. Type '3' means to use only black + * and white colors. A type of '4' means to use a palette from the gimp + * palettes directories. The 'dither type' specifies what kind of + * dithering to use. '0' means no dithering, '1' means standard + * Floyd-Steinberg error diffusion, '2' means Floyd-Steinberg error + * diffusion with reduced bleeding, '3' means dithering based on pixel + * location ('Fixed' dithering). + * + * Returns: TRUE on success. + **/ +gboolean +_gimp_image_convert_indexed (gint32 image_ID, + GimpConvertDitherType dither_type, + GimpConvertPaletteType palette_type, + gint num_cols, + gboolean alpha_dither, + gboolean remove_unused, + const gchar *palette) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + GIMP_TYPE_CONVERT_DITHER_TYPE, dither_type, + GIMP_TYPE_CONVERT_PALETTE_TYPE, palette_type, + G_TYPE_INT, num_cols, + G_TYPE_BOOLEAN, alpha_dither, + G_TYPE_BOOLEAN, remove_unused, + G_TYPE_STRING, palette, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-convert-indexed", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-convert-indexed", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_convert_set_dither_matrix: * @width: Width of the matrix (0 to reset to default matrix). @@ -277,3 +425,48 @@ gimp_image_convert_precision (GimpImage *image, return success; } + +/** + * _gimp_image_convert_precision: (skip) + * @image_ID: The image. + * @precision: The new precision. + * + * Convert the image to the specified precision + * + * This procedure converts the image to the specified precision. Note + * that indexed images cannot be converted and are always in + * GIMP_PRECISION_U8. + * + * Returns: TRUE on success. + * + * Since: 2.10 + **/ +gboolean +_gimp_image_convert_precision (gint32 image_ID, + GimpPrecision precision) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + GIMP_TYPE_PRECISION, precision, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-convert-precision", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-convert-precision", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} diff --git a/libgimp/gimpimageconvert_pdb.h b/libgimp/gimpimageconvert_pdb.h index fe4cfaf973..a319d6470d 100644 --- a/libgimp/gimpimageconvert_pdb.h +++ b/libgimp/gimpimageconvert_pdb.h @@ -32,21 +32,36 @@ G_BEGIN_DECLS /* For information look into the C source or the html documentation */ -gboolean gimp_image_convert_rgb (GimpImage *image); -gboolean gimp_image_convert_grayscale (GimpImage *image); -gboolean gimp_image_convert_indexed (GimpImage *image, - GimpConvertDitherType dither_type, - GimpConvertPaletteType palette_type, - gint num_cols, - gboolean alpha_dither, - gboolean remove_unused, - const gchar *palette); -gboolean gimp_image_convert_set_dither_matrix (gint width, - gint height, - gint matrix_length, - const guint8 *matrix); -gboolean gimp_image_convert_precision (GimpImage *image, - GimpPrecision precision); +gboolean gimp_image_convert_rgb (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_image_convert_rgb) +G_GNUC_INTERNAL gboolean _gimp_image_convert_rgb (gint32 image_ID); +gboolean gimp_image_convert_grayscale (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_image_convert_grayscale) +G_GNUC_INTERNAL gboolean _gimp_image_convert_grayscale (gint32 image_ID); +gboolean gimp_image_convert_indexed (GimpImage *image, + GimpConvertDitherType dither_type, + GimpConvertPaletteType palette_type, + gint num_cols, + gboolean alpha_dither, + gboolean remove_unused, + const gchar *palette); +GIMP_DEPRECATED_FOR(gimp_image_convert_indexed) +G_GNUC_INTERNAL gboolean _gimp_image_convert_indexed (gint32 image_ID, + GimpConvertDitherType dither_type, + GimpConvertPaletteType palette_type, + gint num_cols, + gboolean alpha_dither, + gboolean remove_unused, + const gchar *palette); +gboolean gimp_image_convert_set_dither_matrix (gint width, + gint height, + gint matrix_length, + const guint8 *matrix); +gboolean gimp_image_convert_precision (GimpImage *image, + GimpPrecision precision); +GIMP_DEPRECATED_FOR(gimp_image_convert_precision) +G_GNUC_INTERNAL gboolean _gimp_image_convert_precision (gint32 image_ID, + GimpPrecision precision); G_END_DECLS diff --git a/libgimp/gimpimagegrid_pdb.c b/libgimp/gimpimagegrid_pdb.c index e64ffa672c..78d45f333c 100644 --- a/libgimp/gimpimagegrid_pdb.c +++ b/libgimp/gimpimagegrid_pdb.c @@ -88,6 +88,60 @@ gimp_image_grid_get_spacing (GimpImage *image, return success; } +/** + * _gimp_image_grid_get_spacing: (skip) + * @image_ID: The image. + * @xspacing: (out): The image's grid horizontal spacing. + * @yspacing: (out): The image's grid vertical spacing. + * + * Gets the spacing of an image's grid. + * + * This procedure retrieves the horizontal and vertical spacing of an + * image's grid. It takes the image as parameter. + * + * Returns: TRUE on success. + * + * Since: 2.4 + **/ +gboolean +_gimp_image_grid_get_spacing (gint32 image_ID, + gdouble *xspacing, + gdouble *yspacing) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-grid-get-spacing", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-grid-get-spacing", + args); + gimp_value_array_unref (args); + + *xspacing = 0.0; + *yspacing = 0.0; + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + if (success) + { + *xspacing = g_value_get_double (gimp_value_array_index (return_vals, 1)); + *yspacing = g_value_get_double (gimp_value_array_index (return_vals, 2)); + } + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_grid_set_spacing: * @image: The image. @@ -135,6 +189,53 @@ gimp_image_grid_set_spacing (GimpImage *image, return success; } +/** + * _gimp_image_grid_set_spacing: (skip) + * @image_ID: The image. + * @xspacing: The image's grid horizontal spacing. + * @yspacing: The image's grid vertical spacing. + * + * Sets the spacing of an image's grid. + * + * This procedure sets the horizontal and vertical spacing of an + * image's grid. + * + * Returns: TRUE on success. + * + * Since: 2.4 + **/ +gboolean +_gimp_image_grid_set_spacing (gint32 image_ID, + gdouble xspacing, + gdouble yspacing) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_DOUBLE, xspacing, + G_TYPE_DOUBLE, yspacing, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-grid-set-spacing", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-grid-set-spacing", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_grid_get_offset: * @image: The image. @@ -189,6 +290,60 @@ gimp_image_grid_get_offset (GimpImage *image, return success; } +/** + * _gimp_image_grid_get_offset: (skip) + * @image_ID: The image. + * @xoffset: (out): The image's grid horizontal offset. + * @yoffset: (out): The image's grid vertical offset. + * + * Gets the offset of an image's grid. + * + * This procedure retrieves the horizontal and vertical offset of an + * image's grid. It takes the image as parameter. + * + * Returns: TRUE on success. + * + * Since: 2.4 + **/ +gboolean +_gimp_image_grid_get_offset (gint32 image_ID, + gdouble *xoffset, + gdouble *yoffset) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-grid-get-offset", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-grid-get-offset", + args); + gimp_value_array_unref (args); + + *xoffset = 0.0; + *yoffset = 0.0; + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + if (success) + { + *xoffset = g_value_get_double (gimp_value_array_index (return_vals, 1)); + *yoffset = g_value_get_double (gimp_value_array_index (return_vals, 2)); + } + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_grid_set_offset: * @image: The image. @@ -236,6 +391,53 @@ gimp_image_grid_set_offset (GimpImage *image, return success; } +/** + * _gimp_image_grid_set_offset: (skip) + * @image_ID: The image. + * @xoffset: The image's grid horizontal offset. + * @yoffset: The image's grid vertical offset. + * + * Sets the offset of an image's grid. + * + * This procedure sets the horizontal and vertical offset of an image's + * grid. + * + * Returns: TRUE on success. + * + * Since: 2.4 + **/ +gboolean +_gimp_image_grid_set_offset (gint32 image_ID, + gdouble xoffset, + gdouble yoffset) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_DOUBLE, xoffset, + G_TYPE_DOUBLE, yoffset, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-grid-set-offset", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-grid-set-offset", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_grid_get_foreground_color: * @image: The image. @@ -281,6 +483,51 @@ gimp_image_grid_get_foreground_color (GimpImage *image, return success; } +/** + * _gimp_image_grid_get_foreground_color: (skip) + * @image_ID: The image. + * @fgcolor: (out caller-allocates): The image's grid foreground color. + * + * Sets the foreground color of an image's grid. + * + * This procedure gets the foreground color of an image's grid. + * + * Returns: TRUE on success. + * + * Since: 2.4 + **/ +gboolean +_gimp_image_grid_get_foreground_color (gint32 image_ID, + GimpRGB *fgcolor) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-grid-get-foreground-color", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-grid-get-foreground-color", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + if (success) + gimp_value_get_rgb (gimp_value_array_index (return_vals, 1), &*fgcolor); + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_grid_set_foreground_color: * @image: The image. @@ -324,6 +571,49 @@ gimp_image_grid_set_foreground_color (GimpImage *image, return success; } +/** + * _gimp_image_grid_set_foreground_color: (skip) + * @image_ID: The image. + * @fgcolor: The new foreground color. + * + * Gets the foreground color of an image's grid. + * + * This procedure sets the foreground color of an image's grid. + * + * Returns: TRUE on success. + * + * Since: 2.4 + **/ +gboolean +_gimp_image_grid_set_foreground_color (gint32 image_ID, + const GimpRGB *fgcolor) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + GIMP_TYPE_RGB, fgcolor, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-grid-set-foreground-color", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-grid-set-foreground-color", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_grid_get_background_color: * @image: The image. @@ -369,6 +659,51 @@ gimp_image_grid_get_background_color (GimpImage *image, return success; } +/** + * _gimp_image_grid_get_background_color: (skip) + * @image_ID: The image. + * @bgcolor: (out caller-allocates): The image's grid background color. + * + * Sets the background color of an image's grid. + * + * This procedure gets the background color of an image's grid. + * + * Returns: TRUE on success. + * + * Since: 2.4 + **/ +gboolean +_gimp_image_grid_get_background_color (gint32 image_ID, + GimpRGB *bgcolor) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-grid-get-background-color", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-grid-get-background-color", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + if (success) + gimp_value_get_rgb (gimp_value_array_index (return_vals, 1), &*bgcolor); + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_grid_set_background_color: * @image: The image. @@ -412,6 +747,49 @@ gimp_image_grid_set_background_color (GimpImage *image, return success; } +/** + * _gimp_image_grid_set_background_color: (skip) + * @image_ID: The image. + * @bgcolor: The new background color. + * + * Gets the background color of an image's grid. + * + * This procedure sets the background color of an image's grid. + * + * Returns: TRUE on success. + * + * Since: 2.4 + **/ +gboolean +_gimp_image_grid_set_background_color (gint32 image_ID, + const GimpRGB *bgcolor) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + GIMP_TYPE_RGB, bgcolor, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-grid-set-background-color", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-grid-set-background-color", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_grid_get_style: * @image: The image. @@ -453,6 +831,47 @@ gimp_image_grid_get_style (GimpImage *image) return style; } +/** + * _gimp_image_grid_get_style: (skip) + * @image_ID: The image. + * + * Gets the style of an image's grid. + * + * This procedure retrieves the style of an image's grid. + * + * Returns: The image's grid style. + * + * Since: 2.4 + **/ +GimpGridStyle +_gimp_image_grid_get_style (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + GimpGridStyle style = 0; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-grid-get-style", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-grid-get-style", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + style = g_value_get_enum (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return style; +} + /** * gimp_image_grid_set_style: * @image: The image. @@ -496,3 +915,47 @@ gimp_image_grid_set_style (GimpImage *image, return success; } + +/** + * _gimp_image_grid_set_style: (skip) + * @image_ID: The image. + * @style: The image's grid style. + * + * Sets the style unit of an image's grid. + * + * This procedure sets the style of an image's grid. It takes the image + * and the new style as parameters. + * + * Returns: TRUE on success. + * + * Since: 2.4 + **/ +gboolean +_gimp_image_grid_set_style (gint32 image_ID, + GimpGridStyle style) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + GIMP_TYPE_GRID_STYLE, style, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-grid-set-style", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-grid-set-style", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} diff --git a/libgimp/gimpimagegrid_pdb.h b/libgimp/gimpimagegrid_pdb.h index e256944329..204e37585c 100644 --- a/libgimp/gimpimagegrid_pdb.h +++ b/libgimp/gimpimagegrid_pdb.h @@ -32,29 +32,62 @@ G_BEGIN_DECLS /* For information look into the C source or the html documentation */ -gboolean gimp_image_grid_get_spacing (GimpImage *image, - gdouble *xspacing, - gdouble *yspacing); -gboolean gimp_image_grid_set_spacing (GimpImage *image, - gdouble xspacing, - gdouble yspacing); -gboolean gimp_image_grid_get_offset (GimpImage *image, - gdouble *xoffset, - gdouble *yoffset); -gboolean gimp_image_grid_set_offset (GimpImage *image, - gdouble xoffset, - gdouble yoffset); -gboolean gimp_image_grid_get_foreground_color (GimpImage *image, - GimpRGB *fgcolor); -gboolean gimp_image_grid_set_foreground_color (GimpImage *image, - const GimpRGB *fgcolor); -gboolean gimp_image_grid_get_background_color (GimpImage *image, - GimpRGB *bgcolor); -gboolean gimp_image_grid_set_background_color (GimpImage *image, - const GimpRGB *bgcolor); -GimpGridStyle gimp_image_grid_get_style (GimpImage *image); -gboolean gimp_image_grid_set_style (GimpImage *image, - GimpGridStyle style); +gboolean gimp_image_grid_get_spacing (GimpImage *image, + gdouble *xspacing, + gdouble *yspacing); +GIMP_DEPRECATED_FOR(gimp_image_grid_get_spacing) +G_GNUC_INTERNAL gboolean _gimp_image_grid_get_spacing (gint32 image_ID, + gdouble *xspacing, + gdouble *yspacing); +gboolean gimp_image_grid_set_spacing (GimpImage *image, + gdouble xspacing, + gdouble yspacing); +GIMP_DEPRECATED_FOR(gimp_image_grid_set_spacing) +G_GNUC_INTERNAL gboolean _gimp_image_grid_set_spacing (gint32 image_ID, + gdouble xspacing, + gdouble yspacing); +gboolean gimp_image_grid_get_offset (GimpImage *image, + gdouble *xoffset, + gdouble *yoffset); +GIMP_DEPRECATED_FOR(gimp_image_grid_get_offset) +G_GNUC_INTERNAL gboolean _gimp_image_grid_get_offset (gint32 image_ID, + gdouble *xoffset, + gdouble *yoffset); +gboolean gimp_image_grid_set_offset (GimpImage *image, + gdouble xoffset, + gdouble yoffset); +GIMP_DEPRECATED_FOR(gimp_image_grid_set_offset) +G_GNUC_INTERNAL gboolean _gimp_image_grid_set_offset (gint32 image_ID, + gdouble xoffset, + gdouble yoffset); +gboolean gimp_image_grid_get_foreground_color (GimpImage *image, + GimpRGB *fgcolor); +GIMP_DEPRECATED_FOR(gimp_image_grid_get_foreground_color) +G_GNUC_INTERNAL gboolean _gimp_image_grid_get_foreground_color (gint32 image_ID, + GimpRGB *fgcolor); +gboolean gimp_image_grid_set_foreground_color (GimpImage *image, + const GimpRGB *fgcolor); +GIMP_DEPRECATED_FOR(gimp_image_grid_set_foreground_color) +G_GNUC_INTERNAL gboolean _gimp_image_grid_set_foreground_color (gint32 image_ID, + const GimpRGB *fgcolor); +gboolean gimp_image_grid_get_background_color (GimpImage *image, + GimpRGB *bgcolor); +GIMP_DEPRECATED_FOR(gimp_image_grid_get_background_color) +G_GNUC_INTERNAL gboolean _gimp_image_grid_get_background_color (gint32 image_ID, + GimpRGB *bgcolor); +gboolean gimp_image_grid_set_background_color (GimpImage *image, + const GimpRGB *bgcolor); +GIMP_DEPRECATED_FOR(gimp_image_grid_set_background_color) +G_GNUC_INTERNAL gboolean _gimp_image_grid_set_background_color (gint32 image_ID, + const GimpRGB *bgcolor); +GimpGridStyle gimp_image_grid_get_style (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_image_grid_get_style) +G_GNUC_INTERNAL GimpGridStyle _gimp_image_grid_get_style (gint32 image_ID); +gboolean gimp_image_grid_set_style (GimpImage *image, + GimpGridStyle style); +GIMP_DEPRECATED_FOR(gimp_image_grid_set_style) +G_GNUC_INTERNAL gboolean _gimp_image_grid_set_style (gint32 image_ID, + GimpGridStyle style); G_END_DECLS diff --git a/libgimp/gimpimageguides_pdb.c b/libgimp/gimpimageguides_pdb.c index 43e6342f2b..84d027d58b 100644 --- a/libgimp/gimpimageguides_pdb.c +++ b/libgimp/gimpimageguides_pdb.c @@ -78,6 +78,50 @@ gimp_image_add_hguide (GimpImage *image, return guide_ID; } +/** + * _gimp_image_add_hguide: (skip) + * @image_ID: The image. + * @yposition: The guide's y-offset from top of image. + * + * Add a horizontal guide to an image. + * + * This procedure adds a horizontal guide to an image. It takes the + * input image and the y-position of the new guide as parameters. It + * returns the guide ID of the new guide. + * + * Returns: The new guide. + **/ +gint32 +_gimp_image_add_hguide (gint32 image_ID, + gint yposition) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint32 guide_ID = -1; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_INT, yposition, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-add-hguide", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-add-hguide", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + guide_ID = g_value_get_uint (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return guide_ID; +} + /** * gimp_image_add_vguide: * @image: The image. @@ -122,6 +166,50 @@ gimp_image_add_vguide (GimpImage *image, return guide_ID; } +/** + * _gimp_image_add_vguide: (skip) + * @image_ID: The image. + * @xposition: The guide's x-offset from left of image. + * + * Add a vertical guide to an image. + * + * This procedure adds a vertical guide to an image. It takes the input + * image and the x-position of the new guide as parameters. It returns + * the guide ID of the new guide. + * + * Returns: The new guide. + **/ +gint32 +_gimp_image_add_vguide (gint32 image_ID, + gint xposition) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint32 guide_ID = -1; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_INT, xposition, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-add-vguide", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-add-vguide", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + guide_ID = g_value_get_uint (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return guide_ID; +} + /** * gimp_image_delete_guide: * @image: The image. @@ -164,6 +252,48 @@ gimp_image_delete_guide (GimpImage *image, return success; } +/** + * _gimp_image_delete_guide: (skip) + * @image_ID: The image. + * @guide_ID: The ID of the guide to be removed. + * + * Deletes a guide from an image. + * + * This procedure takes an image and a guide ID as input and removes + * the specified guide from the specified image. + * + * Returns: TRUE on success. + **/ +gboolean +_gimp_image_delete_guide (gint32 image_ID, + gint32 guide_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_UINT, guide_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-delete-guide", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-delete-guide", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_find_next_guide: * @image: The image. @@ -210,6 +340,52 @@ gimp_image_find_next_guide (GimpImage *image, return next_guide_ID; } +/** + * _gimp_image_find_next_guide: (skip) + * @image_ID: The image. + * @guide_ID: The ID of the current guide (0 if first invocation). + * + * Find next guide on an image. + * + * This procedure takes an image and a guide ID as input and finds the + * guide ID of the successor of the given guide ID in the image's guide + * list. If the supplied guide ID is 0, the procedure will return the + * first Guide. The procedure will return 0 if given the final guide ID + * as an argument or the image has no guides. + * + * Returns: The next guide's ID. + **/ +gint32 +_gimp_image_find_next_guide (gint32 image_ID, + gint32 guide_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint32 next_guide_ID = -1; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_UINT, guide_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-find-next-guide", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-find-next-guide", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + next_guide_ID = g_value_get_uint (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return next_guide_ID; +} + /** * gimp_image_get_guide_orientation: * @image: The image. @@ -253,6 +429,49 @@ gimp_image_get_guide_orientation (GimpImage *image, return orientation; } +/** + * _gimp_image_get_guide_orientation: (skip) + * @image_ID: The image. + * @guide_ID: The guide. + * + * Get orientation of a guide on an image. + * + * This procedure takes an image and a guide ID as input and returns + * the orientations of the guide. + * + * Returns: The guide's orientation. + **/ +GimpOrientationType +_gimp_image_get_guide_orientation (gint32 image_ID, + gint32 guide_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + GimpOrientationType orientation = GIMP_ORIENTATION_UNKNOWN; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_UINT, guide_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-get-guide-orientation", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-get-guide-orientation", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + orientation = g_value_get_enum (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return orientation; +} + /** * gimp_image_get_guide_position: * @image: The image. @@ -295,3 +514,46 @@ gimp_image_get_guide_position (GimpImage *image, return position; } + +/** + * _gimp_image_get_guide_position: (skip) + * @image_ID: The image. + * @guide_ID: The guide. + * + * Get position of a guide on an image. + * + * This procedure takes an image and a guide ID as input and returns + * the position of the guide relative to the top or left of the image. + * + * Returns: The guide's position relative to top or left of image. + **/ +gint +_gimp_image_get_guide_position (gint32 image_ID, + gint32 guide_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint position = G_MININT /* GIMP_GUIDE_POSITION_UNDEFINED */; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_UINT, guide_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-get-guide-position", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-get-guide-position", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + position = g_value_get_int (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return position; +} diff --git a/libgimp/gimpimageguides_pdb.h b/libgimp/gimpimageguides_pdb.h index 6e69c4fdec..c510c8c046 100644 --- a/libgimp/gimpimageguides_pdb.h +++ b/libgimp/gimpimageguides_pdb.h @@ -32,18 +32,36 @@ G_BEGIN_DECLS /* For information look into the C source or the html documentation */ -gint32 gimp_image_add_hguide (GimpImage *image, - gint yposition); -gint32 gimp_image_add_vguide (GimpImage *image, - gint xposition); -gboolean gimp_image_delete_guide (GimpImage *image, - gint32 guide_ID); -gint32 gimp_image_find_next_guide (GimpImage *image, - gint32 guide_ID); -GimpOrientationType gimp_image_get_guide_orientation (GimpImage *image, - gint32 guide_ID); -gint gimp_image_get_guide_position (GimpImage *image, - gint32 guide_ID); +gint32 gimp_image_add_hguide (GimpImage *image, + gint yposition); +GIMP_DEPRECATED_FOR(gimp_image_add_hguide) +G_GNUC_INTERNAL gint32 _gimp_image_add_hguide (gint32 image_ID, + gint yposition); +gint32 gimp_image_add_vguide (GimpImage *image, + gint xposition); +GIMP_DEPRECATED_FOR(gimp_image_add_vguide) +G_GNUC_INTERNAL gint32 _gimp_image_add_vguide (gint32 image_ID, + gint xposition); +gboolean gimp_image_delete_guide (GimpImage *image, + gint32 guide_ID); +GIMP_DEPRECATED_FOR(gimp_image_delete_guide) +G_GNUC_INTERNAL gboolean _gimp_image_delete_guide (gint32 image_ID, + gint32 guide_ID); +gint32 gimp_image_find_next_guide (GimpImage *image, + gint32 guide_ID); +GIMP_DEPRECATED_FOR(gimp_image_find_next_guide) +G_GNUC_INTERNAL gint32 _gimp_image_find_next_guide (gint32 image_ID, + gint32 guide_ID); +GimpOrientationType gimp_image_get_guide_orientation (GimpImage *image, + gint32 guide_ID); +GIMP_DEPRECATED_FOR(gimp_image_get_guide_orientation) +G_GNUC_INTERNAL GimpOrientationType _gimp_image_get_guide_orientation (gint32 image_ID, + gint32 guide_ID); +gint gimp_image_get_guide_position (GimpImage *image, + gint32 guide_ID); +GIMP_DEPRECATED_FOR(gimp_image_get_guide_position) +G_GNUC_INTERNAL gint _gimp_image_get_guide_position (gint32 image_ID, + gint32 guide_ID); G_END_DECLS diff --git a/libgimp/gimpimagesamplepoints_pdb.c b/libgimp/gimpimagesamplepoints_pdb.c index 4343f0ac74..effb078a37 100644 --- a/libgimp/gimpimagesamplepoints_pdb.c +++ b/libgimp/gimpimagesamplepoints_pdb.c @@ -83,6 +83,55 @@ gimp_image_add_sample_point (GimpImage *image, return sample_point_ID; } +/** + * _gimp_image_add_sample_point: (skip) + * @image_ID: The image. + * @position_x: The guide'sample points x-offset from left of image. + * @position_y: The guide'sample points y-offset from top of image. + * + * Add a sample point to an image. + * + * This procedure adds a sample point to an image. It takes the input + * image and the position of the new sample points as parameters. It + * returns the sample point ID of the new sample point. + * + * Returns: The new sample point. + * + * Since: 2.10 + **/ +gint32 +_gimp_image_add_sample_point (gint32 image_ID, + gint position_x, + gint position_y) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint32 sample_point_ID = -1; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_INT, position_x, + G_TYPE_INT, position_y, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-add-sample-point", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-add-sample-point", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + sample_point_ID = g_value_get_uint (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return sample_point_ID; +} + /** * gimp_image_delete_sample_point: * @image: The image. @@ -127,6 +176,50 @@ gimp_image_delete_sample_point (GimpImage *image, return success; } +/** + * _gimp_image_delete_sample_point: (skip) + * @image_ID: The image. + * @sample_point_ID: The ID of the sample point to be removed. + * + * Deletes a sample point from an image. + * + * This procedure takes an image and a sample point ID as input and + * removes the specified sample point from the specified image. + * + * Returns: TRUE on success. + * + * Since: 2.10 + **/ +gboolean +_gimp_image_delete_sample_point (gint32 image_ID, + gint32 sample_point_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_UINT, sample_point_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-delete-sample-point", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-delete-sample-point", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_find_next_sample_point: * @image: The image. @@ -176,6 +269,55 @@ gimp_image_find_next_sample_point (GimpImage *image, return next_sample_point_ID; } +/** + * _gimp_image_find_next_sample_point: (skip) + * @image_ID: The image. + * @sample_point_ID: The ID of the current sample point (0 if first invocation). + * + * Find next sample point on an image. + * + * This procedure takes an image and a sample point ID as input and + * finds the sample point ID of the successor of the given sample point + * ID in the image's sample point list. If the supplied sample point ID + * is 0, the procedure will return the first sample point. The + * procedure will return 0 if given the final sample point ID as an + * argument or the image has no sample points. + * + * Returns: The next sample point's ID. + * + * Since: 2.10 + **/ +gint32 +_gimp_image_find_next_sample_point (gint32 image_ID, + gint32 sample_point_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint32 next_sample_point_ID = -1; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_UINT, sample_point_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-find-next-sample-point", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-find-next-sample-point", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + next_sample_point_ID = g_value_get_uint (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return next_sample_point_ID; +} + /** * gimp_image_get_sample_point_position: * @image: The image. @@ -226,3 +368,54 @@ gimp_image_get_sample_point_position (GimpImage *image, return position_x; } + +/** + * _gimp_image_get_sample_point_position: (skip) + * @image_ID: The image. + * @sample_point_ID: The guide. + * @position_y: (out): The sample points's position relative to top of image. + * + * Get position of a sample point on an image. + * + * This procedure takes an image and a sample point ID as input and + * returns the position of the sample point relative to the top and + * left of the image. + * + * Returns: The sample points's position relative to top of image. + * + * Since: 2.10 + **/ +gint +_gimp_image_get_sample_point_position (gint32 image_ID, + gint32 sample_point_ID, + gint *position_y) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint position_x = G_MININT; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_UINT, sample_point_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-get-sample-point-position", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-get-sample-point-position", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + { + position_x = g_value_get_int (gimp_value_array_index (return_vals, 1)); + *position_y = g_value_get_int (gimp_value_array_index (return_vals, 2)); + } + + gimp_value_array_unref (return_vals); + + return position_x; +} diff --git a/libgimp/gimpimagesamplepoints_pdb.h b/libgimp/gimpimagesamplepoints_pdb.h index feb7b20bd9..f0d56994f9 100644 --- a/libgimp/gimpimagesamplepoints_pdb.h +++ b/libgimp/gimpimagesamplepoints_pdb.h @@ -32,16 +32,30 @@ G_BEGIN_DECLS /* For information look into the C source or the html documentation */ -gint32 gimp_image_add_sample_point (GimpImage *image, - gint position_x, - gint position_y); -gboolean gimp_image_delete_sample_point (GimpImage *image, - gint32 sample_point_ID); -gint32 gimp_image_find_next_sample_point (GimpImage *image, - gint32 sample_point_ID); -gint gimp_image_get_sample_point_position (GimpImage *image, - gint32 sample_point_ID, - gint *position_y); +gint32 gimp_image_add_sample_point (GimpImage *image, + gint position_x, + gint position_y); +GIMP_DEPRECATED_FOR(gimp_image_add_sample_point) +G_GNUC_INTERNAL gint32 _gimp_image_add_sample_point (gint32 image_ID, + gint position_x, + gint position_y); +gboolean gimp_image_delete_sample_point (GimpImage *image, + gint32 sample_point_ID); +GIMP_DEPRECATED_FOR(gimp_image_delete_sample_point) +G_GNUC_INTERNAL gboolean _gimp_image_delete_sample_point (gint32 image_ID, + gint32 sample_point_ID); +gint32 gimp_image_find_next_sample_point (GimpImage *image, + gint32 sample_point_ID); +GIMP_DEPRECATED_FOR(gimp_image_find_next_sample_point) +G_GNUC_INTERNAL gint32 _gimp_image_find_next_sample_point (gint32 image_ID, + gint32 sample_point_ID); +gint gimp_image_get_sample_point_position (GimpImage *image, + gint32 sample_point_ID, + gint *position_y); +GIMP_DEPRECATED_FOR(gimp_image_get_sample_point_position) +G_GNUC_INTERNAL gint _gimp_image_get_sample_point_position (gint32 image_ID, + gint32 sample_point_ID, + gint *position_y); G_END_DECLS diff --git a/libgimp/gimpimageselect_pdb.c b/libgimp/gimpimageselect_pdb.c index 6b025373d5..c4e5ef3dea 100644 --- a/libgimp/gimpimageselect_pdb.c +++ b/libgimp/gimpimageselect_pdb.c @@ -99,6 +99,71 @@ gimp_image_select_color (GimpImage *image, return success; } +/** + * _gimp_image_select_color: (skip) + * @image_ID: The affected image. + * @operation: The selection operation. + * @drawable_ID: The affected drawable. + * @color: The color to select. + * + * Create a selection by selecting all pixels (in the specified + * drawable) with the same (or similar) color to that specified. + * + * This tool creates a selection over the specified image. A by-color + * selection is determined by the supplied color under the constraints + * of the current context settings. Essentially, all pixels (in the + * drawable) that have color sufficiently close to the specified color + * (as determined by the threshold and criterion context values) are + * included in the selection. To select transparent regions, the color + * specified must also have minimum alpha. + * + * This procedure is affected by the following context setters: + * gimp_context_set_antialias(), gimp_context_set_feather(), + * gimp_context_set_feather_radius(), gimp_context_set_sample_merged(), + * gimp_context_set_sample_criterion(), + * gimp_context_set_sample_threshold(), + * gimp_context_set_sample_transparent(). + * + * In the case of a merged sampling, the supplied drawable is ignored. + * + * Returns: TRUE on success. + * + * Since: 2.8 + **/ +gboolean +_gimp_image_select_color (gint32 image_ID, + GimpChannelOps operation, + gint32 drawable_ID, + const GimpRGB *color) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + GIMP_TYPE_CHANNEL_OPS, operation, + GIMP_TYPE_DRAWABLE_ID, drawable_ID, + GIMP_TYPE_RGB, color, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-select-color", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-select-color", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_select_contiguous_color: * @image: The affected image. @@ -176,6 +241,83 @@ gimp_image_select_contiguous_color (GimpImage *image, return success; } +/** + * _gimp_image_select_contiguous_color: (skip) + * @image_ID: The affected image. + * @operation: The selection operation. + * @drawable_ID: The affected drawable. + * @x: x coordinate of initial seed fill point: (image coordinates). + * @y: y coordinate of initial seed fill point: (image coordinates). + * + * Create a selection by selecting all pixels around specified + * coordinates with the same (or similar) color to that at the + * coordinates. + * + * This tool creates a contiguous selection over the specified image. A + * contiguous color selection is determined by a seed fill under the + * constraints of the current context settings. Essentially, the color + * at the specified coordinates (in the drawable) is measured and the + * selection expands outwards from that point to any adjacent pixels + * which are not significantly different (as determined by the + * threshold and criterion context settings). This process continues + * until no more expansion is possible. If antialiasing is turned on, + * the final selection mask will contain intermediate values based on + * close misses to the threshold bar at pixels along the seed fill + * boundary. + * + * This procedure is affected by the following context setters: + * gimp_context_set_antialias(), gimp_context_set_feather(), + * gimp_context_set_feather_radius(), gimp_context_set_sample_merged(), + * gimp_context_set_sample_criterion(), + * gimp_context_set_sample_threshold(), + * gimp_context_set_sample_transparent(), + * gimp_context_set_diagonal_neighbors(). + * + * In the case of a merged sampling, the supplied drawable is ignored. + * If the sample is merged, the specified coordinates are relative to + * the image origin; otherwise, they are relative to the drawable's + * origin. + * + * Returns: TRUE on success. + * + * Since: 2.8 + **/ +gboolean +_gimp_image_select_contiguous_color (gint32 image_ID, + GimpChannelOps operation, + gint32 drawable_ID, + gdouble x, + gdouble y) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + GIMP_TYPE_CHANNEL_OPS, operation, + GIMP_TYPE_DRAWABLE_ID, drawable_ID, + G_TYPE_DOUBLE, x, + G_TYPE_DOUBLE, y, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-select-contiguous-color", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-select-contiguous-color", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_select_rectangle: * @image: The image. @@ -236,6 +378,66 @@ gimp_image_select_rectangle (GimpImage *image, return success; } +/** + * _gimp_image_select_rectangle: (skip) + * @image_ID: The image. + * @operation: The selection operation. + * @x: x coordinate of upper-left corner of rectangle. + * @y: y coordinate of upper-left corner of rectangle. + * @width: The width of the rectangle. + * @height: The height of the rectangle. + * + * Create a rectangular selection over the specified image; + * + * This tool creates a rectangular selection over the specified image. + * The rectangular region can be either added to, subtracted from, or + * replace the contents of the previous selection mask. + * + * This procedure is affected by the following context setters: + * gimp_context_set_feather(), gimp_context_set_feather_radius(). + * + * Returns: TRUE on success. + * + * Since: 2.8 + **/ +gboolean +_gimp_image_select_rectangle (gint32 image_ID, + GimpChannelOps operation, + gdouble x, + gdouble y, + gdouble width, + gdouble height) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + GIMP_TYPE_CHANNEL_OPS, operation, + G_TYPE_DOUBLE, x, + G_TYPE_DOUBLE, y, + G_TYPE_DOUBLE, width, + G_TYPE_DOUBLE, height, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-select-rectangle", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-select-rectangle", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_select_round_rectangle: * @image: The image. @@ -305,6 +507,75 @@ gimp_image_select_round_rectangle (GimpImage *image, return success; } +/** + * _gimp_image_select_round_rectangle: (skip) + * @image_ID: The image. + * @operation: The selection operation. + * @x: x coordinate of upper-left corner of rectangle. + * @y: y coordinate of upper-left corner of rectangle. + * @width: The width of the rectangle. + * @height: The height of the rectangle. + * @corner_radius_x: The corner radius in X direction. + * @corner_radius_y: The corner radius in Y direction. + * + * Create a rectangular selection with round corners over the specified + * image; + * + * This tool creates a rectangular selection with round corners over + * the specified image. The rectangular region can be either added to, + * subtracted from, or replace the contents of the previous selection + * mask. + * + * This procedure is affected by the following context setters: + * gimp_context_set_antialias(), gimp_context_set_feather(), + * gimp_context_set_feather_radius(). + * + * Returns: TRUE on success. + * + * Since: 2.8 + **/ +gboolean +_gimp_image_select_round_rectangle (gint32 image_ID, + GimpChannelOps operation, + gdouble x, + gdouble y, + gdouble width, + gdouble height, + gdouble corner_radius_x, + gdouble corner_radius_y) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + GIMP_TYPE_CHANNEL_OPS, operation, + G_TYPE_DOUBLE, x, + G_TYPE_DOUBLE, y, + G_TYPE_DOUBLE, width, + G_TYPE_DOUBLE, height, + G_TYPE_DOUBLE, corner_radius_x, + G_TYPE_DOUBLE, corner_radius_y, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-select-round-rectangle", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-select-round-rectangle", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_select_ellipse: * @image: The image. @@ -366,6 +637,67 @@ gimp_image_select_ellipse (GimpImage *image, return success; } +/** + * _gimp_image_select_ellipse: (skip) + * @image_ID: The image. + * @operation: The selection operation. + * @x: x coordinate of upper-left corner of ellipse bounding box. + * @y: y coordinate of upper-left corner of ellipse bounding box. + * @width: The width of the ellipse. + * @height: The height of the ellipse. + * + * Create an elliptical selection over the specified image. + * + * This tool creates an elliptical selection over the specified image. + * The elliptical region can be either added to, subtracted from, or + * replace the contents of the previous selection mask. + * + * This procedure is affected by the following context setters: + * gimp_context_set_antialias(), gimp_context_set_feather(), + * gimp_context_set_feather_radius(). + * + * Returns: TRUE on success. + * + * Since: 2.8 + **/ +gboolean +_gimp_image_select_ellipse (gint32 image_ID, + GimpChannelOps operation, + gdouble x, + gdouble y, + gdouble width, + gdouble height) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + GIMP_TYPE_CHANNEL_OPS, operation, + G_TYPE_DOUBLE, x, + G_TYPE_DOUBLE, y, + G_TYPE_DOUBLE, width, + G_TYPE_DOUBLE, height, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-select-ellipse", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-select-ellipse", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_select_polygon: * @image: The image. @@ -427,6 +759,67 @@ gimp_image_select_polygon (GimpImage *image, return success; } +/** + * _gimp_image_select_polygon: (skip) + * @image_ID: The image. + * @operation: The selection operation. + * @num_segs: Number of points (count 1 coordinate as two points). + * @segs: (array length=num_segs) (element-type gdouble): Array of points: { p1.x, p1.y, p2.x, p2.y, ..., pn.x, pn.y}. + * + * Create a polygonal selection over the specified image. + * + * This tool creates a polygonal selection over the specified image. + * The polygonal region can be either added to, subtracted from, or + * replace the contents of the previous selection mask. The polygon is + * specified through an array of floating point numbers and its length. + * The length of array must be 2n, where n is the number of points. + * Each point is defined by 2 floating point values which correspond to + * the x and y coordinates. If the final point does not connect to the + * starting point, a connecting segment is automatically added. + * + * This procedure is affected by the following context setters: + * gimp_context_set_antialias(), gimp_context_set_feather(), + * gimp_context_set_feather_radius(). + * + * Returns: TRUE on success. + * + * Since: 2.8 + **/ +gboolean +_gimp_image_select_polygon (gint32 image_ID, + GimpChannelOps operation, + gint num_segs, + const gdouble *segs) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + GIMP_TYPE_CHANNEL_OPS, operation, + G_TYPE_INT, num_segs, + GIMP_TYPE_FLOAT_ARRAY, NULL, + G_TYPE_NONE); + gimp_value_set_float_array (gimp_value_array_index (args, 3), segs, num_segs); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-select-polygon", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-select-polygon", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_select_item: * @image: The image. @@ -479,3 +872,56 @@ gimp_image_select_item (GimpImage *image, return success; } + +/** + * _gimp_image_select_item: (skip) + * @image_ID: The image. + * @operation: The desired operation with current selection. + * @item_ID: The item to render to the selection. + * + * Transforms the specified item into a selection + * + * This procedure renders the item's outline into the current selection + * of the image the item belongs to. What exactly the item's outline is + * depends on the item type: for layers, it's the layer's alpha + * channel, for vectors the vector's shape. + * + * This procedure is affected by the following context setters: + * gimp_context_set_antialias(), gimp_context_set_feather(), + * gimp_context_set_feather_radius(). + * + * Returns: TRUE on success. + * + * Since: 2.8 + **/ +gboolean +_gimp_image_select_item (gint32 image_ID, + GimpChannelOps operation, + gint32 item_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + GIMP_TYPE_CHANNEL_OPS, operation, + GIMP_TYPE_ITEM_ID, item_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-select-item", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-select-item", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} diff --git a/libgimp/gimpimageselect_pdb.h b/libgimp/gimpimageselect_pdb.h index 9918092421..01ae0f879b 100644 --- a/libgimp/gimpimageselect_pdb.h +++ b/libgimp/gimpimageselect_pdb.h @@ -32,42 +32,85 @@ G_BEGIN_DECLS /* For information look into the C source or the html documentation */ -gboolean gimp_image_select_color (GimpImage *image, - GimpChannelOps operation, - gint32 drawable_ID, - const GimpRGB *color); -gboolean gimp_image_select_contiguous_color (GimpImage *image, - GimpChannelOps operation, - gint32 drawable_ID, - gdouble x, - gdouble y); -gboolean gimp_image_select_rectangle (GimpImage *image, - GimpChannelOps operation, - gdouble x, - gdouble y, - gdouble width, - gdouble height); -gboolean gimp_image_select_round_rectangle (GimpImage *image, - GimpChannelOps operation, - gdouble x, - gdouble y, - gdouble width, - gdouble height, - gdouble corner_radius_x, - gdouble corner_radius_y); -gboolean gimp_image_select_ellipse (GimpImage *image, - GimpChannelOps operation, - gdouble x, - gdouble y, - gdouble width, - gdouble height); -gboolean gimp_image_select_polygon (GimpImage *image, - GimpChannelOps operation, - gint num_segs, - const gdouble *segs); -gboolean gimp_image_select_item (GimpImage *image, - GimpChannelOps operation, - gint32 item_ID); +gboolean gimp_image_select_color (GimpImage *image, + GimpChannelOps operation, + gint32 drawable_ID, + const GimpRGB *color); +GIMP_DEPRECATED_FOR(gimp_image_select_color) +G_GNUC_INTERNAL gboolean _gimp_image_select_color (gint32 image_ID, + GimpChannelOps operation, + gint32 drawable_ID, + const GimpRGB *color); +gboolean gimp_image_select_contiguous_color (GimpImage *image, + GimpChannelOps operation, + gint32 drawable_ID, + gdouble x, + gdouble y); +GIMP_DEPRECATED_FOR(gimp_image_select_contiguous_color) +G_GNUC_INTERNAL gboolean _gimp_image_select_contiguous_color (gint32 image_ID, + GimpChannelOps operation, + gint32 drawable_ID, + gdouble x, + gdouble y); +gboolean gimp_image_select_rectangle (GimpImage *image, + GimpChannelOps operation, + gdouble x, + gdouble y, + gdouble width, + gdouble height); +GIMP_DEPRECATED_FOR(gimp_image_select_rectangle) +G_GNUC_INTERNAL gboolean _gimp_image_select_rectangle (gint32 image_ID, + GimpChannelOps operation, + gdouble x, + gdouble y, + gdouble width, + gdouble height); +gboolean gimp_image_select_round_rectangle (GimpImage *image, + GimpChannelOps operation, + gdouble x, + gdouble y, + gdouble width, + gdouble height, + gdouble corner_radius_x, + gdouble corner_radius_y); +GIMP_DEPRECATED_FOR(gimp_image_select_round_rectangle) +G_GNUC_INTERNAL gboolean _gimp_image_select_round_rectangle (gint32 image_ID, + GimpChannelOps operation, + gdouble x, + gdouble y, + gdouble width, + gdouble height, + gdouble corner_radius_x, + gdouble corner_radius_y); +gboolean gimp_image_select_ellipse (GimpImage *image, + GimpChannelOps operation, + gdouble x, + gdouble y, + gdouble width, + gdouble height); +GIMP_DEPRECATED_FOR(gimp_image_select_ellipse) +G_GNUC_INTERNAL gboolean _gimp_image_select_ellipse (gint32 image_ID, + GimpChannelOps operation, + gdouble x, + gdouble y, + gdouble width, + gdouble height); +gboolean gimp_image_select_polygon (GimpImage *image, + GimpChannelOps operation, + gint num_segs, + const gdouble *segs); +GIMP_DEPRECATED_FOR(gimp_image_select_polygon) +G_GNUC_INTERNAL gboolean _gimp_image_select_polygon (gint32 image_ID, + GimpChannelOps operation, + gint num_segs, + const gdouble *segs); +gboolean gimp_image_select_item (GimpImage *image, + GimpChannelOps operation, + gint32 item_ID); +GIMP_DEPRECATED_FOR(gimp_image_select_item) +G_GNUC_INTERNAL gboolean _gimp_image_select_item (gint32 image_ID, + GimpChannelOps operation, + gint32 item_ID); G_END_DECLS diff --git a/libgimp/gimpimagetransform_pdb.c b/libgimp/gimpimagetransform_pdb.c index e159b40141..daff6083c3 100644 --- a/libgimp/gimpimagetransform_pdb.c +++ b/libgimp/gimpimagetransform_pdb.c @@ -90,6 +90,62 @@ gimp_image_resize (GimpImage *image, return success; } +/** + * _gimp_image_resize: (skip) + * @image_ID: The image. + * @new_width: New image width. + * @new_height: New image height. + * @offx: x offset between upper left corner of old and new images: (new - old). + * @offy: y offset between upper left corner of old and new images: (new - old). + * + * Resize the image to the specified extents. + * + * This procedure resizes the image so that it's new width and height + * are equal to the supplied parameters. Offsets are also provided + * which describe the position of the previous image's content. All + * channels within the image are resized according to the specified + * parameters; this includes the image selection mask. All layers + * within the image are repositioned according to the specified + * offsets. + * + * Returns: TRUE on success. + **/ +gboolean +_gimp_image_resize (gint32 image_ID, + gint new_width, + gint new_height, + gint offx, + gint offy) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_INT, new_width, + G_TYPE_INT, new_height, + G_TYPE_INT, offx, + G_TYPE_INT, offy, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-resize", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-resize", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_resize_to_layers: * @image: The image. @@ -133,6 +189,49 @@ gimp_image_resize_to_layers (GimpImage *image) return success; } +/** + * _gimp_image_resize_to_layers: (skip) + * @image_ID: The image. + * + * Resize the image to fit all layers. + * + * This procedure resizes the image to the bounding box of all layers + * of the image. All channels within the image are resized to the new + * size; this includes the image selection mask. All layers within the + * image are repositioned to the new image area. + * + * Returns: TRUE on success. + * + * Since: 2.2 + **/ +gboolean +_gimp_image_resize_to_layers (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-resize-to-layers", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-resize-to-layers", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_scale: * @image: The image. @@ -181,6 +280,54 @@ gimp_image_scale (GimpImage *image, return success; } +/** + * _gimp_image_scale: (skip) + * @image_ID: The image. + * @new_width: New image width. + * @new_height: New image height. + * + * Scale the image using the default interpolation method. + * + * This procedure scales the image so that its new width and height are + * equal to the supplied parameters. All layers and channels within the + * image are scaled according to the specified parameters; this + * includes the image selection mask. The interpolation method used can + * be set with gimp_context_set_interpolation(). + * + * Returns: TRUE on success. + **/ +gboolean +_gimp_image_scale (gint32 image_ID, + gint new_width, + gint new_height) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_INT, new_width, + G_TYPE_INT, new_height, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-scale", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-scale", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_crop: * @image: The image. @@ -236,6 +383,61 @@ gimp_image_crop (GimpImage *image, return success; } +/** + * _gimp_image_crop: (skip) + * @image_ID: The image. + * @new_width: New image width: (0 < new_width <= width). + * @new_height: New image height: (0 < new_height <= height). + * @offx: X offset: (0 <= offx <= (width - new_width)). + * @offy: Y offset: (0 <= offy <= (height - new_height)). + * + * Crop the image to the specified extents. + * + * This procedure crops the image so that it's new width and height are + * equal to the supplied parameters. Offsets are also provided which + * describe the position of the previous image's content. All channels + * and layers within the image are cropped to the new image extents; + * this includes the image selection mask. If any parameters are out of + * range, an error is returned. + * + * Returns: TRUE on success. + **/ +gboolean +_gimp_image_crop (gint32 image_ID, + gint new_width, + gint new_height, + gint offx, + gint offy) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_INT, new_width, + G_TYPE_INT, new_height, + G_TYPE_INT, offx, + G_TYPE_INT, offy, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-crop", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-crop", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_flip: * @image: The image. @@ -277,6 +479,47 @@ gimp_image_flip (GimpImage *image, return success; } +/** + * _gimp_image_flip: (skip) + * @image_ID: The image. + * @flip_type: Type of flip. + * + * Flips the image horizontally or vertically. + * + * This procedure flips (mirrors) the image. + * + * Returns: TRUE on success. + **/ +gboolean +_gimp_image_flip (gint32 image_ID, + GimpOrientationType flip_type) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + GIMP_TYPE_ORIENTATION_TYPE, flip_type, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-flip", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-flip", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_rotate: * @image: The image. @@ -317,3 +560,44 @@ gimp_image_rotate (GimpImage *image, return success; } + +/** + * _gimp_image_rotate: (skip) + * @image_ID: The image. + * @rotate_type: Angle of rotation. + * + * Rotates the image by the specified degrees. + * + * This procedure rotates the image. + * + * Returns: TRUE on success. + **/ +gboolean +_gimp_image_rotate (gint32 image_ID, + GimpRotationType rotate_type) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + GIMP_TYPE_ROTATION_TYPE, rotate_type, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-rotate", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-rotate", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} diff --git a/libgimp/gimpimagetransform_pdb.h b/libgimp/gimpimagetransform_pdb.h index f82c018682..bee76b6852 100644 --- a/libgimp/gimpimagetransform_pdb.h +++ b/libgimp/gimpimagetransform_pdb.h @@ -32,24 +32,48 @@ G_BEGIN_DECLS /* For information look into the C source or the html documentation */ -gboolean gimp_image_resize (GimpImage *image, - gint new_width, - gint new_height, - gint offx, - gint offy); -gboolean gimp_image_resize_to_layers (GimpImage *image); -gboolean gimp_image_scale (GimpImage *image, - gint new_width, - gint new_height); -gboolean gimp_image_crop (GimpImage *image, - gint new_width, - gint new_height, - gint offx, - gint offy); -gboolean gimp_image_flip (GimpImage *image, - GimpOrientationType flip_type); -gboolean gimp_image_rotate (GimpImage *image, - GimpRotationType rotate_type); +gboolean gimp_image_resize (GimpImage *image, + gint new_width, + gint new_height, + gint offx, + gint offy); +GIMP_DEPRECATED_FOR(gimp_image_resize) +G_GNUC_INTERNAL gboolean _gimp_image_resize (gint32 image_ID, + gint new_width, + gint new_height, + gint offx, + gint offy); +gboolean gimp_image_resize_to_layers (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_image_resize_to_layers) +G_GNUC_INTERNAL gboolean _gimp_image_resize_to_layers (gint32 image_ID); +gboolean gimp_image_scale (GimpImage *image, + gint new_width, + gint new_height); +GIMP_DEPRECATED_FOR(gimp_image_scale) +G_GNUC_INTERNAL gboolean _gimp_image_scale (gint32 image_ID, + gint new_width, + gint new_height); +gboolean gimp_image_crop (GimpImage *image, + gint new_width, + gint new_height, + gint offx, + gint offy); +GIMP_DEPRECATED_FOR(gimp_image_crop) +G_GNUC_INTERNAL gboolean _gimp_image_crop (gint32 image_ID, + gint new_width, + gint new_height, + gint offx, + gint offy); +gboolean gimp_image_flip (GimpImage *image, + GimpOrientationType flip_type); +GIMP_DEPRECATED_FOR(gimp_image_flip) +G_GNUC_INTERNAL gboolean _gimp_image_flip (gint32 image_ID, + GimpOrientationType flip_type); +gboolean gimp_image_rotate (GimpImage *image, + GimpRotationType rotate_type); +GIMP_DEPRECATED_FOR(gimp_image_rotate) +G_GNUC_INTERNAL gboolean _gimp_image_rotate (gint32 image_ID, + GimpRotationType rotate_type); G_END_DECLS diff --git a/libgimp/gimpimageundo_pdb.c b/libgimp/gimpimageundo_pdb.c index 0cf0465c62..6fec1695a5 100644 --- a/libgimp/gimpimageundo_pdb.c +++ b/libgimp/gimpimageundo_pdb.c @@ -75,6 +75,47 @@ gimp_image_undo_group_start (GimpImage *image) return success; } +/** + * _gimp_image_undo_group_start: (skip) + * @image_ID: The ID of the image in which to open an undo group. + * + * Starts a group undo. + * + * This function is used to start a group undo--necessary for logically + * combining two or more undo operations into a single operation. This + * call must be used in conjunction with a gimp_image_undo_group_end() + * call. + * + * Returns: TRUE on success. + **/ +gboolean +_gimp_image_undo_group_start (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-undo-group-start", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-undo-group-start", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_undo_group_end: * @image: The ID of the image in which to close an undo group. @@ -114,6 +155,45 @@ gimp_image_undo_group_end (GimpImage *image) return success; } +/** + * _gimp_image_undo_group_end: (skip) + * @image_ID: The ID of the image in which to close an undo group. + * + * Finish a group undo. + * + * This function must be called once for each + * gimp_image_undo_group_start() call that is made. + * + * Returns: TRUE on success. + **/ +gboolean +_gimp_image_undo_group_end (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-undo-group-end", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-undo-group-end", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_image_undo_is_enabled: * @image: The image. @@ -156,6 +236,48 @@ gimp_image_undo_is_enabled (GimpImage *image) return enabled; } +/** + * _gimp_image_undo_is_enabled: (skip) + * @image_ID: The image. + * + * Check if the image's undo stack is enabled. + * + * This procedure checks if the image's undo stack is currently enabled + * or disabled. This is useful when several plug-ins or scripts call + * each other and want to check if their caller has already used + * gimp_image_undo_disable() or gimp_image_undo_freeze(). + * + * Returns: TRUE if undo is enabled for this image. + **/ +gboolean +_gimp_image_undo_is_enabled (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean enabled = FALSE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-undo-is-enabled", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-undo-is-enabled", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + enabled = g_value_get_boolean (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return enabled; +} + /** * gimp_image_undo_disable: * @image: The image. @@ -199,6 +321,49 @@ gimp_image_undo_disable (GimpImage *image) return disabled; } +/** + * _gimp_image_undo_disable: (skip) + * @image_ID: The image. + * + * Disable the image's undo stack. + * + * This procedure disables the image's undo stack, allowing subsequent + * operations to ignore their undo steps. This is generally called in + * conjunction with gimp_image_undo_enable() to temporarily disable an + * image undo stack. This is advantageous because saving undo steps can + * be time and memory intensive. + * + * Returns: TRUE if the image undo has been disabled. + **/ +gboolean +_gimp_image_undo_disable (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean disabled = FALSE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-undo-disable", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-undo-disable", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + disabled = g_value_get_boolean (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return disabled; +} + /** * gimp_image_undo_enable: * @image: The image. @@ -241,6 +406,48 @@ gimp_image_undo_enable (GimpImage *image) return enabled; } +/** + * _gimp_image_undo_enable: (skip) + * @image_ID: The image. + * + * Enable the image's undo stack. + * + * This procedure enables the image's undo stack, allowing subsequent + * operations to store their undo steps. This is generally called in + * conjunction with gimp_image_undo_disable() to temporarily disable an + * image undo stack. + * + * Returns: TRUE if the image undo has been enabled. + **/ +gboolean +_gimp_image_undo_enable (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean enabled = FALSE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-undo-enable", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-undo-enable", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + enabled = g_value_get_boolean (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return enabled; +} + /** * gimp_image_undo_freeze: * @image: The image. @@ -290,6 +497,55 @@ gimp_image_undo_freeze (GimpImage *image) return frozen; } +/** + * _gimp_image_undo_freeze: (skip) + * @image_ID: The image. + * + * Freeze the image's undo stack. + * + * This procedure freezes the image's undo stack, allowing subsequent + * operations to ignore their undo steps. This is generally called in + * conjunction with gimp_image_undo_thaw() to temporarily disable an + * image undo stack. This is advantageous because saving undo steps can + * be time and memory intensive. gimp_image_undo_freeze() / + * gimp_image_undo_thaw() and gimp_image_undo_disable() / + * gimp_image_undo_enable() differ in that the former does not free up + * all undo steps when undo is thawed, so is more suited to interactive + * in-situ previews. It is important in this case that the image is + * back to the same state it was frozen in before thawing, else 'undo' + * behaviour is undefined. + * + * Returns: TRUE if the image undo has been frozen. + **/ +gboolean +_gimp_image_undo_freeze (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean frozen = FALSE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-undo-freeze", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-undo-freeze", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + frozen = g_value_get_boolean (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return frozen; +} + /** * gimp_image_undo_thaw: * @image: The image. @@ -337,3 +593,51 @@ gimp_image_undo_thaw (GimpImage *image) return thawed; } + +/** + * _gimp_image_undo_thaw: (skip) + * @image_ID: The image. + * + * Thaw the image's undo stack. + * + * This procedure thaws the image's undo stack, allowing subsequent + * operations to store their undo steps. This is generally called in + * conjunction with gimp_image_undo_freeze() to temporarily freeze an + * image undo stack. gimp_image_undo_thaw() does NOT free the undo + * stack as gimp_image_undo_enable() does, so is suited for situations + * where one wishes to leave the undo stack in the same state in which + * one found it despite non-destructively playing with the image in the + * meantime. An example would be in-situ plug-in previews. Balancing + * freezes and thaws and ensuring image consistency is the + * responsibility of the caller. + * + * Returns: TRUE if the image undo has been thawed. + **/ +gboolean +_gimp_image_undo_thaw (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean thawed = FALSE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-image-undo-thaw", + args); + else + return_vals = gimp_run_procedure_array ("gimp-image-undo-thaw", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + thawed = g_value_get_boolean (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return thawed; +} diff --git a/libgimp/gimpimageundo_pdb.h b/libgimp/gimpimageundo_pdb.h index 3caa0f2227..947e11604a 100644 --- a/libgimp/gimpimageundo_pdb.h +++ b/libgimp/gimpimageundo_pdb.h @@ -32,13 +32,27 @@ G_BEGIN_DECLS /* For information look into the C source or the html documentation */ -gboolean gimp_image_undo_group_start (GimpImage *image); -gboolean gimp_image_undo_group_end (GimpImage *image); -gboolean gimp_image_undo_is_enabled (GimpImage *image); -gboolean gimp_image_undo_disable (GimpImage *image); -gboolean gimp_image_undo_enable (GimpImage *image); -gboolean gimp_image_undo_freeze (GimpImage *image); -gboolean gimp_image_undo_thaw (GimpImage *image); +gboolean gimp_image_undo_group_start (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_image_undo_group_start) +G_GNUC_INTERNAL gboolean _gimp_image_undo_group_start (gint32 image_ID); +gboolean gimp_image_undo_group_end (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_image_undo_group_end) +G_GNUC_INTERNAL gboolean _gimp_image_undo_group_end (gint32 image_ID); +gboolean gimp_image_undo_is_enabled (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_image_undo_is_enabled) +G_GNUC_INTERNAL gboolean _gimp_image_undo_is_enabled (gint32 image_ID); +gboolean gimp_image_undo_disable (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_image_undo_disable) +G_GNUC_INTERNAL gboolean _gimp_image_undo_disable (gint32 image_ID); +gboolean gimp_image_undo_enable (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_image_undo_enable) +G_GNUC_INTERNAL gboolean _gimp_image_undo_enable (gint32 image_ID); +gboolean gimp_image_undo_freeze (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_image_undo_freeze) +G_GNUC_INTERNAL gboolean _gimp_image_undo_freeze (gint32 image_ID); +gboolean gimp_image_undo_thaw (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_image_undo_thaw) +G_GNUC_INTERNAL gboolean _gimp_image_undo_thaw (gint32 image_ID); G_END_DECLS diff --git a/libgimp/gimpitem_pdb.c b/libgimp/gimpitem_pdb.c index 5fbbedcaff..1761d1b0b6 100644 --- a/libgimp/gimpitem_pdb.c +++ b/libgimp/gimpitem_pdb.c @@ -110,13 +110,54 @@ gimp_item_get_image (gint32 item_ID) gimp_value_array_unref (args); if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) - image = gimp_image_new_by_id (g_value_get_int (gimp_value_array_index (return_vals, 1))); + image = gimp_image_new_by_id (gimp_value_get_image_id (gimp_value_array_index (return_vals, 1))); gimp_value_array_unref (return_vals); return image; } +/** + * _gimp_item_get_image: (skip) + * @item_ID: The item. + * + * Returns the item's image. + * + * This procedure returns the item's image. + * + * Returns: The item's image. + * + * Since: 2.8 + **/ +gint32 +_gimp_item_get_image (gint32 item_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint32 image_ID = -1; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_ITEM_ID, item_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-item-get-image", + args); + else + return_vals = gimp_run_procedure_array ("gimp-item-get-image", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + image_ID = gimp_value_get_image_id (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return image_ID; +} + /** * gimp_item_delete: * @item_ID: The item to delete. diff --git a/libgimp/gimpitem_pdb.h b/libgimp/gimpitem_pdb.h index 97c8ede32e..43f961e39f 100644 --- a/libgimp/gimpitem_pdb.h +++ b/libgimp/gimpitem_pdb.h @@ -32,52 +32,54 @@ G_BEGIN_DECLS /* For information look into the C source or the html documentation */ -gboolean gimp_item_is_valid (gint32 item_ID); -GimpImage* gimp_item_get_image (gint32 item_ID); -gboolean gimp_item_delete (gint32 item_ID); -gboolean gimp_item_is_drawable (gint32 item_ID); -gboolean gimp_item_is_layer (gint32 item_ID); -gboolean gimp_item_is_text_layer (gint32 item_ID); -gboolean gimp_item_is_channel (gint32 item_ID); -gboolean gimp_item_is_layer_mask (gint32 item_ID); -gboolean gimp_item_is_selection (gint32 item_ID); -gboolean gimp_item_is_vectors (gint32 item_ID); -gboolean gimp_item_is_group (gint32 item_ID); -gint32 gimp_item_get_parent (gint32 item_ID); -gint* gimp_item_get_children (gint32 item_ID, - gint *num_children); -gboolean gimp_item_get_expanded (gint32 item_ID); -gboolean gimp_item_set_expanded (gint32 item_ID, - gboolean expanded); -gchar* gimp_item_get_name (gint32 item_ID); -gboolean gimp_item_set_name (gint32 item_ID, - const gchar *name); -gboolean gimp_item_get_visible (gint32 item_ID); -gboolean gimp_item_set_visible (gint32 item_ID, - gboolean visible); -gboolean gimp_item_get_linked (gint32 item_ID); -gboolean gimp_item_set_linked (gint32 item_ID, - gboolean linked); -gboolean gimp_item_get_lock_content (gint32 item_ID); -gboolean gimp_item_set_lock_content (gint32 item_ID, - gboolean lock_content); -gboolean gimp_item_get_lock_position (gint32 item_ID); -gboolean gimp_item_set_lock_position (gint32 item_ID, - gboolean lock_position); -GimpColorTag gimp_item_get_color_tag (gint32 item_ID); -gboolean gimp_item_set_color_tag (gint32 item_ID, - GimpColorTag color_tag); -guint gimp_item_get_tattoo (gint32 item_ID); -gboolean gimp_item_set_tattoo (gint32 item_ID, - guint tattoo); -gboolean gimp_item_attach_parasite (gint32 item_ID, - const GimpParasite *parasite); -gboolean gimp_item_detach_parasite (gint32 item_ID, - const gchar *name); -GimpParasite* gimp_item_get_parasite (gint32 item_ID, - const gchar *name); -gchar** gimp_item_get_parasite_list (gint32 item_ID, - gint *num_parasites); +gboolean gimp_item_is_valid (gint32 item_ID); +GimpImage* gimp_item_get_image (gint32 item_ID); +GIMP_DEPRECATED_FOR(gimp_item_get_image) +G_GNUC_INTERNAL gint32 _gimp_item_get_image (gint32 item_ID); +gboolean gimp_item_delete (gint32 item_ID); +gboolean gimp_item_is_drawable (gint32 item_ID); +gboolean gimp_item_is_layer (gint32 item_ID); +gboolean gimp_item_is_text_layer (gint32 item_ID); +gboolean gimp_item_is_channel (gint32 item_ID); +gboolean gimp_item_is_layer_mask (gint32 item_ID); +gboolean gimp_item_is_selection (gint32 item_ID); +gboolean gimp_item_is_vectors (gint32 item_ID); +gboolean gimp_item_is_group (gint32 item_ID); +gint32 gimp_item_get_parent (gint32 item_ID); +gint* gimp_item_get_children (gint32 item_ID, + gint *num_children); +gboolean gimp_item_get_expanded (gint32 item_ID); +gboolean gimp_item_set_expanded (gint32 item_ID, + gboolean expanded); +gchar* gimp_item_get_name (gint32 item_ID); +gboolean gimp_item_set_name (gint32 item_ID, + const gchar *name); +gboolean gimp_item_get_visible (gint32 item_ID); +gboolean gimp_item_set_visible (gint32 item_ID, + gboolean visible); +gboolean gimp_item_get_linked (gint32 item_ID); +gboolean gimp_item_set_linked (gint32 item_ID, + gboolean linked); +gboolean gimp_item_get_lock_content (gint32 item_ID); +gboolean gimp_item_set_lock_content (gint32 item_ID, + gboolean lock_content); +gboolean gimp_item_get_lock_position (gint32 item_ID); +gboolean gimp_item_set_lock_position (gint32 item_ID, + gboolean lock_position); +GimpColorTag gimp_item_get_color_tag (gint32 item_ID); +gboolean gimp_item_set_color_tag (gint32 item_ID, + GimpColorTag color_tag); +guint gimp_item_get_tattoo (gint32 item_ID); +gboolean gimp_item_set_tattoo (gint32 item_ID, + guint tattoo); +gboolean gimp_item_attach_parasite (gint32 item_ID, + const GimpParasite *parasite); +gboolean gimp_item_detach_parasite (gint32 item_ID, + const gchar *name); +GimpParasite* gimp_item_get_parasite (gint32 item_ID, + const gchar *name); +gchar** gimp_item_get_parasite_list (gint32 item_ID, + gint *num_parasites); G_END_DECLS diff --git a/libgimp/gimplayer_pdb.c b/libgimp/gimplayer_pdb.c index 2e8cae9208..01babe8e57 100644 --- a/libgimp/gimplayer_pdb.c +++ b/libgimp/gimplayer_pdb.c @@ -96,6 +96,68 @@ _gimp_layer_new (GimpImage *image, return layer_ID; } +/** + * __gimp_layer_new: (skip) + * @image_ID: The image to which to add the layer. + * @width: The layer width. + * @height: The layer height. + * @type: The layer type. + * @name: The layer name. + * @opacity: The layer opacity. + * @mode: The layer combination mode. + * + * Create a new layer. + * + * This procedure creates a new layer with the specified width, height, + * and type. Name, opacity, and mode are also supplied parameters. The + * new layer still needs to be added to the image, as this is not + * automatic. Add the new layer with the gimp_image_insert_layer() + * command. Other attributes such as layer mask modes, and offsets + * should be set with explicit procedure calls. + * + * Returns: The newly created layer. + **/ +gint32 +__gimp_layer_new (gint32 image_ID, + gint width, + gint height, + GimpImageType type, + const gchar *name, + gdouble opacity, + GimpLayerMode mode) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint32 layer_ID = -1; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_INT, width, + G_TYPE_INT, height, + GIMP_TYPE_IMAGE_TYPE, type, + G_TYPE_STRING, name, + G_TYPE_DOUBLE, opacity, + GIMP_TYPE_LAYER_MODE, mode, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-layer-new", + args); + else + return_vals = gimp_run_procedure_array ("gimp-layer-new", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return layer_ID; +} + /** * gimp_layer_new_from_visible: * @image: The source image from where the content is copied. @@ -147,6 +209,57 @@ gimp_layer_new_from_visible (GimpImage *image, return layer_ID; } +/** + * _gimp_layer_new_from_visible: (skip) + * @image_ID: The source image from where the content is copied. + * @dest_image_ID: The destination image to which to add the layer. + * @name: The layer name. + * + * Create a new layer from what is visible in an image. + * + * This procedure creates a new layer from what is visible in the given + * image. The new layer still needs to be added to the destination + * image, as this is not automatic. Add the new layer with the + * gimp_image_insert_layer() command. Other attributes such as layer + * mask modes, and offsets should be set with explicit procedure calls. + * + * Returns: The newly created layer. + * + * Since: 2.6 + **/ +gint32 +_gimp_layer_new_from_visible (gint32 image_ID, + gint32 dest_image_ID, + const gchar *name) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint32 layer_ID = -1; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + GIMP_TYPE_IMAGE_ID, dest_image_ID, + G_TYPE_STRING, name, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-layer-new-from-visible", + args); + else + return_vals = gimp_run_procedure_array ("gimp-layer-new-from-visible", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return layer_ID; +} + /** * gimp_layer_new_from_drawable: * @drawable_ID: The source drawable from where the new layer is copied. @@ -193,6 +306,52 @@ gimp_layer_new_from_drawable (gint32 drawable_ID, return layer_copy_ID; } +/** + * _gimp_layer_new_from_drawable: (skip) + * @drawable_ID: The source drawable from where the new layer is copied. + * @dest_image_ID: The destination image to which to add the layer. + * + * Create a new layer by copying an existing drawable. + * + * This procedure creates a new layer as a copy of the specified + * drawable. The new layer still needs to be added to the image, as + * this is not automatic. Add the new layer with the + * gimp_image_insert_layer() command. Other attributes such as layer + * mask modes, and offsets should be set with explicit procedure calls. + * + * Returns: The newly copied layer. + **/ +gint32 +_gimp_layer_new_from_drawable (gint32 drawable_ID, + gint32 dest_image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint32 layer_copy_ID = -1; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_DRAWABLE_ID, drawable_ID, + GIMP_TYPE_IMAGE_ID, dest_image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-layer-new-from-drawable", + args); + else + return_vals = gimp_run_procedure_array ("gimp-layer-new-from-drawable", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + layer_copy_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return layer_copy_ID; +} + /** * gimp_layer_group_new: * @image: The image to which to add the layer group. @@ -240,6 +399,53 @@ gimp_layer_group_new (GimpImage *image) return layer_group_ID; } +/** + * _gimp_layer_group_new: (skip) + * @image_ID: The image to which to add the layer group. + * + * Create a new layer group. + * + * This procedure creates a new layer group. Attributes such as layer + * mode and opacity should be set with explicit procedure calls. Add + * the new layer group (which is a kind of layer) with the + * gimp_image_insert_layer() command. + * Other procedures useful with layer groups: + * gimp_image_reorder_item(), gimp_item_get_parent(), + * gimp_item_get_children(), gimp_item_is_group(). + * + * Returns: The newly created layer group. + * + * Since: 2.8 + **/ +gint32 +_gimp_layer_group_new (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint32 layer_group_ID = -1; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-layer-group-new", + args); + else + return_vals = gimp_run_procedure_array ("gimp-layer-group-new", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + layer_group_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return layer_group_ID; +} + /** * _gimp_layer_copy: * @layer_ID: The layer to copy. diff --git a/libgimp/gimplayer_pdb.h b/libgimp/gimplayer_pdb.h index b46c48dac5..aad5f578fd 100644 --- a/libgimp/gimplayer_pdb.h +++ b/libgimp/gimplayer_pdb.h @@ -39,12 +39,29 @@ G_GNUC_INTERNAL gint32 _gimp_layer_new (GimpImage * const gchar *name, gdouble opacity, GimpLayerMode mode); +GIMP_DEPRECATED_FOR(_gimp_layer_new) +G_GNUC_INTERNAL gint32 __gimp_layer_new (gint32 image_ID, + gint width, + gint height, + GimpImageType type, + const gchar *name, + gdouble opacity, + GimpLayerMode mode); gint32 gimp_layer_new_from_visible (GimpImage *image, GimpImage *dest_image, const gchar *name); +GIMP_DEPRECATED_FOR(gimp_layer_new_from_visible) +G_GNUC_INTERNAL gint32 _gimp_layer_new_from_visible (gint32 image_ID, + gint32 dest_image_ID, + const gchar *name); gint32 gimp_layer_new_from_drawable (gint32 drawable_ID, GimpImage *dest_image); +GIMP_DEPRECATED_FOR(gimp_layer_new_from_drawable) +G_GNUC_INTERNAL gint32 _gimp_layer_new_from_drawable (gint32 drawable_ID, + gint32 dest_image_ID); gint32 gimp_layer_group_new (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_layer_group_new) +G_GNUC_INTERNAL gint32 _gimp_layer_group_new (gint32 image_ID); G_GNUC_INTERNAL gint32 _gimp_layer_copy (gint32 layer_ID, gboolean add_alpha); gboolean gimp_layer_add_alpha (gint32 layer_ID); diff --git a/libgimp/gimpselection_pdb.c b/libgimp/gimpselection_pdb.c index 1f558a9baf..ff61666190 100644 --- a/libgimp/gimpselection_pdb.c +++ b/libgimp/gimpselection_pdb.c @@ -104,6 +104,76 @@ gimp_selection_bounds (GimpImage *image, return success; } +/** + * _gimp_selection_bounds: (skip) + * @image_ID: The image. + * @non_empty: (out): TRUE if there is a selection. + * @x1: (out): x coordinate of upper left corner of selection bounds. + * @y1: (out): y coordinate of upper left corner of selection bounds. + * @x2: (out): x coordinate of lower right corner of selection bounds. + * @y2: (out): y coordinate of lower right corner of selection bounds. + * + * Find the bounding box of the current selection. + * + * This procedure returns whether there is a selection for the + * specified image. If there is one, the upper left and lower right + * corners of the bounding box are returned. These coordinates are + * relative to the image. Please note that the pixel specified by the + * lower right coordinate of the bounding box is not part of the + * selection. The selection ends at the upper left corner of this + * pixel. This means the width of the selection can be calculated as + * (x2 - x1), its height as (y2 - y1). + * + * Returns: TRUE on success. + **/ +gboolean +_gimp_selection_bounds (gint32 image_ID, + gboolean *non_empty, + gint *x1, + gint *y1, + gint *x2, + gint *y2) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-selection-bounds", + args); + else + return_vals = gimp_run_procedure_array ("gimp-selection-bounds", + args); + gimp_value_array_unref (args); + + *non_empty = FALSE; + *x1 = 0; + *y1 = 0; + *x2 = 0; + *y2 = 0; + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + if (success) + { + *non_empty = g_value_get_boolean (gimp_value_array_index (return_vals, 1)); + *x1 = g_value_get_int (gimp_value_array_index (return_vals, 2)); + *y1 = g_value_get_int (gimp_value_array_index (return_vals, 3)); + *x2 = g_value_get_int (gimp_value_array_index (return_vals, 4)); + *y2 = g_value_get_int (gimp_value_array_index (return_vals, 5)); + } + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_selection_value: * @image: The image. @@ -150,6 +220,52 @@ gimp_selection_value (GimpImage *image, return value; } +/** + * _gimp_selection_value: (skip) + * @image_ID: The image. + * @x: x coordinate of value. + * @y: y coordinate of value. + * + * Find the value of the selection at the specified coordinates. + * + * This procedure returns the value of the selection at the specified + * coordinates. If the coordinates lie out of bounds, 0 is returned. + * + * Returns: Value of the selection. + **/ +gint +_gimp_selection_value (gint32 image_ID, + gint x, + gint y) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint value = 0; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_INT, x, + G_TYPE_INT, y, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-selection-value", + args); + else + return_vals = gimp_run_procedure_array ("gimp-selection-value", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + value = g_value_get_int (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return value; +} + /** * gimp_selection_is_empty: * @image: The image. @@ -190,6 +306,46 @@ gimp_selection_is_empty (GimpImage *image) return is_empty; } +/** + * _gimp_selection_is_empty: (skip) + * @image_ID: The image. + * + * Determine whether the selection is empty. + * + * This procedure returns TRUE if the selection for the specified image + * is empty. + * + * Returns: Is the selection empty? + **/ +gboolean +_gimp_selection_is_empty (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean is_empty = FALSE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-selection-is-empty", + args); + else + return_vals = gimp_run_procedure_array ("gimp-selection-is-empty", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + is_empty = g_value_get_boolean (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return is_empty; +} + /** * gimp_selection_translate: * @image: The image. @@ -238,6 +394,54 @@ gimp_selection_translate (GimpImage *image, return success; } +/** + * _gimp_selection_translate: (skip) + * @image_ID: The image. + * @offx: x offset for translation. + * @offy: y offset for translation. + * + * Translate the selection by the specified offsets. + * + * This procedure actually translates the selection for the specified + * image by the specified offsets. Regions that are translated from + * beyond the bounds of the image are set to empty. Valid regions of + * the selection which are translated beyond the bounds of the image + * because of this call are lost. + * + * Returns: TRUE on success. + **/ +gboolean +_gimp_selection_translate (gint32 image_ID, + gint offx, + gint offy) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_INT, offx, + G_TYPE_INT, offy, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-selection-translate", + args); + else + return_vals = gimp_run_procedure_array ("gimp-selection-translate", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * _gimp_selection_float: * @drawable_ID: The drawable from which to float selection. @@ -327,6 +531,45 @@ gimp_selection_invert (GimpImage *image) return success; } +/** + * _gimp_selection_invert: (skip) + * @image_ID: The image. + * + * Invert the selection mask. + * + * This procedure inverts the selection mask. For every pixel in the + * selection channel, its new value is calculated as (255 - old-value). + * + * Returns: TRUE on success. + **/ +gboolean +_gimp_selection_invert (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-selection-invert", + args); + else + return_vals = gimp_run_procedure_array ("gimp-selection-invert", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_selection_sharpen: * @image: The image. @@ -368,6 +611,47 @@ gimp_selection_sharpen (GimpImage *image) return success; } +/** + * _gimp_selection_sharpen: (skip) + * @image_ID: The image. + * + * Sharpen the selection mask. + * + * This procedure sharpens the selection mask. For every pixel in the + * selection channel, if the value is > 127, the new pixel is + * assigned a value of 255. This removes any \"anti-aliasing\" that + * might exist in the selection mask's boundary. + * + * Returns: TRUE on success. + **/ +gboolean +_gimp_selection_sharpen (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-selection-sharpen", + args); + else + return_vals = gimp_run_procedure_array ("gimp-selection-sharpen", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_selection_all: * @image: The image. @@ -407,6 +691,45 @@ gimp_selection_all (GimpImage *image) return success; } +/** + * _gimp_selection_all: (skip) + * @image_ID: The image. + * + * Select all of the image. + * + * This procedure sets the selection mask to completely encompass the + * image. Every pixel in the selection channel is set to 255. + * + * Returns: TRUE on success. + **/ +gboolean +_gimp_selection_all (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-selection-all", + args); + else + return_vals = gimp_run_procedure_array ("gimp-selection-all", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_selection_none: * @image: The image. @@ -446,6 +769,45 @@ gimp_selection_none (GimpImage *image) return success; } +/** + * _gimp_selection_none: (skip) + * @image_ID: The image. + * + * Deselect the entire image. + * + * This procedure deselects the entire image. Every pixel in the + * selection channel is set to 0. + * + * Returns: TRUE on success. + **/ +gboolean +_gimp_selection_none (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-selection-none", + args); + else + return_vals = gimp_run_procedure_array ("gimp-selection-none", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_selection_feather: * @image: The image. @@ -488,6 +850,48 @@ gimp_selection_feather (GimpImage *image, return success; } +/** + * _gimp_selection_feather: (skip) + * @image_ID: The image. + * @radius: Radius of feather (in pixels). + * + * Feather the image's selection + * + * This procedure feathers the selection. Feathering is implemented + * using a gaussian blur. + * + * Returns: TRUE on success. + **/ +gboolean +_gimp_selection_feather (gint32 image_ID, + gdouble radius) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_DOUBLE, radius, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-selection-feather", + args); + else + return_vals = gimp_run_procedure_array ("gimp-selection-feather", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_selection_border: * @image: The image. @@ -531,6 +935,49 @@ gimp_selection_border (GimpImage *image, return success; } +/** + * _gimp_selection_border: (skip) + * @image_ID: The image. + * @radius: Radius of border (in pixels). + * + * Border the image's selection + * + * This procedure borders the selection. Bordering creates a new + * selection which is defined along the boundary of the previous + * selection at every point within the specified radius. + * + * Returns: TRUE on success. + **/ +gboolean +_gimp_selection_border (gint32 image_ID, + gint radius) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_INT, radius, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-selection-border", + args); + else + return_vals = gimp_run_procedure_array ("gimp-selection-border", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_selection_grow: * @image: The image. @@ -573,6 +1020,48 @@ gimp_selection_grow (GimpImage *image, return success; } +/** + * _gimp_selection_grow: (skip) + * @image_ID: The image. + * @steps: Steps of grow (in pixels). + * + * Grow the image's selection + * + * This procedure grows the selection. Growing involves expanding the + * boundary in all directions by the specified pixel amount. + * + * Returns: TRUE on success. + **/ +gboolean +_gimp_selection_grow (gint32 image_ID, + gint steps) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_INT, steps, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-selection-grow", + args); + else + return_vals = gimp_run_procedure_array ("gimp-selection-grow", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_selection_shrink: * @image: The image. @@ -616,6 +1105,49 @@ gimp_selection_shrink (GimpImage *image, return success; } +/** + * _gimp_selection_shrink: (skip) + * @image_ID: The image. + * @steps: Steps of shrink (in pixels). + * + * Shrink the image's selection + * + * This procedure shrinks the selection. Shrinking involves trimming + * the existing selection boundary on all sides by the specified number + * of pixels. + * + * Returns: TRUE on success. + **/ +gboolean +_gimp_selection_shrink (gint32 image_ID, + gint steps) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_INT, steps, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-selection-shrink", + args); + else + return_vals = gimp_run_procedure_array ("gimp-selection-shrink", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_selection_flood: * @image: The image. @@ -659,6 +1191,49 @@ gimp_selection_flood (GimpImage *image) return success; } +/** + * _gimp_selection_flood: (skip) + * @image_ID: The image. + * + * Remove holes from the image's selection + * + * This procedure removes holes from the selection, that can come from + * selecting a patchy area with the Fuzzy Select Tool. In technical + * terms this procedure floods the selection. See the Algorithms page + * in the developer wiki for details. + * + * Returns: TRUE on success. + * + * Since: 2.10 + **/ +gboolean +_gimp_selection_flood (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-selection-flood", + args); + else + return_vals = gimp_run_procedure_array ("gimp-selection-flood", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_selection_save: * @image: The image. @@ -699,3 +1274,44 @@ gimp_selection_save (GimpImage *image) return channel_ID; } + +/** + * _gimp_selection_save: (skip) + * @image_ID: The image. + * + * Copy the selection mask to a new channel. + * + * This procedure copies the selection mask and stores the content in a + * new channel. The new channel is automatically inserted into the + * image's list of channels. + * + * Returns: The new channel. + **/ +gint32 +_gimp_selection_save (gint32 image_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint32 channel_ID = -1; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-selection-save", + args); + else + return_vals = gimp_run_procedure_array ("gimp-selection-save", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + channel_ID = gimp_value_get_channel_id (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return channel_ID; +} diff --git a/libgimp/gimpselection_pdb.h b/libgimp/gimpselection_pdb.h index 740f9c8e73..c42ac1cbaa 100644 --- a/libgimp/gimpselection_pdb.h +++ b/libgimp/gimpselection_pdb.h @@ -32,36 +32,77 @@ G_BEGIN_DECLS /* For information look into the C source or the html documentation */ -gboolean gimp_selection_bounds (GimpImage *image, - gboolean *non_empty, - gint *x1, - gint *y1, - gint *x2, - gint *y2); -gint gimp_selection_value (GimpImage *image, - gint x, - gint y); -gboolean gimp_selection_is_empty (GimpImage *image); -gboolean gimp_selection_translate (GimpImage *image, - gint offx, - gint offy); -G_GNUC_INTERNAL gint32 _gimp_selection_float (gint32 drawable_ID, - gint offx, - gint offy); -gboolean gimp_selection_invert (GimpImage *image); -gboolean gimp_selection_sharpen (GimpImage *image); -gboolean gimp_selection_all (GimpImage *image); -gboolean gimp_selection_none (GimpImage *image); -gboolean gimp_selection_feather (GimpImage *image, - gdouble radius); -gboolean gimp_selection_border (GimpImage *image, - gint radius); -gboolean gimp_selection_grow (GimpImage *image, - gint steps); -gboolean gimp_selection_shrink (GimpImage *image, - gint steps); -gboolean gimp_selection_flood (GimpImage *image); -gint32 gimp_selection_save (GimpImage *image); +gboolean gimp_selection_bounds (GimpImage *image, + gboolean *non_empty, + gint *x1, + gint *y1, + gint *x2, + gint *y2); +GIMP_DEPRECATED_FOR(gimp_selection_bounds) +G_GNUC_INTERNAL gboolean _gimp_selection_bounds (gint32 image_ID, + gboolean *non_empty, + gint *x1, + gint *y1, + gint *x2, + gint *y2); +gint gimp_selection_value (GimpImage *image, + gint x, + gint y); +GIMP_DEPRECATED_FOR(gimp_selection_value) +G_GNUC_INTERNAL gint _gimp_selection_value (gint32 image_ID, + gint x, + gint y); +gboolean gimp_selection_is_empty (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_selection_is_empty) +G_GNUC_INTERNAL gboolean _gimp_selection_is_empty (gint32 image_ID); +gboolean gimp_selection_translate (GimpImage *image, + gint offx, + gint offy); +GIMP_DEPRECATED_FOR(gimp_selection_translate) +G_GNUC_INTERNAL gboolean _gimp_selection_translate (gint32 image_ID, + gint offx, + gint offy); +G_GNUC_INTERNAL gint32 _gimp_selection_float (gint32 drawable_ID, + gint offx, + gint offy); +gboolean gimp_selection_invert (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_selection_invert) +G_GNUC_INTERNAL gboolean _gimp_selection_invert (gint32 image_ID); +gboolean gimp_selection_sharpen (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_selection_sharpen) +G_GNUC_INTERNAL gboolean _gimp_selection_sharpen (gint32 image_ID); +gboolean gimp_selection_all (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_selection_all) +G_GNUC_INTERNAL gboolean _gimp_selection_all (gint32 image_ID); +gboolean gimp_selection_none (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_selection_none) +G_GNUC_INTERNAL gboolean _gimp_selection_none (gint32 image_ID); +gboolean gimp_selection_feather (GimpImage *image, + gdouble radius); +GIMP_DEPRECATED_FOR(gimp_selection_feather) +G_GNUC_INTERNAL gboolean _gimp_selection_feather (gint32 image_ID, + gdouble radius); +gboolean gimp_selection_border (GimpImage *image, + gint radius); +GIMP_DEPRECATED_FOR(gimp_selection_border) +G_GNUC_INTERNAL gboolean _gimp_selection_border (gint32 image_ID, + gint radius); +gboolean gimp_selection_grow (GimpImage *image, + gint steps); +GIMP_DEPRECATED_FOR(gimp_selection_grow) +G_GNUC_INTERNAL gboolean _gimp_selection_grow (gint32 image_ID, + gint steps); +gboolean gimp_selection_shrink (GimpImage *image, + gint steps); +GIMP_DEPRECATED_FOR(gimp_selection_shrink) +G_GNUC_INTERNAL gboolean _gimp_selection_shrink (gint32 image_ID, + gint steps); +gboolean gimp_selection_flood (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_selection_flood) +G_GNUC_INTERNAL gboolean _gimp_selection_flood (gint32 image_ID); +gint32 gimp_selection_save (GimpImage *image); +GIMP_DEPRECATED_FOR(gimp_selection_save) +G_GNUC_INTERNAL gint32 _gimp_selection_save (gint32 image_ID); G_END_DECLS diff --git a/libgimp/gimptextlayer_pdb.c b/libgimp/gimptextlayer_pdb.c index d3c937d1a6..c2082de921 100644 --- a/libgimp/gimptextlayer_pdb.c +++ b/libgimp/gimptextlayer_pdb.c @@ -92,6 +92,64 @@ gimp_text_layer_new (GimpImage *image, return layer_ID; } +/** + * _gimp_text_layer_new: (skip) + * @image_ID: The image. + * @text: The text to generate (in UTF-8 encoding). + * @fontname: The name of the font. + * @size: The size of text in either pixels or points. + * @unit: The units of specified size. + * + * Creates a new text layer. + * + * This procedure creates a new text layer. The arguments are kept as + * simple as necessary for the normal case. All text attributes, + * however, can be modified with the appropriate + * gimp_text_layer_set_*() procedures. The new layer still needs to be + * added to the image, as this is not automatic. Add the new layer + * using gimp_image_insert_layer(). + * + * Returns: The new text layer. + * + * Since: 2.6 + **/ +gint32 +_gimp_text_layer_new (gint32 image_ID, + const gchar *text, + const gchar *fontname, + gdouble size, + GimpUnit unit) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint32 layer_ID = -1; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_STRING, text, + G_TYPE_STRING, fontname, + G_TYPE_DOUBLE, size, + GIMP_TYPE_UNIT, unit, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-text-layer-new", + args); + else + return_vals = gimp_run_procedure_array ("gimp-text-layer-new", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return layer_ID; +} + /** * gimp_text_layer_get_text: * @layer_ID: The text layer. diff --git a/libgimp/gimptextlayer_pdb.h b/libgimp/gimptextlayer_pdb.h index da4be7f6e3..2ef1b94d2a 100644 --- a/libgimp/gimptextlayer_pdb.h +++ b/libgimp/gimptextlayer_pdb.h @@ -32,57 +32,63 @@ G_BEGIN_DECLS /* For information look into the C source or the html documentation */ -gint32 gimp_text_layer_new (GimpImage *image, - const gchar *text, - const gchar *fontname, - gdouble size, - GimpUnit unit); -gchar* gimp_text_layer_get_text (gint32 layer_ID); -gboolean gimp_text_layer_set_text (gint32 layer_ID, - const gchar *text); -gchar* gimp_text_layer_get_markup (gint32 layer_ID); -gchar* gimp_text_layer_get_font (gint32 layer_ID); -gboolean gimp_text_layer_set_font (gint32 layer_ID, - const gchar *font); -gdouble gimp_text_layer_get_font_size (gint32 layer_ID, - GimpUnit *unit); -gboolean gimp_text_layer_set_font_size (gint32 layer_ID, - gdouble font_size, - GimpUnit unit); -gboolean gimp_text_layer_get_antialias (gint32 layer_ID); -gboolean gimp_text_layer_set_antialias (gint32 layer_ID, - gboolean antialias); -GimpTextHintStyle gimp_text_layer_get_hint_style (gint32 layer_ID); -gboolean gimp_text_layer_set_hint_style (gint32 layer_ID, - GimpTextHintStyle style); -gboolean gimp_text_layer_get_kerning (gint32 layer_ID); -gboolean gimp_text_layer_set_kerning (gint32 layer_ID, - gboolean kerning); -gchar* gimp_text_layer_get_language (gint32 layer_ID); -gboolean gimp_text_layer_set_language (gint32 layer_ID, - const gchar *language); -GimpTextDirection gimp_text_layer_get_base_direction (gint32 layer_ID); -gboolean gimp_text_layer_set_base_direction (gint32 layer_ID, - GimpTextDirection direction); -GimpTextJustification gimp_text_layer_get_justification (gint32 layer_ID); -gboolean gimp_text_layer_set_justification (gint32 layer_ID, - GimpTextJustification justify); -gboolean gimp_text_layer_get_color (gint32 layer_ID, - GimpRGB *color); -gboolean gimp_text_layer_set_color (gint32 layer_ID, - const GimpRGB *color); -gdouble gimp_text_layer_get_indent (gint32 layer_ID); -gboolean gimp_text_layer_set_indent (gint32 layer_ID, - gdouble indent); -gdouble gimp_text_layer_get_line_spacing (gint32 layer_ID); -gboolean gimp_text_layer_set_line_spacing (gint32 layer_ID, - gdouble line_spacing); -gdouble gimp_text_layer_get_letter_spacing (gint32 layer_ID); -gboolean gimp_text_layer_set_letter_spacing (gint32 layer_ID, - gdouble letter_spacing); -gboolean gimp_text_layer_resize (gint32 layer_ID, - gdouble width, - gdouble height); +gint32 gimp_text_layer_new (GimpImage *image, + const gchar *text, + const gchar *fontname, + gdouble size, + GimpUnit unit); +GIMP_DEPRECATED_FOR(gimp_text_layer_new) +G_GNUC_INTERNAL gint32 _gimp_text_layer_new (gint32 image_ID, + const gchar *text, + const gchar *fontname, + gdouble size, + GimpUnit unit); +gchar* gimp_text_layer_get_text (gint32 layer_ID); +gboolean gimp_text_layer_set_text (gint32 layer_ID, + const gchar *text); +gchar* gimp_text_layer_get_markup (gint32 layer_ID); +gchar* gimp_text_layer_get_font (gint32 layer_ID); +gboolean gimp_text_layer_set_font (gint32 layer_ID, + const gchar *font); +gdouble gimp_text_layer_get_font_size (gint32 layer_ID, + GimpUnit *unit); +gboolean gimp_text_layer_set_font_size (gint32 layer_ID, + gdouble font_size, + GimpUnit unit); +gboolean gimp_text_layer_get_antialias (gint32 layer_ID); +gboolean gimp_text_layer_set_antialias (gint32 layer_ID, + gboolean antialias); +GimpTextHintStyle gimp_text_layer_get_hint_style (gint32 layer_ID); +gboolean gimp_text_layer_set_hint_style (gint32 layer_ID, + GimpTextHintStyle style); +gboolean gimp_text_layer_get_kerning (gint32 layer_ID); +gboolean gimp_text_layer_set_kerning (gint32 layer_ID, + gboolean kerning); +gchar* gimp_text_layer_get_language (gint32 layer_ID); +gboolean gimp_text_layer_set_language (gint32 layer_ID, + const gchar *language); +GimpTextDirection gimp_text_layer_get_base_direction (gint32 layer_ID); +gboolean gimp_text_layer_set_base_direction (gint32 layer_ID, + GimpTextDirection direction); +GimpTextJustification gimp_text_layer_get_justification (gint32 layer_ID); +gboolean gimp_text_layer_set_justification (gint32 layer_ID, + GimpTextJustification justify); +gboolean gimp_text_layer_get_color (gint32 layer_ID, + GimpRGB *color); +gboolean gimp_text_layer_set_color (gint32 layer_ID, + const GimpRGB *color); +gdouble gimp_text_layer_get_indent (gint32 layer_ID); +gboolean gimp_text_layer_set_indent (gint32 layer_ID, + gdouble indent); +gdouble gimp_text_layer_get_line_spacing (gint32 layer_ID); +gboolean gimp_text_layer_set_line_spacing (gint32 layer_ID, + gdouble line_spacing); +gdouble gimp_text_layer_get_letter_spacing (gint32 layer_ID); +gboolean gimp_text_layer_set_letter_spacing (gint32 layer_ID, + gdouble letter_spacing); +gboolean gimp_text_layer_resize (gint32 layer_ID, + gdouble width, + gdouble height); G_END_DECLS diff --git a/libgimp/gimptexttool_pdb.c b/libgimp/gimptexttool_pdb.c index 041e1925f2..8777c5937c 100644 --- a/libgimp/gimptexttool_pdb.c +++ b/libgimp/gimptexttool_pdb.c @@ -113,6 +113,85 @@ gimp_text_fontname (GimpImage *image, return text_layer_ID; } +/** + * _gimp_text_fontname: (skip) + * @image_ID: The image. + * @drawable_ID: The affected drawable: (-1 for a new text layer). + * @x: The x coordinate for the left of the text bounding box. + * @y: The y coordinate for the top of the text bounding box. + * @text: The text to generate (in UTF-8 encoding). + * @border: The size of the border. + * @antialias: Antialiasing. + * @size: The size of text in either pixels or points. + * @size_type: The units of specified size. + * @fontname: The name of the font. + * + * Add text at the specified location as a floating selection or a new + * layer. + * + * This tool requires a fontname matching an installed PangoFT2 font. + * You can specify the fontsize in units of pixels or points, and the + * appropriate metric is specified using the size_type argument. The x + * and y parameters together control the placement of the new text by + * specifying the upper left corner of the text bounding box. If the + * specified drawable parameter is valid, the text will be created as a + * floating selection attached to the drawable. If the drawable + * parameter is not valid (-1), the text will appear as a new layer. + * Finally, a border can be specified around the final rendered text. + * The border is measured in pixels. Parameter size-type is not used + * and is currently ignored. If you need to display a font in points, + * divide the size in points by 72.0 and multiply it by the image's + * vertical resolution. + * + * Returns: The new text layer or -1 if no layer was created. + **/ +gint32 +_gimp_text_fontname (gint32 image_ID, + gint32 drawable_ID, + gdouble x, + gdouble y, + const gchar *text, + gint border, + gboolean antialias, + gdouble size, + GimpSizeType size_type, + const gchar *fontname) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint32 text_layer_ID = -1; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + GIMP_TYPE_DRAWABLE_ID, drawable_ID, + G_TYPE_DOUBLE, x, + G_TYPE_DOUBLE, y, + G_TYPE_STRING, text, + G_TYPE_INT, border, + G_TYPE_BOOLEAN, antialias, + G_TYPE_DOUBLE, size, + GIMP_TYPE_SIZE_TYPE, size_type, + G_TYPE_STRING, fontname, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-text-fontname", + args); + else + return_vals = gimp_run_procedure_array ("gimp-text-fontname", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + text_layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return text_layer_ID; +} + /** * gimp_text_get_extents_fontname: * @text: The text to generate (in UTF-8 encoding). diff --git a/libgimp/gimptexttool_pdb.h b/libgimp/gimptexttool_pdb.h index cc3b6ab7f7..46a8fdc2ea 100644 --- a/libgimp/gimptexttool_pdb.h +++ b/libgimp/gimptexttool_pdb.h @@ -32,24 +32,35 @@ G_BEGIN_DECLS /* For information look into the C source or the html documentation */ -gint32 gimp_text_fontname (GimpImage *image, - gint32 drawable_ID, - gdouble x, - gdouble y, - const gchar *text, - gint border, - gboolean antialias, - gdouble size, - GimpSizeType size_type, - const gchar *fontname); -gboolean gimp_text_get_extents_fontname (const gchar *text, - gdouble size, - GimpSizeType size_type, - const gchar *fontname, - gint *width, - gint *height, - gint *ascent, - gint *descent); +gint32 gimp_text_fontname (GimpImage *image, + gint32 drawable_ID, + gdouble x, + gdouble y, + const gchar *text, + gint border, + gboolean antialias, + gdouble size, + GimpSizeType size_type, + const gchar *fontname); +GIMP_DEPRECATED_FOR(gimp_text_fontname) +G_GNUC_INTERNAL gint32 _gimp_text_fontname (gint32 image_ID, + gint32 drawable_ID, + gdouble x, + gdouble y, + const gchar *text, + gint border, + gboolean antialias, + gdouble size, + GimpSizeType size_type, + const gchar *fontname); +gboolean gimp_text_get_extents_fontname (const gchar *text, + gdouble size, + GimpSizeType size_type, + const gchar *fontname, + gint *width, + gint *height, + gint *ascent, + gint *descent); G_END_DECLS diff --git a/libgimp/gimpvectors_pdb.c b/libgimp/gimpvectors_pdb.c index f68da7e754..3f3a6c7499 100644 --- a/libgimp/gimpvectors_pdb.c +++ b/libgimp/gimpvectors_pdb.c @@ -79,6 +79,51 @@ gimp_vectors_new (GimpImage *image, return vectors_ID; } +/** + * _gimp_vectors_new: (skip) + * @image_ID: The image. + * @name: the name of the new vector object. + * + * Creates a new empty vectors object. + * + * Creates a new empty vectors object. The vectors object needs to be + * added to the image using gimp_image_insert_vectors(). + * + * Returns: the current vector object, 0 if no vector exists in the image. + * + * Since: 2.4 + **/ +gint32 +_gimp_vectors_new (gint32 image_ID, + const gchar *name) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint32 vectors_ID = -1; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_STRING, name, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-vectors-new", + args); + else + return_vals = gimp_run_procedure_array ("gimp-vectors-new", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + vectors_ID = gimp_value_get_vectors_id (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return vectors_ID; +} + /** * gimp_vectors_new_from_text_layer: * @image: The image. @@ -124,6 +169,51 @@ gimp_vectors_new_from_text_layer (GimpImage *image, return vectors_ID; } +/** + * _gimp_vectors_new_from_text_layer: (skip) + * @image_ID: The image. + * @layer_ID: The text layer. + * + * Creates a new vectors object from a text layer. + * + * Creates a new vectors object from a text layer. The vectors object + * needs to be added to the image using gimp_image_insert_vectors(). + * + * Returns: The vectors of the text layer. + * + * Since: 2.6 + **/ +gint32 +_gimp_vectors_new_from_text_layer (gint32 image_ID, + gint32 layer_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gint32 vectors_ID = -1; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + GIMP_TYPE_LAYER_ID, layer_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-vectors-new-from-text-layer", + args); + else + return_vals = gimp_run_procedure_array ("gimp-vectors-new-from-text-layer", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + vectors_ID = gimp_value_get_vectors_id (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return vectors_ID; +} + /** * gimp_vectors_copy: * @vectors_ID: The vectors object to copy. @@ -1194,6 +1284,69 @@ gimp_vectors_import_from_file (GimpImage *image, return success; } +/** + * _gimp_vectors_import_from_file: (skip) + * @image_ID: The image. + * @filename: The name of the SVG file to import. + * @merge: Merge paths into a single vectors object. + * @scale: Scale the SVG to image dimensions. + * @num_vectors: (out): The number of newly created vectors. + * @vectors_ids: (out) (array length=num_vectors): The list of newly created vectors. + * + * Import paths from an SVG file. + * + * This procedure imports paths from an SVG file. SVG elements other + * than paths and basic shapes are ignored. + * + * Returns: TRUE on success. + * + * Since: 2.4 + **/ +gboolean +_gimp_vectors_import_from_file (gint32 image_ID, + const gchar *filename, + gboolean merge, + gboolean scale, + gint *num_vectors, + gint **vectors_ids) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_STRING, filename, + G_TYPE_BOOLEAN, merge, + G_TYPE_BOOLEAN, scale, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-vectors-import-from-file", + args); + else + return_vals = gimp_run_procedure_array ("gimp-vectors-import-from-file", + args); + gimp_value_array_unref (args); + + *num_vectors = 0; + *vectors_ids = NULL; + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + if (success) + { + *num_vectors = g_value_get_int (gimp_value_array_index (return_vals, 1)); + *vectors_ids = gimp_value_dup_int32_array (gimp_value_array_index (return_vals, 2)); + } + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_vectors_import_from_string: * @image: The image. @@ -1261,6 +1414,73 @@ gimp_vectors_import_from_string (GimpImage *image, return success; } +/** + * _gimp_vectors_import_from_string: (skip) + * @image_ID: The image. + * @string: A string that must be a complete and valid SVG document. + * @length: Number of bytes in string or -1 if the string is NULL terminated. + * @merge: Merge paths into a single vectors object. + * @scale: Scale the SVG to image dimensions. + * @num_vectors: (out): The number of newly created vectors. + * @vectors_ids: (out) (array length=num_vectors): The list of newly created vectors. + * + * Import paths from an SVG string. + * + * This procedure works like gimp_vectors_import_from_file() but takes + * a string rather than reading the SVG from a file. This allows you to + * write scripts that generate SVG and feed it to GIMP. + * + * Returns: TRUE on success. + * + * Since: 2.4 + **/ +gboolean +_gimp_vectors_import_from_string (gint32 image_ID, + const gchar *string, + gint length, + gboolean merge, + gboolean scale, + gint *num_vectors, + gint **vectors_ids) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_STRING, string, + G_TYPE_INT, length, + G_TYPE_BOOLEAN, merge, + G_TYPE_BOOLEAN, scale, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-vectors-import-from-string", + args); + else + return_vals = gimp_run_procedure_array ("gimp-vectors-import-from-string", + args); + gimp_value_array_unref (args); + + *num_vectors = 0; + *vectors_ids = NULL; + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + if (success) + { + *num_vectors = g_value_get_int (gimp_value_array_index (return_vals, 1)); + *vectors_ids = gimp_value_dup_int32_array (gimp_value_array_index (return_vals, 2)); + } + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_vectors_export_to_file: * @image: The image. @@ -1310,6 +1530,55 @@ gimp_vectors_export_to_file (GimpImage *image, return success; } +/** + * _gimp_vectors_export_to_file: (skip) + * @image_ID: The image. + * @filename: The name of the SVG file to create. + * @vectors_ID: The vectors object to be saved, or 0 for all in the image. + * + * save a path as an SVG file. + * + * This procedure creates an SVG file to save a Vectors object, that + * is, a path. The resulting file can be edited using a vector graphics + * application, or later reloaded into GIMP. If you pass 0 as the + * 'vectors' argument, then all paths in the image will be exported. + * + * Returns: TRUE on success. + * + * Since: 2.6 + **/ +gboolean +_gimp_vectors_export_to_file (gint32 image_ID, + const gchar *filename, + gint32 vectors_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + G_TYPE_STRING, filename, + GIMP_TYPE_VECTORS_ID, vectors_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-vectors-export-to-file", + args); + else + return_vals = gimp_run_procedure_array ("gimp-vectors-export-to-file", + args); + gimp_value_array_unref (args); + + success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS; + + gimp_value_array_unref (return_vals); + + return success; +} + /** * gimp_vectors_export_to_string: * @image: The image. @@ -1358,3 +1627,51 @@ gimp_vectors_export_to_string (GimpImage *image, return string; } + +/** + * _gimp_vectors_export_to_string: (skip) + * @image_ID: The image. + * @vectors_ID: The vectors object to save, or 0 for all in the image. + * + * Save a path as an SVG string. + * + * This procedure works like gimp_vectors_export_to_file() but creates + * a string rather than a file. The contents are a NUL-terminated + * string that holds a complete XML document. If you pass 0 as the + * 'vectors' argument, then all paths in the image will be exported. + * + * Returns: A string whose contents are a complete SVG document. + * The returned value must be freed with g_free(). + * + * Since: 2.6 + **/ +gchar * +_gimp_vectors_export_to_string (gint32 image_ID, + gint32 vectors_ID) +{ + GimpPDB *pdb = gimp_get_pdb (); + GimpValueArray *args; + GimpValueArray *return_vals; + gchar *string = NULL; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_IMAGE_ID, image_ID, + GIMP_TYPE_VECTORS_ID, vectors_ID, + G_TYPE_NONE); + + if (pdb) + return_vals = gimp_pdb_run_procedure_array (pdb, + "gimp-vectors-export-to-string", + args); + else + return_vals = gimp_run_procedure_array ("gimp-vectors-export-to-string", + args); + gimp_value_array_unref (args); + + if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS) + string = g_value_dup_string (gimp_value_array_index (return_vals, 1)); + + gimp_value_array_unref (return_vals); + + return string; +} diff --git a/libgimp/gimpvectors_pdb.h b/libgimp/gimpvectors_pdb.h index 27c6719f8e..18cfc9fc73 100644 --- a/libgimp/gimpvectors_pdb.h +++ b/libgimp/gimpvectors_pdb.h @@ -32,111 +32,139 @@ G_BEGIN_DECLS /* For information look into the C source or the html documentation */ -gint32 gimp_vectors_new (GimpImage *image, - const gchar *name); -gint32 gimp_vectors_new_from_text_layer (GimpImage *image, - gint32 layer_ID); -gint32 gimp_vectors_copy (gint32 vectors_ID); -gint* gimp_vectors_get_strokes (gint32 vectors_ID, - gint *num_strokes); -gdouble gimp_vectors_stroke_get_length (gint32 vectors_ID, - gint stroke_id, - gdouble precision); -gboolean gimp_vectors_stroke_get_point_at_dist (gint32 vectors_ID, - gint stroke_id, - gdouble dist, - gdouble precision, - gdouble *x_point, - gdouble *y_point, - gdouble *slope, - gboolean *valid); -gboolean gimp_vectors_remove_stroke (gint32 vectors_ID, - gint stroke_id); -gboolean gimp_vectors_stroke_close (gint32 vectors_ID, - gint stroke_id); -gboolean gimp_vectors_stroke_translate (gint32 vectors_ID, - gint stroke_id, - gint off_x, - gint off_y); -gboolean gimp_vectors_stroke_scale (gint32 vectors_ID, - gint stroke_id, - gdouble scale_x, - gdouble scale_y); -gboolean gimp_vectors_stroke_rotate (gint32 vectors_ID, - gint stroke_id, - gdouble center_x, - gdouble center_y, - gdouble angle); -gboolean gimp_vectors_stroke_flip (gint32 vectors_ID, - gint stroke_id, - GimpOrientationType flip_type, - gdouble axis); -gboolean gimp_vectors_stroke_flip_free (gint32 vectors_ID, - gint stroke_id, - gdouble x1, - gdouble y1, - gdouble x2, - gdouble y2); -GimpVectorsStrokeType gimp_vectors_stroke_get_points (gint32 vectors_ID, - gint stroke_id, - gint *num_points, - gdouble **controlpoints, - gboolean *closed); -gint gimp_vectors_stroke_new_from_points (gint32 vectors_ID, - GimpVectorsStrokeType type, - gint num_points, - const gdouble *controlpoints, - gboolean closed); -gdouble* gimp_vectors_stroke_interpolate (gint32 vectors_ID, - gint stroke_id, - gdouble precision, - gint *num_coords, - gboolean *closed); -gint gimp_vectors_bezier_stroke_new_moveto (gint32 vectors_ID, - gdouble x0, - gdouble y0); -gboolean gimp_vectors_bezier_stroke_lineto (gint32 vectors_ID, - gint stroke_id, - gdouble x0, - gdouble y0); -gboolean gimp_vectors_bezier_stroke_conicto (gint32 vectors_ID, - gint stroke_id, - gdouble x0, - gdouble y0, - gdouble x1, - gdouble y1); -gboolean gimp_vectors_bezier_stroke_cubicto (gint32 vectors_ID, - gint stroke_id, - gdouble x0, - gdouble y0, - gdouble x1, - gdouble y1, - gdouble x2, - gdouble y2); -gint gimp_vectors_bezier_stroke_new_ellipse (gint32 vectors_ID, - gdouble x0, - gdouble y0, - gdouble radius_x, - gdouble radius_y, - gdouble angle); -gboolean gimp_vectors_import_from_file (GimpImage *image, - const gchar *filename, - gboolean merge, - gboolean scale, - gint *num_vectors, - gint **vectors_ids); -gboolean gimp_vectors_import_from_string (GimpImage *image, - const gchar *string, - gint length, - gboolean merge, - gboolean scale, - gint *num_vectors, - gint **vectors_ids); -gboolean gimp_vectors_export_to_file (GimpImage *image, - const gchar *filename, - gint32 vectors_ID); -gchar* gimp_vectors_export_to_string (GimpImage *image, - gint32 vectors_ID); +gint32 gimp_vectors_new (GimpImage *image, + const gchar *name); +GIMP_DEPRECATED_FOR(gimp_vectors_new) +G_GNUC_INTERNAL gint32 _gimp_vectors_new (gint32 image_ID, + const gchar *name); +gint32 gimp_vectors_new_from_text_layer (GimpImage *image, + gint32 layer_ID); +GIMP_DEPRECATED_FOR(gimp_vectors_new_from_text_layer) +G_GNUC_INTERNAL gint32 _gimp_vectors_new_from_text_layer (gint32 image_ID, + gint32 layer_ID); +gint32 gimp_vectors_copy (gint32 vectors_ID); +gint* gimp_vectors_get_strokes (gint32 vectors_ID, + gint *num_strokes); +gdouble gimp_vectors_stroke_get_length (gint32 vectors_ID, + gint stroke_id, + gdouble precision); +gboolean gimp_vectors_stroke_get_point_at_dist (gint32 vectors_ID, + gint stroke_id, + gdouble dist, + gdouble precision, + gdouble *x_point, + gdouble *y_point, + gdouble *slope, + gboolean *valid); +gboolean gimp_vectors_remove_stroke (gint32 vectors_ID, + gint stroke_id); +gboolean gimp_vectors_stroke_close (gint32 vectors_ID, + gint stroke_id); +gboolean gimp_vectors_stroke_translate (gint32 vectors_ID, + gint stroke_id, + gint off_x, + gint off_y); +gboolean gimp_vectors_stroke_scale (gint32 vectors_ID, + gint stroke_id, + gdouble scale_x, + gdouble scale_y); +gboolean gimp_vectors_stroke_rotate (gint32 vectors_ID, + gint stroke_id, + gdouble center_x, + gdouble center_y, + gdouble angle); +gboolean gimp_vectors_stroke_flip (gint32 vectors_ID, + gint stroke_id, + GimpOrientationType flip_type, + gdouble axis); +gboolean gimp_vectors_stroke_flip_free (gint32 vectors_ID, + gint stroke_id, + gdouble x1, + gdouble y1, + gdouble x2, + gdouble y2); +GimpVectorsStrokeType gimp_vectors_stroke_get_points (gint32 vectors_ID, + gint stroke_id, + gint *num_points, + gdouble **controlpoints, + gboolean *closed); +gint gimp_vectors_stroke_new_from_points (gint32 vectors_ID, + GimpVectorsStrokeType type, + gint num_points, + const gdouble *controlpoints, + gboolean closed); +gdouble* gimp_vectors_stroke_interpolate (gint32 vectors_ID, + gint stroke_id, + gdouble precision, + gint *num_coords, + gboolean *closed); +gint gimp_vectors_bezier_stroke_new_moveto (gint32 vectors_ID, + gdouble x0, + gdouble y0); +gboolean gimp_vectors_bezier_stroke_lineto (gint32 vectors_ID, + gint stroke_id, + gdouble x0, + gdouble y0); +gboolean gimp_vectors_bezier_stroke_conicto (gint32 vectors_ID, + gint stroke_id, + gdouble x0, + gdouble y0, + gdouble x1, + gdouble y1); +gboolean gimp_vectors_bezier_stroke_cubicto (gint32 vectors_ID, + gint stroke_id, + gdouble x0, + gdouble y0, + gdouble x1, + gdouble y1, + gdouble x2, + gdouble y2); +gint gimp_vectors_bezier_stroke_new_ellipse (gint32 vectors_ID, + gdouble x0, + gdouble y0, + gdouble radius_x, + gdouble radius_y, + gdouble angle); +gboolean gimp_vectors_import_from_file (GimpImage *image, + const gchar *filename, + gboolean merge, + gboolean scale, + gint *num_vectors, + gint **vectors_ids); +GIMP_DEPRECATED_FOR(gimp_vectors_import_from_file) +G_GNUC_INTERNAL gboolean _gimp_vectors_import_from_file (gint32 image_ID, + const gchar *filename, + gboolean merge, + gboolean scale, + gint *num_vectors, + gint **vectors_ids); +gboolean gimp_vectors_import_from_string (GimpImage *image, + const gchar *string, + gint length, + gboolean merge, + gboolean scale, + gint *num_vectors, + gint **vectors_ids); +GIMP_DEPRECATED_FOR(gimp_vectors_import_from_string) +G_GNUC_INTERNAL gboolean _gimp_vectors_import_from_string (gint32 image_ID, + const gchar *string, + gint length, + gboolean merge, + gboolean scale, + gint *num_vectors, + gint **vectors_ids); +gboolean gimp_vectors_export_to_file (GimpImage *image, + const gchar *filename, + gint32 vectors_ID); +GIMP_DEPRECATED_FOR(gimp_vectors_export_to_file) +G_GNUC_INTERNAL gboolean _gimp_vectors_export_to_file (gint32 image_ID, + const gchar *filename, + gint32 vectors_ID); +gchar* gimp_vectors_export_to_string (GimpImage *image, + gint32 vectors_ID); +GIMP_DEPRECATED_FOR(gimp_vectors_export_to_string) +G_GNUC_INTERNAL gchar* _gimp_vectors_export_to_string (gint32 image_ID, + gint32 vectors_ID); G_END_DECLS diff --git a/pdb/lib.pl b/pdb/lib.pl index 8dda2e79c5..c76b7c8c87 100644 --- a/pdb/lib.pl +++ b/pdb/lib.pl @@ -45,17 +45,23 @@ sub desc_wrap { return $wrapped; } -sub generate { - my @procs = @{(shift)}; - my %out; +sub generate_fun { + my ($proc, $out, $api_deprecated) = @_; + my @inargs = @{$proc->{inargs}} if (defined $proc->{inargs}); + my @outargs = @{$proc->{outargs}} if (defined $proc->{outargs}); sub libtype { my $arg = shift; my $outarg = shift; + my $api_deprecated = shift; my ($type, $name) = &arg_parse($arg->{type}); my $argtype = $arg_types{$type}; my $rettype = ''; - + + if ($api_deprecated && $argtype->{name} eq 'IMAGE') { + return 'gint32 '; + } + if (exists $argtype->{id}) { return 'gint32 '; } @@ -73,371 +79,393 @@ sub generate { } $rettype .= $argtype->{const_type}; } - + $rettype =~ s/int32/int/ unless exists $arg->{keep_size}; $rettype .= '*' if exists $argtype->{struct}; return $rettype; } - foreach $name (@procs) { - my $proc = $main::pdb{$name}; - my $out = \%{$out{$proc->{group}}}; + my $funcname = "gimp_$name"; + my $wrapped = ""; + my %usednames; + my $retdesc = " * Returns:"; + my $func_annotations = ""; - my @inargs = @{$proc->{inargs}} if (defined $proc->{inargs}); - my @outargs = @{$proc->{outargs}} if (defined $proc->{outargs}); + if ($proc->{lib_private}) { + $wrapped = '_'; + } - my $funcname = "gimp_$name"; - my $wrapped = ""; - my %usednames; - my $retdesc = " * Returns:"; + if ($api_deprecated) { + push @{$out->{protos}}, "GIMP_DEPRECATED_FOR($wrapped$funcname)\n"; + $func_annotations .= " (skip)"; + } + elsif ($proc->{deprecated}) { + if ($proc->{deprecated} eq 'NONE') { + push @{$out->{protos}}, "GIMP_DEPRECATED\n"; + } + else { + my $underscores = $proc->{deprecated}; + $underscores =~ s/-/_/g; - if ($proc->{lib_private}) { - $wrapped = '_'; - } + push @{$out->{protos}}, "GIMP_DEPRECATED_FOR($underscores)\n"; + } + } - if ($proc->{deprecated}) { - if ($proc->{deprecated} eq 'NONE') { - push @{$out->{protos}}, "GIMP_DEPRECATED\n"; - } - else { - my $underscores = $proc->{deprecated}; - $underscores =~ s/-/_/g; + # Add an underscore for deprecated API. If the original was already + # private, this will be 2 underscores. + if ($api_deprecated) { + $wrapped .= '_'; + } - push @{$out->{protos}}, "GIMP_DEPRECATED_FOR($underscores)\n"; - } - } + # Find the return argument (defaults to the first arg if not + # explicitly set + my $retarg = undef; + $retvoid = 0; + foreach (@outargs) { + $retarg = $_, last if exists $_->{retval}; + } - # Find the return argument (defaults to the first arg if not - # explicitly set - my $retarg = undef; - $retvoid = 0; - foreach (@outargs) { - $retarg = $_, last if exists $_->{retval}; - } - - unless ($retarg) { - if (scalar @outargs) { - if (exists $outargs[0]->{void_ret}) { - $retvoid = 1; - } - else { - $retarg = exists $outargs[0]->{num} ? $outargs[1] - : $outargs[0]; - } - } - } - - my $rettype; - if ($retarg) { - my ($type) = &arg_parse($retarg->{type}); - my $argtype = $arg_types{$type}; - my $annotate = ""; - $rettype = &libtype($retarg, 1); - chop $rettype unless $rettype =~ /\*$/; - - $retarg->{retval} = 1; - - if (exists $argtype->{array}) { - $annotate = " (array length=$retarg->{array}->{name})"; - } - - if (exists $argtype->{out_annotate}) { - $annotate .= " $argtype->{out_annotate}"; - } - - if ($annotate eq "") { - $retdesc .= " $retarg->{desc}"; - } - else { - if (exists $retarg->{desc}) { - if ((length ($annotate) + - length ($retarg->{desc})) > 65) { - $retdesc .= $annotate . ":\n * " . $retarg->{desc}; - } - else { - $retdesc .= $annotate . ": " . $retarg->{desc}; - } - } - } - - unless ($retdesc =~ /[\.\!\?]$/) { $retdesc .= '.' } - - if ($retarg->{type} eq 'string') { - $retdesc .= "\n * The returned value must be freed with g_free()."; - } - elsif ($retarg->{type} eq 'stringarray') { - $retdesc .= "\n * The returned value must be freed with g_strfreev()."; - } - elsif ($retarg->{type} eq 'param') { - $retdesc .= "\n * The returned value must be freed with g_param_spec_unref()."; - } - elsif (exists $argtype->{array}) { - $retdesc .= "\n * The returned value must be freed with g_free()."; - } - } - else { - # No return values - $rettype = 'void'; - } - - # The parameters to the function - my $arglist = ""; - my $argdesc = ""; - my $sincedesc = ""; - my $value_array = ""; - my $arg_array = ""; - my $argc = 0; - foreach (@inargs) { - my ($type, @typeinfo) = &arg_parse($_->{type}); - my $arg = $arg_types{$type}; - my $var = $_->{name}; - my $desc = exists $_->{desc} ? $_->{desc} : ""; - my $var_len; - my $value; - - $var .= '_ID' if $arg->{id}; - - # This gets passed to gimp_value_array_new_with_types() - if ($type eq 'enum') { - $enum_type = $typeinfo[0]; - $enum_type =~ s/([a-z])([A-Z])/$1_$2/g; - $enum_type =~ s/([A-Z]+)([A-Z])/$1_$2/g; - $enum_type =~ tr/[a-z]/[A-Z]/; - $enum_type =~ s/^GIMP/GIMP_TYPE/; - $enum_type =~ s/^GEGL/GEGL_TYPE/; - - $value_array .= "$enum_type, "; - } - else { - $value_array .= "$arg->{gtype}, "; - } - - if (exists $_->{array}) { - $value_array .= "NULL"; - } - elsif (exists $arg->{convert_func}) { - $value_array .= eval qq/"$arg->{convert_func}"/; + unless ($retarg) { + if (scalar @outargs) { + if (exists $outargs[0]->{void_ret}) { + $retvoid = 1; } - else { - $value_array .= "$var"; - } + else { + $retarg = exists $outargs[0]->{num} ? $outargs[1] + : $outargs[0]; + } + } + } - $value_array .= ",\n" . " " x 42; + my $rettype; + if ($retarg) { + my ($type) = &arg_parse($retarg->{type}); + my $argtype = $arg_types{$type}; + my $annotate = ""; + $rettype = &libtype($retarg, 1, $api_deprecated); + chop $rettype unless $rettype =~ /\*$/; - if (exists $_->{array}) { - my $arrayarg = $_->{array}; + $retarg->{retval} = 1; - $value = "gimp_value_array_index (args, $argc)"; + if (exists $argtype->{array}) { + $annotate = " (array length=$retarg->{array}->{name})"; + } - if (exists $arrayarg->{name}) { - $var_len = $arrayarg->{name}; - } - else { - $var_len = 'num_' . $_->{name}; - } + if ($api_deprecated) { + if (exists $argtype->{out_annotate_d}) { + $annotate .= " $argtype->{out_annotate_d}"; + } + } + elsif (exists $argtype->{out_annotate}) { + $annotate .= " $argtype->{out_annotate}"; + } - # This is the list of g_value_set_foo_array - $arg_array .= eval qq/" $arg->{set_value_func};\n"/; - } + if ($annotate eq "") { + $retdesc .= " $retarg->{desc}"; + } + else { + if (exists $retarg->{desc}) { + if ((length ($annotate) + + length ($retarg->{desc})) > 65) { + $retdesc .= $annotate . ":\n * " . $retarg->{desc}; + } + else { + $retdesc .= $annotate . ": " . $retarg->{desc}; + } + } + } - $usednames{$_->{name}}++; + unless ($retdesc =~ /[\.\!\?]$/) { $retdesc .= '.' } - $arglist .= &libtype($_, 0); - $arglist .= $_->{name}; - $arglist .= '_ID' if $arg->{id}; - $arglist .= ', '; + if ($retarg->{type} eq 'string') { + $retdesc .= "\n * The returned value must be freed with g_free()."; + } + elsif ($retarg->{type} eq 'stringarray') { + $retdesc .= "\n * The returned value must be freed with g_strfreev()."; + } + elsif ($retarg->{type} eq 'param') { + $retdesc .= "\n * The returned value must be freed with g_param_spec_unref()."; + } + elsif (exists $argtype->{array}) { + $retdesc .= "\n * The returned value must be freed with g_free()."; + } + } + else { + # No return values + $rettype = 'void'; + } - $argdesc .= " * \@$_->{name}"; - $argdesc .= '_ID' if $arg->{id}; - $argdesc .= ":"; + # The parameters to the function + my $arglist = ""; + my $argdesc = ""; + my $sincedesc = ""; + my $value_array = ""; + my $arg_array = ""; + my $argc = 0; + foreach (@inargs) { + my ($type, @typeinfo) = &arg_parse($_->{type}); + my $arg = $arg_types{$type}; + my $var = $_->{name}; + my $desc = exists $_->{desc} ? $_->{desc} : ""; + my $var_len; + my $value; + my $is_id = ($arg->{id} || ($api_deprecated && $arg->{name} eq 'IMAGE')); - if (exists $arg->{array}) { - $argdesc .= " (array length=@inargs[$argc - 1]->{name})"; - } + $var .= '_ID' if $is_id; - if (exists $arg->{in_annotate}) { - $argdesc .= " $arg->{in_annotate}"; - } + # This gets passed to gimp_value_array_new_with_types() + if ($type eq 'enum') { + $enum_type = $typeinfo[0]; + $enum_type =~ s/([a-z])([A-Z])/$1_$2/g; + $enum_type =~ s/([A-Z]+)([A-Z])/$1_$2/g; + $enum_type =~ tr/[a-z]/[A-Z]/; + $enum_type =~ s/^GIMP/GIMP_TYPE/; + $enum_type =~ s/^GEGL/GEGL_TYPE/; - if (exists $arg->{array} || exists $arg->{in_annotate}) { - $argdesc .= ":"; + $value_array .= "$enum_type, "; + } + else { + $value_array .= "$arg->{gtype}, "; + } + + if (exists $_->{array}) { + $value_array .= "NULL"; + } + elsif (exists $arg->{convert_func} && ! $api_deprecated) { + $value_array .= eval qq/"$arg->{convert_func}"/; + } + else { + $value_array .= "$var"; + } + + $value_array .= ",\n" . " " x 42; + + if (exists $_->{array}) { + my $arrayarg = $_->{array}; + + $value = "gimp_value_array_index (args, $argc)"; + + if (exists $arrayarg->{name}) { + $var_len = $arrayarg->{name}; + } + else { + $var_len = 'num_' . $_->{name}; } - $argdesc .= " $desc"; + # This is the list of g_value_set_foo_array + $arg_array .= eval qq/" $arg->{set_value_func};\n"/; + } - unless ($argdesc =~ /[\.\!\?]$/) { $argdesc .= '.' } - $argdesc .= "\n"; + $usednames{$_->{name}}++; - $argc++; - } + $arglist .= &libtype($_, 0, $api_deprecated); + $arglist .= $_->{name}; + $arglist .= '_ID' if $is_id; + $arglist .= ', '; - # This marshals the return value(s) - my $return_args = ""; - my $return_marshal = "gimp_value_array_unref (return_vals);"; + $argdesc .= " * \@$_->{name}"; + $argdesc .= '_ID' if $is_id; + $argdesc .= ":"; - # return success/failure boolean if we don't have anything else - if ($rettype eq 'void') { - $return_args .= "\n" . ' ' x 2 . "gboolean success = TRUE;"; - $retdesc .= " TRUE on success."; - } + if (exists $arg->{array}) { + $argdesc .= " (array length=@inargs[$argc - 1]->{name})"; + } - # We only need to bother with this if we have to return a value - if ($rettype ne 'void' || $retvoid) { - my $once = 0; - my $firstvar; - my @initnums; + if (exists $arg->{in_annotate}) { + $argdesc .= " $arg->{in_annotate}"; + } - foreach (@outargs) { - my ($type) = &arg_parse($_->{type}); - my $arg = $arg_types{$type}; - my $var; + if (exists $arg->{array} || exists $arg->{in_annotate}) { + $argdesc .= ":"; + } - $return_marshal = "" unless $once++; + $argdesc .= " $desc"; - $_->{libname} = exists $usednames{$_->{name}} ? "ret_$_->{name}" - : $_->{name}; + unless ($argdesc =~ /[\.\!\?]$/) { $argdesc .= '.' } + $argdesc .= "\n"; - if (exists $_->{num}) { - if (!exists $_->{no_lib}) { - push @initnums, $_; - } - } - elsif (exists $_->{retval}) { - $return_args .= "\n" . ' ' x 2; - $return_args .= &libtype($_, 1); + $argc++; + } - # The return value variable - $var = $_->{libname}; - $var .= '_ID' if $arg->{id}; - $return_args .= $var; + # This marshals the return value(s) + my $return_args = ""; + my $return_marshal = "gimp_value_array_unref (return_vals);"; - # Save the first var to "return" it - $firstvar = $var unless defined $firstvar; + # return success/failure boolean if we don't have anything else + if ($rettype eq 'void') { + $return_args .= "\n" . ' ' x 2 . "gboolean success = TRUE;"; + $retdesc .= " TRUE on success."; + } - if ($arg->{id}) { - # Initialize all IDs to -1 - $return_args .= " = -1"; - } - elsif ($_->{libdef}) { - $return_args .= " = $_->{libdef}"; - } - else { - $return_args .= " = $arg->{init_value}"; - } + # We only need to bother with this if we have to return a value + if ($rettype ne 'void' || $retvoid) { + my $once = 0; + my $firstvar; + my @initnums; - $return_args .= ";"; + foreach (@outargs) { + my ($type) = &arg_parse($_->{type}); + my $arg = $arg_types{$type}; + my $var; + my $is_id = ($arg->{id} || ($api_deprecated && $arg->{name} eq 'IMAGE')); - if (exists $_->{array} && exists $_->{array}->{no_lib}) { - $return_args .= "\n" . ' ' x 2 . "gint num_$var;"; - } - } - elsif ($retvoid) { - push @initnums, $_ unless exists $arg->{struct}; - } - } + $return_marshal = "" unless $once++; - if (scalar(@initnums)) { - foreach (@initnums) { - $return_marshal .= "\*$_->{libname} = "; - my ($type) = &arg_parse($_->{type}); - for ($arg_types{$type}->{type}) { - /\*$/ && do { $return_marshal .= "NULL"; last }; - /boolean/ && do { $return_marshal .= "FALSE"; last }; - /double/ && do { $return_marshal .= "0.0"; last }; - $return_marshal .= "0"; - } - $return_marshal .= ";\n "; - } - $return_marshal =~ s/\n $/\n\n /s; - } + $_->{libname} = exists $usednames{$_->{name}} ? "ret_$_->{name}" + : $_->{name}; - if ($rettype eq 'void') { - $return_marshal .= <{num}) { + if (!exists $_->{no_lib}) { + push @initnums, $_; + } + } + elsif (exists $_->{retval}) { + $return_args .= "\n" . ' ' x 2; + $return_args .= &libtype($_, 1, $api_deprecated); + + # The return value variable + $var = $_->{libname}; + $var .= '_ID' if $is_id; + $return_args .= $var; + + # Save the first var to "return" it + $firstvar = $var unless defined $firstvar; + + if ($is_id) { + # Initialize all IDs to -1 + $return_args .= " = -1"; + } + elsif ($_->{libdef}) { + $return_args .= " = $_->{libdef}"; + } + else { + $return_args .= " = $arg->{init_value}"; + } + + $return_args .= ";"; + + if (exists $_->{array} && exists $_->{array}->{no_lib}) { + $return_args .= "\n" . ' ' x 2 . "gint num_$var;"; + } + } + elsif ($retvoid) { + push @initnums, $_ unless exists $arg->{struct}; + } + } + + if (scalar(@initnums)) { + foreach (@initnums) { + $return_marshal .= "\*$_->{libname} = "; + my ($type) = &arg_parse($_->{type}); + for ($arg_types{$type}->{type}) { + /\*$/ && do { $return_marshal .= "NULL"; last }; + /boolean/ && do { $return_marshal .= "FALSE"; last }; + /double/ && do { $return_marshal .= "0.0"; last }; + $return_marshal .= "0"; + } + $return_marshal .= ";\n "; + } + $return_marshal =~ s/\n $/\n\n /s; + } + + if ($rettype eq 'void') { + $return_marshal .= <{type}); - my $desc = exists $_->{desc} ? $_->{desc} : ""; - my $arg = $arg_types{$type}; - my $var; + my $argc = 1; my ($numpos, $numtype); + foreach (@outargs) { + my ($type) = &arg_parse($_->{type}); + my $desc = exists $_->{desc} ? $_->{desc} : ""; + my $arg = $arg_types{$type}; + my $is_id = ($arg->{id} || ($api_deprecated && $arg->{name} eq 'IMAGE')); + my $var; - # The return value variable - $var = ""; + # The return value variable + $var = ""; - unless (exists $_->{retval}) { - $var .= '*'; - $arglist .= &libtype($_, 1); - $arglist .= '*' unless exists $arg->{struct}; - $arglist .= "$_->{libname}"; - $arglist .= '_ID' if $arg->{id}; - $arglist .= ', '; + unless (exists $_->{retval}) { + $var .= '*'; + $arglist .= &libtype($_, 1); + $arglist .= '*' unless exists $arg->{struct}; + $arglist .= "$_->{libname}"; + $arglist .= '_ID' if $is_id; + $arglist .= ', '; - $argdesc .= " * \@$_->{libname}"; - $argdesc .= '_ID' if $arg->{id}; + $argdesc .= " * \@$_->{libname}"; + $argdesc .= '_ID' if $is_id; - if ($arg->{name} eq 'COLOR') { - $argdesc .= ": (out caller-allocates)"; - } - else { - $argdesc .= ": (out)"; - } + if ($arg->{name} eq 'COLOR') { + $argdesc .= ": (out caller-allocates)"; + } + else { + $argdesc .= ": (out)"; + } - if (exists $arg->{array}) { - $argdesc .= " (array length=@outargs[$argc - 2]->{name})"; - } + if (exists $arg->{array}) { + $argdesc .= " (array length=@outargs[$argc - 2]->{name})"; + } - if (exists $arg->{out_annotate}) { - $argdesc .= " $arg->{out_annotate}"; - } + if ($api_deprecated) { + if (exists $arg->{out_annotate_d}) { + $argdesc .= " $arg->{out_annotate_d}"; + } + } + elsif (exists $arg->{out_annotate}) { + $argdesc .= " $arg->{out_annotate}"; + } - $argdesc .= ": $desc"; - } + $argdesc .= ": $desc"; + } - $var = exists $_->{retval} ? "" : '*'; - $var .= $_->{libname}; - $var .= '_ID' if $arg->{id}; + $var = exists $_->{retval} ? "" : '*'; + $var .= $_->{libname}; + $var .= '_ID' if $is_id; - $value = "gimp_value_array_index (return_vals, $argc)"; + $value = "gimp_value_array_index (return_vals, $argc)"; - $return_marshal .= ' ' x 2 if $#outargs; - $return_marshal .= eval qq/" $arg->{dup_value_func};\n"/; + $return_marshal .= ' ' x 2 if $#outargs; + if ($api_deprecated && $arg->{dup_value_func_d}) { + $return_marshal .= eval qq/" $arg->{dup_value_func_d};\n"/; + } + else { + $return_marshal .= eval qq/" $arg->{dup_value_func};\n"/; + } - if ($argdesc) { - unless ($argdesc =~ /[\.\!\?]$/) { $argdesc .= '.' } - unless ($argdesc =~ /\n$/) { $argdesc .= "\n" } - } + if ($argdesc) { + unless ($argdesc =~ /[\.\!\?]$/) { $argdesc .= '.' } + unless ($argdesc =~ /\n$/) { $argdesc .= "\n" } + } - $argc++; - } + $argc++; + } - $return_marshal .= ' ' x 4 . "}\n" if $#outargs; + $return_marshal .= ' ' x 4 . "}\n" if $#outargs; - $return_marshal .= <<'CODE'; + $return_marshal .= <<'CODE'; gimp_value_array_unref (return_vals); CODE - unless ($retvoid) { - $return_marshal .= ' ' x 2 . "return $firstvar;"; - } - else { - $return_marshal .= ' ' x 2 . "return success;"; - } - } - else { - $return_marshal = < 1; - $arglist .= "\t" if $once; - $arglist .= $_; - $arglist .= ",\n"; - $once++; - } - $arglist =~ s/,\n$//; - } - else { - $arglist = "void"; - } - - $rettype = 'gboolean' if $rettype eq 'void'; + my $once = 0; $arglist = ""; + foreach (@arglist) { + my $space = rindex($_, ' '); + my $len = $longest - $space + 1; + $len -= scalar @{[ /\*/g ]}; + substr($_, $space, 1) = ' ' x $len if $space != -1 && $len > 1; + $arglist .= "\t" if $once; + $arglist .= $_; + $arglist .= ",\n"; + $once++; + } + $arglist =~ s/,\n$//; + } + else { + $arglist = "void"; + } - # Our function prototype for the headers - (my $hrettype = $rettype) =~ s/ //g; + $rettype = 'gboolean' if $rettype eq 'void'; - my $proto = "$hrettype $wrapped$funcname ($arglist);\n"; - $proto =~ s/ +/ /g; + # Our function prototype for the headers + (my $hrettype = $rettype) =~ s/ //g; - push @{$out->{protos}}, $proto; + my $proto = "$hrettype $wrapped$funcname ($arglist);\n"; + $proto =~ s/ +/ /g; - my $clist = $arglist; - my $padlen = length($wrapped) + length($funcname) + 2; - my $padding = ' ' x $padlen; - $clist =~ s/\t/$padding/eg; + push @{$out->{protos}}, $proto; - if ($proc->{since}) { - $sincedesc = "\n *\n * Since: $proc->{since}"; - } + my $clist = $arglist; + my $padlen = length($wrapped) + length($funcname) + 2; + my $padding = ' ' x $padlen; + $clist =~ s/\t/$padding/eg; - my $procdesc = ''; + if ($proc->{since}) { + $sincedesc = "\n *\n * Since: $proc->{since}"; + } - if ($proc->{deprecated}) { - if ($proc->{deprecated} eq 'NONE') { - if ($proc->{blurb}) { - $procdesc = &desc_wrap($proc->{blurb}) . "\n *\n"; - } - if ($proc->{help}) { - $procdesc .= &desc_wrap($proc->{help}) . "\n *\n"; - } - $procdesc .= &desc_wrap("Deprecated: There is no replacement " . - "for this procedure."); - } - else { - my $underscores = $proc->{deprecated}; - $underscores =~ s/-/_/g; + my $procdesc = ''; - if ($proc->{blurb}) { - $procdesc = &desc_wrap($proc->{blurb}) . "\n *\n"; - } - if ($proc->{help}) { - $procdesc .= &desc_wrap($proc->{help}) . "\n *\n"; - } - $procdesc .= &desc_wrap("Deprecated: " . - "Use $underscores() instead."); - } - } - else { - $procdesc = &desc_wrap($proc->{blurb}) . "\n *\n" . - &desc_wrap($proc->{help}); - } + if ($proc->{deprecated}) { + if ($proc->{deprecated} eq 'NONE') { + if ($proc->{blurb}) { + $procdesc = &desc_wrap($proc->{blurb}) . "\n *\n"; + } + if ($proc->{help}) { + $procdesc .= &desc_wrap($proc->{help}) . "\n *\n"; + } + $procdesc .= &desc_wrap("Deprecated: There is no replacement " . + "for this procedure."); + } + else { + my $underscores = $proc->{deprecated}; + $underscores =~ s/-/_/g; - $out->{code} .= <{blurb}) { + $procdesc = &desc_wrap($proc->{blurb}) . "\n *\n"; + } + if ($proc->{help}) { + $procdesc .= &desc_wrap($proc->{help}) . "\n *\n"; + } + $procdesc .= &desc_wrap("Deprecated: " . + "Use $underscores() instead."); + } + } + else { + $procdesc = &desc_wrap($proc->{blurb}) . "\n *\n" . + &desc_wrap($proc->{help}); + } + return <{group}}}; + + my @inargs = @{$proc->{inargs}} if (defined $proc->{inargs}); + my @outargs = @{$proc->{outargs}} if (defined $proc->{outargs}); + + # Check if any of the argument or returned value is an image. + $has_image_arg = 0; + foreach (@outargs) { + my ($type, @typeinfo) = &arg_parse($_->{type}); + my $arg = $arg_types{$type}; + if ($arg->{name} eq 'IMAGE') { + $has_image_arg = 1; + last; + } + } + unless ($has_image_arg) { + foreach (@inargs) { + my ($type, @typeinfo) = &arg_parse($_->{type}); + my $arg = $arg_types{$type}; + if ($arg->{name} eq 'IMAGE') { + $has_image_arg = 1; + last; + } + } + } + $out->{code} .= generate_fun($proc, $out, 0); + if ($has_image_arg) { + $out->{code} .= generate_fun($proc, $out, 1); + } } my $lgpl_top = <<'LGPL'; diff --git a/pdb/pdb.pl b/pdb/pdb.pl index 03fcfeb84c..409ddee7c7 100644 --- a/pdb/pdb.pl +++ b/pdb/pdb.pl @@ -166,7 +166,8 @@ package Gimp::CodeGen::pdb; init_value => 'NULL', out_annotate => '(transfer full)', get_value_func => '$var = gimp_value_get_image ($value, gimp)', - dup_value_func => '$var = gimp_image_new_by_id (g_value_get_int ($value))', + dup_value_func => '$var = gimp_image_new_by_id (gimp_value_get_image_id ($value))', + dup_value_func_d=> '$var = gimp_value_get_image_id ($value)', set_value_func => 'gimp_value_set_image_id ($value, gimp_image_get_id ($var))', take_value_func => 'gimp_value_set_image ($value, $var)', convert_func => 'gimp_image_get_id ($var)',