Adding upstream version 2.10.22.upstream/2.10.22upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1076 insertions, 0 deletions

diff --git a/pdb/groups/edit.pdb b/pdb/groups/edit.pdb
new file mode 100644
index 0000000..4694926
--- /dev/null
+++ b/pdb/groups/edit.pdb
@@ -0,0 +1,1076 @@
+# 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 edit_cut {
+    $blurb = 'Cut from the specified drawable.';
+
+    $help = <<'HELP';
+If there is a selection in the image, then the area specified by the
+selection is cut from the specified drawable and placed in an internal
+GIMP edit buffer. It can subsequently be retrieved using the
+gimp_edit_paste() command. If there is no selection, then the
+specified drawable will be removed and its contents stored in the
+internal GIMP edit buffer. This procedure will fail if the selected area
+lies completely outside the bounds of the current drawable and there is
+nothing to copy from.
+HELP
+
+    &std_pdb_misc;
+
+    @inargs = (
+	{ name => 'drawable', type => 'drawable',
+	  desc => 'The drawable to cut from' }
+    );
+
+    @outargs = (
+	{ name => 'non_empty', type => 'boolean',
+	  desc => 'TRUE if the cut was successful,
+                   FALSE if there was nothing to copy from' }
+    );
+
+    %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))
+    {
+      GimpImage *image    = gimp_item_get_image (GIMP_ITEM (drawable));
+      GError    *my_error = NULL;
+
+      non_empty = gimp_edit_cut (image, drawable, context, &my_error) != NULL;
+
+      if (! non_empty)
+        {
+          gimp_message_literal (gimp,
+                                G_OBJECT (progress), GIMP_MESSAGE_WARNING,
+                                my_error->message);
+          g_clear_error (&my_error);
+        }
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub edit_copy {
+    $blurb = 'Copy from the specified drawable.';
+
+    $help = <<'HELP';
+If there is a selection in the image, then the area specified by the
+selection is copied from the specified drawable and placed in an
+internal GIMP edit buffer. It can subsequently be retrieved using the
+gimp_edit_paste() command.  If there is no selection, then the
+specified drawable's contents will be stored in the internal GIMP edit
+buffer. This procedure will fail if the selected area lies completely
+outside the bounds of the current drawable and there is nothing to
+copy from.
+HELP
+
+    &std_pdb_misc;
+
+    @inargs = (
+	{ name => 'drawable', type => 'drawable',
+	  desc => 'The drawable to copy from' }
+    );
+
+    @outargs = (
+	{ name => 'non_empty', type => 'boolean',
+	  desc => 'TRUE if the cut was successful,
+                   FALSE if there was nothing to copy from' }
+    );
+
+    %invoke = (
+	code => <<CODE
+{
+  if (gimp_pdb_item_is_attached (GIMP_ITEM (drawable), NULL, 0, error))
+    {
+      GimpImage *image    = gimp_item_get_image (GIMP_ITEM (drawable));
+      GError    *my_error = NULL;
+
+      non_empty = gimp_edit_copy (image, drawable, context, &my_error) != NULL;
+
+      if (! non_empty)
+        {
+          gimp_message_literal (gimp,
+                                G_OBJECT (progress), GIMP_MESSAGE_WARNING,
+                                my_error->message);
+          g_clear_error (&my_error);
+        }
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub edit_copy_visible {
+    $blurb = 'Copy from the projection.';
+
+    $help = <<'HELP';
+If there is a selection in the image, then the area specified by the
+selection is copied from the projection and placed in an internal GIMP
+edit buffer. It can subsequently be retrieved using the
+gimp_edit_paste() command. If there is no selection, then the
+projection's contents will be stored in the internal GIMP edit buffer.
+HELP
+
+    &mitch_pdb_misc('2004', '2.2');
+
+    @inargs = (
+	{ name => 'image', type => 'image',
+	  desc => "The image to copy from" }
+    );
+
+    @outargs = (
+	{ name => 'non_empty', type => 'boolean',
+	  desc => 'TRUE if the copy was successful' }
+    );
+
+    %invoke = (
+	code => <<CODE
+{
+  GError *my_error = NULL;
+
+  non_empty = gimp_edit_copy_visible (image, context, &my_error) != NULL;
+
+  if (! non_empty)
+    {
+      gimp_message_literal (gimp,
+                            G_OBJECT (progress), GIMP_MESSAGE_WARNING,
+                            my_error->message);
+      g_clear_error (&my_error);
+    }
+}
+CODE
+    );
+}
+
+sub edit_paste {
+    $blurb = 'Paste buffer to the specified drawable.';
+
+    $help = <<'HELP';
+This procedure pastes a copy of the internal GIMP edit buffer to the
+specified drawable. The GIMP edit buffer will be empty unless a call
+was previously made to either gimp_edit_cut() or gimp_edit_copy(). The
+"paste_into" option specifies whether to clear the current image
+selection, or to paste the buffer "behind" the selection. This allows
+the selection to act as a mask for the pasted buffer. Anywhere that
+the selection mask is non-zero, the pasted buffer will show
+through. The pasted buffer will be a new layer in the image which is
+designated as the image floating selection. If the image has a
+floating selection at the time of pasting, the old floating selection
+will be anchored to its drawable before the new floating selection is
+added. This procedure returns the new floating layer. The resulting
+floating selection will already be attached to the specified drawable,
+and a subsequent call to floating_sel_attach is not needed.
+HELP
+
+    &std_pdb_misc;
+
+    @inargs = (
+	{ name => 'drawable', type => 'drawable',
+	  desc => 'The drawable to paste to' },
+        { name => 'paste_into', type => 'boolean',
+	  desc => 'Clear selection, or paste behind it?' }
+    );
+
+    @outargs = (
+	{ name  => 'floating_sel', type  => 'layer',
+	  desc  => 'The new floating selection' }
+    );
+
+    %invoke = (
+	code => <<CODE
+{
+  GimpObject *paste = gimp_get_clipboard_object (gimp);
+
+  if (paste &&
+      gimp_pdb_item_is_attached (GIMP_ITEM (drawable), NULL,
+                                 GIMP_PDB_ITEM_CONTENT, error) &&
+      gimp_pdb_item_is_not_group (GIMP_ITEM (drawable), error))
+    {
+      floating_sel = gimp_edit_paste (gimp_item_get_image (GIMP_ITEM (drawable)),
+                                      drawable, paste,
+                                      paste_into ?
+                                      GIMP_PASTE_TYPE_FLOATING_INTO :
+                                      GIMP_PASTE_TYPE_FLOATING,
+                                      -1, -1, -1, -1);
+
+      if (! floating_sel)
+        success = FALSE;
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub edit_paste_as_new_image {
+    $blurb = 'Paste buffer to a new image.';
+
+    $help = <<'HELP';
+This procedure pastes a copy of the internal GIMP edit buffer to a new
+image.  The GIMP edit buffer will be empty unless a call was
+previously made to either gimp_edit_cut() or gimp_edit_copy(). This
+procedure returns the new image or -1 if the edit buffer was empty.
+HELP
+
+    &mitch_pdb_misc('2005', '2.10');
+
+    @outargs = (
+	{ name => 'image', type => 'image',
+	  desc => 'The new image' }
+    );
+    %invoke = (
+	code => <<CODE
+{
+  GimpObject *paste = gimp_get_clipboard_object (gimp);
+
+  if (paste)
+    {
+      image = gimp_edit_paste_as_new_image (gimp, paste);
+
+      if (! image)
+        success = FALSE;
+    }
+}
+CODE
+    );
+}
+
+sub edit_named_cut {
+    $blurb = 'Cut into a named buffer.';
+
+    $help = <<'HELP';
+This procedure works like gimp_edit_cut(), but additionally stores the
+cut buffer into a named buffer that will stay available for later
+pasting, regardless of any intermediate copy or cut operations.
+HELP
+
+    &mitch_pdb_misc('2005', '2.4');
+
+    @inargs = (
+	{ name => 'drawable', type => 'drawable',
+	  desc => "The drawable to cut from" },
+        { name => 'buffer_name', type => 'string', non_empty => 1,
+          desc => 'The name of the buffer to create' }
+    );
+
+    @outargs = (
+	{ name => 'real_name', type => 'string',
+	  desc => 'The real name given to the buffer, or NULL if the
+                   cut failed' }
+    );
+
+    %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))
+    {
+      GimpImage *image    = gimp_item_get_image (GIMP_ITEM (drawable));
+      GError    *my_error = NULL;
+
+      real_name = (gchar *) gimp_edit_named_cut (image, buffer_name,
+                                                 drawable, context, &my_error);
+
+      if (real_name)
+        {
+          real_name = g_strdup (real_name);
+        }
+      else
+        {
+          gimp_message_literal (gimp,
+                                G_OBJECT (progress), GIMP_MESSAGE_WARNING,
+                                my_error->message);
+          g_clear_error (&my_error);
+        }
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub edit_named_copy {
+    $blurb = 'Copy into a named buffer.';
+
+    $help = <<'HELP';
+This procedure works like gimp_edit_copy(), but additionally stores the
+copied buffer into a named buffer that will stay available for later
+pasting, regardless of any intermediate copy or cut operations.
+HELP
+
+    &mitch_pdb_misc('2005', '2.4');
+
+    @inargs = (
+	{ name => 'drawable', type => 'drawable',
+	  desc => "The drawable to copy from" },
+        { name => 'buffer_name', type => 'string', non_empty => 1,
+          desc => 'The name of the buffer to create' }
+    );
+
+    @outargs = (
+	{ name => 'real_name', type => 'string',
+	  desc => 'The real name given to the buffer, or NULL if the
+                   copy failed' }
+    );
+
+    %invoke = (
+	code => <<CODE
+{
+  if (gimp_pdb_item_is_attached (GIMP_ITEM (drawable), NULL, 0, error))
+    {
+      GimpImage *image    = gimp_item_get_image (GIMP_ITEM (drawable));
+      GError    *my_error = NULL;
+
+      real_name = (gchar *) gimp_edit_named_copy (image, buffer_name,
+                                                  drawable, context, &my_error);
+
+      if (real_name)
+        {
+          real_name = g_strdup (real_name);
+        }
+      else
+        {
+          gimp_message_literal (gimp,
+                                G_OBJECT (progress), GIMP_MESSAGE_WARNING,
+                                my_error->message);
+          g_clear_error (&my_error);
+        }
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub edit_named_copy_visible {
+    $blurb = 'Copy from the projection into a named buffer.';
+
+    $help = <<'HELP';
+This procedure works like gimp_edit_copy_visible(), but additionally
+stores the copied buffer into a named buffer that will stay available
+for later pasting, regardless of any intermediate copy or cut
+operations.
+HELP
+
+    &mitch_pdb_misc('2005', '2.4');
+
+    @inargs = (
+	{ name => 'image', type => 'image',
+	  desc => "The image to copy from" },
+        { name => 'buffer_name', type => 'string', non_empty => 1,
+          desc => 'The name of the buffer to create' }
+    );
+
+    @outargs = (
+	{ name => 'real_name', type => 'string',
+	  desc => 'The real name given to the buffer, or NULL if the
+                   copy failed' }
+    );
+
+    %invoke = (
+	code => <<CODE
+{
+  GError *my_error = NULL;
+
+  real_name = (gchar *) gimp_edit_named_copy_visible (image, buffer_name,
+                                                      context, &my_error);
+
+  if (real_name)
+    {
+      real_name = g_strdup (real_name);
+    }
+  else
+    {
+      gimp_message_literal (gimp,
+                            G_OBJECT (progress), GIMP_MESSAGE_WARNING,
+                            my_error->message);
+      g_clear_error (&my_error);
+    }
+}
+CODE
+    );
+}
+
+sub edit_named_paste {
+    $blurb = 'Paste named buffer to the specified drawable.';
+
+    $help = <<'HELP';
+This procedure works like gimp_edit_paste() but pastes a named buffer
+instead of the global buffer.
+HELP
+
+    &mitch_pdb_misc('2005', '2.4');
+
+    @inargs = (
+	{ name => 'drawable', type => 'drawable',
+	  desc => 'The drawable to paste to' },
+        { name => 'buffer_name', type => 'string',
+          desc => 'The name of the buffer to paste' },
+        { name => 'paste_into', type => 'boolean',
+	  desc => 'Clear selection, or paste behind it?' }
+    );
+
+    @outargs = (
+	{ name  => 'floating_sel', type  => 'layer',
+	  desc  => 'The new floating selection' }
+    );
+
+    %invoke = (
+	code => <<CODE
+{
+  GimpBuffer *buffer = gimp_pdb_get_buffer (gimp, buffer_name, error);
+
+  if (buffer &&
+      gimp_pdb_item_is_attached (GIMP_ITEM (drawable), NULL,
+                                 GIMP_PDB_ITEM_CONTENT, error) &&
+      gimp_pdb_item_is_not_group (GIMP_ITEM (drawable), error))
+    {
+      floating_sel = gimp_edit_paste (gimp_item_get_image (GIMP_ITEM (drawable)),
+                                      drawable, GIMP_OBJECT (buffer),
+                                      paste_into ?
+                                      GIMP_PASTE_TYPE_FLOATING_INTO :
+                                      GIMP_PASTE_TYPE_FLOATING,
+                                      -1, -1, -1, -1);
+      if (! floating_sel)
+        success = FALSE;
+    }
+  else
+    success = FALSE;
+}
+CODE
+    )
+}
+
+sub edit_named_paste_as_new_image {
+    $blurb = 'Paste named buffer to a new image.';
+
+    $help = <<'HELP';
+This procedure works like gimp_edit_paste_as_new_image() but pastes a
+named buffer instead of the global buffer.
+HELP
+
+    &mitch_pdb_misc('2005', '2.10');
+
+    @inargs = (
+        { name => 'buffer_name', type => 'string',
+          desc => 'The name of the buffer to paste' }
+    );
+
+    @outargs = (
+	{ name => 'image', type => 'image',
+	  desc => 'The new image' }
+    );
+
+    %invoke = (
+	code => <<CODE
+{
+  GimpBuffer *buffer = gimp_pdb_get_buffer (gimp, buffer_name, error);
+
+  if (buffer)
+    {
+      image = gimp_edit_paste_as_new_image (gimp, GIMP_OBJECT (buffer));
+
+      if (! image)
+        success = FALSE;
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub edit_clear {
+    $blurb = 'Clear selected area of drawable.';
+
+    $help = <<'HELP';
+This procedure clears the specified drawable. If the drawable has an
+alpha channel, the cleared pixels will become transparent. If the
+drawable does not have an alpha channel, cleared pixels will be set to
+the background color. This procedure only affects regions within a
+selection if there is a selection active.
+HELP
+
+    &std_pdb_misc;
+
+    $deprecated = 'gimp-drawable-edit-clear';
+
+    @inargs = (
+	{ name => 'drawable', type => 'drawable',
+	  desc => 'The drawable to clear from' }
+    );
+
+    %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_edit_clear (drawable, context);
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub edit_fill {
+    $blurb = 'Fill selected area of drawable.';
+
+    $help = <<'HELP';
+This procedure fills the specified drawable with the fill mode. If the
+fill mode is foreground, the current foreground color is used. If the
+fill mode is background, the current background color is used. Other
+fill modes should not be used. This procedure only affects regions
+within a selection if there is a selection active. If you want to fill
+the whole drawable, regardless of the selection, use
+gimp_drawable_fill().
+HELP
+
+    &std_pdb_misc;
+    $author .= ' & Raphael Quinet';
+    $date = '1995-2000';
+
+    $deprecated = 'gimp-drawable-edit-fill';
+
+    @inargs = (
+	{ name => 'drawable', type => 'drawable',
+	  desc => "The drawable to fill to" },
+	{ name => 'fill_type', type => 'enum GimpFillType',
+	  desc => 'The type of fill' }
+    );
+
+    %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))
+    {
+      GimpFillOptions *options = gimp_fill_options_new (gimp, NULL, FALSE);
+
+      if (gimp_fill_options_set_by_fill_type (options, context,
+                                              fill_type, error))
+        {
+          gimp_drawable_edit_fill (drawable, options, NULL);
+        }
+      else
+        success = FALSE;
+
+      g_object_unref (options);
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub edit_bucket_fill {
+    $blurb = <<'BLURB';
+Fill the area specified either by the current selection if there is one, or by
+a seed fill starting at the specified coordinates.
+BLURB
+
+    $help = <<'HELP';
+This tool requires information on the paint application mode, and the
+fill mode, which can either be in the foreground color, or in the
+currently active pattern. If there is no selection, a seed fill is
+executed at the specified coordinates and extends outward in keeping
+with the threshold parameter. If there is a selection in the target
+image, the threshold, sample merged, x, and y arguments are unused. If
+the sample_merged parameter is TRUE, the data of the composite
+image will be used instead of that for the specified drawable.  This
+is equivalent to sampling for colors after merging all visible
+layers. In the case of merged sampling, the x and y coordinates are
+relative to the image's origin; otherwise, they are relative to the
+drawable's origin.
+HELP
+
+    &std_pdb_misc;
+
+    $deprecated = 'gimp-drawable-edit-bucket-fill';
+
+    @inargs = (
+	{ name => 'drawable', type => 'drawable',
+	  desc => 'The affected drawable' },
+	{ name => 'fill_mode', type => 'enum GimpBucketFillMode',
+	  desc => 'The type of fill' },
+	{ name => paint_mode, type => 'enum GimpLayerMode',
+          default => 'GIMP_LAYER_MODE_NORMAL',
+	  desc => 'The paint application mode' },
+	{ name => 'opacity', type => '0 <= float <= 100',
+	  desc => 'The opacity of the final bucket fill' },
+	{ name => 'threshold', type => '0 <= float <= 255',
+	  desc => "The threshold determines how extensive the seed fill will
+		   be. It's value is specified in terms of intensity levels.
+                   This parameter is only valid when there is no selection in
+		   the specified image." },
+	{ name => 'sample_merged', type => 'boolean',
+	  desc => 'Use the composite image, not the drawable' },
+	{ name => 'x', type => 'float',
+	  desc => "The x coordinate of this bucket fill's application.
+		   This parameter is only valid when there is no selection
+		   in the specified image." },
+	{ name => 'y', type => 'float',
+	  desc => "The y coordinate of this bucket fill's application.
+		   This parameter is only valid when there is no selection
+		   in the specified image." }
+    );
+
+    %invoke = (
+        headers => [ qw ("core/gimpdrawable-bucket-fill.h"
+	                 "core/gimpchannel.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))
+    {
+      GimpImage       *image   = gimp_item_get_image (GIMP_ITEM (drawable));
+      GimpFillOptions *options = gimp_fill_options_new (gimp, NULL, FALSE);
+
+      if (gimp_fill_options_set_by_fill_mode (options, context,
+                                              fill_mode, error))
+        {
+          if (paint_mode == GIMP_LAYER_MODE_OVERLAY_LEGACY)
+            paint_mode = GIMP_LAYER_MODE_SOFTLIGHT_LEGACY;
+
+          gimp_context_set_opacity (GIMP_CONTEXT (options), opacity / 100.0);
+          gimp_context_set_paint_mode (GIMP_CONTEXT (options), paint_mode);
+
+          if (! gimp_channel_is_empty (gimp_image_get_mask (image)))
+            {
+              gimp_drawable_edit_fill (drawable, options, NULL);
+            }
+          else
+            {
+              gimp_drawable_bucket_fill (drawable, options,
+                                         FALSE /* don't fill transparent */,
+                                         GIMP_SELECT_CRITERION_COMPOSITE,
+                                         threshold / 255.0,
+                                         sample_merged,
+                                         FALSE /* no diagonal neighbors */,
+                                         x, y);
+           }
+        }
+      else
+        success = FALSE;
+
+      g_object_unref (options);
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub edit_bucket_fill_full {
+    $blurb = <<'BLURB';
+Fill the area specified either by the current selection if there is one, or by
+a seed fill starting at the specified coordinates.
+BLURB
+
+    $help = <<'HELP';
+This tool requires information on the paint application mode, and the
+fill mode, which can either be in the foreground color, or in the
+currently active pattern. If there is no selection, a seed fill is
+executed at the specified coordinates and extends outward in keeping
+with the threshold parameter. If there is a selection in the target
+image, the threshold, sample merged, x, and y arguments are unused. If
+the sample_merged parameter is TRUE, the data of the composite
+image will be used instead of that for the specified drawable.  This
+is equivalent to sampling for colors after merging all visible
+layers. In the case of merged sampling, the x and y coordinates are
+relative to the image's origin; otherwise, they are relative to the
+drawable's origin.
+HELP
+
+    &david_pdb_misc('2006', '2.4');
+
+    $deprecated = 'gimp-drawable-edit-bucket-fill';
+
+    @inargs = (
+	{ name => 'drawable', type => 'drawable',
+	  desc => 'The affected drawable' },
+	{ name => 'fill_mode', type => 'enum GimpBucketFillMode',
+	  desc => 'The type of fill' },
+	{ name => paint_mode, type => 'enum GimpLayerMode',
+          default => 'GIMP_LAYER_MODE_NORMAL',
+	  desc => 'The paint application mode' },
+	{ name => 'opacity', type => '0 <= float <= 100',
+	  desc => 'The opacity of the final bucket fill' },
+	{ name => 'threshold', type => '0 <= float <= 255',
+	  desc => "The threshold determines how extensive the seed fill will
+		   be. It's value is specified in terms of intensity levels.
+                   This parameter is only valid when there is no selection in
+		   the specified image." },
+	{ name => 'sample_merged', type => 'boolean',
+	  desc => 'Use the composite image, not the drawable' },
+	{ name => 'fill_transparent', type => 'boolean',
+	  desc => "Whether to consider transparent pixels for filling.
+	           If TRUE, transparency is considered as a unique fillable
+		   color." },
+	{ name => 'select_criterion', type => 'enum GimpSelectCriterion',
+	  desc => "The criterion used to determine color similarity.
+	           SELECT_CRITERION_COMPOSITE is the standard choice.
+		   " },
+	{ name => 'x', type => 'float',
+	  desc => "The x coordinate of this bucket fill's application.
+		   This parameter is only valid when there is no selection
+		   in the specified image." },
+	{ name => 'y', type => 'float',
+	  desc => "The y coordinate of this bucket fill's application.
+		   This parameter is only valid when there is no selection
+		   in the specified image." }
+    );
+
+    %invoke = (
+        headers => [ qw ("core/gimpdrawable-bucket-fill.h"
+	                 "core/gimpchannel.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))
+    {
+      GimpImage       *image   = gimp_item_get_image (GIMP_ITEM (drawable));
+      GimpFillOptions *options = gimp_fill_options_new (gimp, NULL, FALSE);
+
+      if (gimp_fill_options_set_by_fill_mode (options, context,
+                                              fill_mode, error))
+        {
+          if (paint_mode == GIMP_LAYER_MODE_OVERLAY_LEGACY)
+            paint_mode = GIMP_LAYER_MODE_SOFTLIGHT_LEGACY;
+
+          gimp_context_set_opacity (GIMP_CONTEXT (options), opacity / 100.0);
+          gimp_context_set_paint_mode (GIMP_CONTEXT (options), paint_mode);
+
+          if (! gimp_channel_is_empty (gimp_image_get_mask (image)))
+            {
+              gimp_drawable_edit_fill (drawable, options, NULL);
+            }
+          else
+            {
+              gimp_drawable_bucket_fill (drawable, options,
+                                         fill_transparent,
+                                         select_criterion,
+                                         threshold / 255.0,
+                                         sample_merged,
+                                         FALSE /* no diagonal neighbors */,
+                                         x, y);
+           }
+        }
+      else
+        success = FALSE;
+
+      g_object_unref (options);
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub edit_blend {
+    $blurb = <<'BLURB';
+Blend between the starting and ending coordinates with the specified
+blend mode and gradient type.
+BLURB
+
+    $help = <<'HELP';
+This tool requires information on the paint application mode, the
+blend mode, and the gradient type. It creates the specified variety of
+blend using the starting and ending coordinates as defined for each
+gradient type.
+For shapeburst gradient types, the context's distance metric is also
+relevant and can be updated with gimp_context_set_distance_metric().
+HELP
+
+    &std_pdb_misc;
+
+    $deprecated = 'gimp-drawable-edit-gradient-fill';
+
+    @inargs = (
+	{ name => 'drawable', type => 'drawable',
+	  desc => 'The affected drawable' },
+        { name => 'blend_mode', type => 'enum GimpBlendMode',
+	  desc => 'The type of blend' },
+	{ name => 'paint_mode', type => 'enum GimpLayerMode',
+          default => 'GIMP_LAYER_MODE_NORMAL',
+	  desc => 'The paint application mode' },
+	{ name => 'gradient_type',  type => 'enum GimpGradientType',
+	  desc => 'The type of gradient' },
+	{ name => 'opacity', type => '0 <= float <= 100',
+	  desc => 'The opacity of the final blend' },
+	{ name => 'offset', type => '0 <= float',
+	  desc => 'Offset relates to the starting and ending coordinates
+		   specified for the blend. This parameter is mode dependent.' },
+	{ name => 'repeat', type => 'enum GimpRepeatMode',
+	  desc => 'Repeat mode' },
+	{ name => 'reverse', type => 'boolean',
+	  desc => 'Use the reverse gradient' },
+	{ name => 'supersample', type => 'boolean',
+	  desc => 'Do adaptive supersampling' },
+	{ name => 'max_depth', type => '1 <= int32 <= 9', no_validate => 1,
+	  desc => 'Maximum recursion levels for supersampling' },
+	{ name => 'threshold', type => '0 <= float <= 4', no_validate => 1,
+	  desc => 'Supersampling threshold' },
+	{ name => 'dither', type => 'boolean',
+	  desc => 'Use dithering to reduce banding' },
+	{ name => 'x1', type => 'float',
+	  desc => "The x coordinate of this blend's starting point" },
+	{ name => 'y1', type => 'float',
+	  desc => "The y coordinate of this blend's starting point" },
+	{ name => 'x2', type => 'float',
+	  desc => "The x coordinate of this blend's ending point" },
+	{ name => 'y2', type => 'float',
+	  desc => "The y coordinate of this blend's ending point" }
+    );
+
+    %invoke = (
+        headers => [ qw("core/gimp-gradients.h" "core/gimpdrawable-gradient.h") ],
+	code => <<'CODE'
+{
+  success = (gimp_pdb_item_is_attached (GIMP_ITEM (drawable), NULL,
+                                        GIMP_PDB_ITEM_CONTENT, error) &&
+             gimp_pdb_item_is_not_group (GIMP_ITEM (drawable), error));
+
+  if (success)
+    {
+      if (supersample)
+        {
+          if (max_depth < 1 || max_depth > 9)
+            success = FALSE;
+
+          if (threshold < 0.0 || threshold > 4.0)
+            success = FALSE;
+	}
+      else
+        {
+	  max_depth = CLAMP (max_depth, 1, 9);
+	  threshold = CLAMP (threshold, 0.0, 4.0);
+	}
+    }
+
+  if (success)
+    {
+      GimpGradient *gradient;
+
+      if (paint_mode == GIMP_LAYER_MODE_OVERLAY_LEGACY)
+        paint_mode = GIMP_LAYER_MODE_SOFTLIGHT_LEGACY;
+
+      if (progress)
+        gimp_progress_start (progress, FALSE, _("Gradient"));
+
+      switch (blend_mode)
+        {
+        case GIMP_BLEND_FG_BG_RGB:
+          gradient = gimp_gradients_get_fg_bg_rgb (context->gimp);
+          break;
+
+        case GIMP_BLEND_FG_BG_HSV:
+          gradient = gimp_gradients_get_fg_bg_hsv_cw (context->gimp);
+          break;
+
+        case GIMP_BLEND_FG_TRANSPARENT:
+          gradient = gimp_gradients_get_fg_transparent (context->gimp);
+          break;
+
+        case GIMP_BLEND_CUSTOM:
+	default:
+          gradient = gimp_context_get_gradient (context);
+          break;
+        }
+
+      gimp_drawable_gradient (drawable,
+                              context,
+                              gradient,
+                              GIMP_PDB_CONTEXT (context)->distance_metric,
+                              paint_mode,
+                              gradient_type,
+                              opacity / 100.0,
+                              offset, repeat, reverse,
+                              GIMP_GRADIENT_BLEND_RGB_PERCEPTUAL,
+                              supersample, max_depth,
+                              threshold, dither,
+                              x1, y1, x2, y2,
+                              progress);
+
+      if (progress)
+        gimp_progress_end (progress);
+    }
+}
+CODE
+    );
+}
+
+sub edit_stroke {
+    $blurb = 'Stroke the current selection';
+
+    $help = <<'HELP';
+This procedure strokes the current selection, painting along the selection
+boundary with the active brush and foreground color. The paint is applied to
+the specified drawable regardless of the active selection.
+HELP
+
+    &std_pdb_misc;
+
+    $deprecated = 'gimp-drawable-edit-stroke-selection';
+
+    @inargs = (
+	{ name => 'drawable', type => 'drawable',
+	  desc => 'The drawable to stroke to' }
+    );
+
+    %invoke = (
+	headers => [ qw("core/gimpstrokeoptions.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))
+    {
+      GimpImage         *image = gimp_item_get_image (GIMP_ITEM (drawable));
+      GimpStrokeOptions *options;
+      GimpPaintOptions  *paint_options;
+
+      options = gimp_pdb_context_get_stroke_options (GIMP_PDB_CONTEXT (context));
+
+      paint_options =
+        gimp_pdb_context_get_paint_options (GIMP_PDB_CONTEXT (context), NULL);
+      paint_options = gimp_config_duplicate (GIMP_CONFIG (paint_options));
+
+      success = gimp_item_stroke (GIMP_ITEM (gimp_image_get_mask (image)),
+                                  drawable, context, options, paint_options,
+                                  TRUE, progress, error);
+
+      g_object_unref (paint_options);
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub edit_stroke_vectors {
+    $blurb = 'Stroke the specified vectors object';
+
+    $help = <<'HELP';
+This procedure strokes the specified vectors object, painting along the
+path with the active brush and foreground color.
+HELP
+
+    &simon_pdb_misc('2006', '2.4');
+
+    $deprecated = 'gimp-drawable-edit-stroke-item';
+
+    @inargs = (
+	{ name => 'drawable', type => 'drawable',
+	  desc => 'The drawable to stroke to' },
+	{ name => 'vectors', type => 'vectors',
+          desc => 'The vectors object' }
+    );
+
+    %invoke = (
+	headers => [ qw("core/gimpstrokeoptions.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) &&
+      gimp_pdb_item_is_attached (GIMP_ITEM (vectors),
+                                 gimp_item_get_image (GIMP_ITEM (drawable)),
+                                 0, error))
+    {
+      GimpStrokeOptions *options;
+      GimpPaintOptions  *paint_options;
+
+      options = gimp_pdb_context_get_stroke_options (GIMP_PDB_CONTEXT (context));
+
+      paint_options =
+        gimp_pdb_context_get_paint_options (GIMP_PDB_CONTEXT (context), NULL);
+      paint_options = gimp_config_duplicate (GIMP_CONFIG (paint_options));
+
+      success = gimp_item_stroke (GIMP_ITEM (vectors),
+                                  drawable, context, options, paint_options,
+                                  TRUE, progress, error);
+
+      g_object_unref (paint_options);
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+
+@headers = qw("libgimpconfig/gimpconfig.h"
+              "core/gimp.h"
+              "core/gimp-edit.h"
+              "core/gimpdrawable-edit.h"
+              "core/gimpbuffer.h"
+              "core/gimpimage.h"
+              "core/gimpprogress.h"
+              "gimppdb-utils.h"
+              "gimppdbcontext.h"
+              "gimp-intl.h");
+
+@procs = qw(edit_cut
+            edit_copy
+            edit_copy_visible
+            edit_paste
+            edit_paste_as_new_image
+            edit_named_cut
+            edit_named_copy
+            edit_named_copy_visible
+            edit_named_paste
+            edit_named_paste_as_new_image
+            edit_clear
+            edit_fill
+            edit_bucket_fill
+            edit_bucket_fill_full
+	    edit_blend
+            edit_stroke
+            edit_stroke_vectors);
+
+%exports = (app => [@procs], lib => [@procs]);
+
+$desc = 'Edit procedures';
+$doc_title = 'gimpedit';
+$doc_short_desc = 'Edit menu functions (cut, copy, paste, clear, etc.)';
+$doc_long_desc = 'Edit menu functions (cut, copy, paste, clear, etc.)';
+
+1;