mirror of https://github.com/GNOME/gimp.git
867 lines
25 KiB
Plaintext
867 lines
25 KiB
Plaintext
# 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 2 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, write to the Free Software
|
|
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
|
|
# "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.
|
|
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 the
|
|
selection contained only transparent pixels' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<CODE
|
|
{
|
|
if (gimp_item_is_attached (GIMP_ITEM (drawable)))
|
|
{
|
|
GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable));
|
|
|
|
non_empty = gimp_edit_cut (image, drawable, context) != NULL;
|
|
}
|
|
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.
|
|
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 copy was successful, FALSE if the
|
|
selection contained only transparent pixels' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<CODE
|
|
{
|
|
if (gimp_item_is_attached (GIMP_ITEM (drawable)))
|
|
{
|
|
GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable));
|
|
|
|
non_empty = gimp_edit_copy (image, drawable, context) != NULL;
|
|
}
|
|
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, FALSE if the
|
|
selection contained only transparent pixels' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<CODE
|
|
{
|
|
non_empty = gimp_edit_copy_visible (image, context) != NULL;
|
|
}
|
|
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 it's 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
|
|
{
|
|
if (gimp->global_buffer && gimp_item_is_attached (GIMP_ITEM (drawable)))
|
|
{
|
|
floating_sel = gimp_edit_paste (gimp_item_get_image (GIMP_ITEM (drawable)),
|
|
drawable, gimp->global_buffer,
|
|
paste_into, -1, -1, -1, -1);
|
|
|
|
if (! floating_sel)
|
|
success = FALSE;
|
|
}
|
|
else
|
|
success = FALSE;
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub edit_paste_as_new {
|
|
$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.
|
|
HELP
|
|
|
|
&mitch_pdb_misc('2005', '2.4');
|
|
|
|
@outargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The new image' }
|
|
);
|
|
%invoke = (
|
|
code => <<CODE
|
|
{
|
|
if (gimp->global_buffer)
|
|
{
|
|
image = gimp_edit_paste_as_new (gimp, NULL, gimp->global_buffer);
|
|
|
|
if (! image)
|
|
success = FALSE;
|
|
}
|
|
else
|
|
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',
|
|
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
|
|
selection contained only transparent pixels' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<CODE
|
|
{
|
|
if (strlen (buffer_name) && gimp_item_is_attached (GIMP_ITEM (drawable)))
|
|
{
|
|
GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable));
|
|
|
|
real_name = (gchar *) gimp_edit_named_cut (image, buffer_name,
|
|
drawable, context);
|
|
|
|
if (real_name)
|
|
real_name = g_strdup (real_name);
|
|
else
|
|
success = FALSE;
|
|
}
|
|
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',
|
|
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
|
|
selection contained only transparent pixels' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<CODE
|
|
{
|
|
if (strlen (buffer_name) && gimp_item_is_attached (GIMP_ITEM (drawable)))
|
|
{
|
|
GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable));
|
|
|
|
real_name = (gchar *) gimp_edit_named_copy (image, buffer_name,
|
|
drawable, context);
|
|
|
|
if (real_name)
|
|
real_name = g_strdup (real_name);
|
|
else
|
|
success = FALSE;
|
|
}
|
|
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',
|
|
desc => 'The name of the buffer to create' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'real_name', type => 'string',
|
|
desc => 'The real name given to the buffer' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<CODE
|
|
{
|
|
if (strlen (buffer_name))
|
|
{
|
|
real_name = (gchar *) gimp_edit_named_copy_visible (image, buffer_name,
|
|
context);
|
|
|
|
if (real_name)
|
|
real_name = g_strdup (real_name);
|
|
else
|
|
success = FALSE;
|
|
}
|
|
else
|
|
success = FALSE;
|
|
}
|
|
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 = (GimpBuffer *)
|
|
gimp_container_get_child_by_name (gimp->named_buffers, buffer_name);
|
|
|
|
if (buffer && gimp_item_is_attached (GIMP_ITEM (drawable)))
|
|
{
|
|
floating_sel = gimp_edit_paste (gimp_item_get_image (GIMP_ITEM (drawable)),
|
|
drawable, buffer,
|
|
paste_into, -1, -1, -1, -1);
|
|
if (! floating_sel)
|
|
success = FALSE;
|
|
}
|
|
else
|
|
success = FALSE;
|
|
}
|
|
CODE
|
|
)
|
|
}
|
|
|
|
sub edit_named_paste_as_new {
|
|
$blurb = 'Paste named buffer to a new image.';
|
|
|
|
$help = <<'HELP';
|
|
This procedure works like gimp_edit_paste_as_new() but pastes a named buffer
|
|
instead of the global buffer.
|
|
HELP
|
|
|
|
&mitch_pdb_misc('2005', '2.4');
|
|
|
|
@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 = (GimpBuffer *)
|
|
gimp_container_get_child_by_name (gimp->named_buffers, buffer_name);
|
|
|
|
if (buffer)
|
|
{
|
|
image = gimp_edit_paste_as_new (gimp, NULL, 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;
|
|
|
|
@inargs = (
|
|
{ name => 'drawable', type => 'drawable',
|
|
desc => 'The drawable to clear from' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<CODE
|
|
{
|
|
if (gimp_item_is_attached (GIMP_ITEM (drawable)))
|
|
{
|
|
GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable));
|
|
|
|
success = gimp_edit_clear (image, 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';
|
|
|
|
@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_item_is_attached (GIMP_ITEM (drawable)))
|
|
{
|
|
GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable));
|
|
|
|
success = gimp_edit_fill (image, drawable, context,
|
|
(GimpFillType) fill_type);
|
|
}
|
|
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;
|
|
|
|
@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 GimpLayerModeEffects',
|
|
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_item_is_attached (GIMP_ITEM (drawable)))
|
|
{
|
|
GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable));
|
|
gboolean do_seed_fill;
|
|
|
|
do_seed_fill = gimp_channel_is_empty (gimp_image_get_mask (image));
|
|
|
|
gimp_drawable_bucket_fill (drawable, context, fill_mode,
|
|
paint_mode, opacity / 100.0,
|
|
do_seed_fill,
|
|
FALSE /* don't fill transparent */,
|
|
GIMP_SELECT_CRITERION_COMPOSITE,
|
|
threshold, sample_merged, x, y);
|
|
}
|
|
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');
|
|
|
|
@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 GimpLayerModeEffects',
|
|
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_item_is_attached (GIMP_ITEM (drawable)))
|
|
{
|
|
GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable));
|
|
gboolean do_seed_fill;
|
|
|
|
do_seed_fill = gimp_channel_is_empty (gimp_image_get_mask (image));
|
|
|
|
gimp_drawable_bucket_fill (drawable, context, fill_mode,
|
|
paint_mode, opacity / 100.0,
|
|
do_seed_fill,
|
|
fill_transparent,
|
|
select_criterion,
|
|
threshold, sample_merged, x, y);
|
|
}
|
|
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.
|
|
HELP
|
|
|
|
&std_pdb_misc;
|
|
|
|
@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 GimpLayerModeEffects',
|
|
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_success => 1,
|
|
desc => 'Maximum recursion levels for supersampling' },
|
|
{ name => 'threshold', type => '0 <= float <= 4', no_success => 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/gimpdrawable-blend.h") ],
|
|
code => <<'CODE'
|
|
{
|
|
success = gimp_item_is_attached (GIMP_ITEM (drawable));
|
|
|
|
if (success && supersample)
|
|
{
|
|
if (max_depth < 1 || max_depth > 9)
|
|
success = FALSE;
|
|
|
|
if (threshold < 0.0 || threshold > 4.0)
|
|
success = FALSE;
|
|
}
|
|
|
|
if (success)
|
|
{
|
|
if (progress)
|
|
gimp_progress_start (progress, _("Blending"), FALSE);
|
|
|
|
gimp_drawable_blend (drawable,
|
|
context,
|
|
blend_mode,
|
|
paint_mode,
|
|
gradient_type,
|
|
opacity / 100.0,
|
|
offset, repeat, reverse,
|
|
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;
|
|
|
|
@inargs = (
|
|
{ name => 'drawable', type => 'drawable',
|
|
desc => 'The drawable to stroke to' }
|
|
);
|
|
|
|
%invoke = (
|
|
headers => [ qw("core/gimpstrokedesc.h") ],
|
|
code => <<'CODE'
|
|
{
|
|
if (gimp_item_is_attached (GIMP_ITEM (drawable)))
|
|
{
|
|
GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable));
|
|
GimpStrokeDesc *desc = gimp_stroke_desc_new (gimp, context);
|
|
|
|
g_object_set (desc, "method", GIMP_STROKE_METHOD_PAINT_CORE, NULL);
|
|
|
|
success = gimp_item_stroke (GIMP_ITEM (gimp_image_get_mask (image)),
|
|
drawable, context, desc, TRUE);
|
|
|
|
g_object_unref (desc);
|
|
}
|
|
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');
|
|
|
|
@inargs = (
|
|
{ name => 'drawable', type => 'drawable',
|
|
desc => 'The drawable to stroke to' },
|
|
{ name => 'vectors', type => 'vectors',
|
|
desc => 'The vectors object' }
|
|
);
|
|
|
|
%invoke = (
|
|
headers => [ qw("core/gimpstrokedesc.h") ],
|
|
code => <<'CODE'
|
|
{
|
|
if (gimp_item_is_attached (GIMP_ITEM (drawable)))
|
|
{
|
|
GimpStrokeDesc *desc = gimp_stroke_desc_new (gimp, context);
|
|
|
|
g_object_set (desc, "method", GIMP_STROKE_METHOD_PAINT_CORE, NULL);
|
|
|
|
success = gimp_item_stroke (GIMP_ITEM (vectors),
|
|
drawable, context, desc, TRUE);
|
|
|
|
g_object_unref (desc);
|
|
}
|
|
else
|
|
success = FALSE;
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
|
|
@headers = qw(<string.h>
|
|
"core/gimp.h"
|
|
"core/gimp-edit.h"
|
|
"core/gimpcontainer.h"
|
|
"core/gimpimage.h"
|
|
"core/gimpprogress.h"
|
|
"gimp-intl.h");
|
|
|
|
@procs = qw(edit_cut edit_copy edit_copy_visible
|
|
edit_paste edit_paste_as_new
|
|
edit_named_cut edit_named_copy edit_named_copy_visible
|
|
edit_named_paste edit_named_paste_as_new
|
|
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';
|
|
|
|
1;
|