dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
gimp/libgimp/gimpdrawable.c

674 lines
22 KiB
C
Raw Permalink Blame History

/* LIBGIMP - The GIMP Library
* Copyright (C) 1995-1997 Peter Mattis and Spencer Kimball
*
* gimpdrawable.c
*
* This library is free software: you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see
* <https://www.gnu.org/licenses/>.
*/
#include "config.h"
#include "gimp.h"
#include <gobject/gvaluecollector.h>
#include "gimppixbuf.h"
#include "gimptilebackendplugin.h"
G_DEFINE_ABSTRACT_TYPE (GimpDrawable, gimp_drawable, GIMP_TYPE_ITEM)
#define parent_class gimp_drawable_parent_class
static void
gimp_drawable_class_init (GimpDrawableClass *klass)
{
}
static void
gimp_drawable_init (GimpDrawable *drawable)
{
}
/* Public API. */
/**
* gimp_drawable_get_by_id:
* @drawable_id: The drawable id.
*
* Returns a #GimpDrawable representing @drawable_id. This function
* calls gimp_item_get_by_id() and returns the item if it is drawable
* or %NULL otherwise.
*
* Returns: (nullable) (transfer none): a #GimpDrawable for
* @drawable_id or %NULL if @drawable_id does not represent a
* valid drawable. The object belongs to libgimp and you must
* not modify or unref it.
*
* Since: 3.0
**/
GimpDrawable *
gimp_drawable_get_by_id (gint32 drawable_id)
{
GimpItem *item = gimp_item_get_by_id (drawable_id);
if (GIMP_IS_DRAWABLE (item))
return (GimpDrawable *) item;
return NULL;
}
/**
* gimp_drawable_get_thumbnail_data:
* @drawable: the drawable
* @width: the requested thumbnail width (<= 1024 pixels)
* @height: the requested thumbnail height (<= 1024 pixels)
* @actual_width: (out): the resulting thumbnail's actual width
* @actual_height: (out): the resulting thumbnail's actual height
* @bpp: (out): the bytes per pixel of the returned thubmnail data
*
* Retrieves thumbnail data for the drawable identified by @drawable.
* The thumbnail will be not larger than the requested size.
*
* Returns: (transfer full) (nullable): thumbnail data or %NULL if
* @drawable is invalid.
**/
GBytes *
gimp_drawable_get_thumbnail_data (GimpDrawable *drawable,
gint width,
gint height,
gint *actual_width,
gint *actual_height,
gint *bpp)
{
GBytes *image_data;
g_return_val_if_fail (actual_width != NULL, NULL);
g_return_val_if_fail (actual_height != NULL, NULL);
g_return_val_if_fail (bpp != NULL, NULL);
_gimp_drawable_thumbnail (drawable,
width,
height,
actual_width,
actual_height,
bpp,
&image_data);
return image_data;
}
/**
* gimp_drawable_get_thumbnail:
* @drawable: the drawable
* @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. The thumbnail will be not larger than the requested
* size.
*
* Returns: (transfer full): a new #GdkPixbuf
*
* Since: 2.2
**/
GdkPixbuf *
gimp_drawable_get_thumbnail (GimpDrawable *drawable,
gint width,
gint height,
GimpPixbufTransparency alpha)
{
gint thumb_width, thumb_height, thumb_bpp;
GBytes *data;
gsize data_size;
GdkPixbuf *pixbuf = NULL;
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,
width,
height,
&thumb_width,
&thumb_height,
&thumb_bpp);
if (data)
pixbuf = _gimp_pixbuf_from_data (g_bytes_unref_to_data (data, &data_size),
thumb_width, thumb_height, thumb_bpp,
alpha);
return pixbuf;
}
/**
* gimp_drawable_get_sub_thumbnail_data:
* @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
* @src_height: the height of the area
* @dest_width: the requested thumbnail width (<= 1024 pixels)
* @dest_height: the requested thumbnail height (<= 1024 pixels)
* @actual_width: (out): the width of the returned thumbnail
* @actual_height: (out): the height of the returned thumbnail
* @bpp: (out): the bytes per pixel of the returned thumbnail data
*
* Retrieves thumbnail data for the drawable identified by @drawable.
* The thumbnail will be not larger than the requested size.
*
* Returns: (transfer full): thumbnail data or %NULL if
* @drawable is invalid.
**/
GBytes *
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 *actual_width,
gint *actual_height,
gint *bpp)
{
GBytes *image_bytes;
_gimp_drawable_sub_thumbnail (drawable,
src_x, src_y,
src_width, src_height,
dest_width,
dest_height,
actual_width,
actual_height,
bpp,
&image_bytes);
return image_bytes;
}
/**
* gimp_drawable_get_sub_thumbnail:
* @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
* @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. 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 (GimpDrawable *drawable,
gint src_x,
gint src_y,
gint src_width,
gint src_height,
gint dest_width,
gint dest_height,
GimpPixbufTransparency alpha)
{
gint thumb_width = dest_width;
gint thumb_height = dest_height;
gint thumb_bpp;
GBytes *data;
gsize data_size;
GdkPixbuf *pixbuf = NULL;
g_return_val_if_fail (src_x >= 0, NULL);
g_return_val_if_fail (src_y >= 0, NULL);
g_return_val_if_fail (src_width > 0, NULL);
g_return_val_if_fail (src_height > 0, NULL);
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,
src_x, src_y,
src_width, src_height,
dest_width, dest_height,
&thumb_width,
&thumb_height,
&thumb_bpp);
if (data)
pixbuf = _gimp_pixbuf_from_data (g_bytes_unref_to_data (data, &data_size),
thumb_width, thumb_height, thumb_bpp,
alpha);
g_bytes_unref (data);
return pixbuf;
}
/**
* gimp_drawable_get_buffer:
* @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
* 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 (GimpDrawable *drawable)
{
if (gimp_item_is_valid (GIMP_ITEM (drawable)))
{
GeglTileBackend *backend;
GeglBuffer *buffer;
backend = _gimp_tile_backend_plugin_new (drawable, FALSE);
buffer = gegl_buffer_new_for_backend (NULL, backend);
g_object_unref (backend);
return buffer;
}
return NULL;
}
/**
* gimp_drawable_get_shadow_buffer:
* @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
* 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.
*
* Since: 2.10
*/
GeglBuffer *
gimp_drawable_get_shadow_buffer (GimpDrawable *drawable)
{
if (gimp_item_is_valid (GIMP_ITEM (drawable)))
{
GeglTileBackend *backend;
GeglBuffer *buffer;
backend = _gimp_tile_backend_plugin_new (drawable, TRUE);
buffer = gegl_buffer_new_for_backend (NULL, backend);
g_object_unref (backend);
return buffer;
}
return NULL;
}
/**
* gimp_drawable_get_format:
* @drawable: 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 (GimpDrawable *drawable)
{
const Babl *format = NULL;
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
*/
if (format_str)
{
const Babl *space = NULL;
GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable));
if (gimp_item_is_layer (GIMP_ITEM (drawable)))
{
GimpColorProfile *profile = gimp_image_get_color_profile (image);
if (profile)
{
GError *error = NULL;
space = gimp_color_profile_get_space
(profile,
GIMP_COLOR_RENDERING_INTENT_RELATIVE_COLORIMETRIC,
&error);
if (! space)
{
g_printerr ("%s: failed to create Babl space from "
"profile: %s\n",
G_STRFUNC, error->message);
g_clear_error (&error);
}
g_object_unref (profile);
}
}
if (gimp_drawable_is_indexed (drawable))
{
const Babl *palette;
const Babl *palette_alpha;
const Babl *color_format;
guchar *colormap;
gint n_colors;
babl_new_palette_with_space (format_str, space,
&palette, &palette_alpha);
if (gimp_drawable_has_alpha (drawable))
format = palette_alpha;
else
format = palette;
color_format = babl_format_with_space ("R'G'B' u8", space);
colormap = gimp_palette_get_colormap (gimp_image_get_palette (image), color_format, &n_colors, NULL);
if (colormap)
{
babl_palette_set_palette (format, color_format, colormap, n_colors);
g_free (colormap);
}
}
else
{
format = babl_format_with_space (format_str, space);
}
g_free (format_str);
}
return format;
}
/**
* 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);
g_free (format_str);
}
return format;
}
/**
* gimp_drawable_append_filter:
* @drawable: The drawable.
* @filter: The drawable filter to append.
*
* This procedure appends the specified drawable effect at the top of the
* effect list of @drawable.
*
* The @drawable argument must be the same as the one used when you
* created the effect with [ctor@Gimp.DrawableFilter.new].
* Some effects may be slower than others to render. In order to
* minimize processing time, it is preferred to customize the
* operation's arguments as received with
* [method@Gimp.DrawableFilter.get_config] before adding the effect.
*
* Since: 3.0
**/
void
gimp_drawable_append_filter (GimpDrawable *drawable,
GimpDrawableFilter *filter)
{
g_return_if_fail (GIMP_IS_DRAWABLE (drawable));
g_return_if_fail (GIMP_IS_DRAWABLE_FILTER (filter));
gimp_drawable_filter_update (filter);
_gimp_drawable_append_filter_private (drawable, filter);
}
/**
* gimp_drawable_merge_filter:
* @drawable: The drawable.
* @filter: The drawable filter to merge.
*
* This procedure applies the specified drawable effect on @drawable
* and merge it (therefore before any non-destructive effects are
* computed).
*
* The @drawable argument must be the same as the one used when you
* created the effect with [ctor@Gimp.DrawableFilter.new].
* Once this is run, @filter is not valid anymore and you should not
* try to do anything with it. In particular, you must customize the
* operation's arguments as received with
* [method@Gimp.DrawableFilter.get_config] or set the filter's opacity
* and blend mode before merging the effect.
*
* Since: 3.0
**/
void
gimp_drawable_merge_filter (GimpDrawable *drawable,
GimpDrawableFilter *filter)
{
g_return_if_fail (GIMP_IS_DRAWABLE (drawable));
g_return_if_fail (GIMP_IS_DRAWABLE_FILTER (filter));
gimp_drawable_filter_update (filter);
_gimp_drawable_merge_filter_private (drawable, filter);
}
/**
* gimp_drawable_append_new_filter: (skip)
* @drawable: The #GimpDrawable.
* @operation_name: The GEGL operation's name.
* @name: The effect name.
* @mode: The blend mode.
* @opacity: The opacity from 0.0 (transparent) to 1.0 (opaque).
* @...: a %NULL-terminated list of operation argument names
* and values.
*
* Utility function which combines [ctor@Gimp.DrawableFilter.new]
* followed by setting arguments for the
* [class@Gimp.DrawableFilterConfig] returned by
* [method@Gimp.DrawableFilter.get_config], and finally appending with
* [method@Gimp.Drawable.append_filter]
*
* The variable arguments are couples of an argument name followed by a
* value, NULL-terminated, such as:
*
* ```C
* filter = gimp_drawable_append_new_filter (drawable,
* GIMP_LAYER_MODE_REPLACE, 1.0,
* "gegl:gaussian-blur", "My Gaussian Blur",
* "std-dev-x", 2.5,
* "std-dev-y", 2.5,
* "abyss-policy", "clamp",
* NULL);
* ```
*
* Returns: (transfer none): The newly created filter.
*/
GimpDrawableFilter *
gimp_drawable_append_new_filter (GimpDrawable *drawable,
const gchar *operation_name,
const gchar *name,
GimpLayerMode mode,
gdouble opacity,
...)
{
GimpDrawableFilter *filter;
GimpDrawableFilterConfig *config;
const gchar *arg_name;
va_list va_args;
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL);
g_return_val_if_fail (opacity >= 0.0 && opacity <= 1.0, NULL);
filter = gimp_drawable_filter_new (drawable, operation_name, name);
g_return_val_if_fail (filter != NULL, NULL);
config = gimp_drawable_filter_get_config (filter);
va_start (va_args, opacity);
while ((arg_name = va_arg (va_args, const gchar *)))
{
GParamSpec *pspec;
gchar *error = NULL;
GValue value = G_VALUE_INIT;
pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (config), arg_name);
if (pspec == NULL)
{
g_warning ("%s: %s has no property named '%s'",
G_STRFUNC,
g_type_name (G_TYPE_FROM_INSTANCE (config)),
arg_name);
break;
}
g_value_init (&value, pspec->value_type);
G_VALUE_COLLECT (&value, va_args, G_VALUE_NOCOPY_CONTENTS, &error);
if (error)
{
g_warning ("%s: %s", G_STRFUNC, error);
g_free (error);
break;
}
g_object_set_property (G_OBJECT (config), arg_name, &value);
g_value_unset (&value);
}
va_end (va_args);
gimp_drawable_filter_set_blend_mode (filter, mode);
gimp_drawable_filter_set_opacity (filter, opacity);
gimp_drawable_append_filter (drawable, filter);
return filter;
}
/**
* gimp_drawable_merge_new_filter: (skip)
* @drawable: The #GimpDrawable.
* @operation_name: The GEGL operation's name.
* @name: The effect name which will show in undo step.
* @mode: The blend mode.
* @opacity: The opacity from 0.0 (transparent) to 1.0 (opaque).
* @...: a %NULL-terminated list of operation argument names
* and values.
*
* Utility function which combines [ctor@Gimp.DrawableFilter.new]
* followed by setting arguments for the
* [class@Gimp.DrawableFilterConfig] returned by
* [method@Gimp.DrawableFilter.get_config], and finally applying the
* effect to @drawable with [method@Gimp.Drawable.merge_filter]
*
* The variable arguments are couples of an argument name followed by a
* value, NULL-terminated, such as:
*
* ```C
* filter = gimp_drawable_merge_new_filter (drawable,
* GIMP_LAYER_MODE_REPLACE, 1.0,
* "gegl:gaussian-blur", "My Gaussian Blur",
* "std-dev-x", 2.5,
* "std-dev-y", 2.5,
* "abyss-policy", "clamp",
* NULL);
* ```
*/
void
gimp_drawable_merge_new_filter (GimpDrawable *drawable,
const gchar *operation_name,
const gchar *name,
GimpLayerMode mode,
gdouble opacity,
...)
{
GimpDrawableFilter *filter;
GimpDrawableFilterConfig *config;
const gchar *arg_name;
va_list va_args;
g_return_if_fail (GIMP_IS_DRAWABLE (drawable));
g_return_if_fail (opacity >= 0.0 && opacity <= 1.0);
filter = gimp_drawable_filter_new (drawable, operation_name, name);
g_return_if_fail (filter != NULL);
config = gimp_drawable_filter_get_config (filter);
va_start (va_args, opacity);
while ((arg_name = va_arg (va_args, const gchar *)))
{
GParamSpec *pspec;
gchar *error = NULL;
GValue value = G_VALUE_INIT;
pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (config), arg_name);
if (pspec == NULL)
{
g_warning ("%s: %s has no property named '%s'",
G_STRFUNC,
g_type_name (G_TYPE_FROM_INSTANCE (config)),
arg_name);
break;
}
g_value_init (&value, pspec->value_type);
G_VALUE_COLLECT (&value, va_args, G_VALUE_NOCOPY_CONTENTS, &error);
if (error)
{
g_warning ("%s: %s", G_STRFUNC, error);
g_free (error);
break;
}
g_object_set_property (G_OBJECT (config), arg_name, &value);
g_value_unset (&value);
}
va_end (va_args);
gimp_drawable_filter_set_blend_mode (filter, mode);
gimp_drawable_filter_set_opacity (filter, opacity);
gimp_drawable_merge_filter (drawable, filter);
}
Reference in New Issue View Git Blame Copy Permalink