From 3f1491e5720eaf94a73a7a0baf454743e8792802 Mon Sep 17 00:00:00 2001 From: Jehan Date: Tue, 13 Aug 2019 16:16:08 +0200 Subject: [PATCH] libgimp: update non-generated API using GimpItem/GimpDrawable/GimpLayer. I did the same trick with GIMP_DEPRECATED_REPLACE_NEW_API macro, apart for some minor widget API to preview drawable, which I will fix right away in our plug-ins. --- libgimp/gimpaspectpreview.c | 111 ++++++----- libgimp/gimpaspectpreview.h | 2 +- libgimp/gimpdrawable.c | 341 +++++++++++++++++++++++++++----- libgimp/gimpdrawable.h | 64 +++++- libgimp/gimpdrawablepreview.c | 148 +++++++------- libgimp/gimpdrawablepreview.h | 8 +- libgimp/gimpexport.c | 200 ++++++++++++------- libgimp/gimpexport.h | 2 +- libgimp/gimpimagemetadata.c | 15 +- libgimp/gimpitemcombobox.c | 14 +- libgimp/gimplayer.c | 100 +++++++--- libgimp/gimplayer.h | 44 +++-- libgimp/gimpparamspecs.c | 14 +- libgimp/gimpselection.c | 63 +++++- libgimp/gimpselection.h | 22 ++- libgimp/gimptilebackendplugin.c | 14 +- libgimp/gimptilebackendplugin.h | 4 +- libgimp/gimpzoompreview.c | 162 +++++++-------- libgimp/gimpzoompreview.h | 9 +- 19 files changed, 909 insertions(+), 428 deletions(-) diff --git a/libgimp/gimpaspectpreview.c b/libgimp/gimpaspectpreview.c index c2441bacff..40ea37fa1b 100644 --- a/libgimp/gimpaspectpreview.c +++ b/libgimp/gimpaspectpreview.c @@ -46,12 +46,12 @@ enum { PROP_0, - PROP_DRAWABLE_ID + PROP_DRAWABLE }; struct _GimpAspectPreviewPrivate { - gint32 drawable_ID; + GimpDrawable *drawable; }; typedef struct @@ -89,9 +89,8 @@ static void gimp_aspect_preview_untransform (GimpPreview *preview, gint *dest_x, gint *dest_y); -static void gimp_aspect_preview_set_drawable_id - (GimpAspectPreview *preview, - gint32 drawable_ID); +static void gimp_aspect_preview_set_drawable (GimpAspectPreview *preview, + GimpDrawable *drawable); G_DEFINE_TYPE_WITH_PRIVATE (GimpAspectPreview, gimp_aspect_preview, @@ -128,13 +127,13 @@ gimp_aspect_preview_class_init (GimpAspectPreviewClass *klass) * * Since: 2.10 */ - g_object_class_install_property (object_class, PROP_DRAWABLE_ID, - g_param_spec_int ("drawable-id", - "Drawable ID", - "The drawable this preview is attached to", - -1, G_MAXINT, -1, - GIMP_PARAM_READWRITE | - G_PARAM_CONSTRUCT_ONLY)); + g_object_class_install_property (object_class, PROP_DRAWABLE, + g_param_spec_object ("drawable", + "Drawable", + "The drawable this preview is attached to", + GIMP_TYPE_DRAWABLE, + GIMP_PARAM_READWRITE | + G_PARAM_CONSTRUCT_ONLY)); } static void @@ -172,9 +171,11 @@ gimp_aspect_preview_constructed (GObject *object) static void gimp_aspect_preview_dispose (GObject *object) { - const gchar *data_name = g_object_get_data (G_OBJECT (object), - "gimp-aspect-preview-data-name"); + GimpAspectPreviewPrivate *priv = GET_PRIVATE (object); + const gchar *data_name; + data_name = g_object_get_data (G_OBJECT (object), + "gimp-aspect-preview-data-name"); if (data_name) { GimpPreview *preview = GIMP_PREVIEW (object); @@ -185,6 +186,8 @@ gimp_aspect_preview_dispose (GObject *object) gimp_set_data (data_name, &settings, sizeof (PreviewSettings)); } + g_clear_object (&priv->drawable); + G_OBJECT_CLASS (parent_class)->dispose (object); } @@ -199,8 +202,8 @@ gimp_aspect_preview_get_property (GObject *object, switch (property_id) { - case PROP_DRAWABLE_ID: - g_value_set_int (value, priv->drawable_ID); + case PROP_DRAWABLE: + g_value_set_object (value, priv->drawable); break; default: @@ -211,17 +214,16 @@ gimp_aspect_preview_get_property (GObject *object, static void gimp_aspect_preview_set_property (GObject *object, - guint property_id, - const GValue *value, - GParamSpec *pspec) + guint property_id, + const GValue *value, + GParamSpec *pspec) { GimpAspectPreview *preview = GIMP_ASPECT_PREVIEW (object); switch (property_id) { - case PROP_DRAWABLE_ID: - gimp_aspect_preview_set_drawable_id (preview, - g_value_get_int (value)); + case PROP_DRAWABLE: + gimp_aspect_preview_set_drawable (preview, g_value_dup_object (value)); break; default: @@ -247,8 +249,8 @@ gimp_aspect_preview_style_updated (GtkWidget *widget) gint preview_height; gint size; - width = gimp_drawable_width (priv->drawable_ID); - height = gimp_drawable_height (priv->drawable_ID); + width = gimp_drawable_width (priv->drawable); + height = gimp_drawable_height (priv->drawable); gtk_widget_style_get (widget, "size", &size, @@ -297,39 +299,42 @@ gimp_aspect_preview_draw_buffer (GimpPreview *preview, gimp_preview_get_size (preview, &width, &height); - image = gimp_item_get_image (priv->drawable_ID); + image = gimp_item_get_image (GIMP_ITEM (priv->drawable)); if (gimp_selection_is_empty (image)) { gimp_preview_area_draw (GIMP_PREVIEW_AREA (area), 0, 0, width, height, - gimp_drawable_type (priv->drawable_ID), + gimp_drawable_type (priv->drawable), buffer, rowstride); } else { - guchar *sel; - guchar *src; - gint selection_ID; - gint w, h; - gint bpp; + guchar *sel; + guchar *src; + GimpDrawable *selection; + gint selection_ID; + gint w, h; + gint bpp; selection_ID = gimp_image_get_selection (image); + selection = GIMP_DRAWABLE (gimp_item_new_by_id (selection_ID)); w = width; h = height; - src = gimp_drawable_get_thumbnail_data (priv->drawable_ID, + src = gimp_drawable_get_thumbnail_data (priv->drawable, &w, &h, &bpp); - sel = gimp_drawable_get_thumbnail_data (selection_ID, + sel = gimp_drawable_get_thumbnail_data (selection, &w, &h, &bpp); + g_object_unref (selection); gimp_preview_area_mask (GIMP_PREVIEW_AREA (area), 0, 0, width, height, - gimp_drawable_type (priv->drawable_ID), - src, width * gimp_drawable_bpp (priv->drawable_ID), + gimp_drawable_type (priv->drawable), + src, width * gimp_drawable_bpp (priv->drawable), buffer, rowstride, sel, width); @@ -352,8 +357,8 @@ gimp_aspect_preview_transform (GimpPreview *preview, gimp_preview_get_size (preview, &width, &height); - *dest_x = (gdouble) src_x * width / gimp_drawable_width (priv->drawable_ID); - *dest_y = (gdouble) src_y * height / gimp_drawable_height (priv->drawable_ID); + *dest_x = (gdouble) src_x * width / gimp_drawable_width (priv->drawable); + *dest_y = (gdouble) src_y * height / gimp_drawable_height (priv->drawable); } static void @@ -369,13 +374,13 @@ gimp_aspect_preview_untransform (GimpPreview *preview, gimp_preview_get_size (preview, &width, &height); - *dest_x = (gdouble) src_x * gimp_drawable_width (priv->drawable_ID) / width; - *dest_y = (gdouble) src_y * gimp_drawable_height (priv->drawable_ID) / height; + *dest_x = (gdouble) src_x * gimp_drawable_width (priv->drawable) / width; + *dest_y = (gdouble) src_y * gimp_drawable_height (priv->drawable) / height; } static void -gimp_aspect_preview_set_drawable_id (GimpAspectPreview *preview, - gint32 drawable_ID) +gimp_aspect_preview_set_drawable (GimpAspectPreview *preview, + GimpDrawable *drawable) { GimpAspectPreviewPrivate *priv = GET_PRIVATE (preview); gint d_width; @@ -383,12 +388,12 @@ gimp_aspect_preview_set_drawable_id (GimpAspectPreview *preview, gint width; gint height; - g_return_if_fail (priv->drawable_ID < 1); + g_return_if_fail (priv->drawable == NULL); - priv->drawable_ID = drawable_ID; + priv->drawable = drawable; - d_width = gimp_drawable_width (priv->drawable_ID); - d_height = gimp_drawable_height (priv->drawable_ID); + d_width = gimp_drawable_width (priv->drawable); + d_height = gimp_drawable_height (priv->drawable); if (d_width > d_height) { @@ -411,23 +416,23 @@ gimp_aspect_preview_set_drawable_id (GimpAspectPreview *preview, } /** - * gimp_aspect_preview_new_from_drawable_id: - * @drawable_ID: a drawable ID + * gimp_aspect_preview_new_from_drawable: + * @drawable: (transfer none): a drawable * - * Creates a new #GimpAspectPreview widget for @drawable_ID. See also - * gimp_drawable_preview_new_from_drawable_id(). + * Creates a new #GimpAspectPreview widget for @drawable_. See also + * gimp_drawable_preview_new_from_drawable(). * * Since: 2.10 * * Returns: a new #GimpAspectPreview. **/ GtkWidget * -gimp_aspect_preview_new_from_drawable_id (gint32 drawable_ID) +gimp_aspect_preview_new_from_drawable (GimpDrawable *drawable) { - g_return_val_if_fail (gimp_item_is_valid (drawable_ID), NULL); - g_return_val_if_fail (gimp_item_is_drawable (drawable_ID), NULL); + g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL); + g_return_val_if_fail (gimp_item_is_valid (GIMP_ITEM (drawable)), NULL); return g_object_new (GIMP_TYPE_ASPECT_PREVIEW, - "drawable-id", drawable_ID, + "drawable", drawable, NULL); } diff --git a/libgimp/gimpaspectpreview.h b/libgimp/gimpaspectpreview.h index 3e7cc4ead0..e7d126aaaf 100644 --- a/libgimp/gimpaspectpreview.h +++ b/libgimp/gimpaspectpreview.h @@ -67,7 +67,7 @@ struct _GimpAspectPreviewClass GType gimp_aspect_preview_get_type (void) G_GNUC_CONST; -GtkWidget * gimp_aspect_preview_new_from_drawable_id (gint32 drawable_ID); +GtkWidget * gimp_aspect_preview_new_from_drawable (GimpDrawable *drawable); G_END_DECLS diff --git a/libgimp/gimpdrawable.c b/libgimp/gimpdrawable.c index c0a9eff740..da86c2b9b0 100644 --- a/libgimp/gimpdrawable.c +++ b/libgimp/gimpdrawable.c @@ -45,17 +45,17 @@ gimp_drawable_init (GimpDrawable *drawable) guchar * -gimp_drawable_get_thumbnail_data (gint32 drawable_ID, - gint *width, - gint *height, - gint *bpp) +gimp_drawable_get_thumbnail_data (GimpDrawable *drawable, + gint *width, + gint *height, + gint *bpp) { gint ret_width; gint ret_height; guchar *image_data; gint data_size; - _gimp_drawable_thumbnail (drawable_ID, + _gimp_drawable_thumbnail (drawable, *width, *height, &ret_width, @@ -72,13 +72,13 @@ gimp_drawable_get_thumbnail_data (gint32 drawable_ID, /** * gimp_drawable_get_thumbnail: - * @drawable_ID: the drawable ID - * @width: the requested thumbnail width (<= 1024 pixels) - * @height: the requested thumbnail height (<= 1024 pixels) - * @alpha: how to handle an alpha channel + * @drawable: the drawable ID + * @width: the requested thumbnail width (<= 1024 pixels) + * @height: the requested thumbnail height (<= 1024 pixels) + * @alpha: how to handle an alpha channel * * Retrieves a thumbnail pixbuf for the drawable identified by - * @drawable_ID. The thumbnail will be not larger than the requested + * @drawable. The thumbnail will be not larger than the requested * size. * * Returns: (transfer full): a new #GdkPixbuf @@ -86,7 +86,7 @@ gimp_drawable_get_thumbnail_data (gint32 drawable_ID, * Since: 2.2 **/ GdkPixbuf * -gimp_drawable_get_thumbnail (gint32 drawable_ID, +gimp_drawable_get_thumbnail (GimpDrawable *drawable, gint width, gint height, GimpPixbufTransparency alpha) @@ -99,7 +99,7 @@ gimp_drawable_get_thumbnail (gint32 drawable_ID, g_return_val_if_fail (width > 0 && width <= 1024, NULL); g_return_val_if_fail (height > 0 && height <= 1024, NULL); - data = gimp_drawable_get_thumbnail_data (drawable_ID, + data = gimp_drawable_get_thumbnail_data (drawable, &thumb_width, &thumb_height, &thumb_bpp); @@ -113,21 +113,21 @@ gimp_drawable_get_thumbnail (gint32 drawable_ID, } guchar * -gimp_drawable_get_sub_thumbnail_data (gint32 drawable_ID, - gint src_x, - gint src_y, - gint src_width, - gint src_height, - gint *dest_width, - gint *dest_height, - gint *bpp) +gimp_drawable_get_sub_thumbnail_data (GimpDrawable *drawable, + gint src_x, + gint src_y, + gint src_width, + gint src_height, + gint *dest_width, + gint *dest_height, + gint *bpp) { gint ret_width; gint ret_height; guchar *image_data; gint data_size; - _gimp_drawable_sub_thumbnail (drawable_ID, + _gimp_drawable_sub_thumbnail (drawable, src_x, src_y, src_width, src_height, *dest_width, @@ -146,7 +146,7 @@ gimp_drawable_get_sub_thumbnail_data (gint32 drawable_ID, /** * gimp_drawable_get_sub_thumbnail: - * @drawable_ID: the drawable ID + * @drawable: the drawable ID * @src_x: the x coordinate of the area * @src_y: the y coordinate of the area * @src_width: the width of the area @@ -156,7 +156,7 @@ gimp_drawable_get_sub_thumbnail_data (gint32 drawable_ID, * @alpha: how to handle an alpha channel * * Retrieves a thumbnail pixbuf for the drawable identified by - * @drawable_ID. The thumbnail will be not larger than the requested + * @drawable. The thumbnail will be not larger than the requested * size. * * Returns: (transfer full): a new #GdkPixbuf @@ -164,7 +164,7 @@ gimp_drawable_get_sub_thumbnail_data (gint32 drawable_ID, * Since: 2.2 **/ GdkPixbuf * -gimp_drawable_get_sub_thumbnail (gint32 drawable_ID, +gimp_drawable_get_sub_thumbnail (GimpDrawable *drawable, gint src_x, gint src_y, gint src_width, @@ -185,7 +185,7 @@ gimp_drawable_get_sub_thumbnail (gint32 drawable_ID, g_return_val_if_fail (dest_width > 0 && dest_width <= 1024, NULL); g_return_val_if_fail (dest_height > 0 && dest_height <= 1024, NULL); - data = gimp_drawable_get_sub_thumbnail_data (drawable_ID, + data = gimp_drawable_get_sub_thumbnail_data (drawable, src_x, src_y, src_width, src_height, &thumb_width, @@ -202,7 +202,7 @@ gimp_drawable_get_sub_thumbnail (gint32 drawable_ID, /** * gimp_drawable_get_buffer: - * @drawable_ID: the ID of the #GimpDrawable to get the buffer for. + * @drawable: the ID of the #GimpDrawable to get the buffer for. * * Returns a #GeglBuffer of a specified drawable. The buffer can be used * like any other GEGL buffer. Its data will we synced back with the core @@ -216,14 +216,14 @@ gimp_drawable_get_sub_thumbnail (gint32 drawable_ID, * Since: 2.10 */ GeglBuffer * -gimp_drawable_get_buffer (gint32 drawable_ID) +gimp_drawable_get_buffer (GimpDrawable *drawable) { - if (gimp_item_is_valid (drawable_ID)) + if (gimp_item_is_valid (GIMP_ITEM (drawable))) { GeglTileBackend *backend; GeglBuffer *buffer; - backend = _gimp_tile_backend_plugin_new (drawable_ID, FALSE); + backend = _gimp_tile_backend_plugin_new (drawable, FALSE); buffer = gegl_buffer_new_for_backend (NULL, backend); g_object_unref (backend); @@ -235,7 +235,7 @@ gimp_drawable_get_buffer (gint32 drawable_ID) /** * gimp_drawable_get_shadow_buffer: - * @drawable_ID: the ID of the #GimpDrawable to get the buffer for. + * @drawable: the ID of the #GimpDrawable to get the buffer for. * * Returns a #GeglBuffer of a specified drawable's shadow tiles. The * buffer can be used like any other GEGL buffer. Its data will we @@ -249,14 +249,14 @@ gimp_drawable_get_buffer (gint32 drawable_ID) * Since: 2.10 */ GeglBuffer * -gimp_drawable_get_shadow_buffer (gint32 drawable_ID) +gimp_drawable_get_shadow_buffer (GimpDrawable *drawable) { - if (gimp_item_is_valid (drawable_ID)) + if (gimp_item_is_valid (GIMP_ITEM (drawable))) { GeglTileBackend *backend; GeglBuffer *buffer; - backend = _gimp_tile_backend_plugin_new (drawable_ID, TRUE); + backend = _gimp_tile_backend_plugin_new (drawable, TRUE); buffer = gegl_buffer_new_for_backend (NULL, backend); g_object_unref (backend); @@ -268,7 +268,7 @@ gimp_drawable_get_shadow_buffer (gint32 drawable_ID) /** * gimp_drawable_get_format: - * @drawable_ID: the ID of the #GimpDrawable to get the format for. + * @drawable: the ID of the #GimpDrawable to get the format for. * * Returns the #Babl format of the drawable. * @@ -277,10 +277,10 @@ gimp_drawable_get_shadow_buffer (gint32 drawable_ID) * Since: 2.10 */ const Babl * -gimp_drawable_get_format (gint32 drawable_ID) +gimp_drawable_get_format (GimpDrawable *drawable) { const Babl *format = NULL; - gchar *format_str = _gimp_drawable_get_format (drawable_ID); + gchar *format_str = _gimp_drawable_get_format (drawable); /* _gimp_drawable_get_format() only returns the encoding, so we * create the actual space from the image's profile @@ -289,9 +289,9 @@ gimp_drawable_get_format (gint32 drawable_ID) if (format_str) { const Babl *space = NULL; - GimpImage *image = gimp_item_get_image (drawable_ID); + GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable)); - if (gimp_item_is_layer (drawable_ID)) + if (gimp_item_is_layer (GIMP_ITEM (drawable))) { GimpColorProfile *profile = gimp_image_get_color_profile (image); @@ -316,7 +316,7 @@ gimp_drawable_get_format (gint32 drawable_ID) } } - if (gimp_drawable_is_indexed (drawable_ID)) + if (gimp_drawable_is_indexed (drawable)) { const Babl *palette; const Babl *palette_alpha; @@ -326,7 +326,7 @@ gimp_drawable_get_format (gint32 drawable_ID) babl_new_palette_with_space (format_str, space, &palette, &palette_alpha); - if (gimp_drawable_has_alpha (drawable_ID)) + if (gimp_drawable_has_alpha (drawable)) format = palette_alpha; else format = palette; @@ -355,6 +355,253 @@ gimp_drawable_get_format (gint32 drawable_ID) } /** * gimp_drawable_get_thumbnail_format: + * @drawable: the ID of the #GimpDrawable to get the thumbnail format for. + * + * Returns the #Babl thumbnail format of the drawable. + * + * Returns: The #Babl thumbnail format. + * + * Since: 2.10.14 + */ +const Babl * +gimp_drawable_get_thumbnail_format (GimpDrawable *drawable) +{ + const Babl *format = NULL; + gchar *format_str = _gimp_drawable_get_thumbnail_format (drawable); + + if (format_str) + format = babl_format (format_str); + + return format; +} + + +/* Deprecated API. */ + + +/** + * gimp_drawable_get_thumbnail_data_deprecated: (skip) + * @drawable_ID: the drawable ID + * @width: the requested thumbnail width (<= 1024 pixels) + * @height: the requested thumbnail height (<= 1024 pixels) + * @bpp: + * + * Retrieves thumbnail data for the drawable identified by @drawable_ID. + * The thumbnail will be not larger than the requested size. + * + * Returns: (transfer full): + **/ +guchar * +gimp_drawable_get_thumbnail_data_deprecated (gint32 drawable_ID, + gint *width, + gint *height, + gint *bpp) +{ + GimpDrawable *drawable; + guchar *data = NULL; + + drawable = GIMP_DRAWABLE (gimp_item_new_by_id (drawable_ID)); + + g_return_val_if_fail (drawable, NULL); + + data = gimp_drawable_get_thumbnail_data (drawable, width, height, bpp); + g_object_unref (drawable); + + return data; +} + +/** + * gimp_drawable_get_thumbnail_deprecated: (skip) + * @drawable_ID: the drawable ID + * @width: the requested thumbnail width (<= 1024 pixels) + * @height: the requested thumbnail height (<= 1024 pixels) + * @alpha: how to handle an alpha channel + * + * Retrieves a thumbnail pixbuf for the drawable identified by + * @drawable_ID. The thumbnail will be not larger than the requested + * size. + * + * Returns: (transfer full): a new #GdkPixbuf + * + * Since: 2.2 + **/ +GdkPixbuf * +gimp_drawable_get_thumbnail_deprecated (gint32 drawable_ID, + gint width, + gint height, + GimpPixbufTransparency alpha) +{ + GimpDrawable *drawable; + GdkPixbuf *thumbnail = NULL; + + drawable = GIMP_DRAWABLE (gimp_item_new_by_id (drawable_ID)); + + g_return_val_if_fail (drawable, NULL); + + thumbnail = gimp_drawable_get_thumbnail (drawable, width, height, alpha); + g_object_unref (drawable); + + return thumbnail; +} + +guchar * +gimp_drawable_get_sub_thumbnail_data_deprecated (gint32 drawable_ID, + gint src_x, + gint src_y, + gint src_width, + gint src_height, + gint *dest_width, + gint *dest_height, + gint *bpp) +{ + GimpDrawable *drawable; + guchar *data = NULL; + + drawable = GIMP_DRAWABLE (gimp_item_new_by_id (drawable_ID)); + + g_return_val_if_fail (drawable, NULL); + + data = gimp_drawable_get_sub_thumbnail_data (drawable, src_x, src_y, + src_width, src_height, + dest_width, dest_height, bpp); + g_object_unref (drawable); + + return data; +} + +/** + * gimp_drawable_get_sub_thumbnail_deprecated: (skip) + * @drawable_ID: the drawable ID + * @src_x: the x coordinate of the area + * @src_y: the y coordinate of the area + * @src_width: the width of the area + * @src_height: the height of the area + * @dest_width: the requested thumbnail width (<= 1024 pixels) + * @dest_height: the requested thumbnail height (<= 1024 pixels) + * @alpha: how to handle an alpha channel + * + * Retrieves a thumbnail pixbuf for the drawable identified by + * @drawable_ID. The thumbnail will be not larger than the requested + * size. + * + * Returns: (transfer full): a new #GdkPixbuf + * + * Since: 2.2 + **/ +GdkPixbuf * +gimp_drawable_get_sub_thumbnail_deprecated (gint32 drawable_ID, + gint src_x, + gint src_y, + gint src_width, + gint src_height, + gint dest_width, + gint dest_height, + GimpPixbufTransparency alpha) +{ + GimpDrawable *drawable; + GdkPixbuf *thumbnail = NULL; + + drawable = GIMP_DRAWABLE (gimp_item_new_by_id (drawable_ID)); + + g_return_val_if_fail (drawable, NULL); + + thumbnail = gimp_drawable_get_sub_thumbnail (drawable, src_x, src_y, + src_width, src_height, + dest_width, dest_height, alpha); + g_object_unref (drawable); + + return thumbnail; +} + +/** + * gimp_drawable_get_buffer_deprecated: (skip) + * @drawable_ID: the ID of the #GimpDrawable to get the buffer for. + * + * Returns a #GeglBuffer of a specified drawable. The buffer can be used + * like any other GEGL buffer. Its data will we synced back with the core + * drawable when the buffer gets destroyed, or when gegl_buffer_flush() + * is called. + * + * Returns: (transfer full): The #GeglBuffer. + * + * See Also: gimp_drawable_get_shadow_buffer() + * + * Since: 2.10 + */ +GeglBuffer * +gimp_drawable_get_buffer_deprecated (gint32 drawable_ID) +{ + GimpDrawable *drawable; + GeglBuffer *buffer = NULL; + + drawable = GIMP_DRAWABLE (gimp_item_new_by_id (drawable_ID)); + + g_return_val_if_fail (drawable, NULL); + + buffer = gimp_drawable_get_buffer (drawable); + g_object_unref (drawable); + + return buffer; +} + +/** + * gimp_drawable_get_shadow_buffer_deprecated: (skip) + * @drawable_ID: the ID of the #GimpDrawable to get the buffer for. + * + * Returns a #GeglBuffer of a specified drawable's shadow tiles. The + * buffer can be used like any other GEGL buffer. Its data will we + * synced back with the core drawable's shadow tiles when the buffer + * gets destroyed, or when gegl_buffer_flush() is called. + * + * Returns: (transfer full): The #GeglBuffer. + * + * See Also: gimp_drawable_get_shadow_buffer() + * + * Since: 2.10 + */ +GeglBuffer * +gimp_drawable_get_shadow_buffer_deprecated (gint32 drawable_ID) +{ + GimpDrawable *drawable; + GeglBuffer *buffer = NULL; + + drawable = GIMP_DRAWABLE (gimp_item_new_by_id (drawable_ID)); + + g_return_val_if_fail (drawable, NULL); + + buffer = gimp_drawable_get_shadow_buffer (drawable); + g_object_unref (drawable); + + return buffer; +} + +/** + * gimp_drawable_get_format_deprecated: (skip) + * @drawable_ID: the ID of the #GimpDrawable to get the format for. + * + * Returns the #Babl format of the drawable. + * + * Returns: The #Babl format. + * + * Since: 2.10 + */ +const Babl * +gimp_drawable_get_format_deprecated (gint32 drawable_ID) +{ + GimpDrawable *drawable; + const Babl *format = NULL; + + drawable = GIMP_DRAWABLE (gimp_item_new_by_id (drawable_ID)); + + g_return_val_if_fail (drawable, NULL); + + format = gimp_drawable_get_format (drawable); + g_object_unref (drawable); + + return format; +} +/** + * gimp_drawable_get_thumbnail_format_deprecated: (skip) * @drawable_ID: the ID of the #GimpDrawable to get the thumbnail format for. * * Returns the #Babl thumbnail format of the drawable. @@ -364,13 +611,17 @@ gimp_drawable_get_format (gint32 drawable_ID) * Since: 2.10.14 */ const Babl * -gimp_drawable_get_thumbnail_format (gint32 drawable_ID) +gimp_drawable_get_thumbnail_format_deprecated (gint32 drawable_ID) { - const Babl *format = NULL; - gchar *format_str = _gimp_drawable_get_thumbnail_format (drawable_ID); + GimpDrawable *drawable; + const Babl *format = NULL; - if (format_str) - format = babl_format (format_str); + drawable = GIMP_DRAWABLE (gimp_item_new_by_id (drawable_ID)); + + g_return_val_if_fail (drawable, NULL); + + format = gimp_drawable_get_thumbnail_format (drawable); + g_object_unref (drawable); return format; } diff --git a/libgimp/gimpdrawable.h b/libgimp/gimpdrawable.h index 95c4abc57a..fdb2d1069e 100644 --- a/libgimp/gimpdrawable.h +++ b/libgimp/gimpdrawable.h @@ -64,22 +64,24 @@ struct _GimpDrawableClass GType gimp_drawable_get_type (void) G_GNUC_CONST; -GeglBuffer * gimp_drawable_get_buffer (gint32 drawable_ID); -GeglBuffer * gimp_drawable_get_shadow_buffer (gint32 drawable_ID); +#ifndef GIMP_DEPRECATED_REPLACE_NEW_API -const Babl * gimp_drawable_get_format (gint32 drawable_ID); -const Babl * gimp_drawable_get_thumbnail_format (gint32 drawable_ID); +GeglBuffer * gimp_drawable_get_buffer (GimpDrawable *drawable); +GeglBuffer * gimp_drawable_get_shadow_buffer (GimpDrawable *drawable); -guchar * gimp_drawable_get_thumbnail_data (gint32 drawable_ID, +const Babl * gimp_drawable_get_format (GimpDrawable *drawable); +const Babl * gimp_drawable_get_thumbnail_format (GimpDrawable *drawable); + +guchar * gimp_drawable_get_thumbnail_data (GimpDrawable *drawable, gint *width, gint *height, gint *bpp); -GdkPixbuf * gimp_drawable_get_thumbnail (gint32 drawable_ID, +GdkPixbuf * gimp_drawable_get_thumbnail (GimpDrawable *drawable, gint width, gint height, GimpPixbufTransparency alpha); -guchar * gimp_drawable_get_sub_thumbnail_data (gint32 drawable_ID, +guchar * gimp_drawable_get_sub_thumbnail_data (GimpDrawable *drawable, gint src_x, gint src_y, gint src_width, @@ -87,7 +89,7 @@ guchar * gimp_drawable_get_sub_thumbnail_data (gint32 drawable_ID, gint *dest_width, gint *dest_height, gint *bpp); -GdkPixbuf * gimp_drawable_get_sub_thumbnail (gint32 drawable_ID, +GdkPixbuf * gimp_drawable_get_sub_thumbnail (GimpDrawable *drawable, gint src_x, gint src_y, gint src_width, @@ -96,6 +98,52 @@ GdkPixbuf * gimp_drawable_get_sub_thumbnail (gint32 drawable_ID, gint dest_height, GimpPixbufTransparency alpha); +#else /* GIMP_DEPRECATED_REPLACE_NEW_API */ + +#define gimp_drawable_get_buffer gimp_drawable_get_buffer_deprecated +#define gimp_drawable_get_shadow_buffer gimp_drawable_get_shadow_buffer_deprecated +#define gimp_drawable_get_format gimp_drawable_get_format_deprecated +#define gimp_drawable_get_thumbnail_format gimp_drawable_get_thumbnail_format_deprecated +#define gimp_drawable_get_thumbnail_data gimp_drawable_get_thumbnail_data_deprecated +#define gimp_drawable_get_thumbnail gimp_drawable_get_thumbnail_deprecated +#define gimp_drawable_get_sub_thumbnail_data gimp_drawable_get_sub_thumbnail_data_deprecated +#define gimp_drawable_get_sub_thumbnail gimp_drawable_get_sub_thumbnail_deprecated + +#endif /* GIMP_DEPRECATED_REPLACE_NEW_API */ + + +GeglBuffer * gimp_drawable_get_buffer_deprecated (gint32 drawable_ID); +GeglBuffer * gimp_drawable_get_shadow_buffer_deprecated (gint32 drawable_ID); + +const Babl * gimp_drawable_get_format_deprecated (gint32 drawable_ID); +const Babl * gimp_drawable_get_thumbnail_format_deprecated (gint32 drawable_ID); + +guchar * gimp_drawable_get_thumbnail_data_deprecated (gint32 drawable_ID, + gint *width, + gint *height, + gint *bpp); +GdkPixbuf * gimp_drawable_get_thumbnail_deprecated (gint32 drawable_ID, + gint width, + gint height, + GimpPixbufTransparency alpha); + +guchar * gimp_drawable_get_sub_thumbnail_data_deprecated (gint32 drawable_ID, + gint src_x, + gint src_y, + gint src_width, + gint src_height, + gint *dest_width, + gint *dest_height, + gint *bpp); +GdkPixbuf * gimp_drawable_get_sub_thumbnail_deprecated (gint32 drawable_ID, + gint src_x, + gint src_y, + gint src_width, + gint src_height, + gint dest_width, + gint dest_height, + GimpPixbufTransparency alpha); + G_END_DECLS diff --git a/libgimp/gimpdrawablepreview.c b/libgimp/gimpdrawablepreview.c index 973e6890a3..c62a6a361e 100644 --- a/libgimp/gimpdrawablepreview.c +++ b/libgimp/gimpdrawablepreview.c @@ -46,7 +46,7 @@ enum { PROP_0, - PROP_DRAWABLE_ID + PROP_DRAWABLE }; typedef struct @@ -59,7 +59,7 @@ typedef struct struct _GimpDrawablePreviewPrivate { - gint32 drawable_ID; + GimpDrawable *drawable; }; #define GET_PRIVATE(obj) (((GimpDrawablePreview *) (obj))->priv) @@ -87,9 +87,8 @@ static void gimp_drawable_preview_draw_buffer (GimpPreview *preview, const guchar *buffer, gint rowstride); -static void gimp_drawable_preview_set_drawable_id - (GimpDrawablePreview *preview, - gint32 drawable_ID); +static void gimp_drawable_preview_set_drawable (GimpDrawablePreview *preview, + GimpDrawable *drawable); G_DEFINE_TYPE_WITH_PRIVATE (GimpDrawablePreview, gimp_drawable_preview, @@ -125,13 +124,13 @@ gimp_drawable_preview_class_init (GimpDrawablePreviewClass *klass) * * Since: 2.10 */ - g_object_class_install_property (object_class, PROP_DRAWABLE_ID, - g_param_spec_int ("drawable-id", - "Drawable ID", - "The drawable this preview is attached to", - -1, G_MAXINT, -1, - GIMP_PARAM_READWRITE | - G_PARAM_CONSTRUCT_ONLY)); + g_object_class_install_property (object_class, PROP_DRAWABLE, + g_param_spec_object ("drawable", + "Drawable", + "The drawable this preview is attached to", + GIMP_TYPE_DRAWABLE, + GIMP_PARAM_READWRITE | + G_PARAM_CONSTRUCT_ONLY)); } @@ -172,9 +171,11 @@ gimp_drawable_preview_constructed (GObject *object) static void gimp_drawable_preview_dispose (GObject *object) { - const gchar *data_name = g_object_get_data (G_OBJECT (object), - "gimp-drawable-preview-data-name"); + GimpDrawablePreviewPrivate *priv = GET_PRIVATE (object); + const gchar *data_name; + data_name = g_object_get_data (G_OBJECT (object), + "gimp-drawable-preview-data-name"); if (data_name) { GimpPreview *preview = GIMP_PREVIEW (object); @@ -186,6 +187,8 @@ gimp_drawable_preview_dispose (GObject *object) gimp_set_data (data_name, &settings, sizeof (PreviewSettings)); } + g_clear_object (&priv->drawable); + G_OBJECT_CLASS (parent_class)->dispose (object); } @@ -199,9 +202,9 @@ gimp_drawable_preview_get_property (GObject *object, switch (property_id) { - case PROP_DRAWABLE_ID: - g_value_set_int (value, - gimp_drawable_preview_get_drawable_id (preview)); + case PROP_DRAWABLE: + g_value_set_object (value, + gimp_drawable_preview_get_drawable (preview)); break; default: @@ -220,9 +223,9 @@ gimp_drawable_preview_set_property (GObject *object, switch (property_id) { - case PROP_DRAWABLE_ID: - gimp_drawable_preview_set_drawable_id (preview, - g_value_get_int (value)); + case PROP_DRAWABLE: + gimp_drawable_preview_set_drawable (preview, + g_value_dup_object (value)); break; default: @@ -269,7 +272,7 @@ gimp_drawable_preview_draw_original (GimpPreview *preview) gint bpp; GimpImageType type; - if (priv->drawable_ID < 1) + if (priv->drawable == NULL) return; gimp_preview_get_size (preview, &width, &height); @@ -281,7 +284,7 @@ gimp_drawable_preview_draw_original (GimpPreview *preview) gimp_preview_set_offsets (preview, xoff, yoff); - buffer = gimp_drawable_get_sub_thumbnail_data (priv->drawable_ID, + buffer = gimp_drawable_get_sub_thumbnail_data (priv->drawable, xoff + xmin, yoff + ymin, width, height, @@ -311,14 +314,14 @@ gimp_drawable_preview_draw_thumb (GimpPreview *preview, { GimpDrawablePreviewPrivate *priv = GET_PRIVATE (preview); - if (priv->drawable_ID > 0) - _gimp_drawable_preview_area_draw_thumb (area, priv->drawable_ID, + if (priv->drawable) + _gimp_drawable_preview_area_draw_thumb (area, priv->drawable, width, height); } void _gimp_drawable_preview_area_draw_thumb (GimpPreviewArea *area, - gint32 drawable_ID, + GimpDrawable *drawable, gint width, gint height) { @@ -329,18 +332,18 @@ _gimp_drawable_preview_area_draw_thumb (GimpPreviewArea *area, gint nav_width, nav_height; g_return_if_fail (GIMP_IS_PREVIEW_AREA (area)); - g_return_if_fail (gimp_item_is_valid (drawable_ID)); - g_return_if_fail (gimp_item_is_drawable (drawable_ID)); + g_return_if_fail (gimp_item_is_valid (GIMP_ITEM (drawable))); + g_return_if_fail (gimp_item_is_drawable (GIMP_ITEM (drawable))); - if (_gimp_drawable_preview_get_bounds (drawable_ID, &x1, &y1, &x2, &y2)) + if (_gimp_drawable_preview_get_bounds (drawable, &x1, &y1, &x2, &y2)) { width = x2 - x1; height = y2 - y1; } else { - width = gimp_drawable_width (drawable_ID); - height = gimp_drawable_height (drawable_ID); + width = gimp_drawable_width (drawable); + height = gimp_drawable_height (drawable); } if (width > height) @@ -354,16 +357,16 @@ _gimp_drawable_preview_area_draw_thumb (GimpPreviewArea *area, nav_width = (width * nav_height) / height; } - if (_gimp_drawable_preview_get_bounds (drawable_ID, &x1, &y1, &x2, &y2)) + if (_gimp_drawable_preview_get_bounds (drawable, &x1, &y1, &x2, &y2)) { - buffer = gimp_drawable_get_sub_thumbnail_data (drawable_ID, + buffer = gimp_drawable_get_sub_thumbnail_data (drawable, x1, y1, x2 - x1, y2 - y1, &nav_width, &nav_height, &bpp); } else { - buffer = gimp_drawable_get_thumbnail_data (drawable_ID, + buffer = gimp_drawable_get_thumbnail_data (drawable, &nav_width, &nav_height, &bpp); } @@ -413,7 +416,7 @@ gimp_drawable_preview_draw_area (GimpDrawablePreview *preview, gimp_preview_get_bounds (gimp_preview, &xmin, &ymin, NULL, NULL); gimp_preview_get_offsets (gimp_preview, &xoff, &yoff); - image = gimp_item_get_image (priv->drawable_ID); + image = gimp_item_get_image (GIMP_ITEM (priv->drawable)); if (gimp_selection_is_empty (image)) { @@ -422,7 +425,7 @@ gimp_drawable_preview_draw_area (GimpDrawablePreview *preview, y - yoff - ymin, width, height, - gimp_drawable_type (priv->drawable_ID), + gimp_drawable_type (priv->drawable), buf, rowstride); } else @@ -433,9 +436,9 @@ gimp_drawable_preview_draw_area (GimpDrawablePreview *preview, gint draw_x, draw_y; gint draw_width, draw_height; - gimp_drawable_offsets (priv->drawable_ID, &offset_x, &offset_y); + gimp_drawable_offsets (priv->drawable, &offset_x, &offset_y); - if (gimp_drawable_mask_intersect (priv->drawable_ID, + if (gimp_drawable_mask_intersect (priv->drawable, &mask_x, &mask_y, &mask_width, &mask_height) && gimp_rectangle_intersect (mask_x, mask_y, @@ -445,6 +448,7 @@ gimp_drawable_preview_draw_area (GimpDrawablePreview *preview, &draw_width, &draw_height)) { GimpImageType type; + GimpDrawable *selection; gint32 selection_ID; guchar *src; guchar *sel; @@ -458,19 +462,21 @@ gimp_drawable_preview_draw_area (GimpDrawablePreview *preview, s_h = draw_height; selection_ID = gimp_image_get_selection (image); + selection = GIMP_DRAWABLE (gimp_item_new_by_id (selection_ID)); - src = gimp_drawable_get_sub_thumbnail_data (priv->drawable_ID, + src = gimp_drawable_get_sub_thumbnail_data (priv->drawable, draw_x, draw_y, draw_width, draw_height, &d_w, &d_h, &d_bpp); - sel = gimp_drawable_get_sub_thumbnail_data (selection_ID, + sel = gimp_drawable_get_sub_thumbnail_data (selection, draw_x + offset_x, draw_y + offset_y, draw_width, draw_height, &s_w, &s_h, &s_bpp); + g_object_unref (selection); switch (d_bpp) { @@ -523,24 +529,24 @@ gimp_drawable_preview_draw_buffer (GimpPreview *preview, } static void -gimp_drawable_preview_set_drawable_id (GimpDrawablePreview *drawable_preview, - gint32 drawable_ID) +gimp_drawable_preview_set_drawable (GimpDrawablePreview *drawable_preview, + GimpDrawable *drawable) { GimpPreview *preview = GIMP_PREVIEW (drawable_preview); GimpDrawablePreviewPrivate *priv = GET_PRIVATE (preview); gint x1, y1, x2, y2; - g_return_if_fail (priv->drawable_ID < 1); + g_return_if_fail (priv->drawable == NULL); - priv->drawable_ID = drawable_ID; + priv->drawable = drawable; - _gimp_drawable_preview_get_bounds (drawable_ID, &x1, &y1, &x2, &y2); + _gimp_drawable_preview_get_bounds (drawable, &x1, &y1, &x2, &y2); gimp_preview_set_bounds (preview, x1, y1, x2, y2); - if (gimp_drawable_is_indexed (drawable_ID)) + if (gimp_drawable_is_indexed (drawable)) { - GimpImage *image = gimp_item_get_image (drawable_ID); + GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable)); GtkWidget *area = gimp_preview_get_area (preview); guchar *cmap; gint num_colors; @@ -558,11 +564,11 @@ gimp_drawable_preview_set_drawable_id (GimpDrawablePreview *drawable_preview, #define MIN3(a, b, c) (MIN (MIN ((a), (b)), (c))) gboolean -_gimp_drawable_preview_get_bounds (gint32 drawable_ID, - gint *xmin, - gint *ymin, - gint *xmax, - gint *ymax) +_gimp_drawable_preview_get_bounds (GimpDrawable *drawable, + gint *xmin, + gint *ymin, + gint *xmax, + gint *ymax) { gint width; gint height; @@ -572,15 +578,15 @@ _gimp_drawable_preview_get_bounds (gint32 drawable_ID, gint x2, y2; gboolean retval; - g_return_val_if_fail (gimp_item_is_valid (drawable_ID), FALSE); - g_return_val_if_fail (gimp_item_is_drawable (drawable_ID), FALSE); + g_return_val_if_fail (gimp_item_is_valid (GIMP_ITEM (drawable)), FALSE); + g_return_val_if_fail (gimp_item_is_drawable (GIMP_ITEM (drawable)), FALSE); - width = gimp_drawable_width (drawable_ID); - height = gimp_drawable_height (drawable_ID); + width = gimp_drawable_width (drawable); + height = gimp_drawable_height (drawable); - retval = gimp_drawable_mask_bounds (drawable_ID, &x1, &y1, &x2, &y2); + retval = gimp_drawable_mask_bounds (drawable, &x1, &y1, &x2, &y2); - gimp_drawable_offsets (drawable_ID, &offset_x, &offset_y); + gimp_drawable_offsets (drawable, &offset_x, &offset_y); *xmin = MAX3 (x1 - SELECTION_BORDER, 0, - offset_x); *ymin = MAX3 (y1 - SELECTION_BORDER, 0, - offset_y); @@ -592,39 +598,39 @@ _gimp_drawable_preview_get_bounds (gint32 drawable_ID, /** - * gimp_drawable_preview_new_from_drawable_id: - * @drawable_ID: a drawable ID + * gimp_drawable_preview_new_from_drawable: + * @drawable: (transfer none): a drawable * - * Creates a new #GimpDrawablePreview widget for @drawable_ID. + * Creates a new #GimpDrawablePreview widget for @drawable. * * Returns: A pointer to the new #GimpDrawablePreview widget. * * Since: 2.10 **/ GtkWidget * -gimp_drawable_preview_new_from_drawable_id (gint32 drawable_ID) +gimp_drawable_preview_new_from_drawable (GimpDrawable *drawable) { - g_return_val_if_fail (gimp_item_is_valid (drawable_ID), NULL); - g_return_val_if_fail (gimp_item_is_drawable (drawable_ID), NULL); + g_return_val_if_fail (gimp_item_is_valid (GIMP_ITEM (drawable)), NULL); + g_return_val_if_fail (gimp_item_is_drawable (GIMP_ITEM (drawable)), NULL); return g_object_new (GIMP_TYPE_DRAWABLE_PREVIEW, - "drawable-id", drawable_ID, + "drawable", drawable, NULL); } /** - * gimp_drawable_preview_get_drawable_id: + * gimp_drawable_preview_get_drawable: * @preview: a #GimpDrawablePreview widget * - * Returns: the drawable_ID that has been passed to - * gimp_drawable_preview_new_from_drawable_id(). + * Returns: (transfer none): the drawable that has been passed to + * gimp_drawable_preview_new_from_drawable(). * * Since: 2.10 **/ -gint32 -gimp_drawable_preview_get_drawable_id (GimpDrawablePreview *preview) +GimpDrawable * +gimp_drawable_preview_get_drawable (GimpDrawablePreview *preview) { - g_return_val_if_fail (GIMP_IS_DRAWABLE_PREVIEW (preview), -1); + g_return_val_if_fail (GIMP_IS_DRAWABLE_PREVIEW (preview), NULL); - return GET_PRIVATE (preview)->drawable_ID; + return GET_PRIVATE (preview)->drawable; } diff --git a/libgimp/gimpdrawablepreview.h b/libgimp/gimpdrawablepreview.h index 17d19610af..48aa389650 100644 --- a/libgimp/gimpdrawablepreview.h +++ b/libgimp/gimpdrawablepreview.h @@ -67,15 +67,15 @@ struct _GimpDrawablePreviewClass GType gimp_drawable_preview_get_type (void) G_GNUC_CONST; -GtkWidget * gimp_drawable_preview_new_from_drawable_id (gint32 drawable_ID); -gint32 gimp_drawable_preview_get_drawable_id (GimpDrawablePreview *preview); +GtkWidget * gimp_drawable_preview_new_from_drawable (GimpDrawable *drawable); +GimpDrawable * gimp_drawable_preview_get_drawable (GimpDrawablePreview *preview); /* for internal use only */ G_GNUC_INTERNAL void _gimp_drawable_preview_area_draw_thumb (GimpPreviewArea *area, - gint32 drawable_ID, + GimpDrawable *drawable, gint width, gint height); -G_GNUC_INTERNAL gboolean _gimp_drawable_preview_get_bounds (gint32 drawable_ID, +G_GNUC_INTERNAL gboolean _gimp_drawable_preview_get_bounds (GimpDrawable *drawable, gint *xmin, gint *ymin, gint *xmax, diff --git a/libgimp/gimpexport.c b/libgimp/gimpexport.c index 0c4725db9d..290a09af49 100644 --- a/libgimp/gimpexport.c +++ b/libgimp/gimpexport.c @@ -51,8 +51,8 @@ **/ -typedef void (* ExportFunc) (GimpImage *image, - gint32 *drawable_ID); +typedef void (* ExportFunc) (GimpImage *image, + GimpDrawable **drawable); /* the export action structure */ @@ -69,25 +69,29 @@ typedef struct /* the functions that do the actual export */ static void -export_merge (GimpImage *image, - gint32 *drawable_ID) +export_merge (GimpImage *image, + GimpDrawable **drawable) { gint32 nlayers; gint32 nvisible = 0; gint32 i; gint32 *layers; - gint32 merged; - gint32 transp; layers = gimp_image_get_layers (image, &nlayers); for (i = 0; i < nlayers; i++) { - if (gimp_item_get_visible (layers[i])) + GimpLayer *layer = GIMP_LAYER (gimp_item_new_by_id (layers[i])); + + if (gimp_item_get_visible (GIMP_ITEM (layer))) nvisible++; + + g_object_unref (layer); } if (nvisible <= 1) { + GimpLayer *transp; + /* if there is only one (or zero) visible layer, add a new * transparent layer that has the same size as the canvas. The * merge that follows will ensure that the offset, opacity and @@ -96,33 +100,42 @@ export_merge (GimpImage *image, transp = gimp_layer_new (image, "-", gimp_image_width (image), gimp_image_height (image), - gimp_drawable_type (*drawable_ID) | 1, + gimp_drawable_type (*drawable) | 1, 100.0, GIMP_LAYER_MODE_NORMAL); - gimp_image_insert_layer (image, transp, -1, 1); + gimp_image_insert_layer (image, transp, NULL, 1); gimp_selection_none (image); - gimp_drawable_edit_clear (transp); + gimp_drawable_edit_clear (GIMP_DRAWABLE (transp)); nvisible++; + + g_object_unref (transp); } if (nvisible > 1) { + GimpLayer *merged; + g_free (layers); merged = gimp_image_merge_visible_layers (image, GIMP_CLIP_TO_IMAGE); - if (merged != -1) - *drawable_ID = merged; + if (merged != NULL) + { + g_clear_object (drawable); + *drawable = GIMP_DRAWABLE (merged); + } else - return; /* shouldn't happen */ + { + return; /* shouldn't happen */ + } layers = gimp_image_get_layers (image, &nlayers); /* make sure that the merged drawable matches the image size */ - if (gimp_drawable_width (merged) != gimp_image_width (image) || - gimp_drawable_height (merged) != gimp_image_height (image)) + if (gimp_drawable_width (GIMP_DRAWABLE (merged)) != gimp_image_width (image) || + gimp_drawable_height (GIMP_DRAWABLE (merged)) != gimp_image_height (image)) { gint off_x, off_y; - gimp_drawable_offsets (merged, &off_x, &off_y); + gimp_drawable_offsets (GIMP_DRAWABLE (merged), &off_x, &off_y); gimp_layer_resize (merged, gimp_image_width (image), gimp_image_height (image), @@ -133,27 +146,33 @@ export_merge (GimpImage *image, /* remove any remaining (invisible) layers */ for (i = 0; i < nlayers; i++) { - if (layers[i] != *drawable_ID) - gimp_image_remove_layer (image, layers[i]); + if (layers[i] != gimp_item_get_id (GIMP_ITEM (*drawable))) + { + GimpLayer *layer = GIMP_LAYER (gimp_item_new_by_id (layers[i])); + + gimp_image_remove_layer (image, layer); + + g_object_unref (layer); + } } g_free (layers); } static void -export_flatten (GimpImage *image, - gint32 *drawable_ID) +export_flatten (GimpImage *image, + GimpDrawable **drawable) { - gint32 flattened; + GimpLayer *flattened; flattened = gimp_image_flatten (image); - if (flattened != -1) - *drawable_ID = flattened; + if (flattened != NULL) + *drawable = GIMP_DRAWABLE (flattened); } static void -export_remove_alpha (GimpImage *image, - gint32 *drawable_ID) +export_remove_alpha (GimpImage *image, + GimpDrawable **drawable) { gint32 n_layers; gint32 *layers; @@ -163,16 +182,21 @@ export_remove_alpha (GimpImage *image, for (i = 0; i < n_layers; i++) { - if (gimp_drawable_has_alpha (layers[i])) - gimp_layer_flatten (layers[i]); + GimpLayer *layer; + + layer = GIMP_LAYER (gimp_item_new_by_id (layers[i])); + if (gimp_drawable_has_alpha (GIMP_DRAWABLE (layer))) + gimp_layer_flatten (layer); + + g_object_unref (layer); } g_free (layers); } static void -export_apply_masks (GimpImage *image, - gint *drawable_ID) +export_apply_masks (GimpImage *image, + GimpDrawable **drawable) { gint32 n_layers; gint32 *layers; @@ -182,36 +206,41 @@ export_apply_masks (GimpImage *image, for (i = 0; i < n_layers; i++) { - if (gimp_layer_get_mask (layers[i]) != -1) - gimp_layer_remove_mask (layers[i], GIMP_MASK_APPLY); + GimpLayer *layer; + + layer = GIMP_LAYER (gimp_item_new_by_id (layers[i])); + if (gimp_layer_get_mask (layer) != -1) + gimp_layer_remove_mask (layer, GIMP_MASK_APPLY); + + g_object_unref (layer); } g_free (layers); } static void -export_convert_rgb (GimpImage *image, - gint32 *drawable_ID) +export_convert_rgb (GimpImage *image, + GimpDrawable **drawable) { gimp_image_convert_rgb (image); } static void -export_convert_grayscale (GimpImage *image, - gint32 *drawable_ID) +export_convert_grayscale (GimpImage *image, + GimpDrawable **drawable) { gimp_image_convert_grayscale (image); } static void -export_convert_indexed (GimpImage *image, - gint32 *drawable_ID) +export_convert_indexed (GimpImage *image, + GimpDrawable **drawable) { gint32 nlayers; /* check alpha */ g_free (gimp_image_get_layers (image, &nlayers)); - if (nlayers > 1 || gimp_drawable_has_alpha (*drawable_ID)) + if (nlayers > 1 || gimp_drawable_has_alpha (*drawable)) gimp_image_convert_indexed (image, GIMP_CONVERT_DITHER_NONE, GIMP_CONVERT_PALETTE_GENERATE, @@ -224,8 +253,8 @@ export_convert_indexed (GimpImage *image, } static void -export_convert_bitmap (GimpImage *image, - gint32 *drawable_ID) +export_convert_bitmap (GimpImage *image, + GimpDrawable **drawable) { if (gimp_image_base_type (image) == GIMP_INDEXED) gimp_image_convert_rgb (image); @@ -237,8 +266,8 @@ export_convert_bitmap (GimpImage *image, } static void -export_add_alpha (GimpImage *image, - gint32 *drawable_ID) +export_add_alpha (GimpImage *image, + GimpDrawable **drawable) { gint32 nlayers; gint32 i; @@ -247,15 +276,20 @@ export_add_alpha (GimpImage *image, layers = gimp_image_get_layers (image, &nlayers); for (i = 0; i < nlayers; i++) { - if (!gimp_drawable_has_alpha (layers[i])) - gimp_layer_add_alpha (layers[i]); + GimpLayer *layer; + + layer = GIMP_LAYER (gimp_item_new_by_id (layers[i])); + if (!gimp_drawable_has_alpha (GIMP_DRAWABLE (layer))) + gimp_layer_add_alpha (GIMP_LAYER (layer)); + + g_object_unref (layer); } g_free (layers); } static void -export_void (GimpImage *image, - gint32 *drawable_ID) +export_void (GimpImage *image, + GimpDrawable **drawable) { /* do nothing */ } @@ -432,9 +466,9 @@ export_action_get_func (const ExportAction *action) static void export_action_perform (const ExportAction *action, GimpImage *image, - gint32 *drawable_ID) + GimpDrawable **drawable) { - export_action_get_func (action) (image, drawable_ID); + export_action_get_func (action) (image, drawable); } @@ -695,7 +729,7 @@ export_dialog (GSList *actions, /** * gimp_export_image: * @image: Pointer to the image. - * @drawable_ID: Pointer to the drawable_ID. + * @drawable: Pointer to the drawable. * @format_name: The (short) name of the image_format (e.g. JPEG or GIF). * @capabilities: What can the image_format do? * @@ -725,7 +759,7 @@ export_dialog (GSList *actions, **/ GimpExportReturn gimp_export_image (GimpImage **image, - gint32 *drawable_ID, + GimpDrawable **drawable, const gchar *format_name, GimpExportCapabilities capabilities) { @@ -740,7 +774,8 @@ gimp_export_image (GimpImage **image, gboolean background_has_alpha = TRUE; GimpExportReturn retval = GIMP_EXPORT_CANCEL; - g_return_val_if_fail (gimp_image_is_valid (*image) && *drawable_ID > -1, FALSE); + g_return_val_if_fail (gimp_image_is_valid (*image) && + gimp_item_is_valid (GIMP_ITEM (*drawable)), FALSE); /* do some sanity checks */ if (capabilities & GIMP_EXPORT_NEEDS_ALPHA) @@ -757,16 +792,16 @@ gimp_export_image (GimpImage **image, /* ask for confirmation if the user is not saving a layer (see bug #51114) */ if (interactive && - ! gimp_item_is_layer (*drawable_ID) && + ! gimp_item_is_layer (GIMP_ITEM (*drawable)) && ! (capabilities & GIMP_EXPORT_CAN_HANDLE_LAYERS)) { - if (gimp_item_is_layer_mask (*drawable_ID)) + if (gimp_item_is_layer_mask (GIMP_ITEM (*drawable))) { retval = confirm_save_dialog (_("You are about to save a layer mask as %s.\n" "This will not save the visible layers."), format_name); } - else if (gimp_item_is_channel (*drawable_ID)) + else if (gimp_item_is_channel (GIMP_ITEM (*drawable))) { retval = confirm_save_dialog (_("You are about to save a channel (saved selection) as %s.\n" @@ -789,7 +824,9 @@ gimp_export_image (GimpImage **image, for (i = 0; i < n_layers; i++) { - if (gimp_drawable_has_alpha (layers[i])) + GimpLayer *layer = GIMP_LAYER (gimp_item_new_by_id (layers[i])); + + if (gimp_drawable_has_alpha (GIMP_DRAWABLE (layer))) { if (! (capabilities & GIMP_EXPORT_CAN_HANDLE_ALPHA)) { @@ -811,7 +848,7 @@ gimp_export_image (GimpImage **image, /* If this is the last layer, it's visible and has no alpha * channel, then the image has a "flat" background */ - if (i == n_layers - 1 && gimp_item_get_visible (layers[i])) + if (i == n_layers - 1 && gimp_item_get_visible (GIMP_ITEM (layer))) background_has_alpha = FALSE; if (capabilities & GIMP_EXPORT_NEEDS_ALPHA) @@ -820,40 +857,47 @@ gimp_export_image (GimpImage **image, break; } } + g_object_unref (layer); } if (! added_flatten) { for (i = 0; i < n_layers; i++) { - if (gimp_layer_get_mask (layers[i]) != -1) + GimpLayer *layer = GIMP_LAYER (gimp_item_new_by_id (layers[i])); + + if (gimp_layer_get_mask (layer) != -1) has_layer_masks = TRUE; + + g_object_unref (layer); } } if (! added_flatten) { - gint32 n_children; - gint32 *children; + GimpLayer *layer = GIMP_LAYER (gimp_item_new_by_id (layers[0])); + gint32 *children; + gint32 n_children; - children = gimp_item_get_children (layers[0], &n_children); + children = gimp_item_get_children (GIMP_ITEM (layer), &n_children); + g_object_unref (layer); /* check if layer size != canvas size, opacity != 100%, or offsets != 0 */ if (n_layers == 1 && ! children && - gimp_item_is_layer (*drawable_ID) && + gimp_item_is_layer (GIMP_ITEM (*drawable)) && ! (capabilities & GIMP_EXPORT_CAN_HANDLE_LAYERS)) { gint offset_x; gint offset_y; - gimp_drawable_offsets (*drawable_ID, &offset_x, &offset_y); + gimp_drawable_offsets (*drawable, &offset_x, &offset_y); - if ((gimp_layer_get_opacity (*drawable_ID) < 100.0) || + if ((gimp_layer_get_opacity (GIMP_LAYER (*drawable)) < 100.0) || (gimp_image_width (*image) != - gimp_drawable_width (*drawable_ID)) || + gimp_drawable_width (*drawable)) || (gimp_image_height (*image) != - gimp_drawable_height (*drawable_ID)) || + gimp_drawable_height (*drawable)) || offset_x || offset_y) { if (capabilities & GIMP_EXPORT_CAN_HANDLE_ALPHA) @@ -1003,13 +1047,13 @@ gimp_export_image (GimpImage **image, GSList *list; *image = gimp_image_duplicate (*image); - *drawable_ID = gimp_image_get_active_layer (*image); + *drawable = GIMP_DRAWABLE (gimp_image_get_active_layer (*image)); gimp_image_undo_disable (*image); for (list = actions; list; list = list->next) { - export_action_perform (list->data, *image, drawable_ID); + export_action_perform (list->data, *image, drawable); } } @@ -1127,18 +1171,30 @@ gimp_export_image_deprecated (gint32 *image_ID, const gchar *format_name, GimpExportCapabilities capabilities) { - GimpImage *image = gimp_image_new_by_id (*image_ID); - GimpImage *new_image = image; + GimpImage *image; + GimpImage *new_image; + GimpDrawable *drawable; + GimpDrawable *new_drawable; GimpExportReturn retval; - retval = gimp_export_image (&new_image, drawable_ID, + image = gimp_image_new_by_id (*image_ID); + new_image = image; + drawable = GIMP_DRAWABLE (gimp_item_new_by_id (*drawable_ID)); + new_drawable = drawable; + + retval = gimp_export_image (&new_image, &new_drawable, format_name, capabilities); - *image_ID = gimp_image_get_id (new_image); + *image_ID = gimp_image_get_id (new_image); + *drawable_ID = gimp_item_get_id (GIMP_ITEM (new_drawable)); if (retval == GIMP_EXPORT_EXPORT) - g_object_unref (new_image); + { + g_object_unref (new_image); + g_object_unref (new_drawable); + } g_object_unref (image); + g_object_unref (drawable); return retval; } diff --git a/libgimp/gimpexport.h b/libgimp/gimpexport.h index 325ca9f3ca..f0ec72f698 100644 --- a/libgimp/gimpexport.h +++ b/libgimp/gimpexport.h @@ -84,7 +84,7 @@ GtkWidget * gimp_export_dialog_get_content_area (GtkWidget * #ifndef GIMP_DEPRECATED_REPLACE_NEW_API GimpExportReturn gimp_export_image (GimpImage **image, - gint32 *drawable_ID, + GimpDrawable **drawable, const gchar *format_name, GimpExportCapabilities capabilities); diff --git a/libgimp/gimpimagemetadata.c b/libgimp/gimpimagemetadata.c index d4eebb31cb..c4758f66d3 100644 --- a/libgimp/gimpimagemetadata.c +++ b/libgimp/gimpimagemetadata.c @@ -702,21 +702,22 @@ gimp_image_metadata_load_thumbnail (GFile *file, if (pixbuf) { - gint32 layer_ID; + GimpLayer *layer; image = gimp_image_new (gdk_pixbuf_get_width (pixbuf), gdk_pixbuf_get_height (pixbuf), GIMP_RGB); gimp_image_undo_disable (image); - layer_ID = gimp_layer_new_from_pixbuf (image, _("Background"), - pixbuf, - 100.0, - gimp_image_get_default_new_layer_mode (image), - 0.0, 0.0); + layer = gimp_layer_new_from_pixbuf (image, _("Background"), + pixbuf, + 100.0, + gimp_image_get_default_new_layer_mode (image), + 0.0, 0.0); g_object_unref (pixbuf); - gimp_image_insert_layer (image, layer_ID, -1, 0); + gimp_image_insert_layer (image, layer, NULL, 0); + g_object_unref (layer); gimp_image_metadata_rotate (image, gexiv2_metadata_get_orientation (GEXIV2_METADATA (metadata))); diff --git a/libgimp/gimpitemcombobox.c b/libgimp/gimpitemcombobox.c index 91650c92de..758afba3ce 100644 --- a/libgimp/gimpitemcombobox.c +++ b/libgimp/gimpitemcombobox.c @@ -467,12 +467,14 @@ gimp_item_combo_box_model_add (GimpIntComboBox *combo_box, for (i = 0; i < num_items; i++) { + GimpItem *item = gimp_item_new_by_id (items[i]); + if ((! private->constraint && ! private->constraint_d) || (private->constraint && (* private->constraint) (image, items[i], private->data)) || (private->constraint_d && (* private->constraint_d) (gimp_image_get_id (image), items[i], private->data))) { gchar *image_name = gimp_image_get_name (image); - gchar *item_name = gimp_item_get_name (items[i]); + gchar *item_name = gimp_item_get_name (item); gchar *label; GdkPixbuf *thumb; @@ -487,7 +489,7 @@ gimp_item_combo_box_model_add (GimpIntComboBox *combo_box, if (GIMP_IS_VECTORS_COMBO_BOX (combo_box)) thumb = NULL; else - thumb = gimp_drawable_get_thumbnail (items[i], + thumb = gimp_drawable_get_thumbnail (GIMP_DRAWABLE (item), THUMBNAIL_SIZE, THUMBNAIL_SIZE, GIMP_PIXBUF_SMALL_CHECKS); @@ -504,18 +506,20 @@ gimp_item_combo_box_model_add (GimpIntComboBox *combo_box, g_free (label); } - if (gimp_item_is_group (items[i])) + if (gimp_item_is_group (item)) { gint32 *children; gint n_children; - children = gimp_item_get_children (items[i], &n_children); + children = gimp_item_get_children (item, &n_children); gimp_item_combo_box_model_add (combo_box, store, image, n_children, children, tree_level + 1); g_free (children); } + + g_object_unref (item); } g_free (indent); @@ -583,7 +587,7 @@ gimp_item_combo_box_changed (GimpIntComboBox *combo_box) if (gimp_int_combo_box_get_active (combo_box, &item_ID)) { - if (item_ID > 0 && ! gimp_item_is_valid (item_ID)) + if (item_ID > 0 && ! _gimp_item_is_valid (item_ID)) { GtkTreeModel *model; GList *remove = NULL; diff --git a/libgimp/gimplayer.c b/libgimp/gimplayer.c index d019cb76a2..f9f6a49dc4 100644 --- a/libgimp/gimplayer.c +++ b/libgimp/gimplayer.c @@ -65,7 +65,7 @@ gimp_layer_init (GimpLayer *layer) * * Returns: The newly created layer. */ -gint32 +GimpLayer * gimp_layer_new (GimpImage *image, const gchar *name, gint width, @@ -85,7 +85,7 @@ gimp_layer_new (GimpImage *image, /** * gimp_layer_copy: - * @layer_ID: The layer to copy. + * @layer: The layer to copy. * * Copy a layer. * @@ -93,12 +93,12 @@ gimp_layer_new (GimpImage *image, * newly copied layer is for use within the original layer's image. It * should not be subsequently added to any other image. * - * Returns: The newly copied layer. + * Returns: (transfer full): The newly copied layer. */ -gint32 -gimp_layer_copy (gint32 layer_ID) +GimpLayer * +gimp_layer_copy (GimpLayer *layer) { - return _gimp_layer_copy (layer_ID, FALSE); + return _gimp_layer_copy (layer, FALSE); } /** @@ -125,7 +125,7 @@ gimp_layer_copy (gint32 layer_ID) * * Since: 2.4 */ -gint32 +GimpLayer * gimp_layer_new_from_pixbuf (GimpImage *image, const gchar *name, GdkPixbuf *pixbuf, @@ -135,24 +135,24 @@ gimp_layer_new_from_pixbuf (GimpImage *image, gdouble progress_end) { GeglBuffer *dest_buffer; - gint32 layer; + GimpLayer *layer; gint width; gint height; gint bpp; gdouble range = progress_end - progress_start; - g_return_val_if_fail (GDK_IS_PIXBUF (pixbuf), -1); + g_return_val_if_fail (GDK_IS_PIXBUF (pixbuf), NULL); if (gimp_image_base_type (image) != GIMP_RGB) { g_warning ("gimp_layer_new_from_pixbuf() needs an RGB image"); - return -1; + return NULL; } if (gdk_pixbuf_get_colorspace (pixbuf) != GDK_COLORSPACE_RGB) { g_warning ("gimp_layer_new_from_pixbuf() assumes that GdkPixbuf is RGB"); - return -1; + return NULL; } width = gdk_pixbuf_get_width (pixbuf); @@ -163,10 +163,10 @@ gimp_layer_new_from_pixbuf (GimpImage *image, bpp == 3 ? GIMP_RGB_IMAGE : GIMP_RGBA_IMAGE, opacity, mode); - if (layer == -1) - return -1; + if (! layer) + return NULL; - dest_buffer = gimp_drawable_get_buffer (layer); + dest_buffer = gimp_drawable_get_buffer (GIMP_DRAWABLE (layer)); gegl_buffer_set (dest_buffer, GEGL_RECTANGLE (0, 0, width, height), 0, gimp_pixbuf_get_format (pixbuf), @@ -203,7 +203,7 @@ gimp_layer_new_from_pixbuf (GimpImage *image, * * Since: 2.8 */ -gint32 +GimpLayer * gimp_layer_new_from_surface (GimpImage *image, const gchar *name, cairo_surface_t *surface, @@ -212,20 +212,20 @@ gimp_layer_new_from_surface (GimpImage *image, { GeglBuffer *src_buffer; GeglBuffer *dest_buffer; - gint32 layer; + GimpLayer *layer; gint width; gint height; cairo_format_t format; gdouble range = progress_end - progress_start; - g_return_val_if_fail (surface != NULL, -1); + g_return_val_if_fail (surface != NULL, NULL); g_return_val_if_fail (cairo_surface_get_type (surface) == - CAIRO_SURFACE_TYPE_IMAGE, -1); + CAIRO_SURFACE_TYPE_IMAGE, NULL); if (gimp_image_base_type (image) != GIMP_RGB) { g_warning ("gimp_layer_new_from_surface() needs an RGB image"); - return -1; + return NULL; } width = cairo_image_surface_get_width (surface); @@ -236,7 +236,7 @@ gimp_layer_new_from_surface (GimpImage *image, format != CAIRO_FORMAT_RGB24) { g_warning ("gimp_layer_new_from_surface() assumes that surface is RGB"); - return -1; + return NULL; } layer = gimp_layer_new (image, name, width, height, @@ -245,11 +245,11 @@ gimp_layer_new_from_surface (GimpImage *image, 100.0, gimp_image_get_default_new_layer_mode (image)); - if (layer == -1) - return -1; + if (layer == NULL) + return NULL; src_buffer = gimp_cairo_surface_create_buffer (surface); - dest_buffer = gimp_drawable_get_buffer (layer); + dest_buffer = gimp_drawable_get_buffer (GIMP_DRAWABLE (layer)); gegl_buffer_copy (src_buffer, NULL, GEGL_ABYSS_NONE, dest_buffer, NULL); @@ -298,12 +298,15 @@ gimp_layer_new_deprecated (gint32 image_id, GimpLayerMode mode) { GimpImage *image = gimp_image_new_by_id (image_id); + GimpLayer *layer; gint32 layer_id; - layer_id = gimp_layer_new (image, name, width, height, - type, opacity, mode); + layer = gimp_layer_new (image, name, width, height, + type, opacity, mode); + layer_id = gimp_item_get_id (GIMP_ITEM (layer)); g_object_unref (image); + g_object_unref (layer); return layer_id; } @@ -342,12 +345,15 @@ gimp_layer_new_from_pixbuf_deprecated (gint32 image_id, gdouble progress_end) { GimpImage *image = gimp_image_new_by_id (image_id); + GimpLayer *layer; gint32 layer_id; - layer_id = gimp_layer_new_from_pixbuf (image, name, pixbuf, opacity, mode, - progress_start, progress_end); + layer = gimp_layer_new_from_pixbuf (image, name, pixbuf, opacity, mode, + progress_start, progress_end); + layer_id = gimp_item_get_id (GIMP_ITEM (layer)); g_object_unref (image); + g_object_unref (layer); return layer_id; } @@ -382,12 +388,48 @@ gimp_layer_new_from_surface_deprecated (gint32 image_id, gdouble progress_end) { GimpImage *image = gimp_image_new_by_id (image_id); + GimpLayer *layer; gint32 layer_id; - layer_id = gimp_layer_new_from_surface (image, name, surface, - progress_start, progress_end); + layer = gimp_layer_new_from_surface (image, name, surface, + progress_start, progress_end); + layer_id = gimp_item_get_id (GIMP_ITEM (layer)); g_object_unref (image); + g_object_unref (layer); return layer_id; } + +/** + * gimp_layer_copy_deprecated: (skip) + * @layer_ID: The layer to copy. + * + * Copy a layer. + * + * This procedure copies the specified layer and returns the copy. The + * newly copied layer is for use within the original layer's image. It + * should not be subsequently added to any other image. + * + * Returns: The newly copied layer. + */ +gint32 +gimp_layer_copy_deprecated (gint32 layer_ID) +{ + GimpLayer *layer; + GimpLayer *copy; + gint32 copy_id; + + layer = GIMP_LAYER (gimp_item_new_by_id (layer_ID)); + g_return_val_if_fail (layer, -1); + + copy = gimp_layer_copy (layer); + g_return_val_if_fail (copy, -1); + + copy_id = gimp_item_get_id (GIMP_ITEM (copy)); + + g_object_unref (copy); + g_object_unref (layer); + + return copy_id; +} diff --git a/libgimp/gimplayer.h b/libgimp/gimplayer.h index fc4dfd530d..aa36e85422 100644 --- a/libgimp/gimplayer.h +++ b/libgimp/gimplayer.h @@ -63,37 +63,38 @@ struct _GimpLayerClass GType gimp_layer_get_type (void) G_GNUC_CONST; -gint32 gimp_layer_copy (gint32 layer_ID); - #ifndef GIMP_DEPRECATED_REPLACE_NEW_API -gint32 gimp_layer_new (GimpImage *image, - const gchar *name, - gint width, - gint height, - GimpImageType type, - gdouble opacity, - GimpLayerMode mode); +GimpLayer * gimp_layer_new (GimpImage *image, + const gchar *name, + gint width, + gint height, + GimpImageType type, + gdouble opacity, + GimpLayerMode mode); -gint32 gimp_layer_new_from_pixbuf (GimpImage *image, - const gchar *name, - GdkPixbuf *pixbuf, - gdouble opacity, - GimpLayerMode mode, - gdouble progress_start, - gdouble progress_end); -gint32 gimp_layer_new_from_surface (GimpImage *image, - const gchar *name, - cairo_surface_t *surface, - gdouble progress_start, - gdouble progress_end); +GimpLayer * gimp_layer_new_from_pixbuf (GimpImage *image, + const gchar *name, + GdkPixbuf *pixbuf, + gdouble opacity, + GimpLayerMode mode, + gdouble progress_start, + gdouble progress_end); +GimpLayer * gimp_layer_new_from_surface (GimpImage *image, + const gchar *name, + cairo_surface_t *surface, + gdouble progress_start, + gdouble progress_end); + +GimpLayer * gimp_layer_copy (GimpLayer *layer); #else /* GIMP_DEPRECATED_REPLACE_NEW_API */ #define gimp_layer_new gimp_layer_new_deprecated #define gimp_layer_new_from_pixbuf gimp_layer_new_from_pixbuf_deprecated #define gimp_layer_new_from_surface gimp_layer_new_from_surface_deprecated +#define gimp_layer_copy gimp_layer_copy_deprecated #endif /* GIMP_DEPRECATED_REPLACE_NEW_API */ @@ -119,6 +120,7 @@ gint32 gimp_layer_new_from_surface_deprecated (gint32 image_id, gdouble progress_start, gdouble progress_end); +gint32 gimp_layer_copy_deprecated (gint32 layer_ID); G_END_DECLS diff --git a/libgimp/gimpparamspecs.c b/libgimp/gimpparamspecs.c index f5e3062511..19ebfc2c1f 100644 --- a/libgimp/gimpparamspecs.c +++ b/libgimp/gimpparamspecs.c @@ -297,7 +297,7 @@ gimp_param_item_id_validate (GParamSpec *pspec, if (ispec->none_ok && (item_id == 0 || item_id == -1)) return FALSE; - if (! gimp_item_is_valid (item_id)) + if (! _gimp_item_is_valid (item_id)) { value->data[0].v_int = -1; return TRUE; @@ -452,7 +452,7 @@ gimp_param_drawable_id_validate (GParamSpec *pspec, if (ispec->none_ok && (item_id == 0 || item_id == -1)) return FALSE; - if (! gimp_item_is_drawable (item_id)) + if (! _gimp_item_is_drawable (item_id)) { value->data[0].v_int = -1; return TRUE; @@ -589,7 +589,7 @@ gimp_param_layer_id_validate (GParamSpec *pspec, if (ispec->none_ok && (item_id == 0 || item_id == -1)) return FALSE; - if (! gimp_item_is_layer (item_id)) + if (! _gimp_item_is_layer (item_id)) { value->data[0].v_int = -1; return TRUE; @@ -726,7 +726,7 @@ gimp_param_channel_id_validate (GParamSpec *pspec, if (ispec->none_ok && (item_id == 0 || item_id == -1)) return FALSE; - if (! gimp_item_is_channel (item_id)) + if (! _gimp_item_is_channel (item_id)) { value->data[0].v_int = -1; return TRUE; @@ -863,7 +863,7 @@ gimp_param_layer_mask_id_validate (GParamSpec *pspec, if (ispec->none_ok && (item_id == 0 || item_id == -1)) return FALSE; - if (! gimp_item_is_layer_mask (item_id)) + if (! _gimp_item_is_layer_mask (item_id)) { value->data[0].v_int = -1; return TRUE; @@ -1000,7 +1000,7 @@ gimp_param_selection_id_validate (GParamSpec *pspec, if (ispec->none_ok && (item_id == 0 || item_id == -1)) return FALSE; - if (! gimp_item_is_selection (item_id)) + if (! _gimp_item_is_selection (item_id)) { value->data[0].v_int = -1; return TRUE; @@ -1137,7 +1137,7 @@ gimp_param_vectors_id_validate (GParamSpec *pspec, if (ispec->none_ok && (item_id == 0 || item_id == -1)) return FALSE; - if (! gimp_item_is_vectors (item_id)) + if (! _gimp_item_is_vectors (item_id)) { value->data[0].v_int = -1; return TRUE; diff --git a/libgimp/gimpselection.c b/libgimp/gimpselection.c index 00c94e3c2f..58bc224366 100644 --- a/libgimp/gimpselection.c +++ b/libgimp/gimpselection.c @@ -24,6 +24,39 @@ /** * gimp_selection_float: + * @image: ignored + * @drawable: The drawable from which to float selection. + * @offx: x offset for translation. + * @offy: y offset for translation. + * + * Float the selection from the specified drawable with initial offsets + * as specified. + * + * This procedure determines the region of the specified drawable that + * lies beneath the current selection. The region is then cut from the + * drawable and the resulting data is made into a new layer which is + * instantiated as a floating selection. The offsets allow initial + * positioning of the new floating selection. + * + * Returns: (transfer full): The floated layer. + */ +GimpLayer * +gimp_selection_float (GimpImage *image, + GimpDrawable *drawable, + gint offx, + gint offy) +{ + return _gimp_selection_float (drawable, + offx, + offy); +} + + +/* Deprecated API. */ + + +/** + * gimp_selection_float_deprecated: (skip) * @image_ID: ignored * @drawable_ID: The drawable from which to float selection. * @offx: x offset for translation. @@ -41,12 +74,28 @@ * Returns: The floated layer. */ gint32 -gimp_selection_float (gint32 image_ID, - gint32 drawable_ID, - gint offx, - gint offy) +gimp_selection_float_deprecated (gint32 image_ID, + gint32 drawable_ID, + gint offx, + gint offy) { - return _gimp_selection_float (drawable_ID, - offx, - offy); + GimpImage *image; + GimpDrawable *drawable; + GimpLayer *selection; + gint32 selection_id = -1; + + image = gimp_image_new_by_id (image_ID); + drawable = GIMP_DRAWABLE (gimp_item_new_by_id (drawable_ID)); + + selection = gimp_selection_float (image, drawable, + offx, + offy); + if (selection) + selection_id = gimp_item_get_id (GIMP_ITEM (selection)); + + g_object_unref (image); + g_object_unref (drawable); + g_object_unref (selection); + + return selection_id; } diff --git a/libgimp/gimpselection.h b/libgimp/gimpselection.h index 8058c343ac..5073b43228 100644 --- a/libgimp/gimpselection.h +++ b/libgimp/gimpselection.h @@ -30,10 +30,24 @@ G_BEGIN_DECLS /* For information look into the C source or the html documentation */ -gint32 gimp_selection_float (gint32 image_ID, - gint32 drawable_ID, - gint offx, - gint offy); +#ifndef GIMP_DEPRECATED_REPLACE_NEW_API + +GimpLayer * gimp_selection_float (GimpImage *image, + GimpDrawable *drawable, + gint offx, + gint offy); + +#else /* GIMP_DEPRECATED_REPLACE_NEW_API */ + +#define gimp_selection_float gimp_selection_float_deprecated + +#endif /* GIMP_DEPRECATED_REPLACE_NEW_API */ + + +gint32 gimp_selection_float_deprecated (gint32 image_ID, + gint32 drawable_ID, + gint offx, + gint offy); G_END_DECLS diff --git a/libgimp/gimptilebackendplugin.c b/libgimp/gimptilebackendplugin.c index 8d52431115..955a0de7a6 100644 --- a/libgimp/gimptilebackendplugin.c +++ b/libgimp/gimptilebackendplugin.c @@ -175,14 +175,14 @@ gimp_tile_backend_plugin_command (GeglTileSource *tile_store, /* public functions */ GeglTileBackend * -_gimp_tile_backend_plugin_new (gint32 drawable_id, - gint shadow) +_gimp_tile_backend_plugin_new (GimpDrawable *drawable, + gint shadow) { GeglTileBackend *backend; GimpTileBackendPlugin *backend_plugin; - const Babl *format = gimp_drawable_get_format (drawable_id); - gint width = gimp_drawable_width (drawable_id); - gint height = gimp_drawable_height (drawable_id); + const Babl *format = gimp_drawable_get_format (drawable); + gint width = gimp_drawable_width (drawable); + gint height = gimp_drawable_height (drawable); backend = g_object_new (GIMP_TYPE_TILE_BACKEND_PLUGIN, "tile-width", TILE_WIDTH, @@ -192,11 +192,11 @@ _gimp_tile_backend_plugin_new (gint32 drawable_id, backend_plugin = GIMP_TILE_BACKEND_PLUGIN (backend); - backend_plugin->priv->drawable_id = drawable_id; + backend_plugin->priv->drawable_id = gimp_item_get_id (GIMP_ITEM (drawable)); backend_plugin->priv->shadow = shadow; backend_plugin->priv->width = width; backend_plugin->priv->height = height; - backend_plugin->priv->bpp = gimp_drawable_bpp (drawable_id); + backend_plugin->priv->bpp = gimp_drawable_bpp (drawable); backend_plugin->priv->ntile_rows = (height + TILE_HEIGHT - 1) / TILE_HEIGHT; backend_plugin->priv->ntile_cols = (width + TILE_WIDTH - 1) / TILE_WIDTH; diff --git a/libgimp/gimptilebackendplugin.h b/libgimp/gimptilebackendplugin.h index cfb77c53a8..3afefc39fd 100644 --- a/libgimp/gimptilebackendplugin.h +++ b/libgimp/gimptilebackendplugin.h @@ -52,8 +52,8 @@ struct _GimpTileBackendPluginClass GType _gimp_tile_backend_plugin_get_type (void) G_GNUC_CONST; -GeglTileBackend * _gimp_tile_backend_plugin_new (gint32 drawable_id, - gint shadow); +GeglTileBackend * _gimp_tile_backend_plugin_new (GimpDrawable *drawable, + gint shadow); G_END_DECLS diff --git a/libgimp/gimpzoompreview.c b/libgimp/gimpzoompreview.c index 8dcae1f7a8..490a558b1e 100644 --- a/libgimp/gimpzoompreview.c +++ b/libgimp/gimpzoompreview.c @@ -46,7 +46,7 @@ enum { PROP_0, - PROP_DRAWABLE_ID, + PROP_DRAWABLE, PROP_MODEL }; @@ -58,7 +58,7 @@ typedef struct struct _GimpZoomPreviewPrivate { - gint32 drawable_ID; + GimpDrawable *drawable; GimpZoomModel *model; GdkRectangle extents; }; @@ -108,8 +108,8 @@ static void gimp_zoom_preview_untransform (GimpPreview *preview, gint *dest_x, gint *dest_y); -static void gimp_zoom_preview_set_drawable_id (GimpZoomPreview *preview, - gint32 drawable_ID); +static void gimp_zoom_preview_set_drawable (GimpZoomPreview *preview, + GimpDrawable *drawable); static void gimp_zoom_preview_set_model (GimpZoomPreview *preview, GimpZoomModel *model); @@ -157,13 +157,13 @@ gimp_zoom_preview_class_init (GimpZoomPreviewClass *klass) * * Since: 2.10 */ - g_object_class_install_property (object_class, PROP_DRAWABLE_ID, - g_param_spec_int ("drawable-id", - "Drawable ID", - "The drawable this preview is attached to", - -1, G_MAXINT, -1, - GIMP_PARAM_READWRITE | - G_PARAM_CONSTRUCT_ONLY)); + g_object_class_install_property (object_class, PROP_DRAWABLE, + g_param_spec_object ("drawable", + "Drawable", + "The drawable this preview is attached to", + GIMP_TYPE_DRAWABLE, + GIMP_PARAM_READWRITE | + G_PARAM_CONSTRUCT_ONLY)); /** * GimpZoomPreview:model: @@ -244,6 +244,7 @@ gimp_zoom_preview_finalize (GObject *object) GimpZoomPreviewPrivate *priv = GET_PRIVATE (object); g_clear_object (&priv->model); + g_clear_object (&priv->drawable); G_OBJECT_CLASS (parent_class)->finalize (object); } @@ -277,8 +278,8 @@ gimp_zoom_preview_get_property (GObject *object, switch (property_id) { - case PROP_DRAWABLE_ID: - g_value_set_int (value, gimp_zoom_preview_get_drawable_id (preview)); + case PROP_DRAWABLE: + g_value_set_object (value, gimp_zoom_preview_get_drawable (preview)); break; case PROP_MODEL: @@ -301,8 +302,8 @@ gimp_zoom_preview_set_property (GObject *object, switch (property_id) { - case PROP_DRAWABLE_ID: - gimp_zoom_preview_set_drawable_id (preview, g_value_get_int (value)); + case PROP_DRAWABLE: + gimp_zoom_preview_set_drawable (preview, g_value_dup_object (value)); break; case PROP_MODEL: @@ -397,7 +398,7 @@ gimp_zoom_preview_style_updated (GtkWidget *widget) gtk_widget_style_get (widget, "size", &size, NULL); - if (_gimp_drawable_preview_get_bounds (priv->drawable_ID, + if (_gimp_drawable_preview_get_bounds (priv->drawable, &x1, &y1, &x2, &y2)) { width = x2 - x1; @@ -405,8 +406,8 @@ gimp_zoom_preview_style_updated (GtkWidget *widget) } else { - width = gimp_drawable_width (priv->drawable_ID); - height = gimp_drawable_height (priv->drawable_ID); + width = gimp_drawable_width (priv->drawable); + height = gimp_drawable_height (priv->drawable); } if (width > height) @@ -473,7 +474,7 @@ gimp_zoom_preview_draw (GimpPreview *preview) if (! priv->model) return; - if (priv->drawable_ID < 1) + if (priv->drawable == NULL) return; data = gimp_zoom_preview_get_source (GIMP_ZOOM_PREVIEW (preview), @@ -485,7 +486,7 @@ gimp_zoom_preview_draw (GimpPreview *preview) gimp_preview_area_draw (GIMP_PREVIEW_AREA (area), 0, 0, width, height, - gimp_drawable_type (priv->drawable_ID), + gimp_drawable_type (priv->drawable), data, width * bpp); g_free (data); } @@ -503,32 +504,34 @@ gimp_zoom_preview_draw_buffer (GimpPreview *preview, gint height; gimp_preview_get_size (preview, &width, &height); - image = gimp_item_get_image (priv->drawable_ID); + image = gimp_item_get_image (GIMP_ITEM (priv->drawable)); if (gimp_selection_is_empty (image)) { gimp_preview_area_draw (GIMP_PREVIEW_AREA (area), 0, 0, width, height, - gimp_drawable_type (priv->drawable_ID), + gimp_drawable_type (priv->drawable), buffer, rowstride); } else { - guchar *sel; - guchar *src; - gint selection_ID; - gint w, h; - gint bpp; - gint src_x; - gint src_y; - gint src_width; - gint src_height; - gint offsx = 0; - gint offsy = 0; + guchar *sel; + guchar *src; + GimpDrawable *selection; + gint selection_ID; + gint w, h; + gint bpp; + gint src_x; + gint src_y; + gint src_width; + gint src_height; + gint offsx = 0; + gint offsy = 0; selection_ID = gimp_image_get_selection (image); + selection = GIMP_DRAWABLE (gimp_item_new_by_id (selection_ID)); w = width; h = height; @@ -537,20 +540,21 @@ gimp_zoom_preview_draw_buffer (GimpPreview *preview, &src_x, &src_y, &src_width, &src_height); - src = gimp_drawable_get_sub_thumbnail_data (priv->drawable_ID, + src = gimp_drawable_get_sub_thumbnail_data (priv->drawable, src_x, src_y, src_width, src_height, &w, &h, &bpp); - gimp_drawable_offsets (priv->drawable_ID, &offsx, &offsy); - sel = gimp_drawable_get_sub_thumbnail_data (selection_ID, + gimp_drawable_offsets (priv->drawable, &offsx, &offsy); + sel = gimp_drawable_get_sub_thumbnail_data (selection, src_x + offsx, src_y + offsy, src_width, src_height, &width, &height, &bpp); + g_object_unref (selection); gimp_preview_area_mask (GIMP_PREVIEW_AREA (area), 0, 0, width, height, - gimp_drawable_type (priv->drawable_ID), - src, width * gimp_drawable_bpp (priv->drawable_ID), + gimp_drawable_type (priv->drawable), + src, width * gimp_drawable_bpp (priv->drawable), buffer, rowstride, sel, width); @@ -569,8 +573,8 @@ gimp_zoom_preview_draw_thumb (GimpPreview *preview, { GimpZoomPreviewPrivate *priv = GIMP_ZOOM_PREVIEW (preview)->priv; - if (priv->drawable_ID > 0) - _gimp_drawable_preview_area_draw_thumb (area, priv->drawable_ID, + if (priv->drawable != NULL) + _gimp_drawable_preview_area_draw_thumb (area, priv->drawable, width, height); } @@ -654,27 +658,27 @@ gimp_zoom_preview_untransform (GimpPreview *preview, } static void -gimp_zoom_preview_set_drawable_id (GimpZoomPreview *preview, - gint32 drawable_ID) +gimp_zoom_preview_set_drawable (GimpZoomPreview *preview, + GimpDrawable *drawable) { GimpZoomPreviewPrivate *priv = preview->priv; gint x, y; gint width, height; gint max_width, max_height; - g_return_if_fail (preview->priv->drawable_ID < 1); + g_return_if_fail (preview->priv->drawable == NULL); - priv->drawable_ID = drawable_ID; + priv->drawable = drawable; - if (gimp_drawable_mask_intersect (drawable_ID, &x, &y, &width, &height)) + if (gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height)) { priv->extents.x = x; priv->extents.y = y; } else { - width = gimp_drawable_width (drawable_ID); - height = gimp_drawable_height (drawable_ID); + width = gimp_drawable_width (drawable); + height = gimp_drawable_height (drawable); priv->extents.x = 0; priv->extents.y = 0; @@ -760,35 +764,35 @@ gimp_zoom_preview_get_source_area (GimpPreview *preview, /** - * gimp_zoom_preview_new_from_drawable_id: - * @drawable_ID: a drawable ID + * gimp_zoom_preview_new_from_drawable: + * @drawable: (transfer none): a drawable * - * Creates a new #GimpZoomPreview widget for @drawable_ID. + * Creates a new #GimpZoomPreview widget for @drawable. * - * Since: 2.10 + * Since: 3.0 * * Returns: a new #GimpZoomPreview. **/ GtkWidget * -gimp_zoom_preview_new_from_drawable_id (gint32 drawable_ID) +gimp_zoom_preview_new_from_drawable (GimpDrawable *drawable) { - g_return_val_if_fail (gimp_item_is_valid (drawable_ID), NULL); - g_return_val_if_fail (gimp_item_is_drawable (drawable_ID), NULL); + g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL); + g_return_val_if_fail (gimp_item_is_valid (GIMP_ITEM (drawable)), NULL); return g_object_new (GIMP_TYPE_ZOOM_PREVIEW, - "drawable-id", drawable_ID, + "drawable", drawable, NULL); } /** * gimp_zoom_preview_new_with_model_from_drawable_id: - * @drawable_ID: a drawable ID - * @model: a #GimpZoomModel + * @drawable: (transfer none): a drawable + * @model: (transfer full): a #GimpZoomModel * - * Creates a new #GimpZoomPreview widget for @drawable_ID using the + * Creates a new #GimpZoomPreview widget for @drawableusing the * given @model. * - * This variant of gimp_zoom_preview_new_from_drawable_id() allows you + * This variant of gimp_zoom_preview_new_from_drawable() allows you * to create a preview using an existing zoom model. This may be * useful if for example you want to have two zoom previews that keep * their zoom factor in sync. @@ -798,37 +802,37 @@ gimp_zoom_preview_new_from_drawable_id (gint32 drawable_ID) * Returns: a new #GimpZoomPreview. **/ GtkWidget * -gimp_zoom_preview_new_with_model_from_drawable_id (gint32 drawable_ID, - GimpZoomModel *model) +gimp_zoom_preview_new_with_model_from_drawable (GimpDrawable *drawable, + GimpZoomModel *model) { - g_return_val_if_fail (gimp_item_is_valid (drawable_ID), NULL); - g_return_val_if_fail (gimp_item_is_drawable (drawable_ID), NULL); + g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL); + g_return_val_if_fail (gimp_item_is_valid (GIMP_ITEM (drawable)), NULL); g_return_val_if_fail (GIMP_IS_ZOOM_MODEL (model), NULL); return g_object_new (GIMP_TYPE_ZOOM_PREVIEW, - "drawable-id", drawable_ID, - "model", model, + "drawable", drawable, + "model", model, NULL); } /** - * gimp_zoom_preview_get_drawable_id: + * gimp_zoom_preview_get_drawable: * @preview: a #GimpZoomPreview widget * - * Returns the drawable_ID the #GimpZoomPreview is attached to. + * Returns the drawable the #GimpZoomPreview is attached to. * - * Returns: the drawable_ID that was passed to - * gimp_zoom_preview_new_from_drawable_id(). + * Returns: (transfer none): the drawable that was passed to + * gimp_zoom_preview_new_from_drawable(). * - * Since: 2.10 + * Since: 3.0 **/ -gint32 -gimp_zoom_preview_get_drawable_id (GimpZoomPreview *preview) +GimpDrawable * +gimp_zoom_preview_get_drawable (GimpZoomPreview *preview) { - g_return_val_if_fail (GIMP_IS_ZOOM_PREVIEW (preview), -1); + g_return_val_if_fail (GIMP_IS_ZOOM_PREVIEW (preview), NULL); - return GET_PRIVATE (preview)->drawable_ID; + return GET_PRIVATE (preview)->drawable; } /** @@ -838,7 +842,7 @@ gimp_zoom_preview_get_drawable_id (GimpZoomPreview *preview) * Returns the #GimpZoomModel the preview is using. * * Returns: (transfer none): a pointer to the #GimpZoomModel owned - * by the @preview + * by the @preview * * Since: 2.4 **/ @@ -897,14 +901,14 @@ gimp_zoom_preview_get_source (GimpZoomPreview *preview, gint *height, gint *bpp) { - gint32 drawable_ID; + GimpDrawable *drawable; g_return_val_if_fail (GIMP_IS_ZOOM_PREVIEW (preview), NULL); g_return_val_if_fail (width != NULL && height != NULL && bpp != NULL, NULL); - drawable_ID = gimp_zoom_preview_get_drawable_id (preview); + drawable = gimp_zoom_preview_get_drawable (preview); - if (drawable_ID > 0) + if (drawable) { GimpPreview *gimp_preview = GIMP_PREVIEW (preview); gint src_x; @@ -918,7 +922,7 @@ gimp_zoom_preview_get_source (GimpZoomPreview *preview, &src_x, &src_y, &src_width, &src_height); - return gimp_drawable_get_sub_thumbnail_data (drawable_ID, + return gimp_drawable_get_sub_thumbnail_data (drawable, src_x, src_y, src_width, src_height, width, height, bpp); diff --git a/libgimp/gimpzoompreview.h b/libgimp/gimpzoompreview.h index eca61d25a2..da358ab21e 100644 --- a/libgimp/gimpzoompreview.h +++ b/libgimp/gimpzoompreview.h @@ -68,10 +68,9 @@ struct _GimpZoomPreviewClass GType gimp_zoom_preview_get_type (void) G_GNUC_CONST; -GtkWidget * gimp_zoom_preview_new_from_drawable_id - (gint32 drawable_ID); -GtkWidget * gimp_zoom_preview_new_with_model_from_drawable_id - (gint32 drawable_ID, +GtkWidget * gimp_zoom_preview_new_from_drawable (GimpDrawable *drawable); +GtkWidget * gimp_zoom_preview_new_with_model_from_drawable + (GimpDrawable *drawable, GimpZoomModel *model); guchar * gimp_zoom_preview_get_source (GimpZoomPreview *preview, @@ -79,7 +78,7 @@ guchar * gimp_zoom_preview_get_source (GimpZoomPreview *preview, gint *height, gint *bpp); -gint32 gimp_zoom_preview_get_drawable_id(GimpZoomPreview *preview); +GimpDrawable * gimp_zoom_preview_get_drawable (GimpZoomPreview *preview); GimpZoomModel * gimp_zoom_preview_get_model (GimpZoomPreview *preview); gdouble gimp_zoom_preview_get_factor (GimpZoomPreview *preview);