summaryrefslogtreecommitdiffstats
path: root/pdb/groups/drawable.pdb
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--pdb/groups/drawable.pdb1068
1 files changed, 1068 insertions, 0 deletions
diff --git a/pdb/groups/drawable.pdb b/pdb/groups/drawable.pdb
new file mode 100644
index 0000000..b36c28c
--- /dev/null
+++ b/pdb/groups/drawable.pdb
@@ -0,0 +1,1068 @@
+# GIMP - The GNU Image Manipulation Program
+# Copyright (C) 1995 Spencer Kimball and Peter Mattis
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+
+# This program 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 General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+# "Perlized" from C source by Manish Singh <yosh@gimp.org>
+
+sub drawable_merge_shadow {
+ $blurb = 'Merge the shadow buffer with the specified drawable.';
+
+ $help = <<'HELP';
+This procedure combines the contents of the drawable's shadow buffer
+(for temporary processing) with the specified drawable. The 'undo'
+parameter specifies whether to add an undo step for the operation.
+Requesting no undo is useful for such applications as 'auto-apply'.
+HELP
+
+ &std_pdb_misc;
+
+ @inargs = (
+ { name => 'drawable', type => 'drawable',
+ desc => 'The drawable' },
+ { name => 'undo', type => 'boolean',
+ desc => 'Push merge to undo stack?' }
+ );
+
+ %invoke = (
+ headers => [ qw("core/gimpdrawable-shadow.h"
+ "plug-in/gimpplugin.h"
+ "plug-in/gimppluginmanager.h") ],
+ code => <<'CODE'
+{
+ if (gimp_pdb_item_is_attached (GIMP_ITEM (drawable), NULL,
+ GIMP_PDB_ITEM_CONTENT, error) &&
+ gimp_pdb_item_is_not_group (GIMP_ITEM (drawable), error))
+ {
+ const gchar *undo_desc = _("Plug-in");
+
+ if (gimp->plug_in_manager->current_plug_in)
+ undo_desc = gimp_plug_in_get_undo_desc (gimp->plug_in_manager->current_plug_in);
+
+ gimp_drawable_merge_shadow_buffer (drawable, undo, undo_desc);
+ }
+ else
+ success = FALSE;
+}
+CODE
+ );
+}
+
+sub drawable_free_shadow {
+ $blurb = "Free the specified drawable's shadow data (if it exists).";
+
+ $help = <<'HELP';
+This procedure is intended as a memory saving device. If any shadow
+memory has been allocated, it will be freed automatically when the
+drawable is removed from the image, or when the plug-in procedure
+which allocated it returns.
+HELP
+
+ &mitch_pdb_misc('2008', '2.6');
+
+ @inargs = (
+ { name => 'drawable', type => 'drawable',
+ desc => 'The drawable' }
+ );
+
+ %invoke = (
+ headers => [ qw("plug-in/gimpplugin-cleanup.h") ],
+ code => <<'CODE'
+{
+ if (gimp->plug_in_manager->current_plug_in)
+ gimp_plug_in_cleanup_remove_shadow (gimp->plug_in_manager->current_plug_in,
+ drawable);
+
+ gimp_drawable_free_shadow_buffer (drawable);
+}
+CODE
+ );
+}
+
+sub drawable_fill {
+ $blurb = 'Fill the drawable with the specified fill mode.';
+
+ $help = <<'HELP';
+This procedure fills the drawable. If the fill mode is foreground the
+current foreground color is used. If the fill mode is background, the
+current background color is used. If the fill type is white, then
+white is used. Transparent fill only affects layers with an alpha
+channel, in which case the alpha channel is set to transparent. If the
+drawable has no alpha channel, it is filled to white. No fill leaves
+the drawable's contents undefined.
+
+This procedure is unlike gimp_edit_fill() or the bucket fill tool
+because it fills regardless of a selection. Its main purpose is to
+fill a newly created drawable before adding it to the image. This
+operation cannot be undone.
+HELP
+
+ &std_pdb_misc;
+
+ @inargs = (
+ { name => 'drawable', type => 'drawable',
+ desc => 'The drawable' },
+ { name => 'fill_type', type => 'enum GimpFillType',
+ desc => 'The type of fill' }
+ );
+
+ %invoke = (
+ headers => [ qw("core/gimpdrawable-fill.h") ],
+ code => <<'CODE'
+{
+ if (gimp_pdb_item_is_modifiable (GIMP_ITEM (drawable),
+ GIMP_PDB_ITEM_CONTENT, error) &&
+ gimp_pdb_item_is_not_group (GIMP_ITEM (drawable), error))
+ {
+ gimp_drawable_fill (drawable, context, (GimpFillType) fill_type);
+ }
+ else
+ success = FALSE;
+}
+CODE
+ );
+}
+
+sub drawable_update {
+ $blurb = 'Update the specified region of the drawable.';
+
+ $help = <<'HELP';
+This procedure updates the specified region of the drawable. The (x, y)
+coordinate pair is relative to the drawable's origin, not to the image origin.
+Therefore, the entire drawable can be updated using (0, 0, width, height).
+HELP
+
+ &std_pdb_misc;
+
+ @inargs = (
+ { name => 'drawable', type => 'drawable',
+ desc => 'The drawable' },
+ { name => 'x', type => 'int32',
+ desc => 'x coordinate of upper left corner of update region' },
+ { name => 'y', type => 'int32',
+ desc => 'y coordinate of upper left corner of update region' },
+ { name => 'width', type => 'int32',
+ desc => 'Width of update region' },
+ { name => 'height', type => 'int32',
+ desc => 'Height of update region' }
+ );
+
+ %invoke = (
+ code => <<'CODE'
+{
+ gimp_drawable_update (drawable, x, y, width, height);
+}
+CODE
+ );
+}
+
+sub drawable_mask_bounds {
+ $blurb = <<'BLURB';
+Find the bounding box of the current selection in relation to the specified
+drawable.
+BLURB
+
+ $help = <<'HELP';
+This procedure returns whether there is a selection. If there is one, the
+upper left and lower right-hand corners of its bounding box are returned. These
+coordinates are specified relative to the drawable's origin, and bounded by
+the drawable's extents. Please note that the pixel specified by the lower
+right-hand coordinate of the bounding box is not part of the selection. The
+selection ends at the upper left corner of this pixel. This means the width
+of the selection can be calculated as (x2 - x1), its height as (y2 - y1).
+
+Note that the returned boolean does NOT correspond with the returned
+region being empty or not, it always returns whether the selection
+is non_empty. See gimp_drawable_mask_intersect() for a boolean
+return value which is more useful in most cases.
+HELP
+
+ &std_pdb_misc;
+
+ @inargs = (
+ { name => 'drawable', type => 'drawable',
+ desc => 'The drawable' }
+ );
+
+ @outargs = (
+ { name => 'non_empty', type => 'boolean',
+ desc => 'TRUE if there is a selection' },
+ { name => 'x1', type => 'int32',
+ desc => "x coordinate of the upper left corner of selection bounds" },
+ { name => 'y1', type => 'int32',
+ desc => "y coordinate of the upper left corner of selection bounds" },
+ { name => 'x2', type => 'int32',
+ desc => "x coordinate of the lower right corner of selection bounds" },
+ { name => 'y2', type => 'int32',
+ desc => "y coordinate of the lower right corner of selection bounds" }
+ );
+
+ %invoke = (
+ code => <<'CODE'
+{
+ if (gimp_pdb_item_is_attached (GIMP_ITEM (drawable), NULL, 0, error))
+ non_empty = gimp_item_mask_bounds (GIMP_ITEM (drawable), &x1, &y1, &x2, &y2);
+ else
+ success = FALSE;
+}
+CODE
+ );
+}
+
+sub drawable_mask_intersect {
+ $blurb = <<'BLURB';
+Find the bounding box of the current selection in relation to the specified
+drawable.
+BLURB
+
+ $help = <<'HELP';
+This procedure returns whether there is an intersection between the
+drawable and the selection. Unlike gimp_drawable_mask_bounds(), the
+intersection's bounds are returned as x, y, width, height.
+
+If there is no selection this function returns TRUE and the returned
+bounds are the extents of the whole drawable.
+HELP
+
+ &mitch_pdb_misc('2004', '2.2');
+
+ @inargs = (
+ { name => 'drawable', type => 'drawable',
+ desc => 'The drawable' }
+ );
+
+ @outargs = (
+ { name => 'non_empty', type => 'boolean',
+ desc => 'TRUE if the returned area is not empty' },
+ { name => 'x', type => 'int32',
+ desc => 'x coordinate of the upper left corner of the intersection' },
+ { name => 'y', type => 'int32',
+ desc => 'y coordinate of the upper left corner of the intersection' },
+ { name => 'width', type => 'int32',
+ desc => 'width of the intersection' },
+ { name => 'height', type => 'int32',
+ desc => 'height of the intersection' }
+ );
+
+ %invoke = (
+ code => <<'CODE'
+{
+ if (gimp_pdb_item_is_attached (GIMP_ITEM (drawable), NULL, 0, error))
+ non_empty = gimp_item_mask_intersect (GIMP_ITEM (drawable),
+ &x, &y, &width, &height);
+ else
+ success = FALSE;
+}
+CODE
+ );
+}
+
+sub drawable_get_format {
+ $blurb = "Returns the drawable's Babl format";
+ $help = "This procedure returns the drawable's Babl format.";
+
+ &mitch_pdb_misc('2012', '2.10');
+
+ @inargs = (
+ { name => 'drawable', type => 'drawable',
+ desc => 'The drawable' }
+ );
+
+ @outargs = (
+ { name => 'format', type => 'string', wrap => 1,
+ desc => "The drawable's Babl format" }
+ );
+
+ %invoke = (
+ code => <<'CODE'
+{
+ if (gimp->plug_in_manager->current_plug_in)
+ gimp_plug_in_enable_precision (gimp->plug_in_manager->current_plug_in);
+
+ format = g_strdup (babl_get_name (gimp_drawable_get_format (drawable)));
+}
+CODE
+ );
+}
+
+sub drawable_get_thumbnail_format {
+ $blurb = "Returns the drawable's thumbnail Babl format";
+
+ $help = <<'HELP';
+This procedure returns the drawable's thumbnail Babl format.
+
+Thumbnails are always 8-bit images, see gimp_drawable_thumbnail() and
+gimp_drawable_sub_thmbnail().
+HELP
+
+ &mitch_pdb_misc('2019', '2.10.14');
+
+ @inargs = (
+ { name => 'drawable', type => 'drawable',
+ desc => 'The drawable' }
+ );
+
+ @outargs = (
+ { name => 'format', type => 'string', wrap => 1,
+ desc => "The drawable's thumbnail Babl format" }
+ );
+
+ %invoke = (
+ code => <<'CODE'
+{
+ format = g_strdup (babl_format_get_encoding (gimp_drawable_get_preview_format (drawable)));
+
+}
+CODE
+ );
+}
+
+sub drawable_type {
+ $blurb = "Returns the drawable's type.";
+ $help = "This procedure returns the drawable's type.";
+
+ &std_pdb_misc;
+
+ @inargs = (
+ { name => 'drawable', type => 'drawable',
+ desc => 'The drawable' }
+ );
+
+ @outargs = (
+ { name => 'type', type => 'enum GimpImageType',
+ desc => "The drawable's type" }
+ );
+
+ %invoke = (
+ code => <<'CODE'
+{
+ type = gimp_babl_format_get_image_type (gimp_drawable_get_format (drawable));
+}
+CODE
+ );
+}
+
+sub drawable_has_alpha {
+ $blurb = 'Returns TRUE if the drawable has an alpha channel.';
+
+ $help = <<'HELP';
+This procedure returns whether the specified drawable has an alpha channel.
+This can only be true for layers, and the associated type will be one of:
+{ RGBA , GRAYA, INDEXEDA }.
+HELP
+
+ &std_pdb_misc;
+
+ @inargs = (
+ { name => 'drawable', type => 'drawable',
+ desc => 'The drawable' }
+ );
+
+ @outargs = (
+ { name => 'has_alpha', type => 'boolean',
+ desc => 'Does the drawable have an alpha channel?' }
+ );
+
+ %invoke = (
+ code => <<'CODE'
+{
+ has_alpha = gimp_drawable_has_alpha (drawable);
+}
+CODE
+ );
+}
+
+sub drawable_type_with_alpha {
+ $blurb = "Returns the drawable's type with alpha.";
+
+ $help = <<'HELP';
+This procedure returns the drawable's type as if had an alpha
+channel. If the type is currently Gray, for instance, the returned
+type would be GrayA. If the drawable already has an alpha channel, the
+drawable's type is simply returned.
+HELP
+
+ &std_pdb_misc;
+
+ @inargs = (
+ { name => 'drawable', type => 'drawable',
+ desc => 'The drawable' }
+ );
+
+ @outargs = (
+ { name => 'type_with_alpha', type => 'enum GimpImageType
+ (no GIMP_RGB_IMAGE,
+ GIMP_GRAY_IMAGE,
+ GIMP_INDEXED_IMAGE)',
+ desc => "The drawable's type with alpha" }
+ );
+
+ %invoke = (
+ code => <<'CODE'
+{
+ const Babl *format = gimp_drawable_get_format_with_alpha (drawable);
+
+ type_with_alpha = gimp_babl_format_get_image_type (format);
+}
+CODE
+ );
+}
+
+sub drawable_is_rgb {
+ $blurb = 'Returns whether the drawable is an RGB type.';
+
+ $help = <<HELP;
+This procedure returns TRUE if the specified drawable
+is of type { RGB, RGBA }.
+HELP
+
+ &std_pdb_misc;
+
+ @inargs = (
+ { name => 'drawable', type => 'drawable',
+ desc => 'The drawable' }
+ );
+
+ @outargs = (
+ { name => 'is_rgb', type => 'boolean',
+ desc => 'TRUE if the drawable is an RGB type' }
+ );
+
+ %invoke = (
+ code => <<'CODE'
+{
+ is_rgb = gimp_drawable_is_rgb (drawable);
+}
+CODE
+ );
+}
+
+sub drawable_is_gray {
+ $blurb = 'Returns whether the drawable is a grayscale type.';
+
+ $help = <<HELP;
+This procedure returns TRUE if the specified drawable
+is of type { Gray, GrayA }.
+HELP
+
+ &std_pdb_misc;
+
+ @inargs = (
+ { name => 'drawable', type => 'drawable',
+ desc => 'The drawable' }
+ );
+
+ @outargs = (
+ { name => 'is_gray', type => 'boolean',
+ desc => 'TRUE if the drawable is a grayscale type' }
+ );
+
+ %invoke = (
+ code => <<'CODE'
+{
+ is_gray = gimp_drawable_is_gray (drawable);
+}
+CODE
+ );
+}
+
+sub drawable_is_indexed {
+ $blurb = 'Returns whether the drawable is an indexed type.';
+
+ $help = <<HELP;
+This procedure returns TRUE if the specified drawable
+is of type { Indexed, IndexedA }.
+HELP
+
+ &std_pdb_misc;
+
+ @inargs = (
+ { name => 'drawable', type => 'drawable',
+ desc => 'The drawable' }
+ );
+
+ @outargs = (
+ { name => 'is_indexed', type => 'boolean',
+ desc => 'TRUE if the drawable is an indexed type' }
+ );
+
+ %invoke = (
+ code => <<'CODE'
+{
+ is_indexed = gimp_drawable_is_indexed (drawable);
+}
+CODE
+ );
+}
+
+sub drawable_bpp {
+ $blurb = 'Returns the bytes per pixel.';
+
+ $help = <<'HELP';
+This procedure returns the number of bytes per pixel, which corresponds to
+the number of components unless gimp_plugin_enable_precision() was called.
+HELP
+
+ &std_pdb_misc;
+
+ @inargs = (
+ { name => 'drawable', type => 'drawable',
+ desc => 'The drawable' }
+ );
+
+ @outargs = (
+ { name => 'bpp', type => 'int32',
+ desc => 'Bytes per pixel' }
+ );
+
+ %invoke = (
+ code => <<'CODE'
+{
+ const Babl *format = gimp_drawable_get_format (drawable);
+
+ if (! gimp->plug_in_manager->current_plug_in ||
+ ! gimp_plug_in_precision_enabled (gimp->plug_in_manager->current_plug_in))
+ {
+ format = gimp_babl_compat_u8_format (format);
+ }
+
+ bpp = babl_format_get_bytes_per_pixel (format);
+}
+CODE
+ );
+}
+
+sub drawable_width {
+ $blurb = 'Returns the width of the drawable.';
+ $help = "This procedure returns the specified drawable's width in pixels.";
+
+ &std_pdb_misc;
+
+ @inargs = (
+ { name => 'drawable', type => 'drawable',
+ desc => 'The drawable' }
+ );
+
+ @outargs = (
+ { name => 'width', type => 'int32',
+ desc => 'Width of drawable' }
+ );
+
+ %invoke = (
+ code => <<'CODE'
+{
+ width = gimp_item_get_width (GIMP_ITEM (drawable));
+}
+CODE
+ );
+}
+
+sub drawable_height {
+ $blurb = 'Returns the height of the drawable.';
+ $help = "This procedure returns the specified drawable's height in pixels.";
+
+ &std_pdb_misc;
+
+ @inargs = (
+ { name => 'drawable', type => 'drawable',
+ desc => 'The drawable' }
+ );
+
+ @outargs = (
+ { name => 'height', type => 'int32',
+ desc => 'Height of drawable' }
+ );
+
+ %invoke = (
+ code => <<'CODE'
+{
+ height = gimp_item_get_height (GIMP_ITEM (drawable));
+}
+CODE
+ );
+}
+
+sub drawable_offsets {
+ $blurb = 'Returns the offsets for the drawable.';
+
+ $help = <<'HELP';
+This procedure returns the specified drawable's offsets. This only makes sense
+if the drawable is a layer since channels are anchored. The offsets of a
+channel will be returned as 0.
+HELP
+
+ &std_pdb_misc;
+
+ @inargs = (
+ { name => 'drawable', type => 'drawable',
+ desc => 'The drawable' }
+ );
+
+ @outargs = (
+ { name => 'offset_x', type => 'int32', void_ret => 1,
+ desc => "x offset of drawable" },
+ { name => 'offset_y', type => 'int32',
+ desc => "y offset of drawable" }
+ );
+
+ %invoke = (
+ code => <<'CODE'
+{
+ gimp_item_get_offset (GIMP_ITEM (drawable), &offset_x, &offset_y);
+}
+CODE
+ );
+}
+
+sub drawable_get_pixel {
+ $blurb = 'Gets the value of the pixel at the specified coordinates.';
+
+ $help = <<'HELP';
+This procedure gets the pixel value at the specified coordinates. The
+'num_channels' argument must always be equal to the bytes-per-pixel value for
+the specified drawable.
+HELP
+
+ &std_pdb_misc;
+ $date = '1997';
+
+ @inargs = (
+ { name => 'drawable', type => 'drawable',
+ desc => 'The drawable' },
+ { name => 'x_coord', type => '0 <= int32',
+ desc => 'The x coordinate' },
+ { name => 'y_coord', type => '0 <= int32',
+ desc => 'The y coordinate' }
+ );
+
+ @outargs = (
+ { name => 'pixel', type => 'int8array',
+ desc => 'The pixel value',
+ array => { name => 'num_channels', no_validate => 1,
+ desc => 'The number of channels for the pixel' } }
+ );
+
+ %invoke = (
+ code => <<'CODE'
+{
+ const Babl *format = gimp_drawable_get_format (drawable);
+
+ if (! gimp->plug_in_manager->current_plug_in ||
+ ! gimp_plug_in_precision_enabled (gimp->plug_in_manager->current_plug_in))
+ {
+ format = gimp_babl_compat_u8_format (format);
+ }
+
+ if (x_coord < gimp_item_get_width (GIMP_ITEM (drawable)) &&
+ y_coord < gimp_item_get_height (GIMP_ITEM (drawable)))
+ {
+ num_channels = babl_format_get_bytes_per_pixel (format);
+ pixel = g_new0 (guint8, num_channels);
+
+ gegl_buffer_sample (gimp_drawable_get_buffer (drawable),
+ x_coord, y_coord, NULL, pixel, format,
+ GEGL_SAMPLER_NEAREST, GEGL_ABYSS_NONE);
+ }
+ else
+ success = FALSE;
+}
+CODE
+ );
+}
+
+sub drawable_set_pixel {
+ $blurb = 'Sets the value of the pixel at the specified coordinates.';
+
+ $help = <<'HELP';
+This procedure sets the pixel value at the specified coordinates. The
+'num_channels' argument must always be equal to the bytes-per-pixel value for
+the specified drawable. Note that this function is not undoable, you should
+use it only on drawables you just created yourself.
+HELP
+
+ &std_pdb_misc;
+ $date = '1997';
+
+ @inargs = (
+ { name => 'drawable', type => 'drawable',
+ desc => 'The drawable' },
+ { name => 'x_coord', type => '0 <= int32',
+ desc => 'The x coordinate' },
+ { name => 'y_coord', type => '0 <= int32',
+ desc => 'The y coordinate' },
+ { name => 'pixel', type => 'int8array',
+ desc => 'The pixel value',
+ array => { name => 'num_channels', no_validate => 1,
+ desc => 'The number of channels for the pixel' } }
+ );
+
+ %invoke = (
+ code => <<'CODE'
+{
+ const Babl *format = gimp_drawable_get_format (drawable);
+
+ if (! gimp->plug_in_manager->current_plug_in ||
+ ! gimp_plug_in_precision_enabled (gimp->plug_in_manager->current_plug_in))
+ {
+ format = gimp_babl_compat_u8_format (format);
+ }
+
+ if (gimp_pdb_item_is_modifiable (GIMP_ITEM (drawable),
+ GIMP_PDB_ITEM_CONTENT, error) &&
+ gimp_pdb_item_is_not_group (GIMP_ITEM (drawable), error) &&
+ x_coord < gimp_item_get_width (GIMP_ITEM (drawable)) &&
+ y_coord < gimp_item_get_height (GIMP_ITEM (drawable)) &&
+ num_channels == babl_format_get_bytes_per_pixel (format))
+ {
+ gegl_buffer_set (gimp_drawable_get_buffer (drawable),
+ GEGL_RECTANGLE (x_coord, y_coord, 1, 1),
+ 0, format, pixel, GEGL_AUTO_ROWSTRIDE);
+ }
+ else
+ success = FALSE;
+}
+CODE
+ );
+}
+
+sub drawable_set_image {
+ &std_pdb_deprecated();
+
+ @inargs = (
+ { name => 'drawable', type => 'drawable',
+ desc => 'The drawable' },
+ { name => 'image', type => 'image',
+ desc => 'The image' }
+ );
+
+ %invoke = (
+ code =><<'CODE'
+{
+ if (image != gimp_item_get_image (GIMP_ITEM (drawable)))
+ success = FALSE;
+}
+CODE
+ );
+}
+
+sub drawable_thumbnail {
+ $blurb = 'Get a thumbnail of a drawable.';
+
+ $help = <<'HELP';
+This function gets data from which a thumbnail of a drawable preview
+can be created. Maximum x or y dimension is 1024 pixels. The pixels are
+returned in RGB[A] or GRAY[A] format. The bpp return value gives the
+number of bytes in the image.
+HELP
+
+ &andy_pdb_misc('1999');
+
+ @inargs = (
+ { name => 'drawable', type => 'drawable',
+ desc => 'The drawable' },
+ { name => 'width', type => '1 <= int32 <= 1024',
+ desc => 'The requested thumbnail width' },
+ { name => 'height', type => '1 <= int32 <= 1024',
+ desc => 'The requested thumbnail height' }
+ );
+
+ @outargs = (
+ { name => 'actual_width', type => 'int32', void_ret => 1,
+ desc => 'The previews width' },
+ { name => 'actual_height', type => 'int32',
+ desc => 'The previews height' },
+ { name => 'bpp', type => 'int32',
+ desc => 'The previews bpp' },
+ { name => 'thumbnail_data', type => 'int8array',
+ desc => 'The thumbnail data', wrap => 1,
+ array => { name => 'thumbnail_data_count',
+ desc => 'The number of bytes in thumbnail data' } }
+ );
+
+ %invoke = (
+ code => <<'CODE'
+{
+ GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable));
+ GimpTempBuf *buf;
+ gint dwidth, dheight;
+
+ gimp_assert (GIMP_VIEWABLE_MAX_PREVIEW_SIZE >= 1024);
+
+ /* Adjust the width/height ratio */
+ dwidth = gimp_item_get_width (GIMP_ITEM (drawable));
+ dheight = gimp_item_get_height (GIMP_ITEM (drawable));
+
+ if (dwidth > dheight)
+ height = MAX (1, (width * dheight) / dwidth);
+ else
+ width = MAX (1, (height * dwidth) / dheight);
+
+ if (image->gimp->config->layer_previews)
+ buf = gimp_viewable_get_new_preview (GIMP_VIEWABLE (drawable), context,
+ width, height);
+ else
+ buf = gimp_viewable_get_dummy_preview (GIMP_VIEWABLE (drawable),
+ width, height,
+ gimp_drawable_get_preview_format (drawable));
+
+ if (buf)
+ {
+ actual_width = gimp_temp_buf_get_width (buf);
+ actual_height = gimp_temp_buf_get_height (buf);
+ bpp = babl_format_get_bytes_per_pixel (gimp_temp_buf_get_format (buf));
+ thumbnail_data_count = gimp_temp_buf_get_data_size (buf);
+ thumbnail_data = g_memdup (gimp_temp_buf_get_data (buf),
+ thumbnail_data_count);
+
+ gimp_temp_buf_unref (buf);
+ }
+ else
+ success = FALSE;
+}
+CODE
+ );
+}
+
+sub drawable_sub_thumbnail {
+ $blurb = 'Get a thumbnail of a sub-area of a drawable drawable.';
+
+ $help = <<'HELP';
+This function gets data from which a thumbnail of a drawable preview
+can be created. Maximum x or y dimension is 1024 pixels. The pixels are
+returned in RGB[A] or GRAY[A] format. The bpp return value gives the
+number of bytes in the image.
+HELP
+
+ &mitch_pdb_misc('2004', '2.2');
+
+ @inargs = (
+ { name => 'drawable', type => 'drawable',
+ desc => 'The drawable' },
+ { name => 'src_x', type => '0 <= int32',
+ desc => 'The x coordinate of the area' },
+ { name => 'src_y', type => '0 <= int32',
+ desc => 'The y coordinate of the area' },
+ { name => 'src_width', type => '1 <= int32',
+ desc => 'The width of the area' },
+ { name => 'src_height', type => '1 <= int32',
+ desc => 'The height of the area' },
+ { name => 'dest_width', type => '1 <= int32 <= 1024',
+ desc => 'The thumbnail width' },
+ { name => 'dest_height', type => '1 <= int32 <= 1024',
+ desc => 'The thumbnail height' }
+ );
+
+ @outargs = (
+ { name => 'width', type => 'int32', void_ret => 1,
+ desc => 'The previews width' },
+ { name => 'height', type => 'int32',
+ desc => 'The previews height' },
+ { name => 'bpp', type => 'int32',
+ desc => 'The previews bpp' },
+ { name => 'thumbnail_data', type => 'int8array',
+ desc => 'The thumbnail data', wrap => 1,
+ array => { name => 'thumbnail_data_count',
+ desc => 'The number of bytes in thumbnail data' } }
+ );
+
+ %invoke = (
+ headers => [ qw("core/gimpdrawable-preview.h") ],
+ code => <<'CODE'
+{
+ if ((src_x + src_width) <= gimp_item_get_width (GIMP_ITEM (drawable)) &&
+ (src_y + src_height) <= gimp_item_get_height (GIMP_ITEM (drawable)))
+ {
+ GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable));
+ GimpTempBuf *buf;
+
+ if (image->gimp->config->layer_previews)
+ buf = gimp_drawable_get_sub_preview (drawable,
+ src_x, src_y,
+ src_width, src_height,
+ dest_width, dest_height);
+ else
+ buf = gimp_viewable_get_dummy_preview (GIMP_VIEWABLE (drawable),
+ dest_width, dest_height,
+ gimp_drawable_get_preview_format (drawable));
+
+ if (buf)
+ {
+ width = gimp_temp_buf_get_width (buf);
+ height = gimp_temp_buf_get_height (buf);
+ bpp = babl_format_get_bytes_per_pixel (gimp_temp_buf_get_format (buf));
+ thumbnail_data_count = gimp_temp_buf_get_data_size (buf);
+ thumbnail_data = g_memdup (gimp_temp_buf_get_data (buf),
+ thumbnail_data_count);
+
+ gimp_temp_buf_unref (buf);
+ }
+ else
+ success = FALSE;
+ }
+ else
+ success = FALSE;
+}
+CODE
+ );
+}
+
+sub drawable_offset {
+ $blurb = <<'BLURB';
+Offset the drawable by the specified amounts in the X and Y directions
+BLURB
+
+ $help = <<'HELP';
+This procedure offsets the specified drawable by the amounts specified by
+'offset_x' and 'offset_y'. If 'wrap_around' is set to TRUE, then portions of
+the drawable which are offset out of bounds are wrapped around. Alternatively,
+the undefined regions of the drawable can be filled with transparency or the
+background color, as specified by the 'fill-type' parameter.
+HELP
+
+ &std_pdb_misc;
+ $date = '1997';
+
+ @inargs = (
+ { name => 'drawable', type => 'drawable',
+ desc => 'The drawable to offset' },
+ { name => 'wrap_around', type => 'boolean',
+ desc => 'wrap image around or fill vacated regions' },
+ { name => 'fill_type', type => 'enum GimpOffsetType',
+ desc => 'fill vacated regions of drawable with background or
+ transparent' },
+ { name => 'offset_x', type => 'int32',
+ desc => 'offset by this amount in X direction' },
+ { name => 'offset_y', type => 'int32',
+ desc => 'offset by this amount in Y direction' }
+ );
+
+ %invoke = (
+ code => <<'CODE'
+{
+ if (gimp_pdb_item_is_attached (GIMP_ITEM (drawable), NULL,
+ GIMP_PDB_ITEM_CONTENT, error) &&
+ gimp_pdb_item_is_not_group (GIMP_ITEM (drawable), error))
+ gimp_drawable_offset (drawable, context, wrap_around, fill_type,
+ offset_x, offset_y);
+ else
+ success = FALSE;
+}
+CODE
+ );
+}
+
+sub drawable_foreground_extract {
+ $blurb = 'Extract the foreground of a drawable using a given trimap.';
+
+ $help = <<'HELP';
+Image Segmentation by Uniform Color Clustering, see
+https://www.inf.fu-berlin.de/inst/pubs/tr-b-05-07.pdf
+HELP
+
+ $author = 'Gerald Friedland <fland@inf.fu-berlin.de>, Kristian Jantz <jantz@inf.fu-berlin.de>, Sven Neumann <sven@gimp.org>';
+ $copyright = 'Gerald Friedland';
+ $date = '2005';
+ $since = '2.4';
+
+ @inargs = (
+ { name => 'drawable', type => 'drawable',
+ desc => 'The drawable' },
+ { name => 'mode', type => 'enum GimpForegroundExtractMode',
+ desc => 'The algorithm to use' },
+ { name => 'mask', type => 'drawable', desc => 'Tri-Map' }
+ );
+
+ %invoke = (
+ headers => [ qw("core/gimpdrawable-foreground-extract.h") ],
+ code => <<'CODE'
+{
+ if (mode == GIMP_FOREGROUND_EXTRACT_MATTING &&
+ gimp_pdb_item_is_attached (GIMP_ITEM (drawable), NULL, 0, error))
+ {
+ GimpPDBContext *pdb_context = GIMP_PDB_CONTEXT (context);
+ GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable));
+ GeglBuffer *buffer;
+
+ buffer = gimp_drawable_foreground_extract (drawable,
+ GIMP_MATTING_ENGINE_GLOBAL,
+ 2,
+ 2,
+ 2,
+ gimp_drawable_get_buffer (mask),
+ progress);
+
+ gimp_channel_select_buffer (gimp_image_get_mask (image),
+ C_("command", "Foreground Select"),
+ buffer,
+ 0, /* x offset */
+ 0, /* y offset */
+ GIMP_CHANNEL_OP_REPLACE,
+ pdb_context->feather,
+ pdb_context->feather_radius_x,
+ pdb_context->feather_radius_y);
+
+ g_object_unref (buffer);
+ }
+ else
+ success = FALSE;
+}
+CODE
+ );
+}
+
+
+@headers = qw("config/gimpcoreconfig.h"
+ "gegl/gimp-babl.h"
+ "gegl/gimp-babl-compat.h"
+ "core/gimp.h"
+ "core/gimpchannel-select.h"
+ "core/gimpdrawable-offset.h"
+ "core/gimptempbuf.h"
+ "gimppdb-utils.h"
+ "gimppdbcontext.h"
+ "gimp-intl.h");
+
+@procs = qw(drawable_get_format
+ drawable_get_thumbnail_format
+ drawable_type
+ drawable_type_with_alpha
+ drawable_has_alpha
+ drawable_is_rgb
+ drawable_is_gray
+ drawable_is_indexed
+ drawable_bpp
+ drawable_width
+ drawable_height
+ drawable_offsets
+ drawable_set_image
+ drawable_mask_bounds
+ drawable_mask_intersect
+ drawable_merge_shadow
+ drawable_free_shadow
+ drawable_update
+ drawable_get_pixel drawable_set_pixel
+ drawable_fill
+ drawable_offset
+ drawable_thumbnail
+ drawable_sub_thumbnail
+ drawable_foreground_extract);
+
+%exports = (app => [@procs], lib => [@procs]);
+
+$desc = 'Drawable procedures';
+$doc_title = 'gimpdrawable';
+$doc_short_desc = 'Functions to manipulate drawables.';
+$doc_long_desc = 'Functions to manipulate drawables.';
+
+1;