Adding upstream version 2.10.34.upstream/2.10.34upstream

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

1 files changed, 1488 insertions, 0 deletions

diff --git a/pdb/groups/gradient.pdb b/pdb/groups/gradient.pdb
new file mode 100644
index 0000000..3e44257
--- /dev/null
+++ b/pdb/groups/gradient.pdb
@@ -0,0 +1,1488 @@
+# 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/>.
+
+sub gradient_new {
+    $blurb = 'Creates a new gradient';
+    $help  = 'This procedure creates a new, uninitialized gradient';
+
+    &shlomi_pdb_misc('2003', '2.2');
+
+    @inargs = (
+	{ name => 'name', type => 'string', non_empty => 1,
+	  desc => 'The requested name of the new gradient' }
+    );
+
+    @outargs = (
+	{ name => 'actual_name', type => 'string',
+	  desc => 'The actual new gradient name' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  GimpData *data = gimp_data_factory_data_new (gimp->gradient_factory,
+                                               context, name);
+
+  if (data)
+    actual_name = g_strdup (gimp_object_get_name (data));
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub gradient_duplicate {
+    $blurb = 'Duplicates a gradient';
+    $help  = 'This procedure creates an identical gradient by a different name';
+
+    &shlomi_pdb_misc('2003', '2.2');
+
+    @inargs = (
+	{ name => 'name', type => 'string', non_empty => 1,
+	  desc => 'The gradient name' }
+    );
+
+    @outargs = (
+	{ name => 'copy_name', type => 'string',
+	  desc => "The name of the gradient's copy" }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  GimpGradient *gradient = gimp_pdb_get_gradient (gimp, name, GIMP_PDB_DATA_ACCESS_READ, error);
+
+  if (gradient)
+    {
+      GimpGradient *gradient_copy = (GimpGradient *)
+        gimp_data_factory_data_duplicate (gimp->gradient_factory,
+                                          GIMP_DATA (gradient));
+
+      if (gradient_copy)
+        copy_name = g_strdup (gimp_object_get_name (gradient_copy));
+      else
+        success = FALSE;
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub gradient_is_editable {
+    $blurb = 'Tests if gradient can be edited';
+    $help  = 'Returns TRUE if you have permission to change the gradient';
+
+    &bill_pdb_misc('2004', '2.4');
+
+    @inargs = (
+	{ name => 'name', type => 'string', non_empty => 1,
+	  desc => 'The gradient name' }
+    );
+
+    @outargs = (
+	{ name => 'editable', type => 'boolean',
+	  desc => 'TRUE if the gradient can be edited' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  GimpGradient *gradient = gimp_pdb_get_gradient (gimp, name, GIMP_PDB_DATA_ACCESS_READ, error);
+
+  if (gradient)
+    editable = gimp_data_is_writable (GIMP_DATA (gradient));
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub gradient_rename {
+    $blurb = 'Rename a gradient';
+    $help  = 'This procedure renames a gradient';
+
+    &shlomi_pdb_misc('2003', '2.2');
+
+    @inargs = (
+	{ name => 'name', type => 'string', non_empty => 1,
+	  desc => 'The gradient name' },
+        { name => 'new_name', type => 'string', non_empty => 1,
+          desc => 'The new name of the gradient' }
+    );
+
+    @outargs = (
+	{ name => 'actual_name', type => 'string',
+	  desc => 'The actual new name of the gradient' }
+    );
+
+    %invoke = (
+	code => <<'CODE'
+{
+  GimpGradient *gradient = gimp_pdb_get_gradient (gimp, name, GIMP_PDB_DATA_ACCESS_RENAME, error);
+
+  if (gradient)
+    {
+      gimp_object_set_name (GIMP_OBJECT (gradient), new_name);
+      actual_name = g_strdup (gimp_object_get_name (gradient));
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub gradient_delete {
+    $blurb = 'Deletes a gradient';
+    $help  = 'This procedure deletes a gradient';
+
+    &shlomi_pdb_misc('2003', '2.2');
+
+    @inargs = (
+	{ name => 'name', type => 'string', non_empty => 1,
+	  desc => 'The gradient name' }
+    );
+
+    %invoke = (
+	code => <<'CODE'
+{
+  GimpGradient *gradient = gimp_pdb_get_gradient (gimp, name, GIMP_PDB_DATA_ACCESS_READ, error);
+
+  if (gradient && gimp_data_is_deletable (GIMP_DATA (gradient)))
+    success = gimp_data_factory_data_delete (gimp->gradient_factory,
+                                             GIMP_DATA (gradient),
+                                             TRUE, error);
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub gradient_get_number_of_segments {
+    $blurb = 'Returns the number of segments of the specified gradient';
+
+    $help = <<'HELP';
+This procedure returns the number of segments of the specified gradient.
+HELP
+
+    $author    = 'Lars-Peter Clausen <lars@metafoo.de>';
+    $copyright = 'Lars-Peter Clausen';
+    $date      = '2008';
+    $since     = '2.6';
+
+
+    @inargs = (
+        { name => 'name', type => 'string', non_empty => 1,
+          desc => 'The gradient name' }
+    );
+
+    @outargs = (
+        { name => 'num_segments', type => 'int32',
+          init => 0, desc => 'Number of segments' }
+    );
+    %invoke = (
+        code => <<'CODE'
+{
+  GimpGradient        *gradient;
+  GimpGradientSegment *seg;
+
+  gradient = gimp_pdb_get_gradient (gimp, name, GIMP_PDB_DATA_ACCESS_READ, error);
+
+  if (gradient)
+    {
+      for (seg = gradient->segments; seg; seg = seg->next)
+        num_segments++;
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub gradient_get_uniform_samples {
+    $blurb = 'Sample the specified in uniform parts.';
+
+    $help = <<'HELP';
+This procedure samples the active gradient in the
+specified number of uniform parts. It returns a list of floating-point values
+which correspond to the RGBA values for each sample. The minimum number of
+samples to take is 2, in which case the returned colors will correspond to the
+{ 0.0, 1.0 } positions in the gradient. For example, if the number of samples
+is 3, the procedure will return the colors at positions { 0.0, 0.5, 1.0 }.
+HELP
+
+    &federico_pdb_misc('1997', '2.2');
+
+    @inargs = (
+	{ name => 'name', type => 'string', non_empty => 1,
+	  desc => 'The gradient name' },
+	{ name => 'num_samples', type => '2 <= int32',
+	  desc => 'The number of samples to take' },
+	{ name => 'reverse', type => 'boolean',
+	  desc => 'Use the reverse gradient' }
+    );
+
+    @outargs = (
+        { name => 'color_samples', type => 'floatarray', void_ret => 1,
+	  desc => 'Color samples: { R1, G1, B1, A1, ..., Rn, Gn, Bn, An }',
+	  array => { desc => 'Length of the color_samples array (4 *
+			      num_samples)' } }
+    );
+
+    %invoke = (
+	code => <<'CODE'
+{
+  GimpGradient *gradient = gimp_pdb_get_gradient (gimp, name,
+                                                  GIMP_PDB_DATA_ACCESS_READ,
+                                                  error);
+
+  if (gradient)
+    {
+      GimpGradientSegment *seg   = NULL;
+      gdouble              pos   = 0.0;
+      gdouble              delta = 1.0 / (num_samples - 1);
+      gdouble             *sample;
+
+      num_color_samples = num_samples * 4;
+
+      sample = color_samples = g_new (gdouble, num_color_samples);
+
+      while (num_samples--)
+        {
+          GimpRGB color;
+
+	  seg = gimp_gradient_get_color_at (gradient, context, seg,
+                                            pos, reverse,
+                                            GIMP_GRADIENT_BLEND_RGB_PERCEPTUAL,
+                                            &color);
+
+          *sample++ = color.r;
+          *sample++ = color.g;
+          *sample++ = color.b;
+          *sample++ = color.a;
+
+          pos += delta;
+        }
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub gradient_get_custom_samples {
+    $blurb = 'Sample the specified gradient in custom positions.';
+
+    $help = <<'HELP';
+This procedure samples the active gradient in the specified number of
+points. The procedure will sample the gradient in the specified
+positions from the list. The left endpoint of the gradient corresponds
+to position 0.0, and the right endpoint corresponds to 1.0. The
+procedure returns a list of floating-point values which correspond to
+the RGBA values for each sample.
+HELP
+
+    &federico_pdb_misc('1997', '2.2');
+
+    @inargs = (
+	{ name => 'name', type => 'string', non_empty => 1,
+	  desc => 'The gradient name' },
+	{ name  => 'positions', type  => 'floatarray',
+	  desc  => 'The list of positions to sample along the gradient',
+	  array => { name => 'num_samples', type => '1 <= int32',
+		     desc => 'The number of samples to take' } },
+	{ name => 'reverse', type => 'boolean',
+	  desc => 'Use the reverse gradient' }
+    );
+
+    @outargs = (
+        { name => 'color_samples', type => 'floatarray', void_ret => 1,
+	  desc => 'Color samples: { R1, G1, B1, A1, ..., Rn, Gn, Bn, An }',
+	  array => { desc => 'Length of the color_samples array (4 *
+			      num_samples)' } }
+    );
+
+    %invoke = (
+	code => <<'CODE'
+{
+  GimpGradient *gradient = gimp_pdb_get_gradient (gimp, name,
+                                                  GIMP_PDB_DATA_ACCESS_READ,
+                                                  error);
+
+  if (gradient)
+    {
+      GimpGradientSegment *seg = NULL;
+      gdouble             *sample;
+
+      num_color_samples = num_samples * 4;
+
+      sample = color_samples = g_new (gdouble, num_color_samples);
+
+      while (num_samples--)
+        {
+          GimpRGB color;
+
+          seg = gimp_gradient_get_color_at (gradient, context,
+                                            seg, *positions,
+                                            reverse,
+                                            GIMP_GRADIENT_BLEND_RGB_PERCEPTUAL,
+                                            &color);
+
+          *sample++ = color.r;
+          *sample++ = color.g;
+          *sample++ = color.b;
+          *sample++ = color.a;
+
+          positions++;
+        }
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub gradient_segment_get_left_color {
+    $blurb = 'Retrieves the left endpoint color of the specified segment';
+
+    $help = <<'HELP';
+This procedure retrieves the left endpoint color of the specified segment of
+the specified gradient.
+HELP
+
+    &shlomi_pdb_misc('2003', '2.2');
+
+    @inargs = (
+	{ name => 'name', type => 'string', non_empty => 1,
+	  desc => 'The gradient name' },
+        { name => 'segment', type => '0 <= int32',
+          desc => 'The index of the segment within the gradient' }
+    );
+
+    @outargs = (
+        { name => 'color', type => 'color', void_ret => 1,
+          desc => 'The return color' },
+        { name => 'opacity', type => 'float',
+          desc => 'The opacity of the endpoint' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  GimpGradient        *gradient;
+  GimpGradientSegment *seg;
+
+  gradient = gradient_get (gimp, name, GIMP_PDB_DATA_ACCESS_READ, segment,
+                           &seg, error);
+
+  if (seg)
+    {
+      gimp_gradient_segment_get_left_color (gradient, seg, &color);
+      opacity = color.a * 100.0;
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub gradient_segment_get_right_color {
+    $blurb = 'Retrieves the right endpoint color of the specified segment';
+
+    $help = <<'HELP';
+This procedure retrieves the right endpoint color of the specified segment of
+the specified gradient.
+HELP
+
+    &shlomi_pdb_misc('2003', '2.2');
+
+    @inargs = (
+	{ name => 'name', type => 'string', non_empty => 1,
+	  desc => 'The gradient name' },
+        { name => 'segment', type => '0 <= int32',
+          desc => 'The index of the segment within the gradient' }
+    );
+
+    @outargs = (
+        { name => 'color', type => 'color', void_ret => 1,
+          desc => 'The return color' },
+        { name => 'opacity', type => 'float',
+          desc => 'The opacity of the endpoint' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  GimpGradient        *gradient;
+  GimpGradientSegment *seg;
+
+  gradient = gradient_get (gimp, name, GIMP_PDB_DATA_ACCESS_READ, segment,
+                           &seg, error);
+
+  if (seg)
+    {
+      gimp_gradient_segment_get_right_color (gradient, seg, &color);
+      opacity = color.a * 100.0;
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub gradient_segment_set_left_color {
+    $blurb = 'Sets the left endpoint color of the specified segment';
+
+    $help = <<'HELP';
+This procedure sets the left endpoint color of the specified segment of
+the specified gradient.
+HELP
+
+    &shlomi_pdb_misc('2003', '2.2');
+
+    @inargs = (
+	{ name => 'name', type => 'string', non_empty => 1,
+	  desc => 'The gradient name' },
+        { name => 'segment', type => '0 <= int32',
+          desc => 'The index of the segment within the gradient' },
+        { name => 'color', type => 'color',
+          desc => 'The color to set' },
+        { name => 'opacity', type => '0 <= float <= 100.0',
+          desc => 'The opacity to set for the endpoint' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  GimpGradient        *gradient;
+  GimpGradientSegment *seg;
+
+  gradient = gradient_get (gimp, name, GIMP_PDB_DATA_ACCESS_WRITE, segment,
+                           &seg, error);
+
+  if (seg)
+    {
+      color.a = opacity / 100.0;
+      gimp_gradient_segment_set_left_color (gradient, seg, &color);
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub gradient_segment_set_right_color {
+    $blurb = 'Sets the right endpoint color of the specified segment';
+
+    $help = <<'HELP';
+This procedure sets the right endpoint color of the specified segment of
+the specified gradient.
+HELP
+
+    &shlomi_pdb_misc('2003', '2.2');
+
+    @inargs = (
+	{ name => 'name', type => 'string', non_empty => 1,
+	  desc => 'The gradient name' },
+        { name => 'segment', type => '0 <= int32',
+          desc => 'The index of the segment within the gradient' },
+        { name => 'color', type => 'color',
+          desc => 'The color to set' },
+        { name => 'opacity', type => '0 <= float <= 100.0',
+          desc => 'The opacity to set for the endpoint' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  GimpGradient        *gradient;
+  GimpGradientSegment *seg;
+
+  gradient = gradient_get (gimp, name, GIMP_PDB_DATA_ACCESS_WRITE, segment,
+                           &seg, error);
+
+  if (seg)
+    {
+      color.a = opacity / 100.0;
+      gimp_gradient_segment_set_right_color (gradient, seg, &color);
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub gradient_segment_get_left_pos {
+    $blurb = 'Retrieves the left endpoint position of the specified segment';
+
+    $help = <<'HELP';
+This procedure retrieves the left endpoint position of the specified segment of
+the specified gradient.
+HELP
+
+    &shlomi_pdb_misc('2003', '2.2');
+
+    @inargs = (
+	{ name => 'name', type => 'string', non_empty => 1,
+	  desc => 'The gradient name' },
+        { name => 'segment', type => '0 <= int32',
+          desc => 'The index of the segment within the gradient' }
+    );
+
+    @outargs = (
+        { name => 'pos', type => 'float', void_ret => 1,
+          desc => 'The return position' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  GimpGradient        *gradient;
+  GimpGradientSegment *seg;
+
+  gradient = gradient_get (gimp, name, GIMP_PDB_DATA_ACCESS_READ, segment,
+                           &seg, error);
+
+  if (seg)
+    {
+      pos = gimp_gradient_segment_get_left_pos (gradient, seg);
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub gradient_segment_get_right_pos {
+    $blurb = 'Retrieves the right endpoint position of the specified segment';
+
+    $help = <<'HELP';
+This procedure retrieves the right endpoint position of the specified segment of
+the specified gradient.
+HELP
+
+    &shlomi_pdb_misc('2003', '2.2');
+
+    @inargs = (
+	{ name => 'name', type => 'string', non_empty => 1,
+	  desc => 'The gradient name' },
+        { name => 'segment', type => '0 <= int32',
+          desc => 'The index of the segment within the gradient' }
+    );
+
+    @outargs = (
+        { name => 'pos', type => 'float', void_ret => 1,
+          desc => 'The return position' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  GimpGradient        *gradient;
+  GimpGradientSegment *seg;
+
+  gradient = gradient_get (gimp, name, GIMP_PDB_DATA_ACCESS_READ, segment,
+                           &seg, error);
+
+  if (seg)
+    {
+      pos = gimp_gradient_segment_get_right_pos (gradient, seg);
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub gradient_segment_get_middle_pos {
+    $blurb = 'Retrieves the middle point position of the specified segment';
+
+    $help = <<'HELP';
+This procedure retrieves the middle point position of the specified segment of
+the specified gradient.
+HELP
+
+    &shlomi_pdb_misc('2003', '2.2');
+
+    @inargs = (
+	{ name => 'name', type => 'string', non_empty => 1,
+	  desc => 'The gradient name' },
+        { name => 'segment', type => '0 <= int32',
+          desc => 'The index of the segment within the gradient' }
+    );
+
+    @outargs = (
+        { name => 'pos', type => 'float', void_ret => 1,
+          desc => 'The return position' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  GimpGradient        *gradient;
+  GimpGradientSegment *seg;
+
+  gradient = gradient_get (gimp, name, GIMP_PDB_DATA_ACCESS_READ, segment,
+                           &seg, error);
+
+  if (seg)
+    {
+      pos = gimp_gradient_segment_get_middle_pos (gradient, seg);
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub gradient_segment_set_left_pos {
+    $blurb = 'Sets the left endpoint position of the specified segment';
+
+    $help = <<'HELP';
+This procedure sets the left endpoint position of the specified
+segment of the specified gradient. The final position will be between
+the position of the middle point to the left to the middle point of
+the current segment.
+
+This procedure returns the final position.
+HELP
+
+    &shlomi_pdb_misc('2003', '2.2');
+
+    @inargs = (
+	{ name => 'name', type => 'string', non_empty => 1,
+	  desc => 'The gradient name' },
+        { name => 'segment', type => '0 <= int32',
+          desc => 'The index of the segment within the gradient' },
+        { name => 'pos', type => '0.0 <= float <= 1.0',
+          desc => 'The position to set the guidepoint to' }
+    );
+
+    @outargs = (
+        { name => 'final_pos', type => 'float', void_ret => 1,
+          desc => 'The return position' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  GimpGradient        *gradient;
+  GimpGradientSegment *seg;
+
+  gradient = gradient_get (gimp, name, GIMP_PDB_DATA_ACCESS_WRITE, segment,
+                           &seg, error);
+
+  if (seg)
+    {
+      final_pos = gimp_gradient_segment_set_left_pos (gradient, seg, pos);
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub gradient_segment_set_right_pos {
+    $blurb = 'Sets the right endpoint position of the specified segment';
+
+    $help = <<'HELP';
+This procedure sets the right endpoint position of the specified
+segment of the specified gradient. The final position will be between
+the position of the middle point of the current segment and the middle
+point of the segment to the right.
+
+This procedure returns the final position.
+HELP
+
+    &shlomi_pdb_misc('2003', '2.2');
+
+    @inargs = (
+	{ name => 'name', type => 'string', non_empty => 1,
+	  desc => 'The gradient name' },
+        { name => 'segment', type => '0 <= int32',
+          desc => 'The index of the segment within the gradient' },
+        { name => 'pos', type => '0.0 <= float <= 1.0',
+          desc => 'The position to set the guidepoint to' }
+    );
+
+    @outargs = (
+        { name => 'final_pos', type => 'float', void_ret => 1,
+          desc => 'The return position' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  GimpGradient        *gradient;
+  GimpGradientSegment *seg;
+
+  gradient = gradient_get (gimp, name, GIMP_PDB_DATA_ACCESS_WRITE, segment,
+                           &seg, error);
+
+  if (seg)
+    {
+      final_pos =
+        gimp_gradient_segment_set_right_pos (gradient, seg, pos);
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub gradient_segment_set_middle_pos {
+    $blurb = 'Sets the middle point position of the specified segment';
+
+    $help = <<'HELP';
+This procedure sets the middle point position of the specified segment
+of the specified gradient. The final position will be between the two
+endpoints of the segment.
+
+This procedure returns the final position.
+HELP
+
+    &shlomi_pdb_misc('2003', '2.2');
+
+    @inargs = (
+	{ name => 'name', type => 'string', non_empty => 1,
+	  desc => 'The gradient name' },
+        { name => 'segment', type => '0 <= int32',
+          desc => 'The index of the segment within the gradient' },
+        { name => 'pos', type => '0.0 <= float <= 1.0',
+          desc => 'The position to set the guidepoint to' }
+    );
+
+    @outargs = (
+        { name => 'final_pos', type => 'float', void_ret => 1,
+          desc => 'The return position' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  GimpGradient        *gradient;
+  GimpGradientSegment *seg;
+
+  gradient = gradient_get (gimp, name, GIMP_PDB_DATA_ACCESS_WRITE, segment,
+                           &seg, error);
+
+  if (seg)
+    {
+      final_pos =
+        gimp_gradient_segment_set_middle_pos (gradient, seg, pos);
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub gradient_segment_get_blending_function {
+    $blurb = "Retrieves the gradient segment's blending function";
+
+    $help = <<'HELP';
+This procedure retrieves the blending function of the segment at the
+specified gradient name and segment index.
+HELP
+
+    &shlomi_pdb_misc('2003', '2.2');
+
+    @inargs = (
+	{ name => 'name', type => 'string', non_empty => 1,
+	  desc => 'The gradient name' },
+        { name => 'segment', type => '0 <= int32',
+          desc => 'The index of the segment within the gradient' }
+    );
+
+    @outargs = (
+        { name => 'blend_func', type => 'enum GimpGradientSegmentType',
+          void_ret => 1,
+	  desc => 'The blending function of the segment' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  GimpGradient        *gradient;
+  GimpGradientSegment *seg;
+
+  gradient = gradient_get (gimp, name, GIMP_PDB_DATA_ACCESS_READ, segment,
+                           &seg, error);
+
+  if (seg)
+    {
+      blend_func = gimp_gradient_segment_get_blending_function (gradient, seg);
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub gradient_segment_get_coloring_type {
+    $blurb = "Retrieves the gradient segment's coloring type";
+
+    $help = <<'HELP';
+This procedure retrieves the coloring type of the segment at the
+specified gradient name and segment index.
+HELP
+
+    &shlomi_pdb_misc('2003', '2.2');
+
+    @inargs = (
+	{ name => 'name', type => 'string', non_empty => 1,
+	  desc => 'The gradient name' },
+        { name => 'segment', type => '0 <= int32',
+          desc => 'The index of the segment within the gradient' }
+    );
+
+    @outargs = (
+        { name => 'coloring_type', type => 'enum GimpGradientSegmentColor',
+          void_ret => 1,
+	  desc => 'The coloring type of the segment' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  GimpGradient        *gradient;
+  GimpGradientSegment *seg;
+
+  gradient = gradient_get (gimp, name, GIMP_PDB_DATA_ACCESS_READ, segment,
+                           &seg, error);
+
+  if (seg)
+    {
+      coloring_type = gimp_gradient_segment_get_coloring_type (gradient, seg);
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub gradient_segment_range_set_blending_function {
+    $blurb = 'Change the blending function of a segments range';
+
+    $help = <<'HELP';
+This function changes the blending function of a segment range to the
+specified blending function.
+HELP
+
+    &shlomi_pdb_misc('2003', '2.2');
+
+    @inargs = (
+	{ name => 'name', type => 'string', non_empty => 1,
+	  desc => 'The gradient name' },
+        { name => 'start_segment', type => '0 <= int32',
+          desc => 'The index of the first segment to operate on' },
+        { name => 'end_segment', type => 'int32',
+          desc => 'The index of the last segment to operate on. If negative,
+                   the selection will extend to the end of the string.' },
+        { name => 'blending_function', type => 'enum GimpGradientSegmentType',
+          desc => 'The blending function' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  GimpGradient        *gradient;
+  GimpGradientSegment *start_seg;
+  GimpGradientSegment *end_seg;
+
+  gradient = gradient_get_range (gimp, name, start_segment, end_segment,
+                                 &start_seg, &end_seg, error);
+
+  if (start_seg)
+    {
+      gimp_gradient_segment_range_set_blending_function (gradient,
+                                                         start_seg, end_seg,
+                                                         blending_function);
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub gradient_segment_range_set_coloring_type {
+    $blurb = 'Change the coloring type of a segments range';
+
+    $help = <<'HELP';
+This function changes the coloring type of a segment range to the
+specified coloring type.
+HELP
+
+    &shlomi_pdb_misc('2003', '2.2');
+
+    @inargs = (
+	{ name => 'name', type => 'string', non_empty => 1,
+	  desc => 'The gradient name' },
+        { name => 'start_segment', type => '0 <= int32',
+          desc => 'The index of the first segment to operate on' },
+        { name => 'end_segment', type => 'int32',
+          desc => 'The index of the last segment to operate on. If negative,
+                   the selection will extend to the end of the string.' },
+        { name => 'coloring_type', type => 'enum GimpGradientSegmentColor',
+          desc => 'The coloring type' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  GimpGradient        *gradient;
+  GimpGradientSegment *start_seg;
+  GimpGradientSegment *end_seg;
+
+  gradient = gradient_get_range (gimp, name, start_segment, end_segment,
+                                 &start_seg, &end_seg, error);
+
+  if (start_seg)
+    {
+      gimp_gradient_segment_range_set_coloring_type (gradient,
+                                                     start_seg, end_seg,
+                                                     coloring_type);
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub gradient_segment_range_flip {
+    $blurb = 'Flip the segment range';
+    $help  = 'This function flips a segment range.';
+
+    &shlomi_pdb_misc('2003', '2.2');
+
+    @inargs = (
+	{ name => 'name', type => 'string', non_empty => 1,
+	  desc => 'The gradient name' },
+        { name => 'start_segment', type => '0 <= int32',
+          desc => 'The index of the first segment to operate on' },
+        { name => 'end_segment', type => 'int32',
+          desc => 'The index of the last segment to operate on. If negative,
+                   the selection will extend to the end of the string.' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  GimpGradient        *gradient;
+  GimpGradientSegment *start_seg;
+  GimpGradientSegment *end_seg;
+
+  gradient = gradient_get_range (gimp, name, start_segment, end_segment,
+                                 &start_seg, &end_seg, error);
+
+  if (start_seg)
+    {
+      gimp_gradient_segment_range_flip (gradient,
+                                        start_seg, end_seg,
+                                        NULL, NULL);
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub gradient_segment_range_replicate {
+    $blurb = 'Replicate the segment range';
+
+    $help = <<'HELP';
+This function replicates a segment range a given number of times. Instead
+of the original segment range, several smaller scaled copies of it
+will appear in equal widths.
+HELP
+
+    &shlomi_pdb_misc('2003', '2.2');
+
+    @inargs = (
+	{ name => 'name', type => 'string', non_empty => 1,
+	  desc => 'The gradient name' },
+        { name => 'start_segment', type => '0 <= int32',
+          desc => 'The index of the first segment to operate on' },
+        { name => 'end_segment', type => 'int32',
+          desc => 'The index of the last segment to operate on. If negative,
+                   the selection will extend to the end of the string.' },
+        { name => 'replicate_times', type => '2 <= int32 <= 20',
+          desc => 'The number of times to replicate' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  GimpGradient        *gradient;
+  GimpGradientSegment *start_seg;
+  GimpGradientSegment *end_seg;
+
+  gradient = gradient_get_range (gimp, name, start_segment, end_segment,
+                                 &start_seg, &end_seg, error);
+
+  if (start_seg && gimp_data_is_writable (GIMP_DATA (gradient)))
+    {
+      gimp_gradient_segment_range_replicate (gradient,
+                                             start_seg, end_seg,
+                                             replicate_times,
+                                             NULL, NULL);
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub gradient_segment_range_split_midpoint {
+    $blurb = 'Splits each segment in the segment range at midpoint';
+
+    $help = <<'HELP';
+This function splits each segment in the segment range at its midpoint.
+HELP
+
+    &shlomi_pdb_misc('2003', '2.2');
+
+    @inargs = (
+	{ name => 'name', type => 'string', non_empty => 1,
+	  desc => 'The gradient name' },
+        { name => 'start_segment', type => '0 <= int32',
+          desc => 'The index of the first segment to operate on' },
+        { name => 'end_segment', type => 'int32',
+          desc => 'The index of the last segment to operate on. If negative,
+                   the selection will extend to the end of the string.' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  GimpGradient        *gradient;
+  GimpGradientSegment *start_seg;
+  GimpGradientSegment *end_seg;
+
+  gradient = gradient_get_range (gimp, name, start_segment, end_segment,
+                                 &start_seg, &end_seg, error);
+
+  if (start_seg)
+    {
+      gimp_gradient_segment_range_split_midpoint (gradient, context,
+                                                  start_seg, end_seg,
+                                                  GIMP_GRADIENT_BLEND_RGB_PERCEPTUAL,
+                                                  NULL, NULL);
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub gradient_segment_range_split_uniform {
+    $blurb = 'Splits each segment in the segment range uniformly';
+
+    $help = <<'HELP';
+This function splits each segment in the segment range uniformly according
+to the number of times specified by the parameter.
+HELP
+
+    &shlomi_pdb_misc('2003', '2.2');
+
+    @inargs = (
+	{ name => 'name', type => 'string', non_empty => 1,
+	  desc => 'The gradient name' },
+        { name => 'start_segment', type => '0 <= int32',
+          desc => 'The index of the first segment to operate on' },
+        { name => 'end_segment', type => 'int32',
+          desc => 'The index of the last segment to operate on. If negative,
+                   the selection will extend to the end of the string.' },
+        { name => 'split_parts', type => '2 <= int32 <= 1024',
+          desc => 'The number of uniform divisions to split each segment to' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  GimpGradient        *gradient;
+  GimpGradientSegment *start_seg;
+  GimpGradientSegment *end_seg;
+
+  gradient = gradient_get_range (gimp, name, start_segment, end_segment,
+                                 &start_seg, &end_seg, error);
+
+  if (start_seg)
+    {
+      gimp_gradient_segment_range_split_uniform (gradient, context,
+                                                 start_seg, end_seg,
+                                                 split_parts,
+                                                 GIMP_GRADIENT_BLEND_RGB_PERCEPTUAL,
+                                                 NULL, NULL);
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub gradient_segment_range_delete {
+    $blurb = 'Delete the segment range';
+    $help  = 'This function deletes a segment range.';
+
+    &shlomi_pdb_misc('2003', '2.2');
+
+    @inargs = (
+	{ name => 'name', type => 'string', non_empty => 1,
+	  desc => 'The gradient name' },
+        { name => 'start_segment', type => '0 <= int32',
+          desc => 'The index of the first segment to operate on' },
+        { name => 'end_segment', type => 'int32',
+          desc => 'The index of the last segment to operate on. If negative,
+                   the selection will extend to the end of the string.' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  GimpGradient        *gradient;
+  GimpGradientSegment *start_seg;
+  GimpGradientSegment *end_seg;
+
+  gradient = gradient_get_range (gimp, name, start_segment, end_segment,
+                                 &start_seg, &end_seg, error);
+
+  if (start_seg)
+    {
+      gimp_gradient_segment_range_delete (gradient,
+                                          start_seg, end_seg,
+                                          NULL, NULL);
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub gradient_segment_range_redistribute_handles {
+    $blurb = "Uniformly redistribute the segment range's handles";
+
+    $help = <<'HELP';
+This function redistributes the handles of the specified segment range of the
+specified gradient, so they'll be evenly spaced.
+HELP
+
+    &shlomi_pdb_misc('2003', '2.2');
+
+    @inargs = (
+	{ name => 'name', type => 'string', non_empty => 1,
+	  desc => 'The gradient name' },
+        { name => 'start_segment', type => '0 <= int32',
+          desc => 'The index of the first segment to operate on' },
+        { name => 'end_segment', type => 'int32',
+          desc => 'The index of the last segment to operate on. If negative,
+                   the selection will extend to the end of the string.' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  GimpGradient        *gradient;
+  GimpGradientSegment *start_seg;
+  GimpGradientSegment *end_seg;
+
+  gradient = gradient_get_range (gimp, name, start_segment, end_segment,
+                                 &start_seg, &end_seg, error);
+
+  if (start_seg)
+    {
+      gimp_gradient_segment_range_redistribute_handles (gradient,
+                                                        start_seg, end_seg);
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub gradient_segment_range_blend_colors {
+    $blurb = 'Blend the colors of the segment range.';
+
+    $help = <<'HELP';
+This function blends the colors (but not the opacity) of the segments'
+range of the gradient. Using it, the colors' transition will be uniform
+across the range.
+HELP
+
+    &shlomi_pdb_misc('2003', '2.2');
+
+    @inargs = (
+	{ name => 'name', type => 'string', non_empty => 1,
+	  desc => 'The gradient name' },
+        { name => 'start_segment', type => '0 <= int32',
+          desc => 'The index of the first segment to operate on' },
+        { name => 'end_segment', type => 'int32',
+          desc => 'The index of the last segment to operate on. If negative,
+                   the selection will extend to the end of the string.' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  GimpGradient        *gradient;
+  GimpGradientSegment *start_seg;
+  GimpGradientSegment *end_seg;
+
+  gradient = gradient_get_range (gimp, name, start_segment, end_segment,
+                                 &start_seg, &end_seg, error);
+
+  if (start_seg)
+    {
+      if (!end_seg)
+        end_seg = gimp_gradient_segment_get_last (start_seg);
+
+      gimp_gradient_segment_range_blend (gradient,
+                                         start_seg, end_seg,
+                                         &start_seg->left_color,
+                                         &end_seg->right_color,
+                                         TRUE, FALSE);
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub gradient_segment_range_blend_opacity {
+    $blurb = 'Blend the opacity of the segment range.';
+
+    $help = <<'HELP';
+This function blends the opacity (but not the colors) of the segments'
+range of the gradient. Using it, the opacity's transition will be uniform
+across the range.
+HELP
+
+    &shlomi_pdb_misc('2003', '2.2');
+
+    @inargs = (
+	{ name => 'name', type => 'string', non_empty => 1,
+	  desc => 'The gradient name' },
+        { name => 'start_segment', type => '0 <= int32',
+          desc => 'The index of the first segment to operate on' },
+        { name => 'end_segment', type => 'int32',
+          desc => 'The index of the last segment to operate on. If negative,
+                   the selection will extend to the end of the string.' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  GimpGradient        *gradient;
+  GimpGradientSegment *start_seg;
+  GimpGradientSegment *end_seg;
+
+  gradient = gradient_get_range (gimp, name, start_segment, end_segment,
+                                 &start_seg, &end_seg, error);
+
+  if (start_seg)
+    {
+      if (!end_seg)
+        end_seg = gimp_gradient_segment_get_last (start_seg);
+
+      gimp_gradient_segment_range_blend (gradient,
+                                         start_seg, end_seg,
+                                         &start_seg->left_color,
+                                         &end_seg->right_color,
+                                         FALSE, TRUE);
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub gradient_segment_range_move {
+    $blurb = 'Move the position of an entire segment range by a delta.';
+
+    $help = <<'HELP';
+This function moves the position of an entire segment range by a delta. The
+actual delta (which is returned) will be limited by the control points of the
+neighboring segments.
+HELP
+
+    &shlomi_pdb_misc('2003', '2.2');
+
+    @inargs = (
+	{ name => 'name', type => 'string', non_empty => 1,
+	  desc => 'The gradient name' },
+        { name => 'start_segment', type => '0 <= int32',
+          desc => 'The index of the first segment to operate on' },
+        { name => 'end_segment', type => 'int32',
+          desc => 'The index of the last segment to operate on. If negative,
+                   the selection will extend to the end of the string.' },
+        { name => 'delta', type => '-1.0 <= float <= 1.0',
+          desc => 'The delta to move the segment range' },
+        { name => 'control_compress', type => 'boolean',
+          desc => 'Whether or not to compress the neighboring segments' }
+    );
+
+    @outargs = (
+        { name => 'final_delta', type => 'float',
+          desc => 'The final delta by which the range moved' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  GimpGradient        *gradient;
+  GimpGradientSegment *start_seg;
+  GimpGradientSegment *end_seg;
+
+  gradient = gradient_get_range (gimp, name, start_segment, end_segment,
+                                 &start_seg, &end_seg, error);
+
+  if (start_seg)
+    {
+      final_delta = gimp_gradient_segment_range_move (gradient,
+                                                      start_seg, end_seg,
+                                                      delta,
+                                                      control_compress);
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+$extra{app}->{code} = <<'CODE';
+static GimpGradient *
+gradient_get (Gimp                 *gimp,
+              const gchar          *name,
+              GimpPDBDataAccess     access,
+              gint                  segment,
+              GimpGradientSegment **seg,
+              GError              **error)
+{
+  GimpGradient *gradient = gimp_pdb_get_gradient (gimp, name, access, error);
+
+  *seg = NULL;
+
+  if (gradient)
+    *seg = gimp_gradient_segment_get_nth (gradient->segments, segment);
+
+  return gradient;
+}
+
+static GimpGradient *
+gradient_get_range (Gimp                 *gimp,
+                    const gchar          *name,
+                    gint                  start_segment,
+                    gint                  end_segment,
+                    GimpGradientSegment **start_seg,
+                    GimpGradientSegment **end_seg,
+                    GError              **error)
+{
+  GimpGradient *gradient = gimp_pdb_get_gradient (gimp, name, GIMP_PDB_DATA_ACCESS_WRITE, error);
+
+  *start_seg = NULL;
+  *end_seg   = NULL;
+
+  if (end_segment >= 0 && end_segment < start_segment)
+    return NULL;
+
+  if (gradient)
+    {
+      *start_seg = gimp_gradient_segment_get_nth (gradient->segments,
+                                                  start_segment);
+
+      if (*start_seg && end_segment >= 0)
+        *end_seg = gimp_gradient_segment_get_nth (*start_seg,
+                                                  end_segment -
+                                                  start_segment);
+    }
+
+  return gradient;
+}
+CODE
+
+
+@headers = qw(<string.h>
+              "core/gimp.h"
+              "core/gimpcontext.h"
+              "core/gimpgradient.h"
+              "core/gimpdatafactory.h"
+              "gimppdb-utils.h");
+
+@procs = qw(gradient_new
+            gradient_duplicate
+            gradient_is_editable
+            gradient_rename
+            gradient_delete
+            gradient_get_number_of_segments
+            gradient_get_uniform_samples gradient_get_custom_samples
+            gradient_segment_get_left_color gradient_segment_set_left_color
+            gradient_segment_get_right_color gradient_segment_set_right_color
+            gradient_segment_get_left_pos gradient_segment_set_left_pos
+            gradient_segment_get_middle_pos gradient_segment_set_middle_pos
+            gradient_segment_get_right_pos gradient_segment_set_right_pos
+            gradient_segment_get_blending_function
+            gradient_segment_get_coloring_type
+            gradient_segment_range_set_blending_function 
+            gradient_segment_range_set_coloring_type
+            gradient_segment_range_flip
+            gradient_segment_range_replicate
+            gradient_segment_range_split_midpoint
+            gradient_segment_range_split_uniform
+            gradient_segment_range_delete
+            gradient_segment_range_redistribute_handles
+            gradient_segment_range_blend_colors
+            gradient_segment_range_blend_opacity
+            gradient_segment_range_move);
+
+%exports = (app => [@procs], lib => [@procs]);
+
+$desc = 'Gradient';
+$doc_title = 'gimpgradient';
+$doc_short_desc = 'Functions operating on a single gradient.';
+$doc_long_desc = 'Functions operating on a single gradient.';
+
+1;