dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

app, libgimp, pdb: add missing functions for selected items. 

Missing functions were:
* gimp_image_get_selected_channels()
* gimp_image_get_selected_vectors()
* gimp_image_list_selected_channels()
* gimp_image_list_selected_vectors()
* gimp_image_set_selected_channels()
* gimp_image_set_selected_vectors()
* gimp_image_take_selected_channels()
* gimp_image_take_selected_vectors()

There are discussions of renaming GimpVectors to GimpPath, which would
also be consistent with the GUI and make the always-plural less akward
in API. We'll see. For now keeping named like this.
This commit is contained in:
Jehan 2022-10-20 02:36:50 +02:00
parent 0c6f7b167a
commit b73278f1a8
8 changed files with 806 additions and 4 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

298
app/pdb/image-cmds.c
View File

@ -1836,6 +1836,164 @@ image_set_selected_layers_invoker (GimpProcedure *procedure,
error ? *error : NULL);
}
static GimpValueArray *
image_get_selected_channels_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpValueArray *return_vals;
GimpImage *image;
gint num_channels = 0;
GimpChannel **channels = NULL;
image = g_value_get_object (gimp_value_array_index (args, 0));
if (success)
{
GList *list = gimp_image_get_selected_channels (image);
num_channels = g_list_length (list);
if (num_channels)
{
gint i;
channels = g_new (GimpLayer *, num_channels);
for (i = 0; i < num_channels; i++, list = g_list_next (list))
channels[i] = g_object_ref (list->data);
}
}
return_vals = gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
if (success)
{
g_value_set_int (gimp_value_array_index (return_vals, 1), num_channels);
gimp_value_take_object_array (gimp_value_array_index (return_vals, 2), GIMP_TYPE_CHANNEL, (GObject **) channels, num_channels);
}
return return_vals;
}
static GimpValueArray *
image_set_selected_channels_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpImage *image;
gint num_channels;
const GimpChannel **channels;
image = g_value_get_object (gimp_value_array_index (args, 0));
num_channels = g_value_get_int (gimp_value_array_index (args, 1));
channels = gimp_value_get_object_array (gimp_value_array_index (args, 2));
if (success)
{
GList *selected_channels = NULL;
gint i;
for (i = 0; i < num_channels; i++)
selected_channels = g_list_prepend (selected_channels,
GIMP_LAYER (channels[i]));
gimp_image_set_selected_channels (image, selected_channels);
g_list_free (selected_channels);
}
return gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
}
static GimpValueArray *
image_get_selected_vectors_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpValueArray *return_vals;
GimpImage *image;
gint num_vectors = 0;
GimpVectors **vectors = NULL;
image = g_value_get_object (gimp_value_array_index (args, 0));
if (success)
{
GList *list = gimp_image_get_selected_vectors (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);
}
}
return_vals = gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
if (success)
{
g_value_set_int (gimp_value_array_index (return_vals, 1), num_vectors);
gimp_value_take_object_array (gimp_value_array_index (return_vals, 2), GIMP_TYPE_VECTORS, (GObject **) vectors, num_vectors);
}
return return_vals;
}
static GimpValueArray *
image_set_selected_vectors_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpImage *image;
gint num_vectors;
const GimpVectors **vectors;
image = g_value_get_object (gimp_value_array_index (args, 0));
num_vectors = g_value_get_int (gimp_value_array_index (args, 1));
vectors = (const GimpVectors **) gimp_value_get_object_array (gimp_value_array_index (args, 2));
if (success)
{
GList *selected_vectors = NULL;
gint i;
for (i = 0; i < num_vectors; i++)
selected_vectors = g_list_prepend (selected_vectors,
GIMP_LAYER (vectors[i]));
gimp_image_set_selected_vectors (image, selected_vectors);
g_list_free (selected_vectors);
}
return gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
}
static GimpValueArray *
image_get_selected_drawables_invoker (GimpProcedure *procedure,
Gimp *gimp,
@ -4425,6 +4583,146 @@ register_image_procs (GimpPDB *pdb)
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-get-selected-channels
*/
procedure = gimp_procedure_new (image_get_selected_channels_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-get-selected-channels");
gimp_procedure_set_static_help (procedure,
"Returns the specified image's selected channels.",
"This procedure returns the list of selected channels in the specified image.",
NULL);
gimp_procedure_set_static_attribution (procedure,
"Jehan",
"Jehan",
"2022");
gimp_procedure_add_argument (procedure,
gimp_param_spec_image ("image",
"image",
"The image",
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
g_param_spec_int ("num-channels",
"num channels",
"The number of selected channels in the image",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_object_array ("channels",
"channels",
"The list of selected channels in the image.",
GIMP_TYPE_CHANNEL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-set-selected-channels
*/
procedure = gimp_procedure_new (image_set_selected_channels_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-set-selected-channels");
gimp_procedure_set_static_help (procedure,
"Sets the specified image's selected channels.",
"The channels are set as the selected channels 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.",
NULL);
gimp_procedure_set_static_attribution (procedure,
"Jehan",
"Jehan",
"2022");
gimp_procedure_add_argument (procedure,
gimp_param_spec_image ("image",
"image",
"The image",
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_int ("num-channels",
"num channels",
"The number of channels to select",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_object_array ("channels",
"channels",
"The list of channels to select",
GIMP_TYPE_CHANNEL,
GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-get-selected-vectors
*/
procedure = gimp_procedure_new (image_get_selected_vectors_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-get-selected-vectors");
gimp_procedure_set_static_help (procedure,
"Returns the specified image's selected vectors.",
"This procedure returns the list of selected vectors in the specified image.",
NULL);
gimp_procedure_set_static_attribution (procedure,
"Jehan",
"Jehan",
"2022");
gimp_procedure_add_argument (procedure,
gimp_param_spec_image ("image",
"image",
"The image",
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
g_param_spec_int ("num-vectors",
"num vectors",
"The number of selected vectors in the image",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_object_array ("vectors",
"vectors",
"The list of selected vectors in the image.",
GIMP_TYPE_VECTORS,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-set-selected-vectors
*/
procedure = gimp_procedure_new (image_set_selected_vectors_invoker);
gimp_object_set_static_name (GIMP_OBJECT (procedure),
"gimp-image-set-selected-vectors");
gimp_procedure_set_static_help (procedure,
"Sets the specified image's selected vectors.",
"The vectors are set as the selected vectors in the image.",
NULL);
gimp_procedure_set_static_attribution (procedure,
"Jehan",
"Jehan",
"2022");
gimp_procedure_add_argument (procedure,
gimp_param_spec_image ("image",
"image",
"The image",
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_int ("num-vectors",
"num vectors",
"The number of vectors to select",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_object_array ("vectors",
"vectors",
"The list of vectors to select",
GIMP_TYPE_VECTORS,
GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
/*
* gimp-image-get-selected-drawables
*/

2
app/pdb/internal-procs.c
View File

@ -30,7 +30,7 @@
#include "internal-procs.h"
/* 763 procedures registered total */
/* 767 procedures registered total */
void
internal_procs_init (GimpPDB *pdb)

8
libgimp/gimp.def
View File

@ -414,8 +414,10 @@ EXPORTS
gimp_image_get_precision
gimp_image_get_resolution
gimp_image_get_sample_point_position
gimp_image_get_selected_channels
gimp_image_get_selected_drawables
gimp_image_get_selected_layers
gimp_image_get_selected_vectors
gimp_image_get_selection
gimp_image_get_simulation_bpc
gimp_image_get_simulation_intent
@ -448,7 +450,9 @@ EXPORTS
gimp_image_is_valid
gimp_image_list_channels
gimp_image_list_layers
gimp_image_list_selected_channels
gimp_image_list_selected_layers
gimp_image_list_selected_vectors
gimp_image_list_vectors
gimp_image_lower_item
gimp_image_lower_item_to_bottom
@ -494,14 +498,18 @@ EXPORTS
gimp_image_set_file
gimp_image_set_metadata
gimp_image_set_resolution
gimp_image_set_selected_channels
gimp_image_set_selected_layers
gimp_image_set_selected_vectors
gimp_image_set_simulation_bpc
gimp_image_set_simulation_intent
gimp_image_set_simulation_profile
gimp_image_set_simulation_profile_from_file
gimp_image_set_tattoo_state
gimp_image_set_unit
gimp_image_take_selected_channels
gimp_image_take_selected_layers
gimp_image_take_selected_vectors
gimp_image_thaw_channels
gimp_image_thaw_layers
gimp_image_thaw_vectors

136
libgimp/gimpimage.c
View File

@ -261,7 +261,7 @@ gimp_image_list_layers (GimpImage *image)
* image.
*
* Returns: (element-type GimpLayer) (transfer container):
* The list of layers contained in the image.
* The list of selected layers in the image.
* The returned list must be freed with g_list_free(). Layer
* elements belong to libgimp and must not be freed.
*
@ -319,6 +319,140 @@ gimp_image_take_selected_layers (GimpImage *image,
return success;
}
/**
* gimp_image_list_selected_channels:
* @image: The image.
*
* Returns the list of channels selected in the specified image.
*
* This procedure returns the list of channels selected in the specified
* image.
*
* Returns: (element-type GimpChannel) (transfer container):
* The list of selected channels in the image.
* The returned list must be freed with g_list_free(). Layer
* elements belong to libgimp and must not be freed.
*
* Since: 3.0
**/
GList *
gimp_image_list_selected_channels (GimpImage *image)
{
GimpChannel **channels;
gint num_channels;
GList *list = NULL;
gint i;
channels = gimp_image_get_selected_channels (image, &num_channels);
for (i = 0; i < num_channels; i++)
list = g_list_prepend (list, channels[i]);
g_free (channels);
return g_list_reverse (list);
}
/**
* gimp_image_take_selected_channels:
* @image: The image.
* @channels: (transfer container) (element-type GimpChannel): The list of channels to select.
*
* The channels are set as the selected channels 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.
*
* Returns: TRUE on success.
*
* Since: 3.0
**/
gboolean
gimp_image_take_selected_channels (GimpImage *image,
GList *channels)
{
GimpChannel **sel_channels;
GList *list;
gboolean success;
gint i;
sel_channels = g_new0 (GimpChannel *, g_list_length (channels));
for (list = channels, i = 0; list; list = list->next, i++)
sel_channels[i] = list->data;
success = gimp_image_set_selected_channels (image, g_list_length (channels),
(const GimpChannel **) sel_channels);
g_list_free (channels);
return success;
}
/**
* gimp_image_list_selected_vectors:
* @image: The image.
*
* Returns the list of paths selected in the specified image.
*
* This procedure returns the list of paths selected in the specified
* image.
*
* Returns: (element-type GimpVectors) (transfer container):
* The list of selected paths in the image.
* The returned list must be freed with g_list_free().
* Path elements belong to libgimp and must not be freed.
*
* Since: 3.0
**/
GList *
gimp_image_list_selected_vectors (GimpImage *image)
{
GimpVectors **vectors;
gint num_vectors;
GList *list = NULL;
gint i;
vectors = gimp_image_get_selected_vectors (image, &num_vectors);
for (i = 0; i < num_vectors; i++)
list = g_list_prepend (list, vectors[i]);
g_free (vectors);
return g_list_reverse (list);
}
/**
* gimp_image_take_selected_vectors:
* @image: The image.
* @vectors: (transfer container) (element-type GimpVectors): The list of paths to select.
*
* The paths are set as the selected paths in the image. Any previous
* selected paths are unselected.
*
* Returns: TRUE on success.
*
* Since: 3.0
**/
gboolean
gimp_image_take_selected_vectors (GimpImage *image,
GList *vectors)
{
GimpVectors **sel_vectors;
GList *list;
gboolean success;
gint i;
sel_vectors = g_new0 (GimpVectors *, g_list_length (vectors));
for (list = vectors, i = 0; list; list = list->next, i++)
sel_vectors[i] = list->data;
success = gimp_image_set_selected_vectors (image, g_list_length (vectors),
(const GimpVectors **) sel_vectors);
g_list_free (vectors);
return success;
}
/**
* gimp_image_list_channels:
* @image: The image.

10
libgimp/gimpimage.h
View File

@ -46,9 +46,15 @@ GList * gimp_image_list_layers (GimpImage *image);
GList * gimp_image_list_channels (GimpImage *image);
GList * gimp_image_list_vectors (GimpImage *image);
GList * gimp_image_list_selected_layers (GimpImage *image);
gboolean gimp_image_take_selected_layers (GimpImage *image,
GList * gimp_image_list_selected_layers (GimpImage *image);
gboolean gimp_image_take_selected_layers (GimpImage *image,
GList *layers);
GList * gimp_image_list_selected_channels (GimpImage *image);
gboolean gimp_image_take_selected_channels (GimpImage *image,
GList *channels);
GList * gimp_image_list_selected_vectors (GimpImage *image);
gboolean gimp_image_take_selected_vectors (GimpImage *image,
GList *vectors);
guchar * gimp_image_get_colormap (GimpImage *image,
gint *num_colors);

179
libgimp/gimpimage_pdb.c
View File

@ -2138,6 +2138,185 @@ gimp_image_set_selected_layers (GimpImage *image,
return success;
}
/**
* gimp_image_get_selected_channels: (skip)
* @image: The image.
* @num_channels: (out): The number of selected channels in the image.
*
* Returns the specified image's selected channels.
*
* This procedure returns the list of selected channels in the
* specified image.
*
* Returns: (array length=num_channels) (element-type GimpChannel) (transfer container):
* The list of selected channels in the image.
* The returned value must be freed with g_free().
*
* Since: 3.0.0
**/
GimpChannel **
gimp_image_get_selected_channels (GimpImage *image,
gint *num_channels)
{
GimpValueArray *args;
GimpValueArray *return_vals;
GimpChannel **channels = NULL;
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_IMAGE, image,
G_TYPE_NONE);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-image-get-selected-channels",
args);
gimp_value_array_unref (args);
*num_channels = 0;
if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
{
*num_channels = GIMP_VALUES_GET_INT (return_vals, 1);
{ GimpObjectArray *a = g_value_get_boxed (gimp_value_array_index (return_vals, 2)); if (a) channels = g_memdup2 (a->data, a->length * sizeof (gpointer)); };
}
gimp_value_array_unref (return_vals);
return channels;
}
/**
* gimp_image_set_selected_channels:
* @image: The image.
* @num_channels: The number of channels to select.
* @channels: (array length=num_channels) (element-type GimpChannel): The list of channels to select.
*
* Sets the specified image's selected channels.
*
* The channels are set as the selected channels 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.
*
* Returns: TRUE on success.
*
* Since: 3.0.0
**/
gboolean
gimp_image_set_selected_channels (GimpImage *image,
gint num_channels,
const GimpChannel **channels)
{
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_IMAGE, image,
G_TYPE_INT, num_channels,
GIMP_TYPE_OBJECT_ARRAY, NULL,
G_TYPE_NONE);
gimp_value_set_object_array (gimp_value_array_index (args, 2), GIMP_TYPE_CHANNEL, (GObject **) channels, num_channels);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-image-set-selected-channels",
args);
gimp_value_array_unref (args);
success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;
gimp_value_array_unref (return_vals);
return success;
}
/**
* gimp_image_get_selected_vectors: (skip)
* @image: The image.
* @num_vectors: (out): The number of selected vectors in the image.
*
* Returns the specified image's selected vectors.
*
* This procedure returns the list of selected vectors in the specified
* image.
*
* Returns: (array length=num_vectors) (element-type GimpVectors) (transfer container):
* The list of selected vectors in the image.
* The returned value must be freed with g_free().
*
* Since: 3.0.0
**/
GimpVectors **
gimp_image_get_selected_vectors (GimpImage *image,
gint *num_vectors)
{
GimpValueArray *args;
GimpValueArray *return_vals;
GimpVectors **vectors = NULL;
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_IMAGE, image,
G_TYPE_NONE);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-image-get-selected-vectors",
args);
gimp_value_array_unref (args);
*num_vectors = 0;
if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
{
*num_vectors = GIMP_VALUES_GET_INT (return_vals, 1);
{ GimpObjectArray *a = g_value_get_boxed (gimp_value_array_index (return_vals, 2)); if (a) vectors = g_memdup2 (a->data, a->length * sizeof (gpointer)); };
}
gimp_value_array_unref (return_vals);
return vectors;
}
/**
* gimp_image_set_selected_vectors:
* @image: The image.
* @num_vectors: The number of vectors to select.
* @vectors: (array length=num_vectors) (element-type GimpVectors): The list of vectors to select.
*
* Sets the specified image's selected vectors.
*
* The vectors are set as the selected vectors in the image.
*
* Returns: TRUE on success.
*
* Since: 3.0.0
**/
gboolean
gimp_image_set_selected_vectors (GimpImage *image,
gint num_vectors,
const GimpVectors **vectors)
{
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_IMAGE, image,
G_TYPE_INT, num_vectors,
GIMP_TYPE_OBJECT_ARRAY, NULL,
G_TYPE_NONE);
gimp_value_set_object_array (gimp_value_array_index (args, 2), GIMP_TYPE_VECTORS, (GObject **) vectors, num_vectors);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-image-set-selected-vectors",
args);
gimp_value_array_unref (args);
success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;
gimp_value_array_unref (return_vals);
return success;
}
/**
* gimp_image_get_selected_drawables:
* @image: The image.

10
libgimp/gimpimage_pdb.h
View File

@ -138,6 +138,16 @@ GimpLayer** gimp_image_get_selected_layers (GimpImage
gboolean gimp_image_set_selected_layers (GimpImage *image,
gint num_layers,
const GimpLayer **layers);
GimpChannel** gimp_image_get_selected_channels (GimpImage *image,
gint *num_channels);
gboolean gimp_image_set_selected_channels (GimpImage *image,
gint num_channels,
const GimpChannel **channels);
GimpVectors** gimp_image_get_selected_vectors (GimpImage *image,
gint *num_vectors);
gboolean gimp_image_set_selected_vectors (GimpImage *image,
gint num_vectors,
const GimpVectors **vectors);
GimpItem** gimp_image_get_selected_drawables (GimpImage *image,
gint *num_drawables);
GimpSelection* gimp_image_get_selection (GimpImage *image);

167
pdb/groups/image.pdb
View File

@ -1884,6 +1884,171 @@ CODE
);
}
sub image_get_selected_channels {
$blurb = "Returns the specified image's selected channels.";
$help = <<'HELP';
This procedure returns the list of selected channels in the specified image.
HELP
&jehan_pdb_misc('2022', '3.0.0');
$skip_gi = 1;
@inargs = (
{ name => 'image', type => 'image',
desc => 'The image' }
);
@outargs = (
{ name => 'channels', type => 'channelarray',
desc => 'The list of selected channels in the image.',
array => { name => 'num_channels',
desc => 'The number of selected channels in the image' } }
);
%invoke = (
code => <<'CODE'
{
GList *list = gimp_image_get_selected_channels (image);
num_channels = g_list_length (list);
if (num_channels)
{
gint i;
channels = g_new (GimpLayer *, num_channels);
for (i = 0; i < num_channels; i++, list = g_list_next (list))
channels[i] = g_object_ref (list->data);
}
}
CODE
);
}
sub image_set_selected_channels {
$blurb = "Sets the specified image's selected channels.";
$help = <<'HELP';
The channels are set as the selected channels 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('2022', '3.0.0');
@inargs = (
{ name => 'image', type => 'image',
desc => 'The image' },
{ name => 'channels', type => 'channelarray',
desc => 'The list of channels to select',
no_validate => 1,
array => { name => 'num_channels',
type => '0 <= int32',
desc => 'The number of channels to select' } }
);
%invoke = (
code => <<'CODE'
{
GList *selected_channels = NULL;
gint i;
for (i = 0; i < num_channels; i++)
selected_channels = g_list_prepend (selected_channels,
GIMP_LAYER (channels[i]));
gimp_image_set_selected_channels (image, selected_channels);
g_list_free (selected_channels);
}
CODE
);
}
sub image_get_selected_vectors {
$blurb = "Returns the specified image's selected vectors.";
$help = <<'HELP';
This procedure returns the list of selected vectors in the specified image.
HELP
&jehan_pdb_misc('2022', '3.0.0');
$skip_gi = 1;
@inargs = (
{ name => 'image', type => 'image',
desc => 'The image' }
);
@outargs = (
{ name => 'vectors', type => 'vectorarray',
desc => 'The list of selected vectors in the image.',
array => { name => 'num_vectors',
desc => 'The number of selected vectors in the image' } }
);
%invoke = (
code => <<'CODE'
{
GList *list = gimp_image_get_selected_vectors (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_set_selected_vectors {
$blurb = "Sets the specified image's selected vectors.";
$help = <<'HELP';
The vectors are set as the selected vectors in the image.
HELP
&jehan_pdb_misc('2022', '3.0.0');
@inargs = (
{ name => 'image', type => 'image',
desc => 'The image' },
{ name => 'vectors', type => 'vectorarray',
desc => 'The list of vectors to select',
no_validate => 1,
array => { name => 'num_vectors',
type => '0 <= int32',
desc => 'The number of vectors to select' } }
);
%invoke = (
code => <<'CODE'
{
GList *selected_vectors = NULL;
gint i;
for (i = 0; i < num_vectors; i++)
selected_vectors = g_list_prepend (selected_vectors,
GIMP_LAYER (vectors[i]));
gimp_image_set_selected_vectors (image, selected_vectors);
g_list_free (selected_vectors);
}
CODE
);
}
sub image_get_selected_drawables {
$blurb = "Get the image's selected drawables";
@ -3015,6 +3180,8 @@ CODE
image_clean_all image_is_dirty
image_thumbnail
image_get_selected_layers image_set_selected_layers
image_get_selected_channels image_set_selected_channels
image_get_selected_vectors image_set_selected_vectors
image_get_selected_drawables
image_get_selection
image_get_component_active image_set_component_active