2006-12-09 21:33:38 +00:00
|
|
|
# GIMP - The GNU Image Manipulation Program
|
1998-10-24 05:21:56 +00:00
|
|
|
# Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
|
|
|
|
2009-01-17 22:28:01 +00:00
|
|
|
# This program is free software: you can redistribute it and/or modify
|
1998-10-24 05:21:56 +00:00
|
|
|
# it under the terms of the GNU General Public License as published by
|
2009-01-17 22:28:01 +00:00
|
|
|
# the Free Software Foundation; either version 3 of the License, or
|
1998-10-24 05:21:56 +00:00
|
|
|
# (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
|
2009-01-17 22:28:01 +00:00
|
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
1998-10-24 05:21:56 +00:00
|
|
|
|
|
|
|
# "Perlized" from C source by Manish Singh <yosh@gimp.org>
|
|
|
|
|
|
|
|
sub edit_cut {
|
|
|
|
$blurb = 'Cut from the specified drawable.';
|
|
|
|
|
|
|
|
$help = <<'HELP';
|
2006-03-14 21:35:50 +00:00
|
|
|
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
|
2008-07-14 22:52:14 +00:00
|
|
|
GIMP edit buffer. It can subsequently be retrieved using the
|
2006-06-14 08:32:08 +00:00
|
|
|
gimp_edit_paste() command. If there is no selection, then the
|
2006-03-14 21:35:50 +00:00
|
|
|
specified drawable will be removed and its contents stored in the
|
2008-07-14 22:52:14 +00:00
|
|
|
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.
|
1998-10-24 05:21:56 +00:00
|
|
|
HELP
|
|
|
|
|
|
|
|
&std_pdb_misc;
|
2005-09-02 22:50:06 +00:00
|
|
|
|
|
|
|
@inargs = (
|
|
|
|
{ name => 'drawable', type => 'drawable',
|
|
|
|
desc => 'The drawable to cut from' }
|
|
|
|
);
|
|
|
|
|
|
|
|
@outargs = (
|
2006-03-15 15:32:39 +00:00
|
|
|
{ name => 'non_empty', type => 'boolean',
|
2008-07-14 22:52:14 +00:00
|
|
|
desc => 'TRUE if the cut was successful,
|
|
|
|
FALSE if there was nothing to copy from' }
|
2005-09-02 22:50:06 +00:00
|
|
|
);
|
|
|
|
|
2006-03-14 21:35:50 +00:00
|
|
|
%invoke = (
|
|
|
|
code => <<CODE
|
|
|
|
{
|
2012-11-08 19:46:18 +00:00
|
|
|
if (gimp_pdb_item_is_attached (GIMP_ITEM (drawable), NULL,
|
|
|
|
GIMP_PDB_ITEM_CONTENT, error) &&
|
2009-08-29 07:16:35 +00:00
|
|
|
gimp_pdb_item_is_not_group (GIMP_ITEM (drawable), error))
|
2006-03-14 21:35:50 +00:00
|
|
|
{
|
2007-12-14 13:58:10 +00:00
|
|
|
GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable));
|
|
|
|
GError *my_error = NULL;
|
2006-03-14 21:35:50 +00:00
|
|
|
|
2007-12-14 13:58:10 +00:00
|
|
|
non_empty = gimp_edit_cut (image, drawable, context, &my_error) != NULL;
|
|
|
|
|
|
|
|
if (! non_empty)
|
|
|
|
{
|
2008-11-04 12:33:09 +00:00
|
|
|
gimp_message_literal (gimp,
|
|
|
|
G_OBJECT (progress), GIMP_MESSAGE_WARNING,
|
|
|
|
my_error->message);
|
2007-12-14 13:58:10 +00:00
|
|
|
g_clear_error (&my_error);
|
|
|
|
}
|
2006-03-14 21:35:50 +00:00
|
|
|
}
|
2006-03-24 21:57:47 +00:00
|
|
|
else
|
|
|
|
success = FALSE;
|
2006-03-14 21:35:50 +00:00
|
|
|
}
|
|
|
|
CODE
|
|
|
|
);
|
1998-10-24 05:21:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
sub edit_copy {
|
|
|
|
$blurb = 'Copy from the specified drawable.';
|
|
|
|
|
|
|
|
$help = <<'HELP';
|
2006-03-14 21:35:50 +00:00
|
|
|
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
|
2006-06-14 08:32:08 +00:00
|
|
|
gimp_edit_paste() command. If there is no selection, then the
|
2006-03-14 21:35:50 +00:00
|
|
|
specified drawable's contents will be stored in the internal GIMP edit
|
2008-07-14 22:52:14 +00:00
|
|
|
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.
|
1998-10-24 05:21:56 +00:00
|
|
|
HELP
|
|
|
|
|
|
|
|
&std_pdb_misc;
|
2005-09-02 22:50:06 +00:00
|
|
|
|
|
|
|
@inargs = (
|
|
|
|
{ name => 'drawable', type => 'drawable',
|
|
|
|
desc => 'The drawable to copy from' }
|
|
|
|
);
|
|
|
|
|
|
|
|
@outargs = (
|
2006-03-15 15:32:39 +00:00
|
|
|
{ name => 'non_empty', type => 'boolean',
|
2008-07-14 22:52:14 +00:00
|
|
|
desc => 'TRUE if the cut was successful,
|
|
|
|
FALSE if there was nothing to copy from' }
|
2005-09-02 22:50:06 +00:00
|
|
|
);
|
|
|
|
|
2006-03-14 21:35:50 +00:00
|
|
|
%invoke = (
|
|
|
|
code => <<CODE
|
|
|
|
{
|
2012-11-08 19:46:18 +00:00
|
|
|
if (gimp_pdb_item_is_attached (GIMP_ITEM (drawable), NULL, 0, error))
|
2006-03-14 21:35:50 +00:00
|
|
|
{
|
2007-12-14 13:58:10 +00:00
|
|
|
GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable));
|
|
|
|
GError *my_error = NULL;
|
|
|
|
|
|
|
|
non_empty = gimp_edit_copy (image, drawable, context, &my_error) != NULL;
|
2006-03-14 21:35:50 +00:00
|
|
|
|
2007-12-14 13:58:10 +00:00
|
|
|
if (! non_empty)
|
|
|
|
{
|
2008-11-04 12:33:09 +00:00
|
|
|
gimp_message_literal (gimp,
|
|
|
|
G_OBJECT (progress), GIMP_MESSAGE_WARNING,
|
|
|
|
my_error->message);
|
2007-12-14 13:58:10 +00:00
|
|
|
g_clear_error (&my_error);
|
|
|
|
}
|
2006-03-14 21:35:50 +00:00
|
|
|
}
|
2006-03-24 21:57:47 +00:00
|
|
|
else
|
|
|
|
success = FALSE;
|
2006-03-14 21:35:50 +00:00
|
|
|
}
|
|
|
|
CODE
|
|
|
|
);
|
1998-10-24 05:21:56 +00:00
|
|
|
}
|
|
|
|
|
2004-12-12 14:01:08 +00:00
|
|
|
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
|
2006-06-14 08:32:08 +00:00
|
|
|
gimp_edit_paste() command. If there is no selection, then the
|
2004-12-12 14:01:08 +00:00
|
|
|
projection's contents will be stored in the internal GIMP edit buffer.
|
|
|
|
HELP
|
|
|
|
|
2006-03-14 21:35:50 +00:00
|
|
|
&mitch_pdb_misc('2004', '2.2');
|
2004-12-12 14:01:08 +00:00
|
|
|
|
|
|
|
@inargs = (
|
|
|
|
{ name => 'image', type => 'image',
|
|
|
|
desc => "The image to copy from" }
|
|
|
|
);
|
2005-09-02 22:50:06 +00:00
|
|
|
|
|
|
|
@outargs = (
|
2006-03-15 15:32:39 +00:00
|
|
|
{ name => 'non_empty', type => 'boolean',
|
2008-07-14 22:52:14 +00:00
|
|
|
desc => 'TRUE if the copy was successful' }
|
2005-09-02 22:50:06 +00:00
|
|
|
);
|
2004-12-12 14:01:08 +00:00
|
|
|
|
|
|
|
%invoke = (
|
|
|
|
code => <<CODE
|
|
|
|
{
|
2007-12-14 13:58:10 +00:00
|
|
|
GError *my_error = NULL;
|
|
|
|
|
|
|
|
non_empty = gimp_edit_copy_visible (image, context, &my_error) != NULL;
|
|
|
|
|
|
|
|
if (! non_empty)
|
|
|
|
{
|
2008-11-04 12:33:09 +00:00
|
|
|
gimp_message_literal (gimp,
|
|
|
|
G_OBJECT (progress), GIMP_MESSAGE_WARNING,
|
|
|
|
my_error->message);
|
2007-12-14 13:58:10 +00:00
|
|
|
g_clear_error (&my_error);
|
|
|
|
}
|
2004-12-12 14:01:08 +00:00
|
|
|
}
|
|
|
|
CODE
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
1998-10-24 05:21:56 +00:00
|
|
|
sub edit_paste {
|
|
|
|
$blurb = 'Paste buffer to the specified drawable.';
|
|
|
|
|
|
|
|
$help = <<'HELP';
|
2006-03-14 21:35:50 +00:00
|
|
|
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
|
2006-06-14 08:32:08 +00:00
|
|
|
was previously made to either gimp_edit_cut() or gimp_edit_copy(). The
|
2006-03-14 21:35:50 +00:00
|
|
|
"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
|
2016-09-20 16:53:57 +00:00
|
|
|
will be anchored to its drawable before the new floating selection is
|
2006-03-14 21:35:50 +00:00
|
|
|
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.
|
1998-10-24 05:21:56 +00:00
|
|
|
HELP
|
|
|
|
|
|
|
|
&std_pdb_misc;
|
|
|
|
|
2005-09-02 22:50:06 +00:00
|
|
|
@inargs = (
|
|
|
|
{ name => 'drawable', type => 'drawable',
|
|
|
|
desc => 'The drawable to paste to' },
|
|
|
|
{ name => 'paste_into', type => 'boolean',
|
|
|
|
desc => 'Clear selection, or paste behind it?' }
|
|
|
|
);
|
1998-10-24 05:21:56 +00:00
|
|
|
|
|
|
|
@outargs = (
|
|
|
|
{ name => 'floating_sel', type => 'layer',
|
2006-03-15 15:32:39 +00:00
|
|
|
desc => 'The new floating selection' }
|
1998-10-24 05:21:56 +00:00
|
|
|
);
|
|
|
|
|
2004-01-26 15:34:47 +00:00
|
|
|
%invoke = (
|
|
|
|
code => <<CODE
|
|
|
|
{
|
2017-04-19 19:44:08 +00:00
|
|
|
GimpObject *paste = gimp_get_clipboard_object (gimp);
|
2016-09-17 15:39:54 +00:00
|
|
|
|
2017-04-19 19:44:08 +00:00
|
|
|
if (paste &&
|
2012-11-08 19:46:18 +00:00
|
|
|
gimp_pdb_item_is_attached (GIMP_ITEM (drawable), NULL,
|
|
|
|
GIMP_PDB_ITEM_CONTENT, error) &&
|
2009-08-29 07:16:35 +00:00
|
|
|
gimp_pdb_item_is_not_group (GIMP_ITEM (drawable), error))
|
2004-01-26 15:34:47 +00:00
|
|
|
{
|
2006-03-15 15:00:01 +00:00
|
|
|
floating_sel = gimp_edit_paste (gimp_item_get_image (GIMP_ITEM (drawable)),
|
2017-04-19 19:44:08 +00:00
|
|
|
drawable, paste,
|
2016-09-19 21:53:40 +00:00
|
|
|
paste_into ?
|
|
|
|
GIMP_PASTE_TYPE_FLOATING_INTO :
|
|
|
|
GIMP_PASTE_TYPE_FLOATING,
|
|
|
|
-1, -1, -1, -1);
|
2006-03-24 21:57:47 +00:00
|
|
|
|
2006-03-15 15:00:01 +00:00
|
|
|
if (! floating_sel)
|
2004-01-26 15:34:47 +00:00
|
|
|
success = FALSE;
|
|
|
|
}
|
2006-03-24 21:57:47 +00:00
|
|
|
else
|
|
|
|
success = FALSE;
|
2004-01-26 15:34:47 +00:00
|
|
|
}
|
2005-09-02 22:50:06 +00:00
|
|
|
CODE
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2016-09-20 18:20:25 +00:00
|
|
|
sub edit_paste_as_new_image {
|
2005-09-02 22:50:06 +00:00
|
|
|
$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
|
2006-06-14 08:32:08 +00:00
|
|
|
previously made to either gimp_edit_cut() or gimp_edit_copy(). This
|
2007-05-06 04:42:51 +00:00
|
|
|
procedure returns the new image or -1 if the edit buffer was empty.
|
2005-09-02 22:50:06 +00:00
|
|
|
HELP
|
|
|
|
|
2016-09-20 18:20:25 +00:00
|
|
|
&mitch_pdb_misc('2005', '2.10');
|
2005-09-02 22:50:06 +00:00
|
|
|
|
|
|
|
@outargs = (
|
2006-03-15 15:32:39 +00:00
|
|
|
{ name => 'image', type => 'image',
|
2005-09-02 22:50:06 +00:00
|
|
|
desc => 'The new image' }
|
|
|
|
);
|
|
|
|
%invoke = (
|
|
|
|
code => <<CODE
|
|
|
|
{
|
2017-04-19 19:44:08 +00:00
|
|
|
GimpObject *paste = gimp_get_clipboard_object (gimp);
|
2016-09-17 15:39:54 +00:00
|
|
|
|
2017-04-19 19:44:08 +00:00
|
|
|
if (paste)
|
2005-09-02 22:50:06 +00:00
|
|
|
{
|
2017-04-19 19:44:08 +00:00
|
|
|
if (GIMP_IS_IMAGE (paste))
|
|
|
|
{
|
|
|
|
image = gimp_image_duplicate (GIMP_IMAGE (paste));
|
|
|
|
}
|
|
|
|
else if (GIMP_IS_BUFFER (paste))
|
|
|
|
{
|
2017-05-01 16:36:33 +00:00
|
|
|
image = gimp_image_new_from_buffer (gimp, GIMP_BUFFER (paste));
|
2017-04-19 19:44:08 +00:00
|
|
|
}
|
2006-03-24 21:57:47 +00:00
|
|
|
|
2005-09-02 22:50:06 +00:00
|
|
|
if (! image)
|
|
|
|
success = FALSE;
|
|
|
|
}
|
2006-03-24 21:57:47 +00:00
|
|
|
else
|
2007-05-06 04:42:51 +00:00
|
|
|
{
|
|
|
|
image = NULL;
|
|
|
|
}
|
2005-09-02 22:50:06 +00:00
|
|
|
}
|
|
|
|
CODE
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
sub edit_named_cut {
|
|
|
|
$blurb = 'Cut into a named buffer.';
|
|
|
|
|
|
|
|
$help = <<'HELP';
|
2006-06-14 08:32:08 +00:00
|
|
|
This procedure works like gimp_edit_cut(), but additionally stores the
|
2006-03-14 21:35:50 +00:00
|
|
|
cut buffer into a named buffer that will stay available for later
|
|
|
|
pasting, regardless of any intermediate copy or cut operations.
|
2005-09-02 22:50:06 +00:00
|
|
|
HELP
|
|
|
|
|
2006-03-14 21:35:50 +00:00
|
|
|
&mitch_pdb_misc('2005', '2.4');
|
2005-09-02 22:50:06 +00:00
|
|
|
|
|
|
|
@inargs = (
|
|
|
|
{ name => 'drawable', type => 'drawable',
|
|
|
|
desc => "The drawable to cut from" },
|
2007-04-25 14:23:05 +00:00
|
|
|
{ name => 'buffer_name', type => 'string', non_empty => 1,
|
2005-09-02 22:50:06 +00:00
|
|
|
desc => 'The name of the buffer to create' }
|
|
|
|
);
|
2016-09-20 18:20:25 +00:00
|
|
|
|
2005-09-02 22:50:06 +00:00
|
|
|
@outargs = (
|
2006-03-15 15:32:39 +00:00
|
|
|
{ name => 'real_name', type => 'string',
|
2006-03-14 21:35:50 +00:00
|
|
|
desc => 'The real name given to the buffer, or NULL if the
|
2008-07-14 22:52:14 +00:00
|
|
|
cut failed' }
|
2005-09-02 22:50:06 +00:00
|
|
|
);
|
|
|
|
|
|
|
|
%invoke = (
|
|
|
|
code => <<CODE
|
|
|
|
{
|
2012-11-08 19:46:18 +00:00
|
|
|
if (gimp_pdb_item_is_attached (GIMP_ITEM (drawable), NULL,
|
|
|
|
GIMP_PDB_ITEM_CONTENT, error) &&
|
2009-08-29 07:16:35 +00:00
|
|
|
gimp_pdb_item_is_not_group (GIMP_ITEM (drawable), error))
|
2006-03-24 21:57:47 +00:00
|
|
|
{
|
2007-12-14 13:58:10 +00:00
|
|
|
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
|
|
|
|
{
|
2008-11-04 12:33:09 +00:00
|
|
|
gimp_message_literal (gimp,
|
|
|
|
G_OBJECT (progress), GIMP_MESSAGE_WARNING,
|
|
|
|
my_error->message);
|
2007-12-14 13:58:10 +00:00
|
|
|
g_clear_error (&my_error);
|
|
|
|
}
|
2006-03-24 21:57:47 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
success = FALSE;
|
2005-09-02 22:50:06 +00:00
|
|
|
}
|
|
|
|
CODE
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
sub edit_named_copy {
|
|
|
|
$blurb = 'Copy into a named buffer.';
|
|
|
|
|
|
|
|
$help = <<'HELP';
|
2006-06-14 08:32:08 +00:00
|
|
|
This procedure works like gimp_edit_copy(), but additionally stores the
|
2006-03-14 21:35:50 +00:00
|
|
|
copied buffer into a named buffer that will stay available for later
|
|
|
|
pasting, regardless of any intermediate copy or cut operations.
|
2005-09-02 22:50:06 +00:00
|
|
|
HELP
|
|
|
|
|
2006-03-14 21:35:50 +00:00
|
|
|
&mitch_pdb_misc('2005', '2.4');
|
2005-09-02 22:50:06 +00:00
|
|
|
|
|
|
|
@inargs = (
|
|
|
|
{ name => 'drawable', type => 'drawable',
|
|
|
|
desc => "The drawable to copy from" },
|
2007-04-25 14:23:05 +00:00
|
|
|
{ name => 'buffer_name', type => 'string', non_empty => 1,
|
2005-09-02 22:50:06 +00:00
|
|
|
desc => 'The name of the buffer to create' }
|
|
|
|
);
|
2016-09-20 18:20:25 +00:00
|
|
|
|
2005-09-02 22:50:06 +00:00
|
|
|
@outargs = (
|
2006-03-15 15:32:39 +00:00
|
|
|
{ name => 'real_name', type => 'string',
|
2006-03-14 21:35:50 +00:00
|
|
|
desc => 'The real name given to the buffer, or NULL if the
|
2008-07-14 22:52:14 +00:00
|
|
|
copy failed' }
|
2005-09-02 22:50:06 +00:00
|
|
|
);
|
|
|
|
|
|
|
|
%invoke = (
|
|
|
|
code => <<CODE
|
|
|
|
{
|
2012-11-08 19:46:18 +00:00
|
|
|
if (gimp_pdb_item_is_attached (GIMP_ITEM (drawable), NULL, 0, error))
|
2006-03-24 21:57:47 +00:00
|
|
|
{
|
2007-12-14 13:58:10 +00:00
|
|
|
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
|
|
|
|
{
|
2008-11-04 12:33:09 +00:00
|
|
|
gimp_message_literal (gimp,
|
|
|
|
G_OBJECT (progress), GIMP_MESSAGE_WARNING,
|
|
|
|
my_error->message);
|
2007-12-14 13:58:10 +00:00
|
|
|
g_clear_error (&my_error);
|
|
|
|
}
|
2006-03-24 21:57:47 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
success = FALSE;
|
2005-09-02 22:50:06 +00:00
|
|
|
}
|
|
|
|
CODE
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
sub edit_named_copy_visible {
|
|
|
|
$blurb = 'Copy from the projection into a named buffer.';
|
|
|
|
|
|
|
|
$help = <<'HELP';
|
2006-06-14 08:32:08 +00:00
|
|
|
This procedure works like gimp_edit_copy_visible(), but additionally
|
2006-03-14 21:35:50 +00:00
|
|
|
stores the copied buffer into a named buffer that will stay available
|
|
|
|
for later pasting, regardless of any intermediate copy or cut
|
|
|
|
operations.
|
2005-09-02 22:50:06 +00:00
|
|
|
HELP
|
|
|
|
|
2006-03-14 21:35:50 +00:00
|
|
|
&mitch_pdb_misc('2005', '2.4');
|
2005-09-02 22:50:06 +00:00
|
|
|
|
|
|
|
@inargs = (
|
|
|
|
{ name => 'image', type => 'image',
|
|
|
|
desc => "The image to copy from" },
|
2007-04-25 14:23:05 +00:00
|
|
|
{ name => 'buffer_name', type => 'string', non_empty => 1,
|
2005-09-02 22:50:06 +00:00
|
|
|
desc => 'The name of the buffer to create' }
|
|
|
|
);
|
2005-09-05 18:59:19 +00:00
|
|
|
|
2005-09-02 22:50:06 +00:00
|
|
|
@outargs = (
|
2006-03-15 15:32:39 +00:00
|
|
|
{ name => 'real_name', type => 'string',
|
2007-12-14 13:58:10 +00:00
|
|
|
desc => 'The real name given to the buffer, or NULL if the
|
2008-07-14 22:52:14 +00:00
|
|
|
copy failed' }
|
2005-09-02 22:50:06 +00:00
|
|
|
);
|
|
|
|
|
|
|
|
%invoke = (
|
|
|
|
code => <<CODE
|
|
|
|
{
|
2007-12-14 13:58:10 +00:00
|
|
|
GError *my_error = NULL;
|
|
|
|
|
2007-04-25 14:23:05 +00:00
|
|
|
real_name = (gchar *) gimp_edit_named_copy_visible (image, buffer_name,
|
2007-12-14 13:58:10 +00:00
|
|
|
context, &my_error);
|
2005-09-02 22:50:06 +00:00
|
|
|
|
2007-04-25 14:23:05 +00:00
|
|
|
if (real_name)
|
2007-12-14 13:58:10 +00:00
|
|
|
{
|
|
|
|
real_name = g_strdup (real_name);
|
|
|
|
}
|
2006-03-24 21:57:47 +00:00
|
|
|
else
|
2007-12-14 13:58:10 +00:00
|
|
|
{
|
2008-11-04 12:33:09 +00:00
|
|
|
gimp_message_literal (gimp,
|
|
|
|
G_OBJECT (progress), GIMP_MESSAGE_WARNING,
|
|
|
|
my_error->message);
|
2007-12-14 13:58:10 +00:00
|
|
|
g_clear_error (&my_error);
|
|
|
|
}
|
2005-09-02 22:50:06 +00:00
|
|
|
}
|
|
|
|
CODE
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
sub edit_named_paste {
|
|
|
|
$blurb = 'Paste named buffer to the specified drawable.';
|
|
|
|
|
|
|
|
$help = <<'HELP';
|
2006-06-14 08:32:08 +00:00
|
|
|
This procedure works like gimp_edit_paste() but pastes a named buffer
|
2006-03-14 21:35:50 +00:00
|
|
|
instead of the global buffer.
|
2005-09-02 22:50:06 +00:00
|
|
|
HELP
|
|
|
|
|
2006-03-14 21:35:50 +00:00
|
|
|
&mitch_pdb_misc('2005', '2.4');
|
2005-09-02 22:50:06 +00:00
|
|
|
|
|
|
|
@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',
|
2006-03-15 15:32:39 +00:00
|
|
|
desc => 'The new floating selection' }
|
2005-09-02 22:50:06 +00:00
|
|
|
);
|
|
|
|
|
|
|
|
%invoke = (
|
|
|
|
code => <<CODE
|
|
|
|
{
|
2007-12-14 14:00:49 +00:00
|
|
|
GimpBuffer *buffer = gimp_pdb_get_buffer (gimp, buffer_name, error);
|
2005-09-02 22:50:06 +00:00
|
|
|
|
2009-08-29 07:16:35 +00:00
|
|
|
if (buffer &&
|
2012-11-08 19:46:18 +00:00
|
|
|
gimp_pdb_item_is_attached (GIMP_ITEM (drawable), NULL,
|
|
|
|
GIMP_PDB_ITEM_CONTENT, error) &&
|
2009-08-29 07:16:35 +00:00
|
|
|
gimp_pdb_item_is_not_group (GIMP_ITEM (drawable), error))
|
2005-09-02 22:50:06 +00:00
|
|
|
{
|
2006-03-15 15:00:01 +00:00
|
|
|
floating_sel = gimp_edit_paste (gimp_item_get_image (GIMP_ITEM (drawable)),
|
2016-09-19 21:53:40 +00:00
|
|
|
drawable, GIMP_OBJECT (buffer),
|
|
|
|
paste_into ?
|
|
|
|
GIMP_PASTE_TYPE_FLOATING_INTO :
|
|
|
|
GIMP_PASTE_TYPE_FLOATING,
|
|
|
|
-1, -1, -1, -1);
|
2006-03-15 15:00:01 +00:00
|
|
|
if (! floating_sel)
|
2005-09-02 22:50:06 +00:00
|
|
|
success = FALSE;
|
|
|
|
}
|
2006-03-24 21:57:47 +00:00
|
|
|
else
|
|
|
|
success = FALSE;
|
2005-09-02 22:50:06 +00:00
|
|
|
}
|
2004-01-26 15:34:47 +00:00
|
|
|
CODE
|
|
|
|
)
|
1998-10-24 05:21:56 +00:00
|
|
|
}
|
|
|
|
|
2016-09-20 18:20:25 +00:00
|
|
|
sub edit_named_paste_as_new_image {
|
2005-09-02 22:50:06 +00:00
|
|
|
$blurb = 'Paste named buffer to a new image.';
|
|
|
|
|
|
|
|
$help = <<'HELP';
|
2016-09-20 18:20:25 +00:00
|
|
|
This procedure works like gimp_edit_paste_as_new_image() but pastes a
|
|
|
|
named buffer instead of the global buffer.
|
2005-09-02 22:50:06 +00:00
|
|
|
HELP
|
|
|
|
|
2016-09-20 18:20:25 +00:00
|
|
|
&mitch_pdb_misc('2005', '2.10');
|
2005-09-02 22:50:06 +00:00
|
|
|
|
|
|
|
@inargs = (
|
|
|
|
{ name => 'buffer_name', type => 'string',
|
|
|
|
desc => 'The name of the buffer to paste' }
|
|
|
|
);
|
|
|
|
|
|
|
|
@outargs = (
|
2006-03-15 15:32:39 +00:00
|
|
|
{ name => 'image', type => 'image',
|
2005-09-02 22:50:06 +00:00
|
|
|
desc => 'The new image' }
|
|
|
|
);
|
|
|
|
|
|
|
|
%invoke = (
|
|
|
|
code => <<CODE
|
|
|
|
{
|
2007-12-14 14:00:49 +00:00
|
|
|
GimpBuffer *buffer = gimp_pdb_get_buffer (gimp, buffer_name, error);
|
2005-09-02 22:50:06 +00:00
|
|
|
|
2006-03-24 21:57:47 +00:00
|
|
|
if (buffer)
|
2005-09-02 22:50:06 +00:00
|
|
|
{
|
2017-05-01 16:36:33 +00:00
|
|
|
image = gimp_image_new_from_buffer (gimp, buffer);
|
2006-03-24 21:57:47 +00:00
|
|
|
|
2005-09-02 22:50:06 +00:00
|
|
|
if (! image)
|
|
|
|
success = FALSE;
|
|
|
|
}
|
2006-03-24 21:57:47 +00:00
|
|
|
else
|
|
|
|
success = FALSE;
|
2005-09-02 22:50:06 +00:00
|
|
|
}
|
|
|
|
CODE
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
1998-10-24 05:21:56 +00:00
|
|
|
sub edit_clear {
|
|
|
|
$blurb = 'Clear selected area of drawable.';
|
|
|
|
|
|
|
|
$help = <<'HELP';
|
2006-03-14 21:35:50 +00:00
|
|
|
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.
|
1998-10-24 05:21:56 +00:00
|
|
|
HELP
|
|
|
|
|
|
|
|
&std_pdb_misc;
|
2006-03-14 21:35:50 +00:00
|
|
|
|
2005-09-02 22:50:06 +00:00
|
|
|
@inargs = (
|
|
|
|
{ name => 'drawable', type => 'drawable',
|
|
|
|
desc => 'The drawable to clear from' }
|
|
|
|
);
|
2006-03-14 21:35:50 +00:00
|
|
|
|
|
|
|
%invoke = (
|
|
|
|
code => <<CODE
|
|
|
|
{
|
2012-11-08 19:46:18 +00:00
|
|
|
if (gimp_pdb_item_is_attached (GIMP_ITEM (drawable), NULL,
|
|
|
|
GIMP_PDB_ITEM_CONTENT, error) &&
|
2009-08-29 07:16:35 +00:00
|
|
|
gimp_pdb_item_is_not_group (GIMP_ITEM (drawable), error))
|
2006-03-14 21:35:50 +00:00
|
|
|
{
|
|
|
|
GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable));
|
|
|
|
|
2016-03-11 21:41:25 +00:00
|
|
|
gimp_edit_clear (image, drawable, context);
|
2006-03-14 21:35:50 +00:00
|
|
|
}
|
2006-03-24 21:57:47 +00:00
|
|
|
else
|
|
|
|
success = FALSE;
|
2006-03-14 21:35:50 +00:00
|
|
|
}
|
|
|
|
CODE
|
|
|
|
);
|
1998-10-24 05:21:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
sub edit_fill {
|
|
|
|
$blurb = 'Fill selected area of drawable.';
|
|
|
|
|
|
|
|
$help = <<'HELP';
|
2006-03-14 21:35:50 +00:00
|
|
|
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().
|
1998-10-24 05:21:56 +00:00
|
|
|
HELP
|
|
|
|
|
|
|
|
&std_pdb_misc;
|
2000-03-24 14:54:59 +00:00
|
|
|
$author .= ' & Raphael Quinet';
|
|
|
|
$date = '1995-2000';
|
2006-03-14 21:35:50 +00:00
|
|
|
|
2000-03-24 14:54:59 +00:00
|
|
|
@inargs = (
|
|
|
|
{ name => 'drawable', type => 'drawable',
|
|
|
|
desc => "The drawable to fill to" },
|
|
|
|
{ name => 'fill_type', type => 'enum GimpFillType',
|
2006-05-18 17:25:15 +00:00
|
|
|
desc => 'The type of fill' }
|
2000-03-24 14:54:59 +00:00
|
|
|
);
|
2006-03-14 21:35:50 +00:00
|
|
|
|
|
|
|
%invoke = (
|
|
|
|
code => <<CODE
|
|
|
|
{
|
2012-11-08 19:46:18 +00:00
|
|
|
if (gimp_pdb_item_is_attached (GIMP_ITEM (drawable), NULL,
|
|
|
|
GIMP_PDB_ITEM_CONTENT, error) &&
|
2009-08-29 07:16:35 +00:00
|
|
|
gimp_pdb_item_is_not_group (GIMP_ITEM (drawable), error))
|
2006-03-14 21:35:50 +00:00
|
|
|
{
|
2016-03-11 18:52:36 +00:00
|
|
|
GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable));
|
2016-03-15 19:10:16 +00:00
|
|
|
GimpFillOptions *options = gimp_fill_options_new (gimp, NULL, FALSE);
|
2016-03-11 18:52:36 +00:00
|
|
|
|
2016-03-11 21:41:25 +00:00
|
|
|
if (gimp_fill_options_set_by_fill_type (options, context,
|
|
|
|
fill_type, error))
|
|
|
|
{
|
|
|
|
gimp_edit_fill (image, drawable, options, NULL);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
success = FALSE;
|
2016-03-11 18:52:36 +00:00
|
|
|
|
|
|
|
g_object_unref (options);
|
2006-03-14 21:35:50 +00:00
|
|
|
}
|
2006-03-24 21:57:47 +00:00
|
|
|
else
|
|
|
|
success = FALSE;
|
2006-03-14 21:35:50 +00:00
|
|
|
}
|
|
|
|
CODE
|
|
|
|
);
|
1998-10-24 05:21:56 +00:00
|
|
|
}
|
|
|
|
|
2004-01-05 14:35:19 +00:00
|
|
|
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
|
2006-03-24 21:57:47 +00:00
|
|
|
the sample_merged parameter is TRUE, the data of the composite
|
2004-01-05 14:35:19 +00:00
|
|
|
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 = (
|
2005-09-02 22:50:06 +00:00
|
|
|
{ name => 'drawable', type => 'drawable',
|
|
|
|
desc => 'The affected drawable' },
|
2004-01-05 14:35:19 +00:00
|
|
|
{ name => 'fill_mode', type => 'enum GimpBucketFillMode',
|
2006-05-18 17:25:15 +00:00
|
|
|
desc => 'The type of fill' },
|
2017-01-08 22:00:19 +00:00
|
|
|
{ name => paint_mode, type => 'enum GimpLayerMode',
|
2006-05-18 17:25:15 +00:00
|
|
|
desc => 'The paint application mode' },
|
2004-01-05 14:35:19 +00:00
|
|
|
{ name => 'opacity', type => '0 <= float <= 100',
|
2006-05-18 17:25:15 +00:00
|
|
|
desc => 'The opacity of the final bucket fill' },
|
2004-01-05 14:35:19 +00:00
|
|
|
{ name => 'threshold', type => '0 <= float <= 255',
|
|
|
|
desc => "The threshold determines how extensive the seed fill will
|
2006-05-18 17:25:15 +00:00
|
|
|
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." },
|
2005-09-02 22:50:06 +00:00
|
|
|
{ name => 'sample_merged', type => 'boolean',
|
2006-03-22 09:58:08 +00:00
|
|
|
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." }
|
2004-01-05 14:35:19 +00:00
|
|
|
);
|
|
|
|
|
|
|
|
%invoke = (
|
|
|
|
headers => [ qw ("core/gimpdrawable-bucket-fill.h"
|
|
|
|
"core/gimpchannel.h") ],
|
|
|
|
code => <<'CODE'
|
|
|
|
{
|
2012-11-08 19:46:18 +00:00
|
|
|
if (gimp_pdb_item_is_attached (GIMP_ITEM (drawable), NULL,
|
|
|
|
GIMP_PDB_ITEM_CONTENT, error) &&
|
2009-08-29 07:16:35 +00:00
|
|
|
gimp_pdb_item_is_not_group (GIMP_ITEM (drawable), error))
|
2004-01-05 14:35:19 +00:00
|
|
|
{
|
2016-03-11 21:03:32 +00:00
|
|
|
GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable));
|
2016-03-15 19:10:16 +00:00
|
|
|
GimpFillOptions *options = gimp_fill_options_new (gimp, NULL, FALSE);
|
2015-04-27 21:48:00 +00:00
|
|
|
|
2016-03-11 21:03:32 +00:00
|
|
|
if (gimp_fill_options_set_by_fill_mode (options, context,
|
|
|
|
fill_mode, error))
|
2014-06-02 23:34:51 +00:00
|
|
|
{
|
2017-01-09 00:27:20 +00:00
|
|
|
if (paint_mode == GIMP_LAYER_MODE_OVERLAY_LEGACY)
|
|
|
|
paint_mode = GIMP_LAYER_MODE_SOFTLIGHT_LEGACY;
|
2016-03-11 18:52:36 +00:00
|
|
|
|
2016-03-11 21:03:32 +00:00
|
|
|
gimp_context_set_opacity (GIMP_CONTEXT (options), opacity / 100.0);
|
|
|
|
gimp_context_set_paint_mode (GIMP_CONTEXT (options), paint_mode);
|
2016-03-11 18:52:36 +00:00
|
|
|
|
2016-03-11 21:03:32 +00:00
|
|
|
if (! gimp_channel_is_empty (gimp_image_get_mask (image)))
|
2016-03-11 18:52:36 +00:00
|
|
|
{
|
2016-03-11 21:41:25 +00:00
|
|
|
gimp_edit_fill (image, drawable, options, NULL);
|
2016-03-11 18:52:36 +00:00
|
|
|
}
|
2016-03-11 21:03:32 +00:00
|
|
|
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);
|
|
|
|
}
|
2012-03-18 22:05:44 +00:00
|
|
|
}
|
|
|
|
else
|
2016-03-11 21:03:32 +00:00
|
|
|
success = FALSE;
|
2016-03-11 18:52:36 +00:00
|
|
|
|
2016-03-11 21:03:32 +00:00
|
|
|
g_object_unref (options);
|
2004-01-05 14:35:19 +00:00
|
|
|
}
|
2006-03-24 21:57:47 +00:00
|
|
|
else
|
|
|
|
success = FALSE;
|
2004-01-05 14:35:19 +00:00
|
|
|
}
|
|
|
|
CODE
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2006-08-15 16:20:46 +00:00
|
|
|
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' },
|
2017-01-08 22:00:19 +00:00
|
|
|
{ name => paint_mode, type => 'enum GimpLayerMode',
|
2006-08-15 16:20:46 +00:00
|
|
|
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'
|
|
|
|
{
|
2012-11-08 19:46:18 +00:00
|
|
|
if (gimp_pdb_item_is_attached (GIMP_ITEM (drawable), NULL,
|
|
|
|
GIMP_PDB_ITEM_CONTENT, error) &&
|
2009-08-29 07:16:35 +00:00
|
|
|
gimp_pdb_item_is_not_group (GIMP_ITEM (drawable), error))
|
2006-08-15 16:20:46 +00:00
|
|
|
{
|
2016-03-11 21:03:32 +00:00
|
|
|
GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable));
|
2016-03-15 19:10:16 +00:00
|
|
|
GimpFillOptions *options = gimp_fill_options_new (gimp, NULL, FALSE);
|
2015-04-27 21:48:00 +00:00
|
|
|
|
2016-03-11 21:03:32 +00:00
|
|
|
if (gimp_fill_options_set_by_fill_mode (options, context,
|
|
|
|
fill_mode, error))
|
2014-06-02 23:34:51 +00:00
|
|
|
{
|
2017-01-09 00:27:20 +00:00
|
|
|
if (paint_mode == GIMP_LAYER_MODE_OVERLAY_LEGACY)
|
|
|
|
paint_mode = GIMP_LAYER_MODE_SOFTLIGHT_LEGACY;
|
2016-03-11 18:52:36 +00:00
|
|
|
|
2016-03-11 21:03:32 +00:00
|
|
|
gimp_context_set_opacity (GIMP_CONTEXT (options), opacity / 100.0);
|
|
|
|
gimp_context_set_paint_mode (GIMP_CONTEXT (options), paint_mode);
|
2016-03-11 18:52:36 +00:00
|
|
|
|
2016-03-11 21:03:32 +00:00
|
|
|
if (! gimp_channel_is_empty (gimp_image_get_mask (image)))
|
2016-03-11 18:52:36 +00:00
|
|
|
{
|
2016-03-11 21:41:25 +00:00
|
|
|
gimp_edit_fill (image, drawable, options, NULL);
|
2016-03-11 18:52:36 +00:00
|
|
|
}
|
2016-03-11 21:03:32 +00:00
|
|
|
else
|
|
|
|
{
|
|
|
|
gimp_drawable_bucket_fill (drawable, options,
|
|
|
|
fill_transparent,
|
|
|
|
select_criterion,
|
|
|
|
threshold / 255.0,
|
|
|
|
sample_merged,
|
|
|
|
FALSE /* no diagonal neighbors */,
|
|
|
|
x, y);
|
|
|
|
}
|
2012-03-18 22:05:44 +00:00
|
|
|
}
|
|
|
|
else
|
2016-03-11 21:03:32 +00:00
|
|
|
success = FALSE;
|
2016-03-11 18:52:36 +00:00
|
|
|
|
2016-03-11 21:03:32 +00:00
|
|
|
g_object_unref (options);
|
2006-08-15 16:20:46 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
success = FALSE;
|
|
|
|
}
|
|
|
|
CODE
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2004-01-05 14:35:19 +00:00
|
|
|
sub edit_blend {
|
|
|
|
$blurb = <<'BLURB';
|
2006-03-14 21:35:50 +00:00
|
|
|
Blend between the starting and ending coordinates with the specified
|
|
|
|
blend mode and gradient type.
|
2004-01-05 14:35:19 +00:00
|
|
|
BLURB
|
|
|
|
|
|
|
|
$help = <<'HELP';
|
2006-03-14 21:35:50 +00:00
|
|
|
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.
|
2004-01-05 14:35:19 +00:00
|
|
|
HELP
|
|
|
|
|
|
|
|
&std_pdb_misc;
|
|
|
|
|
|
|
|
@inargs = (
|
2005-09-02 22:50:06 +00:00
|
|
|
{ name => 'drawable', type => 'drawable',
|
|
|
|
desc => 'The affected drawable' },
|
2004-01-05 14:35:19 +00:00
|
|
|
{ name => 'blend_mode', type => 'enum GimpBlendMode',
|
2006-05-18 17:25:15 +00:00
|
|
|
desc => 'The type of blend' },
|
2017-01-08 22:00:19 +00:00
|
|
|
{ name => 'paint_mode', type => 'enum GimpLayerMode',
|
2006-05-18 17:25:15 +00:00
|
|
|
desc => 'The paint application mode' },
|
2004-01-05 14:35:19 +00:00
|
|
|
{ name => 'gradient_type', type => 'enum GimpGradientType',
|
2006-05-18 17:25:15 +00:00
|
|
|
desc => 'The type of gradient' },
|
2004-01-05 14:35:19 +00:00
|
|
|
{ name => 'opacity', type => '0 <= float <= 100',
|
2006-05-18 17:25:15 +00:00
|
|
|
desc => 'The opacity of the final blend' },
|
2004-01-05 14:35:19 +00:00
|
|
|
{ name => 'offset', type => '0 <= float',
|
|
|
|
desc => 'Offset relates to the starting and ending coordinates
|
2006-05-18 17:25:15 +00:00
|
|
|
specified for the blend. This parameter is mode dependent.' },
|
2004-01-05 14:35:19 +00:00
|
|
|
{ name => 'repeat', type => 'enum GimpRepeatMode',
|
2006-05-18 17:25:15 +00:00
|
|
|
desc => 'Repeat mode' },
|
2004-01-05 14:35:19 +00:00
|
|
|
{ name => 'reverse', type => 'boolean',
|
2006-05-18 17:25:15 +00:00
|
|
|
desc => 'Use the reverse gradient' },
|
2004-01-05 14:35:19 +00:00
|
|
|
{ name => 'supersample', type => 'boolean',
|
2006-05-18 17:25:15 +00:00
|
|
|
desc => 'Do adaptive supersampling' },
|
2007-04-26 19:10:23 +00:00
|
|
|
{ name => 'max_depth', type => '1 <= int32 <= 9', no_validate => 1,
|
2006-03-21 16:13:27 +00:00
|
|
|
desc => 'Maximum recursion levels for supersampling' },
|
2007-04-26 19:10:23 +00:00
|
|
|
{ name => 'threshold', type => '0 <= float <= 4', no_validate => 1,
|
2006-03-21 16:13:27 +00:00
|
|
|
desc => 'Supersampling threshold' },
|
2004-01-05 14:35:19 +00:00
|
|
|
{ name => 'dither', type => 'boolean',
|
2006-05-18 17:25:15 +00:00
|
|
|
desc => 'Use dithering to reduce banding' },
|
2004-01-05 14:35:19 +00:00
|
|
|
{ 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 = (
|
2014-04-30 07:17:42 +00:00
|
|
|
headers => [ qw("core/gimp-gradients.h" "core/gimpdrawable-blend.h") ],
|
2004-01-05 14:35:19 +00:00
|
|
|
code => <<'CODE'
|
|
|
|
{
|
2012-11-08 19:46:18 +00:00
|
|
|
success = (gimp_pdb_item_is_attached (GIMP_ITEM (drawable), NULL,
|
|
|
|
GIMP_PDB_ITEM_CONTENT, error) &&
|
2009-08-29 07:16:35 +00:00
|
|
|
gimp_pdb_item_is_not_group (GIMP_ITEM (drawable), error));
|
2004-11-11 14:05:34 +00:00
|
|
|
|
2006-03-21 16:13:27 +00:00
|
|
|
if (success && supersample)
|
|
|
|
{
|
|
|
|
if (max_depth < 1 || max_depth > 9)
|
|
|
|
success = FALSE;
|
|
|
|
|
|
|
|
if (threshold < 0.0 || threshold > 4.0)
|
|
|
|
success = FALSE;
|
|
|
|
}
|
|
|
|
|
2004-11-11 14:05:34 +00:00
|
|
|
if (success)
|
2004-01-05 14:35:19 +00:00
|
|
|
{
|
2014-04-30 07:17:42 +00:00
|
|
|
GimpGradient *gradient;
|
|
|
|
|
2017-01-09 00:27:20 +00:00
|
|
|
if (paint_mode == GIMP_LAYER_MODE_OVERLAY_LEGACY)
|
|
|
|
paint_mode = GIMP_LAYER_MODE_SOFTLIGHT_LEGACY;
|
2015-04-27 21:48:00 +00:00
|
|
|
|
2004-08-31 14:17:33 +00:00
|
|
|
if (progress)
|
2014-07-12 21:45:20 +00:00
|
|
|
gimp_progress_start (progress, FALSE, _("Blending"));
|
2004-08-31 14:17:33 +00:00
|
|
|
|
2014-04-30 07:17:42 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2004-01-05 14:35:19 +00:00
|
|
|
gimp_drawable_blend (drawable,
|
2004-04-14 23:37:34 +00:00
|
|
|
context,
|
2014-04-30 07:17:42 +00:00
|
|
|
gradient,
|
2004-01-05 14:35:19 +00:00
|
|
|
paint_mode,
|
|
|
|
gradient_type,
|
|
|
|
opacity / 100.0,
|
|
|
|
offset, repeat, reverse,
|
|
|
|
supersample, max_depth,
|
|
|
|
threshold, dither,
|
|
|
|
x1, y1, x2, y2,
|
2004-08-31 14:17:33 +00:00
|
|
|
progress);
|
|
|
|
|
|
|
|
if (progress)
|
|
|
|
gimp_progress_end (progress);
|
2004-01-05 14:35:19 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
CODE
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
1998-10-24 05:21:56 +00:00
|
|
|
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;
|
2006-03-14 21:35:50 +00:00
|
|
|
|
2005-09-02 22:50:06 +00:00
|
|
|
@inargs = (
|
|
|
|
{ name => 'drawable', type => 'drawable',
|
|
|
|
desc => 'The drawable to stroke to' }
|
|
|
|
);
|
2003-09-01 17:56:44 +00:00
|
|
|
|
|
|
|
%invoke = (
|
2008-10-24 07:37:46 +00:00
|
|
|
headers => [ qw("core/gimpstrokeoptions.h") ],
|
2003-09-01 17:56:44 +00:00
|
|
|
code => <<'CODE'
|
|
|
|
{
|
2012-11-08 19:46:18 +00:00
|
|
|
if (gimp_pdb_item_is_attached (GIMP_ITEM (drawable), NULL,
|
|
|
|
GIMP_PDB_ITEM_CONTENT, error) &&
|
2009-08-29 07:16:35 +00:00
|
|
|
gimp_pdb_item_is_not_group (GIMP_ITEM (drawable), error))
|
2004-11-11 14:05:34 +00:00
|
|
|
{
|
2014-02-06 22:20:39 +00:00
|
|
|
GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable));
|
2015-11-09 00:46:07 +00:00
|
|
|
GimpStrokeOptions *options;
|
2014-02-06 22:20:39 +00:00
|
|
|
GimpPaintOptions *paint_options;
|
2003-09-01 17:56:44 +00:00
|
|
|
|
2015-11-09 00:46:07 +00:00
|
|
|
options = gimp_pdb_context_get_stroke_options (GIMP_PDB_CONTEXT (context));
|
2004-10-22 12:32:31 +00:00
|
|
|
|
2014-02-06 22:20:39 +00:00
|
|
|
paint_options =
|
|
|
|
gimp_pdb_context_get_paint_options (GIMP_PDB_CONTEXT (context), NULL);
|
|
|
|
paint_options = gimp_config_duplicate (GIMP_CONFIG (paint_options));
|
|
|
|
|
2005-09-02 22:50:06 +00:00
|
|
|
success = gimp_item_stroke (GIMP_ITEM (gimp_image_get_mask (image)),
|
2014-02-06 22:20:39 +00:00
|
|
|
drawable, context, options, paint_options,
|
|
|
|
TRUE, progress, error);
|
2004-11-11 14:05:34 +00:00
|
|
|
|
2014-02-06 22:20:39 +00:00
|
|
|
g_object_unref (paint_options);
|
2004-11-11 14:05:34 +00:00
|
|
|
}
|
2006-03-24 21:57:47 +00:00
|
|
|
else
|
|
|
|
success = FALSE;
|
2003-09-01 17:56:44 +00:00
|
|
|
}
|
|
|
|
CODE
|
|
|
|
);
|
1998-10-24 05:21:56 +00:00
|
|
|
}
|
|
|
|
|
2006-10-25 22:43:21 +00:00
|
|
|
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 = (
|
2008-10-24 07:37:46 +00:00
|
|
|
headers => [ qw("core/gimpstrokeoptions.h") ],
|
2006-10-25 22:43:21 +00:00
|
|
|
code => <<'CODE'
|
|
|
|
{
|
2012-11-08 19:46:18 +00:00
|
|
|
if (gimp_pdb_item_is_attached (GIMP_ITEM (drawable), NULL,
|
|
|
|
GIMP_PDB_ITEM_CONTENT, error) &&
|
2009-08-29 07:16:35 +00:00
|
|
|
gimp_pdb_item_is_not_group (GIMP_ITEM (drawable), error) &&
|
2010-07-08 19:00:53 +00:00
|
|
|
gimp_pdb_item_is_attached (GIMP_ITEM (vectors),
|
2012-11-08 19:46:18 +00:00
|
|
|
gimp_item_get_image (GIMP_ITEM (drawable)),
|
|
|
|
0, error))
|
2006-10-25 22:43:21 +00:00
|
|
|
{
|
2014-02-06 22:20:39 +00:00
|
|
|
GimpStrokeOptions *options;
|
|
|
|
GimpPaintOptions *paint_options;
|
2006-10-25 22:43:21 +00:00
|
|
|
|
2015-11-09 00:46:07 +00:00
|
|
|
options = gimp_pdb_context_get_stroke_options (GIMP_PDB_CONTEXT (context));
|
2006-10-25 22:43:21 +00:00
|
|
|
|
2014-02-06 22:20:39 +00:00
|
|
|
paint_options =
|
|
|
|
gimp_pdb_context_get_paint_options (GIMP_PDB_CONTEXT (context), NULL);
|
|
|
|
paint_options = gimp_config_duplicate (GIMP_CONFIG (paint_options));
|
|
|
|
|
2006-10-25 22:43:21 +00:00
|
|
|
success = gimp_item_stroke (GIMP_ITEM (vectors),
|
2014-02-06 22:20:39 +00:00
|
|
|
drawable, context, options, paint_options,
|
|
|
|
TRUE, progress, error);
|
2006-10-25 22:43:21 +00:00
|
|
|
|
2014-02-06 22:20:39 +00:00
|
|
|
g_object_unref (paint_options);
|
2006-10-25 22:43:21 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
success = FALSE;
|
|
|
|
}
|
|
|
|
CODE
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2005-09-05 18:59:19 +00:00
|
|
|
|
2016-03-11 21:03:32 +00:00
|
|
|
@headers = qw("libgimpconfig/gimpconfig.h"
|
2006-06-14 08:32:08 +00:00
|
|
|
"core/gimp.h"
|
|
|
|
"core/gimp-edit.h"
|
2017-04-19 19:44:08 +00:00
|
|
|
"core/gimpbuffer.h"
|
2006-06-14 08:32:08 +00:00
|
|
|
"core/gimpimage.h"
|
2017-04-19 19:44:08 +00:00
|
|
|
"core/gimpimage-duplicate.h"
|
2010-02-08 14:19:03 +00:00
|
|
|
"core/gimpimage-new.h"
|
2006-06-14 08:32:08 +00:00
|
|
|
"core/gimpprogress.h"
|
2007-12-14 14:00:49 +00:00
|
|
|
"gimppdb-utils.h"
|
2014-02-06 22:20:39 +00:00
|
|
|
"gimppdbcontext.h"
|
2004-08-31 14:17:33 +00:00
|
|
|
"gimp-intl.h");
|
2001-08-14 14:54:22 +00:00
|
|
|
|
2008-02-07 17:08:54 +00:00
|
|
|
@procs = qw(edit_cut
|
2016-09-20 18:20:25 +00:00
|
|
|
edit_copy
|
|
|
|
edit_copy_visible
|
|
|
|
edit_paste
|
|
|
|
edit_paste_as_new_image
|
2008-02-07 17:08:54 +00:00
|
|
|
edit_named_cut
|
2016-09-20 18:20:25 +00:00
|
|
|
edit_named_copy
|
|
|
|
edit_named_copy_visible
|
|
|
|
edit_named_paste
|
|
|
|
edit_named_paste_as_new_image
|
2008-02-07 17:08:54 +00:00
|
|
|
edit_clear
|
|
|
|
edit_fill
|
|
|
|
edit_bucket_fill
|
|
|
|
edit_bucket_fill_full
|
|
|
|
edit_blend
|
|
|
|
edit_stroke
|
|
|
|
edit_stroke_vectors);
|
2006-03-23 21:17:16 +00:00
|
|
|
|
2000-06-01 12:20:13 +00:00
|
|
|
%exports = (app => [@procs], lib => [@procs]);
|
1998-10-24 05:21:56 +00:00
|
|
|
|
|
|
|
$desc = 'Edit procedures';
|
2010-07-07 09:43:10 +00:00
|
|
|
$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.)';
|
1998-10-24 05:21:56 +00:00
|
|
|
|
|
|
|
1;
|