mirror of https://github.com/GNOME/gimp.git
3051 lines
78 KiB
Plaintext
3051 lines
78 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 3 of the License, or
|
|
# (at your option) any later version.
|
|
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
# "Perlized" from C source by Manish Singh <yosh@gimp.org>
|
|
|
|
sub image_id_is_valid {
|
|
$blurb = 'Returns TRUE if the image ID is valid.';
|
|
|
|
$help = <<'HELP';
|
|
This procedure checks if the given image ID is valid and refers to an
|
|
existing image.
|
|
HELP
|
|
|
|
&neo_pdb_misc('2007', '3.0');
|
|
|
|
@inargs = (
|
|
{ name => 'image_id', type => 'int32',
|
|
desc => 'The image ID to check' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'valid', type => 'boolean',
|
|
desc => 'Whether the image ID is valid' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
valid = (gimp_image_get_by_id (gimp, image_id) != NULL);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub get_images {
|
|
$blurb = 'Returns the list of images currently open.';
|
|
|
|
$help = <<'HELP';
|
|
This procedure returns the list of images currently open in GIMP.
|
|
HELP
|
|
|
|
&std_pdb_misc;
|
|
|
|
$skip_gi = 1;
|
|
|
|
@outargs = (
|
|
{ name => 'images', type => 'imagearray',
|
|
desc => 'The list of images currently open.',
|
|
array => { name => 'num_images',
|
|
desc => 'The number of images currently open' } }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<CODE
|
|
{
|
|
GList *list = gimp_get_image_iter (gimp);
|
|
|
|
num_images = g_list_length (list);
|
|
|
|
if (num_images)
|
|
{
|
|
gint i;
|
|
|
|
images = g_new (GimpImage *, num_images);
|
|
|
|
for (i = 0; i < num_images; i++, list = g_list_next (list))
|
|
images[i] = g_object_ref (list->data);
|
|
}
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_new {
|
|
$blurb = 'Creates a new image with the specified width, height, and type.';
|
|
|
|
$help = <<'HELP';
|
|
Creates a new image, undisplayed, with the specified extents and
|
|
type. A layer should be created and added before this image is
|
|
displayed, or subsequent calls to gimp_display_new() with this image
|
|
as an argument will fail. Layers can be created using the
|
|
gimp_layer_new() commands. They can be added to an image using the
|
|
gimp_image_insert_layer() command.
|
|
|
|
|
|
If your image's type if INDEXED, a colormap must also be added with
|
|
gimp_image_set_colormap(). An indexed image without a colormap will
|
|
output unexpected colors.
|
|
HELP
|
|
|
|
&std_pdb_misc;
|
|
|
|
@inargs = (
|
|
{ name => 'width', type => '1 <= int32 <= GIMP_MAX_IMAGE_SIZE',
|
|
desc => 'The width of the image' },
|
|
{ name => 'height', type => '1 <= int32 <= GIMP_MAX_IMAGE_SIZE',
|
|
desc => 'The height of the image' },
|
|
{ name => 'type', type => 'enum GimpImageBaseType',
|
|
desc => 'The type of image' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The newly created image' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
image = gimp_create_image (gimp, width, height, type,
|
|
GIMP_PRECISION_U8_NON_LINEAR, FALSE);
|
|
|
|
if (! image)
|
|
success = FALSE;
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_new_with_precision {
|
|
$blurb = 'Creates a new image with the specified width, height, type and precision.';
|
|
|
|
$help = <<'HELP';
|
|
Creates a new image, undisplayed with the specified extents, type and
|
|
precision. Indexed images can only be created at
|
|
GIMP_PRECISION_U8_NON_LINEAR precision. See gimp_image_new() for
|
|
further details.
|
|
HELP
|
|
|
|
&mitch_pdb_misc('2012', '2.10');
|
|
|
|
@inargs = (
|
|
{ name => 'width', type => '1 <= int32 <= GIMP_MAX_IMAGE_SIZE',
|
|
desc => 'The width of the image' },
|
|
{ name => 'height', type => '1 <= int32 <= GIMP_MAX_IMAGE_SIZE',
|
|
desc => 'The height of the image' },
|
|
{ name => 'type', type => 'enum GimpImageBaseType',
|
|
desc => 'The type of image' },
|
|
{ name => 'precision', type => 'enum GimpPrecision',
|
|
desc => 'The precision' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The newly created image' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
if (gimp_babl_is_valid (type, precision))
|
|
{
|
|
image = gimp_create_image (gimp, width, height, type,
|
|
precision, FALSE);
|
|
if (! image)
|
|
success = FALSE;
|
|
}
|
|
else
|
|
success = FALSE;
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_duplicate {
|
|
$blurb = 'Duplicate the specified image';
|
|
|
|
$help = <<'HELP';
|
|
This procedure duplicates the specified image, copying all layers, channels,
|
|
and image information.
|
|
HELP
|
|
|
|
&std_pdb_misc;
|
|
$date = '1997';
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'new_image', type => 'image',
|
|
desc => 'The new, duplicated image' }
|
|
);
|
|
|
|
%invoke = (
|
|
headers => [ qw("core/gimpimage-duplicate.h") ],
|
|
code => <<'CODE'
|
|
{
|
|
new_image = gimp_image_duplicate (image);
|
|
|
|
if (! new_image)
|
|
success = FALSE;
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_delete {
|
|
$blurb = 'Delete the specified image.';
|
|
|
|
$help = <<'HELP';
|
|
If there are no displays associated with this image it will be deleted.
|
|
This means that you can not delete an image through the PDB that was
|
|
created by the user. If the associated display was however created
|
|
through the PDB and you know the display ID, you may delete the display.
|
|
Removal of the last associated display will then delete the image.
|
|
HELP
|
|
|
|
&std_pdb_misc;
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
if (gimp_image_get_display_count (image) == 0)
|
|
g_object_unref (image);
|
|
else
|
|
success = FALSE;
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_get_layers {
|
|
$blurb = 'Returns the list of root layers contained in the specified image.';
|
|
|
|
$help = <<HELP;
|
|
This procedure returns the list of root layers contained in the specified image.
|
|
The order of layers is from topmost to bottommost.
|
|
|
|
Note that this is not the full list of layers, but only the root layers,
|
|
i.e. layers with no parents themselves. If you need all layers, it is up
|
|
to you to verify that any of these layers is a group layer with
|
|
gimp_item_is_group() and to obtain its children with
|
|
gimp_item_get_children() (possibly recursively checking if these have
|
|
children too).
|
|
HELP
|
|
|
|
&std_pdb_misc;
|
|
|
|
$skip_gi = 1;
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'layers', type => 'layerarray',
|
|
desc => 'The list of layers contained in the image.',
|
|
array => { name => 'num_layers',
|
|
desc => 'The number of root layers contained in the image' } }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
GList *list = gimp_image_get_layer_iter (image);
|
|
|
|
num_layers = g_list_length (list);
|
|
|
|
if (num_layers)
|
|
{
|
|
gint i;
|
|
|
|
layers = g_new (GimpLayer *, num_layers);
|
|
|
|
for (i = 0; i < num_layers; i++, list = g_list_next (list))
|
|
layers[i] = g_object_ref (list->data);
|
|
}
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_get_channels {
|
|
$blurb = 'Returns the list of channels contained in the specified image.';
|
|
|
|
$help = <<HELP;
|
|
This procedure returns the list of channels contained in the specified image.
|
|
This does not include the selection mask, or layer masks. The order is from
|
|
topmost to bottommost. Note that "channels" are custom channels and do not
|
|
include the image's color components.
|
|
HELP
|
|
|
|
&std_pdb_misc;
|
|
|
|
$skip_gi = 1;
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'channels', type => 'channelarray',
|
|
desc => 'The list of channels contained in the image.',
|
|
array => { name => 'num_channels',
|
|
desc => 'The number of channels contained in the image' } }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
GList *list = gimp_image_get_channel_iter (image);
|
|
|
|
num_channels = g_list_length (list);
|
|
|
|
if (num_channels)
|
|
{
|
|
gint i;
|
|
|
|
channels = g_new (GimpChannel *, num_channels);
|
|
|
|
for (i = 0; i < num_channels; i++, list = g_list_next (list))
|
|
channels[i] = g_object_ref (list->data);
|
|
}
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_get_vectors {
|
|
$blurb = 'Returns the list of vectors contained in the specified image.';
|
|
|
|
$help = <<HELP;
|
|
This procedure returns the list of vectors contained in the specified image.
|
|
HELP
|
|
|
|
&simon_pdb_misc('2005', '2.4');
|
|
|
|
$skip_gi = 1;
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'vectors', type => 'vectorarray',
|
|
desc => 'The list of vectors contained in the image.',
|
|
array => { name => 'num_vectors',
|
|
desc => 'The number of vectors contained in the image' } }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
GList *list = gimp_image_get_vectors_iter (image);
|
|
|
|
num_vectors = g_list_length (list);
|
|
|
|
if (num_vectors)
|
|
{
|
|
gint i;
|
|
|
|
vectors = g_new (GimpVectors *, num_vectors);
|
|
|
|
for (i = 0; i < num_vectors; i++, list = g_list_next (list))
|
|
vectors[i] = g_object_ref (list->data);
|
|
}
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_unset_active_channel {
|
|
$blurb = 'Unsets the active channel in the specified image.';
|
|
|
|
$help = <<'HELP';
|
|
If an active channel exists, it is unset. There then exists no active
|
|
channel, and if desired, one can be set through a call to 'Set Active
|
|
Channel'. No error is returned in the case of no existing active
|
|
channel.
|
|
HELP
|
|
|
|
&std_pdb_misc;
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
gimp_image_unset_selected_channels (image);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_pick_color {
|
|
$blurb = <<'BLURB';
|
|
Determine the color at the given coordinates
|
|
BLURB
|
|
|
|
$help = <<'HELP';
|
|
This tool determines the color at the specified coordinates. The
|
|
returned color is an RGB triplet even for grayscale and indexed
|
|
drawables. If the coordinates lie outside of the extents of the
|
|
specified drawables, then an error is returned. All drawables must
|
|
belong to the image and be of the same type.
|
|
|
|
If only one drawable is given and it has an alpha channel, the algorithm
|
|
examines the alpha value of the drawable at the coordinates. If the
|
|
alpha value is completely transparent (0), then an error is returned.
|
|
With several drawables specified, the composite image with only these
|
|
drawables is used.
|
|
|
|
If the sample_merged parameter is TRUE, the data of the composite image
|
|
will be used instead of that for the specified drawables. This is
|
|
equivalent to sampling for colors after merging all visible layers. In
|
|
the case of a merged sampling, the supplied drawables are ignored.
|
|
HELP
|
|
|
|
&std_pdb_misc;
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' },
|
|
{ name => 'drawables', type => 'itemarray',
|
|
desc => 'The drawables to pick from',
|
|
no_validate => 1,
|
|
array => { name => 'num_drawables',
|
|
type => '1 <= int32',
|
|
desc => "The number of drawables" } },
|
|
{ name => 'x', type => 'float',
|
|
desc => 'x coordinate of upper-left corner of rectangle' },
|
|
{ name => 'y', type => 'float',
|
|
desc => 'y coordinate of upper-left corner of rectangle' },
|
|
{ name => 'sample_merged', type => 'boolean',
|
|
desc => 'Use the composite image, not the drawables' },
|
|
{ name => 'sample_average', type => 'boolean',
|
|
desc => 'Average the color of all the pixels in a specified
|
|
radius' },
|
|
{ name => 'average_radius', type => '0 < float', no_validate => 1,
|
|
desc => 'The radius of pixels to average' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'color', type => 'color', has_alpha => 1, void_ret => 1,
|
|
desc => 'The return color' }
|
|
);
|
|
|
|
%invoke = (
|
|
headers => [ qw("core/gimpimage-pick-color.h" "core/gimppickable.h") ],
|
|
code => <<'CODE'
|
|
{
|
|
gint i;
|
|
|
|
if (! sample_merged)
|
|
{
|
|
if (num_drawables == 0)
|
|
{
|
|
success = FALSE;
|
|
}
|
|
else
|
|
{
|
|
for (i = 0; i < num_drawables; i++)
|
|
if (gimp_item_get_image (GIMP_ITEM (drawables[i])) != image)
|
|
{
|
|
success = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (success && sample_average)
|
|
{
|
|
if (average_radius <= 0.0)
|
|
success = FALSE;
|
|
}
|
|
|
|
if (success)
|
|
{
|
|
GList *drawable_list = NULL;
|
|
|
|
for (i = 0; i < num_drawables; i++)
|
|
{
|
|
GimpPickable *pickable = (GimpPickable *) drawables[i];
|
|
|
|
drawable_list = g_list_prepend (drawable_list, pickable);
|
|
if (! sample_merged)
|
|
gimp_pickable_flush (pickable);
|
|
}
|
|
|
|
if (sample_merged)
|
|
gimp_pickable_flush (GIMP_PICKABLE (image));
|
|
|
|
success = gimp_image_pick_color (image,
|
|
drawable_list,
|
|
(gint) x, (gint) y,
|
|
FALSE,
|
|
sample_merged,
|
|
sample_average,
|
|
average_radius,
|
|
NULL,
|
|
NULL,
|
|
&color);
|
|
|
|
g_list_free (drawable_list);
|
|
}
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_pick_correlate_layer {
|
|
$blurb = 'Find the layer visible at the specified coordinates.';
|
|
|
|
$help = <<'HELP';
|
|
This procedure finds the layer which is visible at the specified
|
|
coordinates. Layers which do not qualify are those whose extents do
|
|
not pass within the specified coordinates, or which are transparent at
|
|
the specified coordinates. This procedure will return -1 if no layer
|
|
is found.
|
|
HELP
|
|
|
|
&std_pdb_misc;
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' },
|
|
{ name => 'x', type => 'int32',
|
|
desc => 'The x coordinate for the pick' },
|
|
{ name => 'y', type => 'int32',
|
|
desc => 'The y coordinate for the pick' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'layer', type => 'layer',
|
|
desc => 'The layer found at the specified coordinates' }
|
|
);
|
|
|
|
%invoke = (
|
|
headers => [ qw("core/gimpimage-pick-item.h") ],
|
|
code => <<'CODE'
|
|
{
|
|
layer = gimp_image_pick_layer (image, x, y, NULL);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_get_item_position {
|
|
$blurb = 'Returns the position of the item in its level of its item tree.';
|
|
|
|
$help = <<'HELP';
|
|
This procedure determines the position of the specified item in its
|
|
level in its item tree in the image. If the item doesn't exist in the
|
|
image, or the item is not part of an item tree, an error is returned.
|
|
HELP
|
|
|
|
&mitch_pdb_misc('2010', '2.8');
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' },
|
|
{ name => 'item', type => 'item',
|
|
desc => 'The item' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'position', type => 'int32',
|
|
desc => "The position of the item in its level in the item tree" }
|
|
);
|
|
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
if (gimp_pdb_item_is_in_tree (item, image, 0, error))
|
|
position = gimp_item_get_index (item);
|
|
else
|
|
success = FALSE;
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_raise_item {
|
|
$blurb = "Raise the specified item in its level in its item tree";
|
|
|
|
$help = <<'HELP';
|
|
This procedure raises the specified item one step in the item tree.
|
|
The procedure call will fail if there is no item above it.
|
|
HELP
|
|
|
|
&mitch_pdb_misc('2010', '2.8');
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' },
|
|
{ name => 'item', type => 'item',
|
|
desc => 'The item to raise' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
if (gimp_pdb_item_is_in_tree (item, image, 0, error))
|
|
success = gimp_image_raise_item (image, item, error);
|
|
else
|
|
success = FALSE;
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_lower_item {
|
|
$blurb = "Lower the specified item in its level in its item tree";
|
|
|
|
$help = <<'HELP';
|
|
This procedure lowers the specified item one step in the item tree.
|
|
The procedure call will fail if there is no item below it.
|
|
HELP
|
|
|
|
&mitch_pdb_misc('2010', '2.8');
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' },
|
|
{ name => 'item', type => 'item',
|
|
desc => 'The item to lower' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
if (gimp_pdb_item_is_in_tree (item, image, 0, error))
|
|
success = gimp_image_lower_item (image, item, error);
|
|
else
|
|
success = FALSE;
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_raise_item_to_top {
|
|
$blurb = <<'BLURB';
|
|
Raise the specified item to the top of its level in its item tree
|
|
BLURB
|
|
|
|
$help = <<'HELP';
|
|
This procedure raises the specified item to top of its level in the
|
|
item tree. It will not move the item if there is no item above it.
|
|
HELP
|
|
|
|
&mitch_pdb_misc('2010', '2.8');
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' },
|
|
{ name => 'item', type => 'item',
|
|
desc => 'The item to raise to top' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
if (gimp_pdb_item_is_in_tree (item, image, 0, error))
|
|
success = gimp_image_raise_item_to_top (image, item);
|
|
else
|
|
success = FALSE;
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_lower_item_to_bottom {
|
|
$blurb = <<'BLURB';
|
|
Lower the specified item to the bottom of its level in its item tree
|
|
BLURB
|
|
|
|
$help = <<'HELP';
|
|
This procedure lowers the specified item to bottom of its level in the
|
|
item tree. It will not move the layer if there is no layer below it.
|
|
HELP
|
|
|
|
&mitch_pdb_misc('2010', '2.8');
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' },
|
|
{ name => 'item', type => 'item',
|
|
desc => 'The item to lower to bottom' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
if (gimp_pdb_item_is_in_tree (item, image, 0, error))
|
|
success = gimp_image_lower_item_to_bottom (image, item);
|
|
else
|
|
success = FALSE;
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_reorder_item {
|
|
$blurb = "Reorder the specified item within its item tree";
|
|
|
|
$help = <<'HELP';
|
|
This procedure reorders the specified item within its item tree.
|
|
HELP
|
|
|
|
&mitch_pdb_misc('2010', '2.8');
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' },
|
|
{ name => 'item', type => 'item',
|
|
desc => 'The item to reorder' },
|
|
{ name => 'parent', type => 'item', none_ok => 1,
|
|
desc => 'The new parent item' },
|
|
{ name => 'position', type => 'int32',
|
|
desc => 'The new position of the item' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
if (gimp_pdb_item_is_in_tree (item, image, 0, error) &&
|
|
(parent == NULL ||
|
|
(gimp_pdb_item_is_in_same_tree (item, parent, image, error) &&
|
|
gimp_pdb_item_is_group (parent, error) &&
|
|
gimp_pdb_item_is_not_ancestor (item, parent, error))))
|
|
{
|
|
success = gimp_image_reorder_item (image, item, parent, position,
|
|
TRUE, NULL);
|
|
}
|
|
else
|
|
success = FALSE;
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_merge_visible_layers {
|
|
$blurb = 'Merge the visible image layers into one.';
|
|
|
|
$help = <<'HELP';
|
|
This procedure combines the visible layers into a single layer using
|
|
the specified merge type. A merge type of EXPAND_AS_NECESSARY expands
|
|
the final layer to encompass the areas of the visible layers. A merge
|
|
type of CLIP_TO_IMAGE clips the final layer to the extents of the
|
|
image. A merge type of CLIP_TO_BOTTOM_LAYER clips the final layer to
|
|
the size of the bottommost layer.
|
|
HELP
|
|
|
|
&std_pdb_misc;
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' },
|
|
{ name => 'merge_type',
|
|
type => 'enum GimpMergeType (no GIMP_FLATTEN_IMAGE)',
|
|
desc => 'The type of merge' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'layer', type => 'layer',
|
|
desc => 'The resulting layer' }
|
|
);
|
|
|
|
%invoke = (
|
|
headers => [ qw("core/gimpimage-merge.h") ],
|
|
code => <<'CODE'
|
|
{
|
|
GList *layers;
|
|
|
|
layers = gimp_image_merge_visible_layers (image, context, merge_type,
|
|
FALSE, FALSE, progress);
|
|
|
|
if (layers)
|
|
/* With merge_selected_groups set to FALSE, we always get only a
|
|
* single selected layer.
|
|
*/
|
|
layer = layers->data;
|
|
|
|
if (! layer)
|
|
success = FALSE;
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_merge_down {
|
|
$blurb = 'Merge the layer passed and the first visible layer below.';
|
|
|
|
$help = <<'HELP';
|
|
This procedure combines the passed layer and the first visible layer
|
|
below it using the specified merge type. A merge type of
|
|
EXPAND_AS_NECESSARY expands the final layer to encompass the areas of
|
|
the visible layers. A merge type of CLIP_TO_IMAGE clips the final
|
|
layer to the extents of the image. A merge type of
|
|
CLIP_TO_BOTTOM_LAYER clips the final layer to the size of the
|
|
bottommost layer.
|
|
HELP
|
|
|
|
&larry_pdb_misc('1998');
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' },
|
|
{ name => 'merge_layer', type => 'layer',
|
|
desc => 'The layer to merge down from' },
|
|
{ name => 'merge_type',
|
|
type => 'enum GimpMergeType (no GIMP_FLATTEN_IMAGE)',
|
|
desc => 'The type of merge' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'layer', type => 'layer',
|
|
desc => 'The resulting layer' }
|
|
);
|
|
|
|
%invoke = (
|
|
headers => [ qw("core/gimpimage-merge.h") ],
|
|
code => <<'CODE'
|
|
{
|
|
if (gimp_pdb_item_is_attached (GIMP_ITEM (merge_layer), image, 0, error))
|
|
{
|
|
GList *merge_layers = g_list_prepend (NULL, merge_layer);
|
|
GList *layers;
|
|
|
|
layers = gimp_image_merge_down (image, merge_layers, context,
|
|
merge_type, progress, error);
|
|
g_list_free (merge_layers);
|
|
|
|
if (! layers)
|
|
success = FALSE;
|
|
else
|
|
layer = layers->data;
|
|
|
|
g_list_free (layers);
|
|
}
|
|
else
|
|
success = FALSE;
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_merge_layer_group {
|
|
$blurb = 'Merge the passed layer group\'s layers into one normal layer.';
|
|
|
|
$help = <<'HELP';
|
|
This procedure combines the layers of the passed layer group into
|
|
a single normal layer, replacing the group.
|
|
HELP
|
|
|
|
&ell_pdb_misc('2019', '2.10.14');
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' },
|
|
{ name => 'layer_group', type => 'layer',
|
|
desc => 'The layer group to merge' },
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'layer', type => 'layer',
|
|
desc => 'The resulting layer' }
|
|
);
|
|
|
|
%invoke = (
|
|
headers => [ qw("core/gimpgrouplayer.h" "core/gimpimage-merge.h") ],
|
|
code => <<'CODE'
|
|
{
|
|
if (gimp_pdb_item_is_attached (GIMP_ITEM (layer_group), image, 0, error) &&
|
|
gimp_pdb_item_is_group (GIMP_ITEM (layer_group), error))
|
|
{
|
|
layer = gimp_image_merge_group_layer (image,
|
|
GIMP_GROUP_LAYER (layer_group));
|
|
|
|
if (! layer)
|
|
success = FALSE;
|
|
}
|
|
else
|
|
success = FALSE;
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_flatten {
|
|
$blurb = <<'BLURB';
|
|
Flatten all visible layers into a single layer. Discard all invisible layers.
|
|
BLURB
|
|
|
|
$help = <<'HELP';
|
|
This procedure combines the visible layers in a manner analogous to merging
|
|
with the CLIP_TO_IMAGE merge type. Non-visible layers are discarded, and the
|
|
resulting image is stripped of its alpha channel.
|
|
HELP
|
|
|
|
&std_pdb_misc;
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'layer', type => 'layer',
|
|
desc => 'The resulting layer' }
|
|
);
|
|
|
|
%invoke = (
|
|
headers => [ qw("core/gimpimage-merge.h") ],
|
|
code => <<'CODE'
|
|
{
|
|
layer = gimp_image_flatten (image, context,
|
|
progress, error);
|
|
|
|
if (! layer)
|
|
success = FALSE;
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_insert_layer {
|
|
$blurb = 'Add the specified layer to the image.';
|
|
|
|
$help = <<'HELP';
|
|
This procedure adds the specified layer to the image at the given
|
|
position. If the specified parent is a valid layer group (See
|
|
gimp_item_is_group() and gimp_layer_group_new()) then the layer is
|
|
added inside the group. If the parent is 0, the layer is added inside
|
|
the main stack, outside of any group. The position argument specifies
|
|
the location of the layer inside the stack (or the group, if a valid
|
|
parent was supplied), starting from the top (0) and increasing. If
|
|
the position is specified as -1 and the parent is specified as 0, then
|
|
the layer is inserted above the active layer, or inside the group if
|
|
the active layer is a layer group. The layer type must be compatible
|
|
with the image base type.
|
|
HELP
|
|
|
|
&std_pdb_misc;
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' },
|
|
{ name => 'layer', type => 'layer',
|
|
desc => 'The layer' },
|
|
{ name => 'parent', type => 'layer', none_ok => 1,
|
|
desc => 'The parent layer' },
|
|
{ name => 'position', type => 'int32',
|
|
desc => 'The layer position' }
|
|
);
|
|
|
|
$invoke{code} = <<'CODE';
|
|
{
|
|
if (gimp_pdb_item_is_floating (GIMP_ITEM (layer), image, error) &&
|
|
gimp_pdb_image_is_base_type (image,
|
|
gimp_drawable_get_base_type (GIMP_DRAWABLE (layer)),
|
|
error) &&
|
|
(parent == NULL ||
|
|
(gimp_pdb_item_is_in_tree (GIMP_ITEM (parent), image, 0, error) &&
|
|
gimp_pdb_item_is_group (GIMP_ITEM (parent), error))))
|
|
{
|
|
if (position == -1 && parent == NULL)
|
|
parent = GIMP_IMAGE_ACTIVE_PARENT;
|
|
|
|
/* see layer-new */
|
|
if (gimp_drawable_is_gray (GIMP_DRAWABLE (layer)))
|
|
gimp_layer_fix_format_space (layer, TRUE, FALSE);
|
|
|
|
success = gimp_image_add_layer (image, layer,
|
|
parent, MAX (position, -1), TRUE);
|
|
}
|
|
else
|
|
{
|
|
success = FALSE;
|
|
}
|
|
}
|
|
CODE
|
|
}
|
|
|
|
sub image_remove_layer {
|
|
$blurb = 'Remove the specified layer from the image.';
|
|
|
|
$help = <<'HELP';
|
|
This procedure removes the specified layer from the image. If the
|
|
layer doesn't exist, an error is returned. If there are no layers left
|
|
in the image, this call will fail. If this layer is the last layer
|
|
remaining, the image will become empty and have no active layer.
|
|
HELP
|
|
|
|
&std_pdb_misc;
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' },
|
|
{ name => 'layer', type => 'layer',
|
|
desc => 'The layer' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
if (gimp_pdb_item_is_attached (GIMP_ITEM (layer), image, 0, error))
|
|
gimp_image_remove_layer (image, layer, TRUE, NULL);
|
|
else
|
|
success = FALSE;
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_freeze_layers {
|
|
$blurb = "Freeze the image's layer list.";
|
|
|
|
$help = <<'HELP';
|
|
This procedure freezes the layer list of the image, suppressing any
|
|
updates to the Layers dialog in response to changes to the image's
|
|
layers. This can significantly improve performance while applying
|
|
changes affecting the layer list.
|
|
|
|
|
|
Each call to gimp_image_freeze_layers() should be matched by a
|
|
corresponding call to gimp_image_thaw_layers(), undoing its
|
|
effects.
|
|
HELP
|
|
|
|
&ell_pdb_misc('2018', '2.10.2');
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
GimpPlugIn *plug_in = gimp->plug_in_manager->current_plug_in;
|
|
GimpContainer *container = gimp_image_get_layers (image);
|
|
|
|
if (plug_in)
|
|
success = gimp_plug_in_cleanup_layers_freeze (plug_in, image);
|
|
|
|
if (success)
|
|
gimp_container_freeze (container);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_thaw_layers {
|
|
$blurb = "Thaw the image's layer list.";
|
|
|
|
$help = <<'HELP';
|
|
This procedure thaws the layer list of the image, re-enabling
|
|
updates to the Layers dialog.
|
|
|
|
|
|
This procedure should match a corresponding call to
|
|
gimp_image_freeze_layers().
|
|
HELP
|
|
|
|
&ell_pdb_misc('2018', '2.10.2');
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
GimpPlugIn *plug_in = gimp->plug_in_manager->current_plug_in;
|
|
GimpContainer *container = gimp_image_get_layers (image);
|
|
|
|
if (plug_in)
|
|
success = gimp_plug_in_cleanup_layers_thaw (plug_in, image);
|
|
|
|
if (success)
|
|
success = gimp_container_frozen (container);
|
|
|
|
if (success)
|
|
gimp_container_thaw (container);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_insert_channel {
|
|
$blurb = 'Add the specified channel to the image.';
|
|
|
|
$help = <<'HELP';
|
|
This procedure adds the specified channel to the image at the given
|
|
position. Since channel groups are not currently supported, the parent
|
|
argument must always be 0. The position argument specifies the
|
|
location of the channel inside the stack, starting from the top (0) and
|
|
increasing. If the position is specified as -1, then the channel is
|
|
inserted above the active channel.
|
|
HELP
|
|
|
|
&std_pdb_misc;
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' },
|
|
{ name => 'channel', type => 'channel',
|
|
desc => 'The channel' },
|
|
{ name => 'parent', type => 'channel', none_ok => 1,
|
|
desc => 'The parent channel' },
|
|
{ name => 'position', type => 'int32',
|
|
desc => 'The channel position' }
|
|
);
|
|
|
|
$invoke{code} = <<'CODE';
|
|
{
|
|
if (gimp_pdb_item_is_floating (GIMP_ITEM (channel), image, error) &&
|
|
(parent == NULL ||
|
|
(gimp_pdb_item_is_in_tree (GIMP_ITEM (parent), image, 0, error) &&
|
|
gimp_pdb_item_is_group (GIMP_ITEM (parent), error))))
|
|
{
|
|
if (position == -1 && parent == NULL)
|
|
parent = GIMP_IMAGE_ACTIVE_PARENT;
|
|
|
|
success = gimp_image_add_channel (image, channel,
|
|
parent, MAX (position, -1), TRUE);
|
|
}
|
|
else
|
|
{
|
|
success = FALSE;
|
|
}
|
|
}
|
|
CODE
|
|
}
|
|
|
|
sub image_remove_channel {
|
|
$blurb = 'Remove the specified channel from the image.';
|
|
|
|
$help = <<'HELP';
|
|
This procedure removes the specified channel from the image. If the channel
|
|
doesn't exist, an error is returned.
|
|
HELP
|
|
|
|
&std_pdb_misc;
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' },
|
|
{ name => 'channel', type => 'channel',
|
|
desc => 'The channel' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
if (gimp_pdb_item_is_attached (GIMP_ITEM (channel), image, 0, error))
|
|
gimp_image_remove_channel (image, channel, TRUE, NULL);
|
|
else
|
|
success = FALSE;
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_freeze_channels {
|
|
$blurb = "Freeze the image's channel list.";
|
|
|
|
&ell_pdb_misc('2018', '2.10.2');
|
|
|
|
$help = <<'HELP';
|
|
This procedure freezes the channel list of the image, suppressing any
|
|
updates to the Channels dialog in response to changes to the image's
|
|
channels. This can significantly improve performance while applying
|
|
changes affecting the channel list.
|
|
|
|
|
|
Each call to gimp_image_freeze_channels() should be matched by a
|
|
corresponding call to gimp_image_thaw_channels(), undoing its
|
|
effects.
|
|
HELP
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
GimpPlugIn *plug_in = gimp->plug_in_manager->current_plug_in;
|
|
GimpContainer *container = gimp_image_get_channels (image);
|
|
|
|
if (plug_in)
|
|
success = gimp_plug_in_cleanup_channels_freeze (plug_in, image);
|
|
|
|
if (success)
|
|
gimp_container_freeze (container);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_thaw_channels {
|
|
$blurb = "Thaw the image's channel list.";
|
|
|
|
&ell_pdb_misc('2018', '2.10.2');
|
|
|
|
$help = <<'HELP';
|
|
This procedure thaws the channel list of the image, re-enabling
|
|
updates to the Channels dialog.
|
|
|
|
|
|
This procedure should match a corresponding call to
|
|
gimp_image_freeze_channels().
|
|
HELP
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
GimpPlugIn *plug_in = gimp->plug_in_manager->current_plug_in;
|
|
GimpContainer *container = gimp_image_get_channels (image);
|
|
|
|
if (plug_in)
|
|
success = gimp_plug_in_cleanup_channels_thaw (plug_in, image);
|
|
|
|
if (success)
|
|
success = gimp_container_frozen (container);
|
|
|
|
if (success)
|
|
gimp_container_thaw (container);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_insert_vectors {
|
|
$blurb = 'Add the specified vectors to the image.';
|
|
|
|
$help = <<'HELP';
|
|
This procedure adds the specified vectors to the image at the given
|
|
position. Since vectors groups are not currently supported, the parent
|
|
argument must always be 0. The position argument specifies the
|
|
location of the vectors inside the stack, starting from the top (0) and
|
|
increasing. If the position is specified as -1, then the vectors is
|
|
inserted above the active vectors.
|
|
HELP
|
|
|
|
&std_pdb_misc;
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' },
|
|
{ name => 'vectors', type => 'vectors',
|
|
desc => 'The vectors' },
|
|
{ name => 'parent', type => 'vectors', none_ok => 1,
|
|
desc => 'The parent vectors' },
|
|
{ name => 'position', type => 'int32',
|
|
desc => 'The vectors position' }
|
|
);
|
|
|
|
$invoke{code} = <<'CODE';
|
|
{
|
|
if (gimp_pdb_item_is_floating (GIMP_ITEM (vectors), image, error) &&
|
|
(parent == NULL ||
|
|
(gimp_pdb_item_is_in_tree (GIMP_ITEM (parent), image, 0, error) &&
|
|
gimp_pdb_item_is_group (GIMP_ITEM (parent), error))))
|
|
{
|
|
if (position == -1 && parent == NULL)
|
|
parent = GIMP_IMAGE_ACTIVE_PARENT;
|
|
|
|
success = gimp_image_add_vectors (image, vectors,
|
|
parent, MAX (position, -1), TRUE);
|
|
}
|
|
else
|
|
{
|
|
success = FALSE;
|
|
}
|
|
}
|
|
CODE
|
|
}
|
|
|
|
sub image_remove_vectors {
|
|
$blurb = 'Remove the specified path from the image.';
|
|
|
|
$help = <<'HELP';
|
|
This procedure removes the specified path from the image. If the path
|
|
doesn't exist, an error is returned.
|
|
HELP
|
|
|
|
&simon_pdb_misc('2005', '2.4');
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' },
|
|
{ name => 'vectors', type => 'vectors',
|
|
desc => 'The vectors object' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
if (gimp_pdb_item_is_attached (GIMP_ITEM (vectors), image, 0, error))
|
|
gimp_image_remove_vectors (image, vectors, TRUE, NULL);
|
|
else
|
|
success = FALSE;
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_freeze_vectors {
|
|
$blurb = "Freeze the image's vectors list.";
|
|
|
|
&ell_pdb_misc('2018', '2.10.2');
|
|
|
|
$help = <<'HELP';
|
|
This procedure freezes the vectors list of the image, suppressing any
|
|
updates to the Paths dialog in response to changes to the image's
|
|
vectors. This can significantly improve performance while applying
|
|
changes affecting the vectors list.
|
|
|
|
|
|
Each call to gimp_image_freeze_vectors() should be matched by a
|
|
corresponding call to gimp_image_thaw_vectors(), undoing its
|
|
effects.
|
|
HELP
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
GimpPlugIn *plug_in = gimp->plug_in_manager->current_plug_in;
|
|
GimpContainer *container = gimp_image_get_vectors (image);
|
|
|
|
if (plug_in)
|
|
success = gimp_plug_in_cleanup_vectors_freeze (plug_in, image);
|
|
|
|
if (success)
|
|
gimp_container_freeze (container);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_thaw_vectors {
|
|
$blurb = "Thaw the image's vectors list.";
|
|
|
|
&ell_pdb_misc('2018', '2.10.2');
|
|
|
|
$help = <<'HELP';
|
|
This procedure thaws the vectors list of the image, re-enabling
|
|
updates to the Paths dialog.
|
|
|
|
|
|
This procedure should match a corresponding call to
|
|
gimp_image_freeze_vectors().
|
|
HELP
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
GimpPlugIn *plug_in = gimp->plug_in_manager->current_plug_in;
|
|
GimpContainer *container = gimp_image_get_vectors (image);
|
|
|
|
if (plug_in)
|
|
success = gimp_plug_in_cleanup_vectors_thaw (plug_in, image);
|
|
|
|
if (success)
|
|
success = gimp_container_frozen (container);
|
|
|
|
if (success)
|
|
gimp_container_thaw (container);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_get_base_type {
|
|
$blurb = 'Get the base type of the image.';
|
|
|
|
$help = <<'HELP';
|
|
This procedure returns the image's base type. Layers in the image must be of
|
|
this subtype, but can have an optional alpha channel.
|
|
HELP
|
|
|
|
&std_pdb_misc;
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'base_type', type => 'enum GimpImageBaseType',
|
|
desc => "The image's base type" }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
base_type = gimp_image_get_base_type (image);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_get_precision {
|
|
$blurb = 'Get the precision of the image.';
|
|
|
|
$help = <<'HELP';
|
|
This procedure returns the image's precision.
|
|
HELP
|
|
|
|
&mitch_pdb_misc('2012', '2.10');
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'precision', type => 'enum GimpPrecision',
|
|
desc => "The image's precision" }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
precision = gimp_image_get_precision (image);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_get_default_new_layer_mode {
|
|
$blurb = 'Get the default mode for newly created layers of this image.';
|
|
$help = 'Returns the default mode for newly created layers of this image.';
|
|
|
|
&mitch_pdb_misc('2017', '2.10');
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'mode', type => 'enum GimpLayerMode',
|
|
default => 'GIMP_LAYER_MODE_NORMAL',
|
|
desc => 'The layer mode' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
mode = gimp_image_get_default_new_layer_mode (image);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_get_colormap {
|
|
$blurb = "Returns the image's colormap";
|
|
|
|
$help = <<'HELP';
|
|
This procedure returns an actual pointer to the image's colormap, as well as
|
|
the number of bytes contained in the colormap. The actual number of colors in
|
|
the transmitted colormap will be 'num-bytes' / 3. If the image is not in
|
|
Indexed color mode, no colormap is returned.
|
|
HELP
|
|
|
|
&std_pdb_misc;
|
|
|
|
$lib_private = 1;
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'colormap', type => 'int8array',
|
|
desc => "The image's colormap.",
|
|
array => { name => 'num_bytes',
|
|
desc => 'Number of bytes in the colormap array' } }
|
|
);
|
|
|
|
%invoke = (
|
|
headers => [ qw("core/gimpimage-colormap.h") ],
|
|
code => <<'CODE'
|
|
{
|
|
num_bytes = 3 * gimp_image_get_colormap_size (image);
|
|
colormap = gimp_image_get_colormap (image);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_set_colormap {
|
|
$blurb = "Sets the entries in the image's colormap.";
|
|
|
|
$help = <<'HELP';
|
|
This procedure sets the entries in the specified image's colormap. The number
|
|
of entries is specified by the 'num-bytes' parameter and corresponds to the
|
|
number of INT8 triples that must be contained in the 'colormap' array. The
|
|
actual number of colors in the transmitted colormap is 'num-bytes' / 3.
|
|
HELP
|
|
|
|
&std_pdb_misc;
|
|
|
|
$lib_private = 1;
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' },
|
|
{ name => 'colormap', type => 'int8array',
|
|
desc => 'The new colormap values',
|
|
array => { name => 'num_bytes', type => '0 <= int32 <= 768',
|
|
desc => 'Number of bytes in the colormap array' } }
|
|
);
|
|
|
|
%invoke = (
|
|
headers => [ qw("core/gimpimage-colormap.h") ],
|
|
code => <<'CODE'
|
|
{
|
|
gimp_image_set_colormap (image, colormap, num_bytes / 3, TRUE);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_get_metadata {
|
|
$blurb = "Returns the image's metadata.";
|
|
$help = 'Returns exif/iptc/xmp metadata from the image.';
|
|
|
|
&std_pdb_misc('2013', '2.10');
|
|
|
|
$lib_private = 1;
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'metadata_string', type => 'string',
|
|
desc => 'The exif/ptc/xmp metadata as a string'}
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
GimpMetadata *metadata = gimp_image_get_metadata (image);
|
|
|
|
if (metadata)
|
|
metadata_string = gimp_metadata_serialize (metadata);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_set_metadata {
|
|
$blurb = "Set the image's metadata.";
|
|
$help = 'Sets exif/iptc/xmp metadata on the image.';
|
|
|
|
&std_pdb_misc('2013', '2.10');
|
|
|
|
$lib_private = 1;
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' },
|
|
{ name => 'metadata_string', type => 'string',
|
|
desc => 'The exif/ptc/xmp metadata as a string' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
GimpMetadata *metadata = gimp_metadata_deserialize (metadata_string);
|
|
|
|
gimp_image_set_metadata (image, metadata, TRUE);
|
|
|
|
if (metadata)
|
|
g_object_unref (metadata);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_clean_all {
|
|
$blurb = 'Set the image dirty count to 0.';
|
|
|
|
$help = <<'HELP';
|
|
This procedure sets the specified image's dirty count to 0, allowing
|
|
operations to occur without having a 'dirtied' image. This is
|
|
especially useful for creating and loading images which should not
|
|
initially be considered dirty, even though layers must be created,
|
|
filled, and installed in the image. Note that save plug-ins must NOT
|
|
call this function themselves after saving the image.
|
|
HELP
|
|
|
|
&std_pdb_misc;
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
gimp_image_clean_all (image);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_is_dirty {
|
|
$blurb = 'Checks if the image has unsaved changes.';
|
|
|
|
$help = <<'HELP';
|
|
This procedure checks the specified image's dirty count to see if it
|
|
needs to be saved. Note that saving the image does not automatically
|
|
set the dirty count to 0, you need to call gimp_image_clean_all() after
|
|
calling a save procedure to make the image clean.
|
|
HELP
|
|
|
|
&std_pdb_misc;
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'dirty', type => 'boolean',
|
|
desc => 'TRUE if the image has unsaved changes.' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
dirty = gimp_image_is_dirty (image);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_get_floating_sel {
|
|
$blurb = 'Return the floating selection of the image.';
|
|
|
|
$help = <<'HELP';
|
|
This procedure returns the image's floating selection, if it exists.
|
|
If it doesn't exist, -1 is returned as the layer ID.
|
|
HELP
|
|
|
|
&std_pdb_misc;
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'floating_sel', type => 'layer',
|
|
desc => "The image's floating selection" }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
floating_sel = gimp_image_get_floating_selection (image);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_floating_sel_attached_to {
|
|
$blurb = 'Return the drawable the floating selection is attached to.';
|
|
|
|
$help = <<'HELP';
|
|
This procedure returns the drawable the image's floating selection is attached
|
|
to, if it exists. If it doesn't exist, -1 is returned as the drawable ID.
|
|
HELP
|
|
|
|
&wolfgang_pdb_misc('1998');
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'drawable', type => 'drawable',
|
|
desc => 'The drawable the floating selection is attached to' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
GimpLayer *floating_sel = gimp_image_get_floating_selection (image);
|
|
|
|
if (floating_sel)
|
|
drawable = gimp_layer_get_floating_sel_drawable (floating_sel);
|
|
else
|
|
drawable = NULL;
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_get_width {
|
|
$blurb = 'Return the width of the image';
|
|
|
|
$help = <<'HELP';
|
|
This procedure returns the image's width. This value is independent of any of
|
|
the layers in this image. This is the "canvas" width.
|
|
HELP
|
|
|
|
&std_pdb_misc;
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'width', type => 'int32',
|
|
desc => "The image's width" }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
width = gimp_image_get_width (image);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_get_height {
|
|
$blurb = 'Return the height of the image';
|
|
|
|
$help = <<'HELP';
|
|
This procedure returns the image's height. This value is independent of any of
|
|
the layers in this image. This is the "canvas" height.
|
|
HELP
|
|
|
|
&std_pdb_misc;
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'height', type => 'int32',
|
|
desc => "The image's height" }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
height = gimp_image_get_height (image);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_get_selected_layers {
|
|
$blurb = "Returns the specified image's selected layers.";
|
|
|
|
$help = <<'HELP';
|
|
This procedure returns the list of selected layers in the specified image.
|
|
HELP
|
|
|
|
&jehan_pdb_misc('2020', '3.0.0');
|
|
|
|
$skip_gi = 1;
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'layers', type => 'layerarray',
|
|
desc => 'The list of selected layers in the image.',
|
|
array => { name => 'num_layers',
|
|
desc => 'The number of selected layers in the image' } }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
GList *list = gimp_image_get_selected_layers (image);
|
|
|
|
num_layers = g_list_length (list);
|
|
|
|
if (num_layers)
|
|
{
|
|
gint i;
|
|
|
|
layers = g_new (GimpLayer *, num_layers);
|
|
|
|
for (i = 0; i < num_layers; i++, list = g_list_next (list))
|
|
layers[i] = g_object_ref (list->data);
|
|
}
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_set_selected_layers {
|
|
$blurb = "Sets the specified image's selected layers.";
|
|
|
|
$help = <<'HELP';
|
|
The layers are set as the selected layers in the image. Any previous
|
|
selected layers or channels are unselected. An exception is a previously
|
|
existing floating selection, in which case this procedure will return an
|
|
execution error.
|
|
HELP
|
|
|
|
&jehan_pdb_misc('2021', '3.0.0');
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' },
|
|
{ name => 'layers', type => 'layerarray',
|
|
desc => 'The list of layers to select',
|
|
no_validate => 1,
|
|
array => { name => 'num_layers',
|
|
type => '0 <= int32',
|
|
desc => 'The number of layers to select' } }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
GList *selected_layers = NULL;
|
|
gint i;
|
|
|
|
for (i = 0; i < num_layers; i++)
|
|
selected_layers = g_list_prepend (selected_layers,
|
|
GIMP_LAYER (layers[i]));
|
|
|
|
gimp_image_set_selected_layers (image, selected_layers);
|
|
g_list_free (selected_layers);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_get_selected_drawables {
|
|
$blurb = "Get the image's selected drawables";
|
|
|
|
$help = <<'HELP';
|
|
This procedure returns the list of selected drawable in the specified image.
|
|
This can be either layers, channels, or a layer mask.
|
|
|
|
The active drawables are the active image channels. If there are none,
|
|
these are the active image layers. If the active image layer has a layer
|
|
mask and the layer mask is in edit mode, then the layer mask is the
|
|
active drawable.
|
|
HELP
|
|
|
|
&jehan_pdb_misc('2022', '3.0.0');
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'drawables', type => 'itemarray',
|
|
desc => 'The list of selected drawables in the image.',
|
|
array => { name => 'num_drawables',
|
|
desc => 'The number of selected drawables in the image' } }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
GList *list = gimp_image_get_selected_drawables (image);
|
|
|
|
num_drawables = g_list_length (list);
|
|
|
|
if (num_drawables)
|
|
{
|
|
gint i;
|
|
|
|
drawables = g_new (GimpItem *, num_drawables);
|
|
|
|
for (i = 0; i < num_drawables; i++, list = g_list_next (list))
|
|
drawables[i] = g_object_ref (list->data);
|
|
}
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_get_selection {
|
|
$blurb = "Returns the specified image's selection.";
|
|
|
|
$help = <<'HELP';
|
|
This will always return a valid ID for a selection -- which is represented as a
|
|
channel internally.
|
|
HELP
|
|
|
|
&std_pdb_misc;
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'selection', type => 'selection',
|
|
desc => 'The selection channel' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
selection = GIMP_SELECTION (gimp_image_get_mask (image));
|
|
|
|
if (! selection)
|
|
success = FALSE;
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_get_component_active {
|
|
$blurb = "Returns if the specified image's image component is active.";
|
|
|
|
$help = <<'HELP';
|
|
This procedure returns if the specified image's image component
|
|
(i.e. Red, Green, Blue intensity channels in an RGB image) is active
|
|
or inactive -- whether or not it can be modified. If the specified
|
|
component is not valid for the image type, an error is returned.
|
|
HELP
|
|
|
|
&std_pdb_misc;
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' },
|
|
{ name => 'component', type => 'enum GimpChannelType',
|
|
desc => 'The image component' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'active', type => 'boolean',
|
|
desc => 'Component is active' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
if (component == GIMP_CHANNEL_GRAY)
|
|
success = gimp_pdb_image_is_base_type (image, GIMP_GRAY, error);
|
|
else if (component == GIMP_CHANNEL_INDEXED)
|
|
success = gimp_pdb_image_is_base_type (image, GIMP_INDEXED, error);
|
|
else
|
|
success = gimp_pdb_image_is_base_type (image, GIMP_RGB, error);
|
|
|
|
if (success)
|
|
active = gimp_image_get_component_active (image, component);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_set_component_active {
|
|
$blurb = "Sets if the specified image's image component is active.";
|
|
|
|
$help = <<'HELP';
|
|
This procedure sets if the specified image's image component
|
|
(i.e. Red, Green, Blue intensity channels in an RGB image) is active
|
|
or inactive -- whether or not it can be modified. If the specified
|
|
component is not valid for the image type, an error is returned.
|
|
HELP
|
|
|
|
&std_pdb_misc;
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' },
|
|
{ name => 'component', type => 'enum GimpChannelType',
|
|
desc => 'The image component' },
|
|
{ name => 'active', type => 'boolean',
|
|
desc => 'Component is active' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
if (component == GIMP_CHANNEL_GRAY)
|
|
success = gimp_pdb_image_is_base_type (image, GIMP_GRAY, error);
|
|
else if (component == GIMP_CHANNEL_INDEXED)
|
|
success = gimp_pdb_image_is_base_type (image, GIMP_INDEXED, error);
|
|
else
|
|
success = gimp_pdb_image_is_base_type (image, GIMP_RGB, error);
|
|
|
|
if (success)
|
|
gimp_image_set_component_active (image, component, active);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_get_component_visible {
|
|
$blurb = "Returns if the specified image's image component is visible.";
|
|
|
|
$help = <<'HELP';
|
|
This procedure returns if the specified image's image component
|
|
(i.e. Red, Green, Blue intensity channels in an RGB image) is visible
|
|
or invisible -- whether or not it can be seen. If the specified
|
|
component is not valid for the image type, an error is returned.
|
|
HELP
|
|
|
|
&std_pdb_misc;
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' },
|
|
{ name => 'component', type => 'enum GimpChannelType',
|
|
desc => 'The image component' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'visible', type => 'boolean',
|
|
desc => 'Component is visible' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
if (component == GIMP_CHANNEL_GRAY)
|
|
success = gimp_pdb_image_is_base_type (image, GIMP_GRAY, error);
|
|
else if (component == GIMP_CHANNEL_INDEXED)
|
|
success = gimp_pdb_image_is_base_type (image, GIMP_INDEXED, error);
|
|
else
|
|
success = gimp_pdb_image_is_base_type (image, GIMP_RGB, error);
|
|
|
|
if (success)
|
|
visible = gimp_image_get_component_visible (image, component);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_set_component_visible {
|
|
$blurb = "Sets if the specified image's image component is visible.";
|
|
|
|
$help = <<'HELP';
|
|
This procedure sets if the specified image's image component
|
|
(i.e. Red, Green, Blue intensity channels in an RGB image) is visible
|
|
or invisible -- whether or not it can be seen. If the specified
|
|
component is not valid for the image type, an error is returned.
|
|
HELP
|
|
|
|
&std_pdb_misc;
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' },
|
|
{ name => 'component', type => 'enum GimpChannelType',
|
|
desc => 'The image component' },
|
|
{ name => 'visible', type => 'boolean',
|
|
desc => 'Component is visible' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
if (component == GIMP_CHANNEL_GRAY)
|
|
success = gimp_pdb_image_is_base_type (image, GIMP_GRAY, error);
|
|
else if (component == GIMP_CHANNEL_INDEXED)
|
|
success = gimp_pdb_image_is_base_type (image, GIMP_INDEXED, error);
|
|
else
|
|
success = gimp_pdb_image_is_base_type (image, GIMP_RGB, error);
|
|
|
|
if (success)
|
|
gimp_image_set_component_visible (image, component, visible);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_get_file {
|
|
$blurb = "Returns the file for the specified image.";
|
|
|
|
$help = <<'HELP';
|
|
This procedure returns the file associated with the specified image.
|
|
The image has a file only if it was loaded or imported from a file or
|
|
has since been saved or exported. Otherwise, this function returns
|
|
%NULL. See also gimp-image-get-imported-file to get the
|
|
current file if it was imported from a non-GIMP file format and not
|
|
yet saved, or gimp-image-get-exported-file if the image has been
|
|
exported to a non-GIMP file format.
|
|
HELP
|
|
|
|
&neo_pdb_misc('2009', '2.8');
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'file', type => 'file',
|
|
desc => 'The file.' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
file = gimp_image_get_any_file (image);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_set_file {
|
|
$blurb = "Sets the specified image's file.";
|
|
|
|
$help = <<'HELP';
|
|
This procedure sets the specified image's file.
|
|
HELP
|
|
|
|
&std_pdb_misc;
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' },
|
|
{ name => 'file', type => 'file',
|
|
desc => 'The new image file' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
gimp_image_set_file (image, file);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_get_xcf_file {
|
|
$blurb = "Returns the XCF file for the specified image.";
|
|
|
|
$help = <<'HELP';
|
|
This procedure returns the XCF file associated with the image. If
|
|
there is no such file, this procedure returns %NULL.
|
|
HELP
|
|
|
|
$author = 'Eric Grivel <gimp@lumenssolutions.com>';
|
|
$copyright = 'Eric Grivel';
|
|
$date = '2011';
|
|
$since = '2.8';
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'file', type => 'file',
|
|
desc => 'The imported XCF file.' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
file = gimp_image_get_file (image);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_get_imported_file {
|
|
$blurb = "Returns the imported file for the specified image.";
|
|
|
|
$help = <<'HELP';
|
|
This procedure returns the file associated with the specified image
|
|
if the image was imported from a non-native Gimp format. If the
|
|
image was not imported, or has since been saved in the native Gimp
|
|
format, this procedure returns %NULL.
|
|
HELP
|
|
|
|
$author = 'Eric Grivel <gimp@lumenssolutions.com>';
|
|
$copyright = 'Eric Grivel';
|
|
$date = '2011';
|
|
$since = '2.8';
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'file', type => 'file',
|
|
desc => 'The imported file.' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
file = gimp_image_get_imported_file (image);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_get_exported_file {
|
|
$blurb = "Returns the exported file for the specified image.";
|
|
|
|
$help = <<'HELP';
|
|
This procedure returns the file associated with the specified image
|
|
if the image was exported a non-native GIMP format. If the
|
|
image was not exported, this procedure returns %NULL.
|
|
HELP
|
|
|
|
$author = 'Eric Grivel <gimp@lumenssolutions.com>';
|
|
$copyright = 'Eric Grivel';
|
|
$date = '2011';
|
|
$since = '2.8';
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'file', type => 'file',
|
|
desc => 'The exported file.' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
file = gimp_image_get_exported_file (image);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_get_name {
|
|
$blurb = "Returns the specified image's name.";
|
|
$help = <<'HELP';
|
|
This procedure returns the image's name. If the image has a filename
|
|
or an URI, then the returned name contains the filename's or URI's
|
|
base name (the last component of the path). Otherwise it is the
|
|
translated string "Untitled". The returned name is formatted like the
|
|
image name in the image window title, it may contain '[]',
|
|
'(imported)' etc. and should only be used to label user interface
|
|
elements. Never use it to construct filenames.
|
|
HELP
|
|
|
|
&std_pdb_misc;
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'name', type => 'string',
|
|
desc => 'The name.' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
name = g_strdup (gimp_image_get_display_name (image));
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_get_resolution {
|
|
$blurb = "Returns the specified image's resolution.";
|
|
|
|
$help = <<'HELP';
|
|
This procedure returns the specified image's resolution in dots per inch.
|
|
This value is independent of any of the layers in this image.
|
|
HELP
|
|
|
|
&austin_pdb_misc('1998');
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'xresolution', type => 'float', void_ret => 1,
|
|
desc => 'The resolution in the x-axis, in dots per inch' },
|
|
{ name => 'yresolution', type => 'float',
|
|
desc => 'The resolution in the y-axis, in dots per inch' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
gimp_image_get_resolution (image, &xresolution, &yresolution);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_set_resolution {
|
|
$blurb = "Sets the specified image's resolution.";
|
|
|
|
$help = <<'HELP';
|
|
This procedure sets the specified image's resolution in dots per inch.
|
|
This value is independent of any of the layers in this image.
|
|
No scaling or resizing is performed.
|
|
HELP
|
|
|
|
&austin_pdb_misc('1998');
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' },
|
|
{ name => 'xresolution', type => 'float',
|
|
desc => 'The new image resolution in the x-axis, in dots per inch' },
|
|
{ name => 'yresolution', type => 'float',
|
|
desc => 'The new image resolution in the y-axis, in dots per inch' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
if (! isfinite (xresolution) ||
|
|
xresolution < GIMP_MIN_RESOLUTION || xresolution > GIMP_MAX_RESOLUTION ||
|
|
! isfinite (yresolution) ||
|
|
yresolution < GIMP_MIN_RESOLUTION || yresolution > GIMP_MAX_RESOLUTION)
|
|
{
|
|
g_set_error_literal (error, GIMP_PDB_ERROR,
|
|
GIMP_PDB_ERROR_INVALID_ARGUMENT,
|
|
_("Image resolution is out of bounds, "
|
|
"using the default resolution instead."));
|
|
success = FALSE;
|
|
}
|
|
else
|
|
{
|
|
gimp_image_set_resolution (image, xresolution, yresolution);
|
|
}
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_get_unit {
|
|
$blurb = "Returns the specified image's unit.";
|
|
|
|
$help = <<'HELP';
|
|
This procedure returns the specified image's unit. This value is
|
|
independent of any of the layers in this image. See the gimp_unit_*()
|
|
procedure definitions for the valid range of unit IDs and a
|
|
description of the unit system.
|
|
HELP
|
|
|
|
&mitch_pdb_misc('1998');
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'unit', type => 'unit',
|
|
desc => 'The unit' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
unit = gimp_image_get_unit (image);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_set_unit {
|
|
$blurb = "Sets the specified image's unit.";
|
|
|
|
$help = <<'HELP';
|
|
This procedure sets the specified image's unit. No scaling or resizing
|
|
is performed. This value is independent of any of the layers in this
|
|
image. See the gimp_unit_*() procedure definitions for the valid range
|
|
of unit IDs and a description of the unit system.
|
|
HELP
|
|
|
|
&mitch_pdb_misc('1998');
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' },
|
|
{ name => 'unit', type => 'unit (min GIMP_UNIT_INCH)',
|
|
desc => 'The new image unit' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
gimp_image_set_unit (image, unit);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_get_tattoo_state {
|
|
$blurb = 'Returns the tattoo state associated with the image.';
|
|
|
|
$help = <<'HELP';
|
|
This procedure returns the tattoo state of the image. Use only by
|
|
save/load plug-ins that wish to preserve an images tattoo state. Using this
|
|
function at other times will produce unexpected results.
|
|
HELP
|
|
|
|
&andy_pdb_misc('2000');
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'tattoo_state', type => 'tattoo',
|
|
desc => 'The tattoo state' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
tattoo_state = gimp_image_get_tattoo_state (image);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_set_tattoo_state {
|
|
$blurb = 'Set the tattoo state associated with the image.';
|
|
|
|
$help = <<'HELP';
|
|
This procedure sets the tattoo state of the image. Use only by
|
|
save/load plug-ins that wish to preserve an images tattoo state. Using
|
|
this function at other times will produce unexpected results. A full
|
|
check of uniqueness of states in layers, channels and paths will be
|
|
performed by this procedure and a execution failure will be returned
|
|
if this fails. A failure will also be returned if the new tattoo state
|
|
value is less than the maximum tattoo value from all of the tattoos
|
|
from the paths, layers and channels. After the image data has been
|
|
loaded and all the tattoos have been set then this is the last
|
|
procedure that should be called. If effectively does a status check on
|
|
the tattoo values that have been set to make sure that all is OK.
|
|
HELP
|
|
|
|
&andy_pdb_misc('2000');
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' },
|
|
{ name => 'tattoo_state', type => 'tattoo',
|
|
desc => 'The new image tattoo state' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
gimp_image_set_tattoo_state (image, tattoo_state);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_get_layer_by_tattoo {
|
|
$blurb = 'Find a layer with a given tattoo in an image.';
|
|
|
|
$help = <<'HELP';
|
|
This procedure returns the layer with the given tattoo in the specified image.
|
|
HELP
|
|
|
|
&jay_pdb_misc('1998');
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' },
|
|
{ name => 'tattoo', type => 'tattoo',
|
|
desc => 'The tattoo of the layer to find' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'layer', type => 'layer',
|
|
desc => 'The layer with the specified tattoo' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
layer = gimp_image_get_layer_by_tattoo (image, tattoo);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_get_channel_by_tattoo {
|
|
$blurb = 'Find a channel with a given tattoo in an image.';
|
|
|
|
$help = <<'HELP';
|
|
This procedure returns the channel with the given tattoo in the specified image.
|
|
HELP
|
|
|
|
&jay_pdb_misc('1998');
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' },
|
|
{ name => 'tattoo', type => 'tattoo',
|
|
desc => 'The tattoo of the channel to find' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'channel', type => 'channel',
|
|
desc => 'The channel with the specified tattoo' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
channel = gimp_image_get_channel_by_tattoo (image, tattoo);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_get_vectors_by_tattoo {
|
|
$blurb = 'Find a vectors with a given tattoo in an image.';
|
|
|
|
$help = <<'HELP';
|
|
This procedure returns the vectors with the given tattoo in the
|
|
specified image.
|
|
HELP
|
|
|
|
&simon_pdb_misc('2005', '2.6');
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' },
|
|
{ name => 'tattoo', type => 'tattoo',
|
|
desc => 'The tattoo of the vectors to find' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'vectors', type => 'vectors',
|
|
desc => 'The vectors with the specified tattoo' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
vectors = gimp_image_get_vectors_by_tattoo (image, tattoo);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_get_layer_by_name {
|
|
$blurb = 'Find a layer with a given name in an image.';
|
|
|
|
$help = <<'HELP';
|
|
This procedure returns the layer with the given name in the specified image.
|
|
HELP
|
|
|
|
&mitch_pdb_misc('2011', '2.8');
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' },
|
|
{ name => 'name', type => 'string', non_empty => 1,
|
|
desc => 'The name of the layer to find' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'layer', type => 'layer',
|
|
desc => 'The layer with the specified name' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
layer = gimp_image_get_layer_by_name (image, name);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_get_channel_by_name {
|
|
$blurb = 'Find a channel with a given name in an image.';
|
|
|
|
$help = <<'HELP';
|
|
This procedure returns the channel with the given name in the specified image.
|
|
HELP
|
|
|
|
&mitch_pdb_misc('2011', '2.8');
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' },
|
|
{ name => 'name', type => 'string', non_empty => 1,
|
|
desc => 'The name of the channel to find' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'channel', type => 'channel',
|
|
desc => 'The channel with the specified name' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
channel = gimp_image_get_channel_by_name (image, name);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_get_vectors_by_name {
|
|
$blurb = 'Find a vectors with a given name in an image.';
|
|
|
|
$help = <<'HELP';
|
|
This procedure returns the vectors with the given name in the
|
|
specified image.
|
|
HELP
|
|
|
|
&mitch_pdb_misc('2011', '2.8');
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' },
|
|
{ name => 'name', type => 'string', non_empty => 1,
|
|
desc => 'The name of the vectors to find' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'vectors', type => 'vectors',
|
|
desc => 'The vectors with the specified name' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
vectors = gimp_image_get_vectors_by_name (image, name);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_attach_parasite {
|
|
$blurb = 'Add a parasite to an image.';
|
|
|
|
$help = <<'HELP';
|
|
This procedure attaches a parasite to an image. It has no return values.
|
|
HELP
|
|
|
|
&jay_pdb_misc('1998', '2.8');
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' },
|
|
{ name => 'parasite', type => 'parasite',
|
|
desc => 'The parasite to attach to an image' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
if (gimp_image_parasite_validate (image, parasite, error))
|
|
gimp_image_parasite_attach (image, parasite, TRUE);
|
|
else
|
|
success = FALSE;
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_detach_parasite {
|
|
$blurb = 'Removes a parasite from an image.';
|
|
|
|
$help = <<'HELP';
|
|
This procedure detaches a parasite from an image. It has no return values.
|
|
HELP
|
|
|
|
&jay_pdb_misc('1998', '2.8');
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' },
|
|
{ name => 'name', type => 'string',
|
|
desc => 'The name of the parasite to detach from an image.' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
gimp_image_parasite_detach (image, name, TRUE);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_get_parasite {
|
|
$blurb = 'Look up a parasite in an image';
|
|
|
|
$help = <<'HELP';
|
|
Finds and returns the parasite that was previously attached to an image.
|
|
HELP
|
|
|
|
&jay_pdb_misc('1998', '2.8');
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' },
|
|
{ name => 'name', type => 'string',
|
|
desc => 'The name of the parasite to find' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'parasite', type => 'parasite',
|
|
desc => 'The found parasite' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
parasite = gimp_parasite_copy (gimp_image_parasite_find (image, name));
|
|
|
|
if (! parasite)
|
|
success = FALSE;
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_get_parasite_list {
|
|
$blurb = 'List all parasites.';
|
|
$help = <<'HELP';
|
|
Returns a list of the names of all currently attached parasites.
|
|
These names can later be used to get the actual #GimpParasite with
|
|
gimp_image_get_parasite() when needed.
|
|
HELP
|
|
|
|
&marc_pdb_misc('1999', '2.8');
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'parasites', type => 'strv',
|
|
desc => 'The names of currently attached parasites' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
parasites = gimp_image_parasite_list (image);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_thumbnail {
|
|
$blurb = 'Get a thumbnail of an image.';
|
|
|
|
$help = <<'HELP';
|
|
This function gets data from which a thumbnail of an image preview can
|
|
be created. Maximum x or y dimension is 1024 pixels. The pixels are
|
|
returned in RGB[A] or GRAY[A] format. The bpp return value gives the
|
|
number of bits per pixel in the image.
|
|
HELP
|
|
|
|
&andy_pdb_misc('1999');
|
|
|
|
$lib_private = 1;
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' },
|
|
{ name => 'width', type => '1 <= int32 <= 1024',
|
|
desc => 'The requested thumbnail width' },
|
|
{ name => 'height', type => '1 <= int32 <= 1024',
|
|
desc => 'The requested thumbnail height' }
|
|
);
|
|
|
|
@outargs = (
|
|
{ name => 'actual_width', type => 'int32', void_ret => 1,
|
|
desc => 'The previews width' },
|
|
{ name => 'actual_height', type => 'int32',
|
|
desc => 'The previews height' },
|
|
{ name => 'bpp', type => 'int32',
|
|
desc => 'The previews bpp' },
|
|
{ name => 'thumbnail_data', type => 'int8array',
|
|
desc => 'The thumbnail data',
|
|
array => { name => 'thumbnail_data_count',
|
|
desc => 'The number of bytes in thumbnail data' } }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
GimpTempBuf *buf;
|
|
gint dwidth, dheight;
|
|
|
|
gimp_assert (GIMP_VIEWABLE_MAX_PREVIEW_SIZE >= 1024);
|
|
|
|
/* Adjust the width/height ratio */
|
|
dwidth = gimp_image_get_width (image);
|
|
dheight = gimp_image_get_height (image);
|
|
|
|
if (dwidth > dheight)
|
|
height = MAX (1, (width * dheight) / dwidth);
|
|
else
|
|
width = MAX (1, (height * dwidth) / dheight);
|
|
|
|
gimp_pickable_flush (GIMP_PICKABLE (image));
|
|
|
|
buf = gimp_viewable_get_new_preview (GIMP_VIEWABLE (image), context,
|
|
width, height);
|
|
|
|
if (buf)
|
|
{
|
|
actual_width = gimp_temp_buf_get_width (buf);
|
|
actual_height = gimp_temp_buf_get_height (buf);
|
|
bpp = babl_format_get_bytes_per_pixel (gimp_temp_buf_get_format (buf));
|
|
thumbnail_data_count = gimp_temp_buf_get_data_size (buf);
|
|
thumbnail_data = g_memdup2 (gimp_temp_buf_get_data (buf),
|
|
thumbnail_data_count);
|
|
|
|
gimp_temp_buf_unref (buf);
|
|
}
|
|
else
|
|
success = FALSE;
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_policy_rotate {
|
|
$blurb = 'Execute the "Orientation" metadata policy.';
|
|
$help = <<'HELP';
|
|
Process the image according to the rotation policy as set in Preferences.
|
|
If GIMP is running as a GUI and interactive is TRUE, a dialog may be
|
|
presented to the user depending on the set policy. Otherwise, if the
|
|
policy does not mandate the action to perform, the image will be rotated
|
|
following the Orientation metadata.
|
|
|
|
If you wish absolutely to rotate a loaded image following the
|
|
Orientation metadata, do not use this function and process the metadata
|
|
yourself. Indeed even with `interactive` to FALSE, user settings may
|
|
leave the image unrotated.
|
|
|
|
Finally it is unnecessary to call this function in a format load
|
|
procedure because this is called automatically by the core code when
|
|
loading any image. You should only call this function explicitly when
|
|
loading an image through a PDB call.
|
|
HELP
|
|
|
|
&jehan_pdb_misc('2020', '3.0');
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' },
|
|
{ name => 'interactive', type => 'boolean',
|
|
desc => 'Querying the user through a dialog is a possibility' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
gimp_image_import_rotation_metadata (image, context, progress, interactive);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
sub image_policy_color_profile {
|
|
$blurb = 'Execute the color profile conversion policy.';
|
|
$help = <<'HELP';
|
|
Process the image according to the color profile policy as set in
|
|
Preferences.
|
|
|
|
If GIMP is running as a GUI and interactive is TRUE, a dialog may be
|
|
presented to the user depending on the policy. Otherwise, if the policy
|
|
does not mandate the conversion to perform, the conversion to the
|
|
preferred RGB or grayscale profile will happen, defaulting to built-in
|
|
profiles if no preferred profiles were set in `Preferences`.
|
|
|
|
This function should be used only if you want to follow user settings.
|
|
If you intend to convert to a specific profile, call preferably
|
|
gimp_image_convert_color_profile(). And if you wish to leave whatever
|
|
profile an image has, do not call any of these functions.
|
|
|
|
Finally it is unnecessary to call this function in a format load
|
|
procedure because this is called automatically by the core code when
|
|
loading any image. You should only call this function explicitly when
|
|
loading an image through a PDB call.
|
|
HELP
|
|
|
|
&jehan_pdb_misc('2020', '3.0');
|
|
|
|
@inargs = (
|
|
{ name => 'image', type => 'image',
|
|
desc => 'The image' },
|
|
{ name => 'interactive', type => 'boolean',
|
|
desc => 'Querying the user through a dialog is a possibility' }
|
|
);
|
|
|
|
%invoke = (
|
|
code => <<'CODE'
|
|
{
|
|
gimp_image_import_color_profile (image, context, progress, interactive);
|
|
}
|
|
CODE
|
|
);
|
|
}
|
|
|
|
@headers = qw("libgimpmath/gimpmath.h"
|
|
"libgimpbase/gimpbase.h"
|
|
"gegl/gimp-babl.h"
|
|
"core/gimp.h"
|
|
"core/gimpcontainer.h"
|
|
"core/gimpimage-color-profile.h"
|
|
"core/gimpimage-metadata.h"
|
|
"core/gimpimage-rotate.h"
|
|
"core/gimpprogress.h"
|
|
"core/gimptempbuf.h"
|
|
"file/file-utils.h"
|
|
"plug-in/gimpplugin.h"
|
|
"plug-in/gimpplugin-cleanup.h"
|
|
"plug-in/gimppluginmanager.h"
|
|
"gimppdbcontext.h"
|
|
"gimppdberror.h"
|
|
"gimppdb-utils.h"
|
|
"gimp-intl.h");
|
|
|
|
@procs = qw(image_id_is_valid
|
|
get_images
|
|
image_new image_new_with_precision
|
|
image_duplicate image_delete
|
|
image_get_base_type
|
|
image_get_precision
|
|
image_get_default_new_layer_mode
|
|
image_get_width image_get_height
|
|
image_get_layers
|
|
image_get_channels
|
|
image_get_vectors
|
|
image_unset_active_channel
|
|
image_get_floating_sel
|
|
image_floating_sel_attached_to
|
|
image_pick_color
|
|
image_pick_correlate_layer
|
|
image_insert_layer image_remove_layer
|
|
image_freeze_layers image_thaw_layers
|
|
image_insert_channel image_remove_channel
|
|
image_freeze_channels image_thaw_channels
|
|
image_insert_vectors image_remove_vectors
|
|
image_freeze_vectors image_thaw_vectors
|
|
image_get_item_position
|
|
image_raise_item image_lower_item
|
|
image_raise_item_to_top image_lower_item_to_bottom
|
|
image_reorder_item
|
|
image_flatten image_merge_visible_layers image_merge_down
|
|
image_merge_layer_group
|
|
image_get_colormap image_set_colormap
|
|
image_get_metadata image_set_metadata
|
|
image_clean_all image_is_dirty
|
|
image_thumbnail
|
|
image_get_selected_layers image_set_selected_layers
|
|
image_get_selected_drawables
|
|
image_get_selection
|
|
image_get_component_active image_set_component_active
|
|
image_get_component_visible image_set_component_visible
|
|
image_get_file
|
|
image_set_file
|
|
image_get_xcf_file
|
|
image_get_imported_file
|
|
image_get_exported_file
|
|
image_get_name
|
|
image_get_resolution image_set_resolution
|
|
image_get_unit image_set_unit
|
|
image_get_tattoo_state image_set_tattoo_state
|
|
image_get_layer_by_tattoo
|
|
image_get_channel_by_tattoo
|
|
image_get_vectors_by_tattoo
|
|
image_get_layer_by_name
|
|
image_get_channel_by_name
|
|
image_get_vectors_by_name
|
|
image_attach_parasite image_detach_parasite
|
|
image_get_parasite
|
|
image_get_parasite_list
|
|
image_policy_rotate
|
|
image_policy_color_profile);
|
|
|
|
%exports = (app => [@procs], lib => [@procs]);
|
|
|
|
$desc = 'Image';
|
|
$doc_title = 'gimpimage';
|
|
$doc_short_desc = 'Operations on complete images.';
|
|
$doc_long_desc = 'Operations on complete images: creation, resizing/rescaling, and operations involving multiple layers.';
|
|
|
|
1;
|