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

app, libgimp*, plug-ins: move all GimpObjectArray procedure args to GimpCoreObjectArray.

This commit is contained in:
Jehan 2024-10-22 22:46:21 +02:00
parent 08fd3a3f0d
commit e1e2941d9e
20 changed files with 317 additions and 298 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
app/actions/gimpgeglprocedure.c
View File

@ -210,10 +210,11 @@ gimp_gegl_procedure_execute (GimpProcedure *procedure,
GObject **drawables;
GObject *config;
image = g_value_get_object (gimp_value_array_index (args, 1));
n_drawables = g_value_get_int (gimp_value_array_index (args, 2));
drawables = gimp_value_get_object_array (gimp_value_array_index (args, 3));
config = g_value_get_object (gimp_value_array_index (args, 4));
image = g_value_get_object (gimp_value_array_index (args, 1));
drawables = g_value_get_boxed (gimp_value_array_index (args, 2));
config = g_value_get_object (gimp_value_array_index (args, 3));
n_drawables = gimp_core_object_array_get_length ((GObject **) drawables);
if (n_drawables == 1)
{
@ -254,7 +255,7 @@ gimp_gegl_procedure_execute_async (GimpProcedure *procedure,
const gchar *tool_name;
run_mode = g_value_get_enum (gimp_value_array_index (args, 0));
settings = g_value_get_object (gimp_value_array_index (args, 4));
settings = g_value_get_object (gimp_value_array_index (args, 3));
if (! settings &&
(run_mode != GIMP_RUN_INTERACTIVE ||
@ -292,7 +293,7 @@ gimp_gegl_procedure_execute_async (GimpProcedure *procedure,
{
GimpValueArray *return_vals;
g_value_set_object (gimp_value_array_index (args, 4), settings);
g_value_set_object (gimp_value_array_index (args, 3), settings);
return_vals = gimp_procedure_execute (procedure, gimp, context, progress,
args, NULL);
gimp_value_array_unref (return_vals);
@ -514,17 +515,11 @@ gimp_gegl_procedure_new (Gimp *gimp,
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_int ("num-drawables",
"N drawables",
"The number of drawables",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_object_array ("drawables",
"Drawables",
"Input drawables",
GIMP_TYPE_DRAWABLE,
GIMP_PARAM_READWRITE));
gimp_param_spec_core_object_array ("drawables",
"Drawables",
"Input drawables",
GIMP_TYPE_DRAWABLE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_object ("settings",
"Settings",

53
app/actions/procedure-commands.c
View File

@ -193,31 +193,20 @@ procedure_commands_get_items_args (GimpProcedure *procedure,
return NULL;
}
}
else if (gimp_value_array_length (args) > n_args + 1 &&
G_IS_PARAM_SPEC_INT (procedure->args[n_args]) &&
GIMP_IS_PARAM_SPEC_OBJECT_ARRAY (procedure->args[n_args + 1]))
else if (GIMP_IS_PARAM_SPEC_CORE_OBJECT_ARRAY (procedure->args[n_args]))
{
GimpItem **items = NULL;
gint n_items;
GList *iter;
gint i;
n_items = g_list_length (items_list);
items = g_new0 (GimpItem *, n_items + 1);
for (iter = items_list, i = 0; iter; iter = iter->next, i++)
items[i] = iter->data;
g_value_set_int (gimp_value_array_index (args, n_args++),
n_items);
if (items_list)
{
GList *iter;
gint i;
items = g_new (GimpItem *, n_items);
for (iter = items_list, i = 0; iter; iter = iter->next, i++)
items[i] = iter->data;
}
gimp_value_set_object_array (gimp_value_array_index (args, n_args++),
GIMP_TYPE_ITEM,
(GObject **) items, n_items);
g_value_set_boxed (gimp_value_array_index (args, n_args++), (GObject **) items);
g_free (items);
}
@ -298,31 +287,21 @@ procedure_commands_get_display_args (GimpProcedure *procedure,
return NULL;
}
}
else if (gimp_value_array_length (args) > n_args + 1 &&
G_IS_PARAM_SPEC_INT (procedure->args[n_args]) &&
GIMP_IS_PARAM_SPEC_OBJECT_ARRAY (procedure->args[n_args + 1]))
else if (GIMP_IS_PARAM_SPEC_CORE_OBJECT_ARRAY (procedure->args[n_args]))
{
GimpDrawable **drawables = NULL;
gint n_drawables;
GList *iter;
gint i;
n_drawables = g_list_length (drawables_list);
g_value_set_int (gimp_value_array_index (args, n_args++),
n_drawables);
drawables = g_new0 (GimpDrawable *, n_drawables + 1);
for (iter = drawables_list, i = 0; iter; iter = iter->next, i++)
drawables[i] = iter->data;
if (drawables_list)
{
GList *iter;
gint i;
drawables = g_new (GimpDrawable *, n_drawables);
for (iter = drawables_list, i = 0; iter; iter = iter->next, i++)
drawables[i] = iter->data;
}
gimp_value_set_object_array (gimp_value_array_index (args, n_args++),
GIMP_TYPE_DRAWABLE,
(GObject **) drawables, n_drawables);
g_value_set_boxed (gimp_value_array_index (args, n_args++), (GObject **) drawables);
g_free (drawables);
}

9
app/errors.c
View File

@ -471,11 +471,10 @@ gimp_eek (const gchar *reason,
gimp_get_user_context (the_errors_gimp),
NULL, NULL,
"gimp-xcf-save",
GIMP_TYPE_RUN_MODE, GIMP_RUN_NONINTERACTIVE,
GIMP_TYPE_IMAGE, image,
G_TYPE_INT, 0,
GIMP_TYPE_OBJECT_ARRAY, NULL,
G_TYPE_FILE, backup_file,
GIMP_TYPE_RUN_MODE, GIMP_RUN_NONINTERACTIVE,
GIMP_TYPE_IMAGE, image,
GIMP_TYPE_CORE_OBJECT_ARRAY, NULL,
G_TYPE_FILE, backup_file,
G_TYPE_NONE);
g_rename (g_file_peek_path (backup_file), backup_path);
i++;

10
app/file-data/file-data-gbr.c
View File

@ -134,11 +134,11 @@ file_gbr_save_invoker (GimpProcedure *procedure,
gimp_set_busy (gimp);
image = g_value_get_object (gimp_value_array_index (args, 1));
n_drawables = g_value_get_int (gimp_value_array_index (args, 2));
drawables = (GimpDrawable **) gimp_value_get_object_array (gimp_value_array_index (args, 3));
file = g_value_get_object (gimp_value_array_index (args, 4));
spacing = g_value_get_int (gimp_value_array_index (args, 5));
name = g_value_get_string (gimp_value_array_index (args, 6));
drawables = (GimpDrawable **) g_value_get_boxed (gimp_value_array_index (args, 2));
n_drawables = gimp_core_object_array_get_length ((GObject **) drawables);
file = g_value_get_object (gimp_value_array_index (args, 3));
spacing = g_value_get_int (gimp_value_array_index (args, 4));
name = g_value_get_string (gimp_value_array_index (args, 5));
brush = file_gbr_image_to_brush (image, context, n_drawables, drawables, name, spacing);

8
app/file-data/file-data-gih.c
View File

@ -134,10 +134,10 @@ file_gih_save_invoker (GimpProcedure *procedure,
/* XXX: drawable list is currently unused. GIH saving just uses the
* whole layer list.
*/
file = g_value_get_object (gimp_value_array_index (args, 4));
spacing = g_value_get_int (gimp_value_array_index (args, 5));
name = g_value_get_string (gimp_value_array_index (args, 6));
params = g_value_get_string (gimp_value_array_index (args, 7));
file = g_value_get_object (gimp_value_array_index (args, 3));
spacing = g_value_get_int (gimp_value_array_index (args, 4));
name = g_value_get_string (gimp_value_array_index (args, 5));
params = g_value_get_string (gimp_value_array_index (args, 6));
pipe = file_gih_image_to_pipe (image, name, spacing, params);

8
app/file-data/file-data-pat.c
View File

@ -134,10 +134,10 @@ file_pat_save_invoker (GimpProcedure *procedure,
gimp_set_busy (gimp);
image = g_value_get_object (gimp_value_array_index (args, 1));
n_drawables = g_value_get_int (gimp_value_array_index (args, 2));
drawables = (GimpDrawable **) gimp_value_get_object_array (gimp_value_array_index (args, 3));
file = g_value_get_object (gimp_value_array_index (args, 4));
name = g_value_get_string (gimp_value_array_index (args, 5));
drawables = (GimpDrawable **) g_value_get_boxed (gimp_value_array_index (args, 2));
n_drawables = gimp_core_object_array_get_length ((GObject **) drawables);
file = g_value_get_object (gimp_value_array_index (args, 3));
name = g_value_get_string (gimp_value_array_index (args, 4));
pattern = file_pat_image_to_pattern (image, context, n_drawables, drawables, name);

48
app/file-data/file-data.c
View File

@ -154,17 +154,11 @@ file_data_init (Gimp *gimp)
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_int ("num-drawables",
"Num drawables",
"Number of drawables",
1, G_MAXINT, 1,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_object_array ("drawables",
"Drawables",
"Selected drawables",
GIMP_TYPE_DRAWABLE,
GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
gimp_param_spec_core_object_array ("drawables",
"Drawables",
"Selected drawables",
GIMP_TYPE_DRAWABLE,
GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
gimp_procedure_add_argument (procedure,
g_param_spec_object ("file",
"File",
@ -291,17 +285,11 @@ file_data_init (Gimp *gimp)
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_int ("num-drawables",
"num drawables",
"The number of drawables to save",
1, G_MAXINT32, 1,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_object_array ("drawables",
"drawables",
"Drawables to save",
GIMP_TYPE_DRAWABLE,
GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
gimp_param_spec_core_object_array ("drawables",
"drawables",
"Drawables to save",
GIMP_TYPE_DRAWABLE,
GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
gimp_procedure_add_argument (procedure,
g_param_spec_object ("file",
"File",
@ -434,17 +422,11 @@ file_data_init (Gimp *gimp)
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_int ("num-drawables",
"Num drawables",
"Number of drawables",
1, G_MAXINT, 1,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_object_array ("drawables",
"Drawables",
"Selected drawables",
GIMP_TYPE_DRAWABLE,
GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
gimp_param_spec_core_object_array ("drawables",
"Drawables",
"Selected drawables",
GIMP_TYPE_DRAWABLE,
GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
gimp_procedure_add_argument (procedure,
g_param_spec_object ("file",
"File",

8
app/pdb/gimppdb.c
View File

@ -447,7 +447,7 @@ gimp_pdb_execute_procedure_by_name (GimpPDB *pdb,
if (GIMP_VALUE_HOLDS_INT32_ARRAY (value) ||
GIMP_VALUE_HOLDS_FLOAT_ARRAY (value) ||
GIMP_VALUE_HOLDS_OBJECT_ARRAY (value))
GIMP_VALUE_HOLDS_CORE_OBJECT_ARRAY (value))
{
/* Array arguments don't have their size information when they
* are set by core code, in C array form.
@ -464,10 +464,8 @@ gimp_pdb_execute_procedure_by_name (GimpPDB *pdb,
gimp_value_set_float_array (value,
(const gdouble *) va_arg (va_args, gpointer),
prev_int_value);
else if (GIMP_VALUE_HOLDS_OBJECT_ARRAY (value))
gimp_value_set_object_array (value, GIMP_TYPE_ITEM,
va_arg (va_args, gpointer),
prev_int_value);
else if (GIMP_VALUE_HOLDS_CORE_OBJECT_ARRAY (value))
g_value_set_boxed (value, va_arg (va_args, gpointer));
}
else
{

22
app/plug-in/gimppluginprocedure.c
View File

@ -672,21 +672,20 @@ gimp_plug_in_procedure_add_menu_path (GimpPlugInProcedure *proc,
if ((procedure->num_args < 4) ||
! GIMP_IS_PARAM_SPEC_RUN_MODE (procedure->args[0]) ||
! GIMP_IS_PARAM_SPEC_IMAGE (procedure->args[1]) ||
! (G_TYPE_FROM_INSTANCE (procedure->args[3])
== GIMP_TYPE_PARAM_OBJECT_ARRAY))
! (G_TYPE_FROM_INSTANCE (procedure->args[2]) == GIMP_TYPE_PARAM_CORE_OBJECT_ARRAY))
{
required = "GimpRunMode, GimpImage, length, array of (GimpLayer | GimpDrawable)";
required = "GimpRunMode, GimpImage, NULL-terminated array of (GimpLayer | GimpDrawable)";
goto failure;
}
else
{
GimpParamSpecObjectArray *spec = GIMP_PARAM_SPEC_OBJECT_ARRAY (procedure->args[3]);
const gchar *type_name = g_type_name (spec->object_type);
GimpParamSpecCoreObjectArray *spec = GIMP_PARAM_SPEC_CORE_OBJECT_ARRAY (procedure->args[2]);
const gchar *type_name = g_type_name (spec->object_type);
if (g_strcmp0 (type_name, "GimpDrawable") != 0 &&
g_strcmp0 (type_name, "GimpLayer") != 0)
{
required = "GimpRunMode, GimpImage, length, array of (GimpLayer | GimpDrawable)";
required = "GimpRunMode, GimpImage, NULL-terminated array of (GimpLayer | GimpDrawable)";
goto failure;
}
}
@ -696,21 +695,20 @@ gimp_plug_in_procedure_add_menu_path (GimpPlugInProcedure *proc,
if ((procedure->num_args < 4) ||
! GIMP_IS_PARAM_SPEC_RUN_MODE (procedure->args[0]) ||
! GIMP_IS_PARAM_SPEC_IMAGE (procedure->args[1]) ||
! (G_TYPE_FROM_INSTANCE (procedure->args[3])
== GIMP_TYPE_PARAM_OBJECT_ARRAY))
! (G_TYPE_FROM_INSTANCE (procedure->args[2]) == GIMP_TYPE_PARAM_CORE_OBJECT_ARRAY))
{
required = "GimpRunMode, GimpImage, length, array of (GimpChannel | GimpDrawable)";
required = "GimpRunMode, GimpImage, NULL-terminated array of (GimpChannel | GimpDrawable)";
goto failure;
}
else
{
GimpParamSpecObjectArray *spec = GIMP_PARAM_SPEC_OBJECT_ARRAY (procedure->args[3]);
const gchar *type_name = g_type_name (spec->object_type);
GimpParamSpecCoreObjectArray *spec = GIMP_PARAM_SPEC_CORE_OBJECT_ARRAY (procedure->args[2]);
const gchar *type_name = g_type_name (spec->object_type);
if (g_strcmp0 (type_name, "GimpDrawable") != 0 &&
g_strcmp0 (type_name, "GimpChannel") != 0)
{
required = "GimpRunMode, GimpImage, length, array of (GimpChannel | GimpDrawable)";
required = "GimpRunMode, GimpImage, NULL-terminated array of (GimpChannel | GimpDrawable)";
goto failure;
}
}

3
libgimp/gimp.def
View File

@ -791,6 +791,9 @@ EXPORTS
gimp_procedure_add_color_from_string_aux_argument
gimp_procedure_add_color_from_string_return_value
gimp_procedure_add_color_return_value
gimp_procedure_add_core_object_array_argument
gimp_procedure_add_core_object_array_aux_argument
gimp_procedure_add_core_object_array_return_value
gimp_procedure_add_display_argument
gimp_procedure_add_display_aux_argument
gimp_procedure_add_display_return_value

28
libgimp/gimpimageprocedure.c
View File

@ -118,17 +118,11 @@ gimp_image_procedure_constructed (GObject *object)
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "num-drawables",
"Number of drawables",
"Number of input drawables",
0, G_MAXINT, 1,
G_PARAM_READWRITE);
gimp_procedure_add_object_array_argument (procedure, "drawables",
"Drawables",
"The input drawables",
GIMP_TYPE_DRAWABLE,
G_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE);
gimp_procedure_add_core_object_array_argument (procedure, "drawables",
"Drawables",
"The input drawables",
GIMP_TYPE_DRAWABLE,
G_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE);
}
static void
@ -142,7 +136,7 @@ gimp_image_procedure_finalize (GObject *object)
G_OBJECT_CLASS (parent_class)->finalize (object);
}
#define ARG_OFFSET 4
#define ARG_OFFSET 3
static GimpValueArray *
gimp_image_procedure_run (GimpProcedure *procedure,
@ -160,12 +154,12 @@ gimp_image_procedure_run (GimpProcedure *procedure,
gint n_drawables;
gint i;
run_mode = GIMP_VALUES_GET_ENUM (args, 0);
image = GIMP_VALUES_GET_IMAGE (args, 1);
n_drawables = GIMP_VALUES_GET_INT (args, 2);
drawables = GIMP_VALUES_GET_OBJECT_ARRAY (args, 3);
run_mode = GIMP_VALUES_GET_ENUM (args, 0);
image = GIMP_VALUES_GET_IMAGE (args, 1);
drawables = GIMP_VALUES_GET_CORE_OBJECT_ARRAY (args, 2);
remaining = gimp_value_array_new (gimp_value_array_length (args) - ARG_OFFSET);
n_drawables = gimp_core_object_array_get_length ((GObject **) drawables);
remaining = gimp_value_array_new (gimp_value_array_length (args) - ARG_OFFSET);
for (i = ARG_OFFSET; i < gimp_value_array_length (args); i++)
{

78
libgimp/gimpprocedure-params.c
View File

@ -1338,6 +1338,84 @@ gimp_procedure_add_string_array_return_value (GimpProcedure *procedure,
G_TYPE_STRV, flags));
}
/**
* gimp_procedure_add_core_object_array_argument:
* @procedure: the #GimpProcedure.
* @name: the name of the argument to be created.
* @nick: the label used in #GimpProcedureDialog.
* @blurb: a more detailed help description.
* @object_type the type of object stored in the array
* @flags: argument flags.
*
* Add a new object array argument to @procedure.
*
* Since: 3.0
**/
void
gimp_procedure_add_core_object_array_argument (GimpProcedure *procedure,
const gchar *name,
const gchar *nick,
const gchar *blurb,
GType object_type,
GParamFlags flags)
{
_gimp_procedure_add_argument (procedure,
gimp_param_spec_core_object_array (name, nick, blurb,
object_type, flags));
}
/**
* gimp_procedure_add_core_object_array_aux_argument:
* @procedure: the #GimpProcedure.
* @name: the name of the argument to be created.
* @nick: the label used in #GimpProcedureDialog.
* @blurb: a more detailed help description.
* @object_type the type of object stored in the array
* @flags: argument flags.
*
* Add a new object array auxiliary argument to @procedure.
*
* Since: 3.0
**/
void
gimp_procedure_add_core_object_array_aux_argument (GimpProcedure *procedure,
const gchar *name,
const gchar *nick,
const gchar *blurb,
GType object_type,
GParamFlags flags)
{
_gimp_procedure_add_aux_argument (procedure,
gimp_param_spec_core_object_array (name, nick, blurb,
object_type, flags));
}
/**
* gimp_procedure_add_core_object_array_return_value:
* @procedure: the #GimpProcedure.
* @name: the name of the argument to be created.
* @nick: the label used in #GimpProcedureDialog.
* @blurb: a more detailed help description.
* @object_type the type of object stored in the array
* @flags: argument flags.
*
* Add a new object array return value to @procedure.
*
* Since: 3.0
**/
void
gimp_procedure_add_core_object_array_return_value (GimpProcedure *procedure,
const gchar *name,
const gchar *nick,
const gchar *blurb,
GType object_type,
GParamFlags flags)
{
_gimp_procedure_add_return_value (procedure,
gimp_param_spec_core_object_array (name, nick, blurb,
object_type, flags));
}
/**
* gimp_procedure_add_object_array_argument:
* @procedure: the #GimpProcedure.

32
libgimp/gimpprocedure-params.h
View File

@ -228,6 +228,19 @@ G_BEGIN_DECLS
/* object array */
#define GIMP_VALUES_GET_CORE_OBJECT_ARRAY(args, n) \
(gpointer) g_value_get_boxed (gimp_value_array_index (args, n))
#define GIMP_VALUES_DUP_CORE_OBJECT_ARRAY(args, n) \
(gpointer) g_value_dup_boxed (gimp_value_array_index (args, n))
#define GIMP_VALUES_SET_CORE_OBJECT_ARRAY(args, n, value) \
g_value_set_boxed (gimp_value_array_index (args, n), (gconstpointer) value)
#define GIMP_VALUES_TAKE_CORE_OBJECT_ARRAY(args, n, value) \
g_value_take_boxed (gimp_value_array_index (args, n), (gconstpointer) value)
#define GIMP_VALUES_GET_OBJECT_ARRAY(args, n) \
(gpointer) gimp_value_get_object_array (gimp_value_array_index (args, n))
@ -756,6 +769,25 @@ void gimp_procedure_add_string_array_return_value (GimpProcedure *procedure
const gchar *blurb,
GParamFlags flags);
void gimp_procedure_add_core_object_array_argument (GimpProcedure *procedure,
const gchar *name,
const gchar *nick,
const gchar *blurb,
GType object_type,
GParamFlags flags);
void gimp_procedure_add_core_object_array_aux_argument (GimpProcedure *procedure,
const gchar *name,
const gchar *nick,
const gchar *blurb,
GType object_type,
GParamFlags flags);
void gimp_procedure_add_core_object_array_return_value (GimpProcedure *procedure,
const gchar *name,
const gchar *nick,
const gchar *blurb,
GType object_type,
GParamFlags flags);
void gimp_procedure_add_object_array_argument (GimpProcedure *procedure,
const gchar *name,
const gchar *nick,

8
libgimpconfig/gimpconfig-params.c
View File

@ -294,6 +294,14 @@ gimp_config_param_spec_duplicate (GParamSpec *pspec)
flags);
}
}
else if (GIMP_IS_PARAM_SPEC_CORE_OBJECT_ARRAY (pspec))
{
GimpParamSpecCoreObjectArray *spec = GIMP_PARAM_SPEC_CORE_OBJECT_ARRAY (pspec);
copy = gimp_param_spec_core_object_array (name, nick, blurb,
spec->object_type,
flags);
}
else if (GIMP_IS_PARAM_SPEC_OBJECT_ARRAY (pspec))
{
GimpParamSpecObjectArray *spec = GIMP_PARAM_SPEC_OBJECT_ARRAY (pspec);

23
plug-ins/common/file-gbr.c
View File

@ -182,8 +182,7 @@ gbr_export (GimpProcedure *procedure,
{
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
GimpExportReturn export = GIMP_EXPORT_IGNORE;
GList *drawables;
gint n_drawables;
GimpLayer **layers;
gchar *description;
GError *error = NULL;
@ -217,14 +216,12 @@ gbr_export (GimpProcedure *procedure,
}
export = gimp_export_options_get_image (options, &image);
drawables = gimp_image_list_layers (image);
n_drawables = g_list_length (drawables);
layers = gimp_image_get_layers (image);
if (status == GIMP_PDB_SUCCESS)
{
GimpProcedure *procedure;
GimpValueArray *save_retvals;
GimpObjectArray *drawables_array;
gint spacing;
g_object_get (config,
@ -232,20 +229,16 @@ gbr_export (GimpProcedure *procedure,
"spacing", &spacing,
NULL);
drawables_array = gimp_object_array_new (GIMP_TYPE_DRAWABLE, (GObject **) drawables,
n_drawables, FALSE);
procedure = gimp_pdb_lookup_procedure (gimp_get_pdb (),
"file-gbr-export-internal");
save_retvals = gimp_procedure_run (procedure,
"image", image,
"num-drawables", n_drawables,
"drawables", drawables_array,
"file", file,
"spacing", spacing,
"name", description,
"image", image,
"drawables", (GimpDrawable **) layers,
"file", file,
"spacing", spacing,
"name", description,
NULL);
gimp_object_array_free (drawables_array);
g_free (description);
if (GIMP_VALUES_GET_ENUM (save_retvals, 0) != GIMP_PDB_SUCCESS)
@ -264,7 +257,7 @@ gbr_export (GimpProcedure *procedure,
if (export == GIMP_EXPORT_EXPORT)
gimp_image_delete (image);
g_list_free (drawables);
g_free (layers);
return gimp_procedure_new_return_values (procedure, status, error);
}

41
plug-ins/common/file-gih.c
View File

@ -262,8 +262,7 @@ gih_export (GimpProcedure *procedure,
{
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
GimpExportReturn export = GIMP_EXPORT_IGNORE;
GList *layers = NULL;
gint n_drawables;
GimpLayer **layers = NULL;
GimpParasite *parasite;
GimpImage *orig_image;
GError *error = NULL;
@ -397,9 +396,8 @@ gih_export (GimpProcedure *procedure,
}
}
export = gimp_export_options_get_image (options, &image);
layers = gimp_image_list_layers (image);
n_drawables = g_list_length (layers);
export = gimp_export_options_get_image (options, &image);
layers = gimp_image_get_layers (image);
g_object_get (config,
"spacing", &spacing,
@ -428,35 +426,22 @@ gih_export (GimpProcedure *procedure,
if (status == GIMP_PDB_SUCCESS)
{
GimpProcedure *procedure;
GimpValueArray *save_retvals;
GimpDrawable **drawables = NULL;
GimpObjectArray *drawables_array;
GList *iter;
gint i;
gchar *paramstring;
GimpProcedure *procedure;
GimpValueArray *save_retvals;
gchar *paramstring;
paramstring = gimp_pixpipe_params_build (&gihparams);
drawables = g_new (GimpDrawable *, n_drawables);
for (iter = layers, i = 0; iter; iter = iter->next, i++)
drawables[i] = iter->data;
drawables_array = gimp_object_array_new (GIMP_TYPE_DRAWABLE, (GObject **) drawables,
n_drawables, FALSE);
procedure = gimp_pdb_lookup_procedure (gimp_get_pdb (),
"file-gih-export-internal");
save_retvals = gimp_procedure_run (procedure,
"image", image,
"num-drawables", n_drawables,
"drawables", drawables_array,
"file", file,
"spacing", spacing,
"name", description,
"params", paramstring,
"image", image,
"drawables", (GimpDrawable **) layers,
"file", file,
"spacing", spacing,
"name", description,
"params", paramstring,
NULL);
g_free (drawables);
gimp_object_array_free (drawables_array);
if (GIMP_VALUES_GET_ENUM (save_retvals, 0) == GIMP_PDB_SUCCESS)
{
@ -489,7 +474,7 @@ gih_export (GimpProcedure *procedure,
if (export == GIMP_EXPORT_EXPORT)
gimp_image_delete (image);
g_list_free (layers);
g_free (layers);
return gimp_procedure_new_return_values (procedure, status, error);
}

22
plug-ins/common/file-pat.c
View File

@ -161,8 +161,7 @@ pat_export (GimpProcedure *procedure,
{
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
GimpExportReturn export = GIMP_EXPORT_IGNORE;
GList *drawables;
gint n_drawables;
GimpLayer **layers;
gchar *description;
GError *error = NULL;
@ -196,16 +195,12 @@ pat_export (GimpProcedure *procedure,
}
export = gimp_export_options_get_image (options, &image);
drawables = gimp_image_list_layers (image);
n_drawables = g_list_length (drawables);
layers = gimp_image_get_layers (image);
if (status == GIMP_PDB_SUCCESS)
{
GimpProcedure *procedure;
GimpValueArray *save_retvals;
GimpObjectArray *drawables_array;
drawables_array = gimp_object_array_new (GIMP_TYPE_DRAWABLE, (GObject **) drawables, n_drawables, FALSE);
g_object_get (config,
"description", &description,
@ -214,11 +209,10 @@ pat_export (GimpProcedure *procedure,
procedure = gimp_pdb_lookup_procedure (gimp_get_pdb (),
"file-pat-export-internal");
save_retvals = gimp_procedure_run (procedure,
"image", image,
"num-drawables", n_drawables,
"drawables", drawables_array,
"file", file,
"name", description,
"image", image,
"drawables", (GimpDrawable **) layers,
"file", file,
"name", description,
NULL);
if (GIMP_VALUES_GET_ENUM (save_retvals, 0) != GIMP_PDB_SUCCESS)
@ -232,13 +226,13 @@ pat_export (GimpProcedure *procedure,
}
gimp_value_array_unref (save_retvals);
gimp_object_array_free (drawables_array);
}
if (export == GIMP_EXPORT_EXPORT)
gimp_image_delete (image);
g_list_free (drawables);
g_free (layers);
return gimp_procedure_new_return_values (procedure, status, error);
}

136
plug-ins/common/film.c
View File

@ -240,11 +240,11 @@ film_create_procedure (GimpPlugIn *plug_in,
/* Arguments ignored in interactive mode. */
gimp_procedure_add_object_array_argument (procedure, "images",
"Images",
"Images to be used for film",
GIMP_TYPE_IMAGE,
G_PARAM_READWRITE);
gimp_procedure_add_core_object_array_argument (procedure, "images",
"Images",
"Images to be used for film",
GIMP_TYPE_IMAGE,
G_PARAM_READWRITE);
/* The more specific settings. */
@ -405,43 +405,43 @@ film_run (GimpProcedure *procedure,
static GimpImage *
film (GimpProcedureConfig *config)
{
GimpObjectArray *images;
gint width, height;
guchar *hole;
gint film_height;
gint film_width;
gint picture_width;
gdouble picture_height;
gdouble picture_space;
gint picture_x0;
gint picture_y0;
gdouble hole_offset;
gdouble hole_width;
gdouble hole_height;
gdouble hole_space;
gint hole_x;
gdouble number_height;
gint num_pictures;
gint number_start;
gboolean at_top;
gboolean at_bottom;
gint picture_count;
GeglColor *number_color = NULL;
GeglColor *film_color = NULL;
gboolean keep_height;
gdouble f;
GimpImage *image_dst;
GimpImage *image_tmp;
GimpLayer *layer_src;
GimpLayer *layer_dst;
GimpLayer *new_layer;
GimpLayer *floating_sel;
GimpImage **images;
gint width, height;
guchar *hole;
gint film_height;
gint film_width;
gint picture_width;
gdouble picture_height;
gdouble picture_space;
gint picture_x0;
gint picture_y0;
gdouble hole_offset;
gdouble hole_width;
gdouble hole_height;
gdouble hole_space;
gint hole_x;
gdouble number_height;
gint num_pictures;
gint number_start;
gboolean at_top;
gboolean at_bottom;
gint picture_count;
GeglColor *number_color = NULL;
GeglColor *film_color = NULL;
gboolean keep_height;
gdouble f;
GimpImage *image_dst;
GimpImage *image_tmp;
GimpLayer *layer_src;
GimpLayer *layer_dst;
GimpLayer *new_layer;
GimpLayer *floating_sel;
GimpFont *number_font;
GimpFont *number_font;
GList *layers = NULL;
GList *iter2;
gint i;
GList *layers = NULL;
GList *iter2;
gint i;
g_object_get (config,
"images", &images,
@ -462,7 +462,7 @@ film (GimpProcedureConfig *config)
"at-bottom", &at_bottom,
NULL);
if (images->length <= 0)
if (images[0] == NULL)
return NULL;
if (film_color == NULL)
@ -484,9 +484,9 @@ film (GimpProcedureConfig *config)
{
gdouble max_height = 0;
for (i = 0; i < images->length; i++)
for (i = 0; images[i] != NULL; i++)
{
GimpImage *image = GIMP_IMAGE (images->data[i]);
GimpImage *image = images[i];
height = gimp_image_get_height (image);
if ((gdouble) height > max_height)
@ -505,9 +505,9 @@ film (GimpProcedureConfig *config)
/* Calculate total film width */
film_width = 0;
num_pictures = 0;
for (i = 0; i < images->length; i++)
for (i = 0; images[i] != NULL; i++)
{
GimpImage *image = GIMP_IMAGE (images->data[i]);
GimpImage *image = images[i];
layers = gimp_image_list_layers (image);
@ -592,9 +592,9 @@ film (GimpProcedureConfig *config)
/* Compose all images and layers */
picture_x0 = 0;
picture_count = 0;
for (i = 0; i < images->length; i++)
for (i = 0; images[i] != NULL; i++)
{
GimpImage *image = GIMP_IMAGE (images->data[i]);
GimpImage *image = images[i];
image_tmp = gimp_image_duplicate (image);
width = gimp_image_get_width (image_tmp);
@ -663,7 +663,7 @@ film (GimpProcedureConfig *config)
gimp_context_pop ();
gimp_object_array_free (images);
g_free (images);
g_clear_object (&number_color);
g_clear_object (&film_color);
g_clear_object (&number_font);
@ -677,11 +677,11 @@ static gboolean
check_filmvals (GimpProcedureConfig *config,
GError **error)
{
GimpFont *font = NULL;
GimpObjectArray *images;
gint film_height;
gint i, j;
gboolean success = FALSE;
GimpFont *font = NULL;
GimpImage **images;
gint film_height;
gint i, j;
gboolean success = FALSE;
g_object_get (config,
"images", &images,
@ -698,20 +698,20 @@ check_filmvals (GimpProcedureConfig *config,
g_object_set (config, "number-font", gimp_context_get_font (), NULL);
}
if (images != NULL)
if (images != NULL && images[0] != NULL)
{
for (i = 0, j = 0; i < images->length; i++)
for (i = 0, j = 0; images[i] != NULL; i++)
{
if (gimp_image_is_valid (GIMP_IMAGE (images->data[i])))
if (gimp_image_is_valid (images[i]))
{
images->data[j] = images->data[i];
images[j] = images[i];
j++;
}
}
if (j > 0)
{
images->length = j;
images[j] = NULL;
g_object_set (config,
"images", images,
NULL);
@ -719,11 +719,11 @@ check_filmvals (GimpProcedureConfig *config,
}
}
if (images == NULL || images->length == 0)
if (images == NULL || images[0] == NULL)
g_set_error_literal (error, GIMP_PLUG_IN_ERROR, 0,
_("\"Filmstrip\" cannot be run without any input images"));
gimp_object_array_free (images);
g_free (images);
g_clear_object (&font);
return success;
@ -1176,11 +1176,10 @@ film_dialog (GimpImage *image,
if (run)
{
GimpObjectArray *images_array;
GimpImage *images[MAX_FILM_PICTURES];
gint num_images = 0;
gboolean iter_valid;
GtkTreeIter iter;
GimpImage *images[MAX_FILM_PICTURES + 1];
gint num_images = 0;
gboolean iter_valid;
GtkTreeIter iter;
for (iter_valid = gtk_tree_model_get_iter_first (filmint.image_list_film,
&iter);
@ -1200,14 +1199,11 @@ film_dialog (GimpImage *image,
num_images++;
}
}
images_array = gimp_object_array_new (GIMP_TYPE_IMAGE, (GObject **) images, num_images, TRUE);
images[num_images] = NULL;
g_object_set (config,
"images", images_array,
"images", images,
NULL);
gimp_object_array_free (images_array);
}
gtk_widget_destroy (dialog);

23
plug-ins/common/guillotine.c
View File

@ -125,17 +125,11 @@ guillotine_create_procedure (GimpPlugIn *plug_in,
"Adam D. Moss (adam@foxbox.org)",
"1998");
gimp_procedure_add_int_return_value (procedure, "image-count",
"Number of images created",
"Number of images created",
0, G_MAXINT, 0,
G_PARAM_READWRITE);
gimp_procedure_add_object_array_return_value (procedure, "images",
"Output images",
"Output images",
GIMP_TYPE_IMAGE,
G_PARAM_READWRITE);
gimp_procedure_add_core_object_array_return_value (procedure, "images",
"Output images",
"Output images",
GIMP_TYPE_IMAGE,
G_PARAM_READWRITE);
}
return procedure;
@ -168,19 +162,18 @@ guillotine_run (GimpProcedure *procedure,
image_list = guillotine (image, run_mode == GIMP_RUN_INTERACTIVE);
num_images = g_list_length (image_list);
images = g_new (GimpImage *, num_images);
images = g_new0 (GimpImage *, num_images + 1);
for (list = image_list, i = 0;
list;
list = g_list_next (list), i++)
{
images[i] = g_object_ref (list->data);
images[i] = list->data;
}
g_list_free (image_list);
GIMP_VALUES_SET_INT (return_vals, 1, num_images);
GIMP_VALUES_TAKE_OBJECT_ARRAY (return_vals, 2, GIMP_TYPE_IMAGE, images, num_images);
GIMP_VALUES_TAKE_CORE_OBJECT_ARRAY (return_vals, 1, images);
if (run_mode == GIMP_RUN_INTERACTIVE)
gimp_displays_flush ();

26
plug-ins/twain/twain.c
View File

@ -216,17 +216,11 @@ twain_create_procedure (GimpPlugIn *plug_in,
PLUG_IN_COPYRIGHT,
PLUG_IN_VERSION);
gimp_procedure_add_int_return_value (procedure, "image-count",
"Number of acquired images",
"Number of acquired images",
0, G_MAXINT, 0,
G_PARAM_READWRITE);
gimp_procedure_add_object_array_return_value (procedure, "images",
"Array of acquired images",
"Array of acquired images",
GIMP_TYPE_IMAGE,
G_PARAM_READWRITE);
gimp_procedure_add_core_object_array_return_value (procedure, "images",
"Array of acquired images",
"Array of acquired images",
GIMP_TYPE_IMAGE,
G_PARAM_READWRITE);
}
return procedure;
@ -443,22 +437,20 @@ twain_run (GimpProcedure *procedure,
*/
num_images = g_list_length (image_list);
images = g_new (GimpImage *, num_images);
images = g_new0 (GimpImage *, num_images + 1);
for (list = image_list, i = 0;
list;
list = g_list_next (list), i++)
{
images[i] = g_object_ref (list->data);
images[i] = list->data;
}
g_list_free (image_list);
/* Set return values */
return_vals = gimp_procedure_new_return_values (procedure, status,
NULL);
GIMP_VALUES_SET_INT (return_vals, 1, num_images);
GIMP_VALUES_TAKE_OBJECT_ARRAY (return_vals, 2, GIMP_TYPE_IMAGE, images, num_images);
return_vals = gimp_procedure_new_return_values (procedure, status, NULL);
GIMP_VALUES_TAKE_CORE_OBJECT_ARRAY (return_vals, 1, images);
return return_vals;
}