diff options
Diffstat (limited to '')
| -rw-r--r-- | pdb/groups/drawable.pdb | 1068 |
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; |