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

libgimp, pdb: remove gimp_run_procedure_with_array() from gimp.[ch] 

and add it to gimplegacy.[ch] as gimp_run_procedure_array().
Regenerate all PDB wrapper accordingly.
This commit is contained in:
Michael Natterer 2019-08-06 21:44:26 +02:00
parent c2e5374845
commit caa61eef4f
59 changed files with 1383 additions and 1395 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

47
libgimp/gimp.c
View File

@ -739,53 +739,6 @@ gimp_quit (void)
exit (EXIT_SUCCESS);
}
GimpValueArray *
gimp_run_procedure_with_array (const gchar *name,
GimpValueArray *arguments)
{
GPProcRun proc_run;
GPProcReturn *proc_return;
GimpWireMessage msg;
GimpValueArray *return_values;
g_return_val_if_fail (name != NULL, NULL);
g_return_val_if_fail (arguments != NULL, NULL);
proc_run.name = (gchar *) name;
proc_run.nparams = gimp_value_array_length (arguments);
proc_run.params = _gimp_value_array_to_gp_params (arguments, FALSE);
if (PLUG_IN)
{
if (! gp_proc_run_write (_gimp_plug_in_get_write_channel (PLUG_IN),
&proc_run, PLUG_IN))
gimp_quit ();
_gimp_plug_in_read_expect_msg (PLUG_IN, &msg, GP_PROC_RETURN);
}
else
{
if (! gp_proc_run_write (_gimp_writechannel, &proc_run, NULL))
gimp_quit ();
_gimp_read_expect_msg (&msg, GP_PROC_RETURN);
}
proc_return = msg.data;
return_values = _gimp_gp_params_to_value_array (NULL,
NULL, 0,
proc_return->params,
proc_return->nparams,
TRUE, FALSE);
gimp_wire_destroy (&msg);
_gimp_set_pdb_error (return_values);
return return_values;
}
/**
* gimp_get_pdb_error:
*

2
libgimp/gimp.def
View File

@ -700,7 +700,7 @@ EXPORTS
gimp_register_thumbnail_loader
gimp_run_procedure
gimp_run_procedure2
gimp_run_procedure_with_array
gimp_run_procedure_array
gimp_selection_all
gimp_selection_border
gimp_selection_bounds

8
libgimp/gimp.h
View File

@ -157,14 +157,6 @@ GimpPDB * gimp_get_pdb (void);
*/
void gimp_quit (void) G_GNUC_NORETURN;
/* Run a procedure in the procedure database. The parameters are
* specified as a GimpValueArray, so are the return values.
*
* FIXME this API is not final!
*/
GimpValueArray * gimp_run_procedure_with_array (const gchar *name,
GimpValueArray *arguments);
/* Retrieve the error message and return status for the last procedure
* call.
*/

28
libgimp/gimp_pdb.c
View File

@ -64,8 +64,8 @@ gimp_version (void)
"gimp-version",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-version",
args);
return_vals = gimp_run_procedure_array ("gimp-version",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -102,8 +102,8 @@ gimp_getpid (void)
"gimp-getpid",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-getpid",
args);
return_vals = gimp_run_procedure_array ("gimp-getpid",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -143,8 +143,8 @@ gimp_attach_parasite (const GimpParasite *parasite)
"gimp-attach-parasite",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-attach-parasite",
args);
return_vals = gimp_run_procedure_array ("gimp-attach-parasite",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -184,8 +184,8 @@ gimp_detach_parasite (const gchar *name)
"gimp-detach-parasite",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-detach-parasite",
args);
return_vals = gimp_run_procedure_array ("gimp-detach-parasite",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -224,8 +224,8 @@ gimp_get_parasite (const gchar *name)
"gimp-get-parasite",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-get-parasite",
args);
return_vals = gimp_run_procedure_array ("gimp-get-parasite",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -265,8 +265,8 @@ gimp_get_parasite_list (gint *num_parasites)
"gimp-get-parasite-list",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-get-parasite-list",
args);
return_vals = gimp_run_procedure_array ("gimp-get-parasite-list",
args);
gimp_value_array_unref (args);
*num_parasites = 0;
@ -311,8 +311,8 @@ gimp_temp_name (const gchar *extension)
"gimp-temp-name",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-temp-name",
args);
return_vals = gimp_run_procedure_array ("gimp-temp-name",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)

88
libgimp/gimpbrush_pdb.c
View File

@ -64,8 +64,8 @@ gimp_brush_new (const gchar *name)
"gimp-brush-new",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-brush-new",
args);
return_vals = gimp_run_procedure_array ("gimp-brush-new",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -106,8 +106,8 @@ gimp_brush_duplicate (const gchar *name)
"gimp-brush-duplicate",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-brush-duplicate",
args);
return_vals = gimp_run_procedure_array ("gimp-brush-duplicate",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -147,8 +147,8 @@ gimp_brush_is_generated (const gchar *name)
"gimp-brush-is-generated",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-brush-is-generated",
args);
return_vals = gimp_run_procedure_array ("gimp-brush-is-generated",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -193,8 +193,8 @@ gimp_brush_rename (const gchar *name,
"gimp-brush-rename",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-brush-rename",
args);
return_vals = gimp_run_procedure_array ("gimp-brush-rename",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -234,8 +234,8 @@ gimp_brush_delete (const gchar *name)
"gimp-brush-delete",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-brush-delete",
args);
return_vals = gimp_run_procedure_array ("gimp-brush-delete",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -274,8 +274,8 @@ gimp_brush_is_editable (const gchar *name)
"gimp-brush-is-editable",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-brush-is-editable",
args);
return_vals = gimp_run_procedure_array ("gimp-brush-is-editable",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -324,8 +324,8 @@ gimp_brush_get_info (const gchar *name,
"gimp-brush-get-info",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-brush-get-info",
args);
return_vals = gimp_run_procedure_array ("gimp-brush-get-info",
args);
gimp_value_array_unref (args);
*width = 0;
@ -394,8 +394,8 @@ gimp_brush_get_pixels (const gchar *name,
"gimp-brush-get-pixels",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-brush-get-pixels",
args);
return_vals = gimp_run_procedure_array ("gimp-brush-get-pixels",
args);
gimp_value_array_unref (args);
*width = 0;
@ -459,8 +459,8 @@ gimp_brush_get_spacing (const gchar *name,
"gimp-brush-get-spacing",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-brush-get-spacing",
args);
return_vals = gimp_run_procedure_array ("gimp-brush-get-spacing",
args);
gimp_value_array_unref (args);
*spacing = 0;
@ -509,8 +509,8 @@ gimp_brush_set_spacing (const gchar *name,
"gimp-brush-set-spacing",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-brush-set-spacing",
args);
return_vals = gimp_run_procedure_array ("gimp-brush-set-spacing",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -554,8 +554,8 @@ gimp_brush_get_shape (const gchar *name)
"gimp-brush-get-shape",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-brush-get-shape",
args);
return_vals = gimp_run_procedure_array ("gimp-brush-get-shape",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -604,8 +604,8 @@ gimp_brush_set_shape (const gchar *name,
"gimp-brush-set-shape",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-brush-set-shape",
args);
return_vals = gimp_run_procedure_array ("gimp-brush-set-shape",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -646,8 +646,8 @@ gimp_brush_get_radius (const gchar *name)
"gimp-brush-get-radius",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-brush-get-radius",
args);
return_vals = gimp_run_procedure_array ("gimp-brush-get-radius",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -692,8 +692,8 @@ gimp_brush_set_radius (const gchar *name,
"gimp-brush-set-radius",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-brush-set-radius",
args);
return_vals = gimp_run_procedure_array ("gimp-brush-set-radius",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -734,8 +734,8 @@ gimp_brush_get_spikes (const gchar *name)
"gimp-brush-get-spikes",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-brush-get-spikes",
args);
return_vals = gimp_run_procedure_array ("gimp-brush-get-spikes",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -780,8 +780,8 @@ gimp_brush_set_spikes (const gchar *name,
"gimp-brush-set-spikes",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-brush-set-spikes",
args);
return_vals = gimp_run_procedure_array ("gimp-brush-set-spikes",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -824,8 +824,8 @@ gimp_brush_get_hardness (const gchar *name)
"gimp-brush-get-hardness",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-brush-get-hardness",
args);
return_vals = gimp_run_procedure_array ("gimp-brush-get-hardness",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -871,8 +871,8 @@ gimp_brush_set_hardness (const gchar *name,
"gimp-brush-set-hardness",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-brush-set-hardness",
args);
return_vals = gimp_run_procedure_array ("gimp-brush-set-hardness",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -914,8 +914,8 @@ gimp_brush_get_aspect_ratio (const gchar *name)
"gimp-brush-get-aspect-ratio",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-brush-get-aspect-ratio",
args);
return_vals = gimp_run_procedure_array ("gimp-brush-get-aspect-ratio",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -961,8 +961,8 @@ gimp_brush_set_aspect_ratio (const gchar *name,
"gimp-brush-set-aspect-ratio",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-brush-set-aspect-ratio",
args);
return_vals = gimp_run_procedure_array ("gimp-brush-set-aspect-ratio",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -1003,8 +1003,8 @@ gimp_brush_get_angle (const gchar *name)
"gimp-brush-get-angle",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-brush-get-angle",
args);
return_vals = gimp_run_procedure_array ("gimp-brush-get-angle",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -1049,8 +1049,8 @@ gimp_brush_set_angle (const gchar *name,
"gimp-brush-set-angle",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-brush-set-angle",
args);
return_vals = gimp_run_procedure_array ("gimp-brush-set-angle",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)

8
libgimp/gimpbrushes_pdb.c
View File

@ -59,8 +59,8 @@ gimp_brushes_refresh (void)
"gimp-brushes-refresh",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-brushes-refresh",
args);
return_vals = gimp_run_procedure_array ("gimp-brushes-refresh",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -103,8 +103,8 @@ gimp_brushes_get_list (const gchar *filter,
"gimp-brushes-get-list",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-brushes-get-list",
args);
return_vals = gimp_run_procedure_array ("gimp-brushes-get-list",
args);
gimp_value_array_unref (args);
*num_brushes = 0;

12
libgimp/gimpbrushselect_pdb.c
View File

@ -81,8 +81,8 @@ gimp_brushes_popup (const gchar *brush_callback,
"gimp-brushes-popup",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-brushes-popup",
args);
return_vals = gimp_run_procedure_array ("gimp-brushes-popup",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -119,8 +119,8 @@ gimp_brushes_close_popup (const gchar *brush_callback)
"gimp-brushes-close-popup",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-brushes-close-popup",
args);
return_vals = gimp_run_procedure_array ("gimp-brushes-close-popup",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -173,8 +173,8 @@ gimp_brushes_set_popup (const gchar *brush_callback,
"gimp-brushes-set-popup",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-brushes-set-popup",
args);
return_vals = gimp_run_procedure_array ("gimp-brushes-set-popup",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;

28
libgimp/gimpbuffer_pdb.c
View File

@ -68,8 +68,8 @@ gimp_buffers_get_list (const gchar *filter,
"gimp-buffers-get-list",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-buffers-get-list",
args);
return_vals = gimp_run_procedure_array ("gimp-buffers-get-list",
args);
gimp_value_array_unref (args);
*num_buffers = 0;
@ -119,8 +119,8 @@ gimp_buffer_rename (const gchar *buffer_name,
"gimp-buffer-rename",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-buffer-rename",
args);
return_vals = gimp_run_procedure_array ("gimp-buffer-rename",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -160,8 +160,8 @@ gimp_buffer_delete (const gchar *buffer_name)
"gimp-buffer-delete",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-buffer-delete",
args);
return_vals = gimp_run_procedure_array ("gimp-buffer-delete",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -200,8 +200,8 @@ gimp_buffer_get_width (const gchar *buffer_name)
"gimp-buffer-get-width",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-buffer-get-width",
args);
return_vals = gimp_run_procedure_array ("gimp-buffer-get-width",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -241,8 +241,8 @@ gimp_buffer_get_height (const gchar *buffer_name)
"gimp-buffer-get-height",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-buffer-get-height",
args);
return_vals = gimp_run_procedure_array ("gimp-buffer-get-height",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -282,8 +282,8 @@ gimp_buffer_get_bytes (const gchar *buffer_name)
"gimp-buffer-get-bytes",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-buffer-get-bytes",
args);
return_vals = gimp_run_procedure_array ("gimp-buffer-get-bytes",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -323,8 +323,8 @@ gimp_buffer_get_image_type (const gchar *buffer_name)
"gimp-buffer-get-image-type",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-buffer-get-image-type",
args);
return_vals = gimp_run_procedure_array ("gimp-buffer-get-image-type",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)

40
libgimp/gimpchannel_pdb.c
View File

@ -87,8 +87,8 @@ _gimp_channel_new (gint32 image_ID,
"gimp-channel-new",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-channel-new",
args);
return_vals = gimp_run_procedure_array ("gimp-channel-new",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -140,8 +140,8 @@ gimp_channel_new_from_component (gint32 image_ID,
"gimp-channel-new-from-component",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-channel-new-from-component",
args);
return_vals = gimp_run_procedure_array ("gimp-channel-new-from-component",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -181,8 +181,8 @@ gimp_channel_copy (gint32 channel_ID)
"gimp-channel-copy",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-channel-copy",
args);
return_vals = gimp_run_procedure_array ("gimp-channel-copy",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -237,8 +237,8 @@ gimp_channel_combine_masks (gint32 channel1_ID,
"gimp-channel-combine-masks",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-channel-combine-masks",
args);
return_vals = gimp_run_procedure_array ("gimp-channel-combine-masks",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -277,8 +277,8 @@ gimp_channel_get_show_masked (gint32 channel_ID)
"gimp-channel-get-show-masked",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-channel-get-show-masked",
args);
return_vals = gimp_run_procedure_array ("gimp-channel-get-show-masked",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -322,8 +322,8 @@ gimp_channel_set_show_masked (gint32 channel_ID,
"gimp-channel-set-show-masked",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-channel-set-show-masked",
args);
return_vals = gimp_run_procedure_array ("gimp-channel-set-show-masked",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -360,8 +360,8 @@ gimp_channel_get_opacity (gint32 channel_ID)
"gimp-channel-get-opacity",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-channel-get-opacity",
args);
return_vals = gimp_run_procedure_array ("gimp-channel-get-opacity",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -403,8 +403,8 @@ gimp_channel_set_opacity (gint32 channel_ID,
"gimp-channel-set-opacity",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-channel-set-opacity",
args);
return_vals = gimp_run_procedure_array ("gimp-channel-set-opacity",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -443,8 +443,8 @@ gimp_channel_get_color (gint32 channel_ID,
"gimp-channel-get-color",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-channel-get-color",
args);
return_vals = gimp_run_procedure_array ("gimp-channel-get-color",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -488,8 +488,8 @@ gimp_channel_set_color (gint32 channel_ID,
"gimp-channel-set-color",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-channel-set-color",
args);
return_vals = gimp_run_procedure_array ("gimp-channel-set-color",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;

452
libgimp/gimpcontext_pdb.c
View File

File diff suppressed because it is too large Load Diff

8
libgimp/gimpdebug_pdb.c
View File

@ -66,8 +66,8 @@ gimp_debug_timer_start (void)
"gimp-debug-timer-start",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-debug-timer-start",
args);
return_vals = gimp_run_procedure_array ("gimp-debug-timer-start",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -108,8 +108,8 @@ gimp_debug_timer_end (void)
"gimp-debug-timer-end",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-debug-timer-end",
args);
return_vals = gimp_run_procedure_array ("gimp-debug-timer-end",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)

24
libgimp/gimpdisplay_pdb.c
View File

@ -64,8 +64,8 @@ gimp_display_is_valid (gint32 display_ID)
"gimp-display-is-valid",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-display-is-valid",
args);
return_vals = gimp_run_procedure_array ("gimp-display-is-valid",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -108,8 +108,8 @@ gimp_display_new (gint32 image_ID)
"gimp-display-new",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-display-new",
args);
return_vals = gimp_run_procedure_array ("gimp-display-new",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -151,8 +151,8 @@ gimp_display_delete (gint32 display_ID)
"gimp-display-delete",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-display-delete",
args);
return_vals = gimp_run_procedure_array ("gimp-display-delete",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -195,8 +195,8 @@ gimp_display_get_window_handle (gint32 display_ID)
"gimp-display-get-window-handle",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-display-get-window-handle",
args);
return_vals = gimp_run_procedure_array ("gimp-display-get-window-handle",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -234,8 +234,8 @@ gimp_displays_flush (void)
"gimp-displays-flush",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-displays-flush",
args);
return_vals = gimp_run_procedure_array ("gimp-displays-flush",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -279,8 +279,8 @@ gimp_displays_reconnect (gint32 old_image_ID,
"gimp-displays-reconnect",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-displays-reconnect",
args);
return_vals = gimp_run_procedure_array ("gimp-displays-reconnect",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;

96
libgimp/gimpdrawable_pdb.c
View File

@ -67,8 +67,8 @@ _gimp_drawable_get_format (gint32 drawable_ID)
"gimp-drawable-get-format",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-drawable-get-format",
args);
return_vals = gimp_run_procedure_array ("gimp-drawable-get-format",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -111,8 +111,8 @@ _gimp_drawable_get_thumbnail_format (gint32 drawable_ID)
"gimp-drawable-get-thumbnail-format",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-drawable-get-thumbnail-format",
args);
return_vals = gimp_run_procedure_array ("gimp-drawable-get-thumbnail-format",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -150,8 +150,8 @@ gimp_drawable_type (gint32 drawable_ID)
"gimp-drawable-type",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-drawable-type",
args);
return_vals = gimp_run_procedure_array ("gimp-drawable-type",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -192,8 +192,8 @@ gimp_drawable_type_with_alpha (gint32 drawable_ID)
"gimp-drawable-type-with-alpha",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-drawable-type-with-alpha",
args);
return_vals = gimp_run_procedure_array ("gimp-drawable-type-with-alpha",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -233,8 +233,8 @@ gimp_drawable_has_alpha (gint32 drawable_ID)
"gimp-drawable-has-alpha",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-drawable-has-alpha",
args);
return_vals = gimp_run_procedure_array ("gimp-drawable-has-alpha",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -273,8 +273,8 @@ gimp_drawable_is_rgb (gint32 drawable_ID)
"gimp-drawable-is-rgb",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-drawable-is-rgb",
args);
return_vals = gimp_run_procedure_array ("gimp-drawable-is-rgb",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -313,8 +313,8 @@ gimp_drawable_is_gray (gint32 drawable_ID)
"gimp-drawable-is-gray",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-drawable-is-gray",
args);
return_vals = gimp_run_procedure_array ("gimp-drawable-is-gray",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -353,8 +353,8 @@ gimp_drawable_is_indexed (gint32 drawable_ID)
"gimp-drawable-is-indexed",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-drawable-is-indexed",
args);
return_vals = gimp_run_procedure_array ("gimp-drawable-is-indexed",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -392,8 +392,8 @@ gimp_drawable_bpp (gint32 drawable_ID)
"gimp-drawable-bpp",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-drawable-bpp",
args);
return_vals = gimp_run_procedure_array ("gimp-drawable-bpp",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -431,8 +431,8 @@ gimp_drawable_width (gint32 drawable_ID)
"gimp-drawable-width",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-drawable-width",
args);
return_vals = gimp_run_procedure_array ("gimp-drawable-width",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -470,8 +470,8 @@ gimp_drawable_height (gint32 drawable_ID)
"gimp-drawable-height",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-drawable-height",
args);
return_vals = gimp_run_procedure_array ("gimp-drawable-height",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -515,8 +515,8 @@ gimp_drawable_offsets (gint32 drawable_ID,
"gimp-drawable-offsets",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-drawable-offsets",
args);
return_vals = gimp_run_procedure_array ("gimp-drawable-offsets",
args);
gimp_value_array_unref (args);
*offset_x = 0;
@ -582,8 +582,8 @@ gimp_drawable_mask_bounds (gint32 drawable_ID,
"gimp-drawable-mask-bounds",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-drawable-mask-bounds",
args);
return_vals = gimp_run_procedure_array ("gimp-drawable-mask-bounds",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -642,8 +642,8 @@ gimp_drawable_mask_intersect (gint32 drawable_ID,
"gimp-drawable-mask-intersect",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-drawable-mask-intersect",
args);
return_vals = gimp_run_procedure_array ("gimp-drawable-mask-intersect",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -694,8 +694,8 @@ gimp_drawable_merge_shadow (gint32 drawable_ID,
"gimp-drawable-merge-shadow",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-drawable-merge-shadow",
args);
return_vals = gimp_run_procedure_array ("gimp-drawable-merge-shadow",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -737,8 +737,8 @@ gimp_drawable_free_shadow (gint32 drawable_ID)
"gimp-drawable-free-shadow",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-drawable-free-shadow",
args);
return_vals = gimp_run_procedure_array ("gimp-drawable-free-shadow",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -794,8 +794,8 @@ gimp_drawable_update (gint32 drawable_ID,
"gimp-drawable-update",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-drawable-update",
args);
return_vals = gimp_run_procedure_array ("gimp-drawable-update",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -846,8 +846,8 @@ gimp_drawable_get_pixel (gint32 drawable_ID,
"gimp-drawable-get-pixel",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-drawable-get-pixel",
args);
return_vals = gimp_run_procedure_array ("gimp-drawable-get-pixel",
args);
gimp_value_array_unref (args);
*num_channels = 0;
@ -910,8 +910,8 @@ gimp_drawable_set_pixel (gint32 drawable_ID,
"gimp-drawable-set-pixel",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-drawable-set-pixel",
args);
return_vals = gimp_run_procedure_array ("gimp-drawable-set-pixel",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -962,8 +962,8 @@ gimp_drawable_fill (gint32 drawable_ID,
"gimp-drawable-fill",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-drawable-fill",
args);
return_vals = gimp_run_procedure_array ("gimp-drawable-fill",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1022,8 +1022,8 @@ gimp_drawable_offset (gint32 drawable_ID,
"gimp-drawable-offset",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-drawable-offset",
args);
return_vals = gimp_run_procedure_array ("gimp-drawable-offset",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1081,8 +1081,8 @@ _gimp_drawable_thumbnail (gint32 drawable_ID,
"gimp-drawable-thumbnail",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-drawable-thumbnail",
args);
return_vals = gimp_run_procedure_array ("gimp-drawable-thumbnail",
args);
gimp_value_array_unref (args);
*actual_width = 0;
@ -1173,8 +1173,8 @@ _gimp_drawable_sub_thumbnail (gint32 drawable_ID,
"gimp-drawable-sub-thumbnail",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-drawable-sub-thumbnail",
args);
return_vals = gimp_run_procedure_array ("gimp-drawable-sub-thumbnail",
args);
gimp_value_array_unref (args);
*width = 0;
@ -1237,8 +1237,8 @@ gimp_drawable_foreground_extract (gint32 drawable_ID,
"gimp-drawable-foreground-extract",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-drawable-foreground-extract",
args);
return_vals = gimp_run_procedure_array ("gimp-drawable-foreground-extract",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;

56
libgimp/gimpdrawablecolor_pdb.c
View File

@ -74,8 +74,8 @@ gimp_drawable_brightness_contrast (gint32 drawable_ID,
"gimp-drawable-brightness-contrast",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-drawable-brightness-contrast",
args);
return_vals = gimp_run_procedure_array ("gimp-drawable-brightness-contrast",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -141,8 +141,8 @@ gimp_drawable_color_balance (gint32 drawable_ID,
"gimp-drawable-color-balance",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-drawable-color-balance",
args);
return_vals = gimp_run_procedure_array ("gimp-drawable-color-balance",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -196,8 +196,8 @@ gimp_drawable_colorize_hsl (gint32 drawable_ID,
"gimp-drawable-colorize-hsl",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-drawable-colorize-hsl",
args);
return_vals = gimp_run_procedure_array ("gimp-drawable-colorize-hsl",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -253,8 +253,8 @@ gimp_drawable_curves_explicit (gint32 drawable_ID,
"gimp-drawable-curves-explicit",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-drawable-curves-explicit",
args);
return_vals = gimp_run_procedure_array ("gimp-drawable-curves-explicit",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -310,8 +310,8 @@ gimp_drawable_curves_spline (gint32 drawable_ID,
"gimp-drawable-curves-spline",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-drawable-curves-spline",
args);
return_vals = gimp_run_procedure_array ("gimp-drawable-curves-spline",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -357,8 +357,8 @@ gimp_drawable_desaturate (gint32 drawable_ID,
"gimp-drawable-desaturate",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-drawable-desaturate",
args);
return_vals = gimp_run_procedure_array ("gimp-drawable-desaturate",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -407,8 +407,8 @@ gimp_drawable_equalize (gint32 drawable_ID,
"gimp-drawable-equalize",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-drawable-equalize",
args);
return_vals = gimp_run_procedure_array ("gimp-drawable-equalize",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -486,8 +486,8 @@ gimp_drawable_histogram (gint32 drawable_ID,
"gimp-drawable-histogram",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-drawable-histogram",
args);
return_vals = gimp_run_procedure_array ("gimp-drawable-histogram",
args);
gimp_value_array_unref (args);
*mean = 0.0;
@ -567,8 +567,8 @@ gimp_drawable_hue_saturation (gint32 drawable_ID,
"gimp-drawable-hue-saturation",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-drawable-hue-saturation",
args);
return_vals = gimp_run_procedure_array ("gimp-drawable-hue-saturation",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -614,8 +614,8 @@ gimp_drawable_invert (gint32 drawable_ID,
"gimp-drawable-invert",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-drawable-invert",
args);
return_vals = gimp_run_procedure_array ("gimp-drawable-invert",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -697,8 +697,8 @@ gimp_drawable_levels (gint32 drawable_ID,
"gimp-drawable-levels",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-drawable-levels",
args);
return_vals = gimp_run_procedure_array ("gimp-drawable-levels",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -739,8 +739,8 @@ gimp_drawable_levels_stretch (gint32 drawable_ID)
"gimp-drawable-levels-stretch",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-drawable-levels-stretch",
args);
return_vals = gimp_run_procedure_array ("gimp-drawable-levels-stretch",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -784,8 +784,8 @@ gimp_drawable_posterize (gint32 drawable_ID,
"gimp-drawable-posterize",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-drawable-posterize",
args);
return_vals = gimp_run_procedure_array ("gimp-drawable-posterize",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -839,8 +839,8 @@ gimp_drawable_threshold (gint32 drawable_ID,
"gimp-drawable-threshold",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-drawable-threshold",
args);
return_vals = gimp_run_procedure_array ("gimp-drawable-threshold",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;

24
libgimp/gimpdrawableedit_pdb.c
View File

@ -68,8 +68,8 @@ gimp_drawable_edit_clear (gint32 drawable_ID)
"gimp-drawable-edit-clear",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-drawable-edit-clear",
args);
return_vals = gimp_run_procedure_array ("gimp-drawable-edit-clear",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -118,8 +118,8 @@ gimp_drawable_edit_fill (gint32 drawable_ID,
"gimp-drawable-edit-fill",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-drawable-edit-fill",
args);
return_vals = gimp_run_procedure_array ("gimp-drawable-edit-fill",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -182,8 +182,8 @@ gimp_drawable_edit_bucket_fill (gint32 drawable_ID,
"gimp-drawable-edit-bucket-fill",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-drawable-edit-bucket-fill",
args);
return_vals = gimp_run_procedure_array ("gimp-drawable-edit-bucket-fill",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -273,8 +273,8 @@ gimp_drawable_edit_gradient_fill (gint32 drawable_ID,
"gimp-drawable-edit-gradient-fill",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-drawable-edit-gradient-fill",
args);
return_vals = gimp_run_procedure_array ("gimp-drawable-edit-gradient-fill",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -322,8 +322,8 @@ gimp_drawable_edit_stroke_selection (gint32 drawable_ID)
"gimp-drawable-edit-stroke-selection",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-drawable-edit-stroke-selection",
args);
return_vals = gimp_run_procedure_array ("gimp-drawable-edit-stroke-selection",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -377,8 +377,8 @@ gimp_drawable_edit_stroke_item (gint32 drawable_ID,
"gimp-drawable-edit-stroke-item",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-drawable-edit-stroke-item",
args);
return_vals = gimp_run_procedure_array ("gimp-drawable-edit-stroke-item",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;

8
libgimp/gimpdynamics_pdb.c
View File

@ -62,8 +62,8 @@ gimp_dynamics_refresh (void)
"gimp-dynamics-refresh",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-dynamics-refresh",
args);
return_vals = gimp_run_procedure_array ("gimp-dynamics-refresh",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -107,8 +107,8 @@ gimp_dynamics_get_list (const gchar *filter,
"gimp-dynamics-get-list",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-dynamics-get-list",
args);
return_vals = gimp_run_procedure_array ("gimp-dynamics-get-list",
args);
gimp_value_array_unref (args);
*num_dynamics = 0;

40
libgimp/gimpedit_pdb.c
View File

@ -68,8 +68,8 @@ gimp_edit_cut (gint32 drawable_ID)
"gimp-edit-cut",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-edit-cut",
args);
return_vals = gimp_run_procedure_array ("gimp-edit-cut",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -114,8 +114,8 @@ gimp_edit_copy (gint32 drawable_ID)
"gimp-edit-copy",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-edit-copy",
args);
return_vals = gimp_run_procedure_array ("gimp-edit-copy",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -160,8 +160,8 @@ gimp_edit_copy_visible (gint32 image_ID)
"gimp-edit-copy-visible",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-edit-copy-visible",
args);
return_vals = gimp_run_procedure_array ("gimp-edit-copy-visible",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -217,8 +217,8 @@ gimp_edit_paste (gint32 drawable_ID,
"gimp-edit-paste",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-edit-paste",
args);
return_vals = gimp_run_procedure_array ("gimp-edit-paste",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -258,8 +258,8 @@ gimp_edit_paste_as_new_image (void)
"gimp-edit-paste-as-new-image",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-edit-paste-as-new-image",
args);
return_vals = gimp_run_procedure_array ("gimp-edit-paste-as-new-image",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -308,8 +308,8 @@ gimp_edit_named_cut (gint32 drawable_ID,
"gimp-edit-named-cut",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-edit-named-cut",
args);
return_vals = gimp_run_procedure_array ("gimp-edit-named-cut",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -358,8 +358,8 @@ gimp_edit_named_copy (gint32 drawable_ID,
"gimp-edit-named-copy",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-edit-named-copy",
args);
return_vals = gimp_run_procedure_array ("gimp-edit-named-copy",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -408,8 +408,8 @@ gimp_edit_named_copy_visible (gint32 image_ID,
"gimp-edit-named-copy-visible",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-edit-named-copy-visible",
args);
return_vals = gimp_run_procedure_array ("gimp-edit-named-copy-visible",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -458,8 +458,8 @@ gimp_edit_named_paste (gint32 drawable_ID,
"gimp-edit-named-paste",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-edit-named-paste",
args);
return_vals = gimp_run_procedure_array ("gimp-edit-named-paste",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -500,8 +500,8 @@ gimp_edit_named_paste_as_new_image (const gchar *buffer_name)
"gimp-edit-named-paste-as-new-image",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-edit-named-paste-as-new-image",
args);
return_vals = gimp_run_procedure_array ("gimp-edit-named-paste-as-new-image",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)

52
libgimp/gimpfileops_pdb.c
View File

@ -75,8 +75,8 @@ gimp_file_load (GimpRunMode run_mode,
"gimp-file-load",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-file-load",
args);
return_vals = gimp_run_procedure_array ("gimp-file-load",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -127,8 +127,8 @@ gimp_file_load_layer (GimpRunMode run_mode,
"gimp-file-load-layer",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-file-load-layer",
args);
return_vals = gimp_run_procedure_array ("gimp-file-load-layer",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -183,8 +183,8 @@ gimp_file_load_layers (GimpRunMode run_mode,
"gimp-file-load-layers",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-file-load-layers",
args);
return_vals = gimp_run_procedure_array ("gimp-file-load-layers",
args);
gimp_value_array_unref (args);
*num_layers = 0;
@ -249,8 +249,8 @@ gimp_file_save (GimpRunMode run_mode,
"gimp-file-save",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-file-save",
args);
return_vals = gimp_run_procedure_array ("gimp-file-save",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -296,8 +296,8 @@ gimp_file_save_thumbnail (gint32 image_ID,
"gimp-file-save-thumbnail",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-file-save-thumbnail",
args);
return_vals = gimp_run_procedure_array ("gimp-file-save-thumbnail",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -347,8 +347,8 @@ gimp_register_magic_load_handler (const gchar *procedure_name,
"gimp-register-magic-load-handler",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-register-magic-load-handler",
args);
return_vals = gimp_run_procedure_array ("gimp-register-magic-load-handler",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -394,8 +394,8 @@ gimp_register_load_handler (const gchar *procedure_name,
"gimp-register-load-handler",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-register-load-handler",
args);
return_vals = gimp_run_procedure_array ("gimp-register-load-handler",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -441,8 +441,8 @@ gimp_register_save_handler (const gchar *procedure_name,
"gimp-register-save-handler",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-register-save-handler",
args);
return_vals = gimp_run_procedure_array ("gimp-register-save-handler",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -489,8 +489,8 @@ gimp_register_file_handler_priority (const gchar *procedure_name,
"gimp-register-file-handler-priority",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-register-file-handler-priority",
args);
return_vals = gimp_run_procedure_array ("gimp-register-file-handler-priority",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -538,8 +538,8 @@ gimp_register_file_handler_mime (const gchar *procedure_name,
"gimp-register-file-handler-mime",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-register-file-handler-mime",
args);
return_vals = gimp_run_procedure_array ("gimp-register-file-handler-mime",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -581,8 +581,8 @@ gimp_register_file_handler_uri (const gchar *procedure_name)
"gimp-register-file-handler-uri",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-register-file-handler-uri",
args);
return_vals = gimp_run_procedure_array ("gimp-register-file-handler-uri",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -624,8 +624,8 @@ gimp_register_file_handler_raw (const gchar *procedure_name)
"gimp-register-file-handler-raw",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-register-file-handler-raw",
args);
return_vals = gimp_run_procedure_array ("gimp-register-file-handler-raw",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -673,8 +673,8 @@ gimp_register_thumbnail_loader (const gchar *load_proc,
"gimp-register-thumbnail-loader",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-register-thumbnail-loader",
args);
return_vals = gimp_run_procedure_array ("gimp-register-thumbnail-loader",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;

16
libgimp/gimpfloatingsel_pdb.c
View File

@ -63,8 +63,8 @@ gimp_floating_sel_remove (gint32 floating_sel_ID)
"gimp-floating-sel-remove",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-floating-sel-remove",
args);
return_vals = gimp_run_procedure_array ("gimp-floating-sel-remove",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -104,8 +104,8 @@ gimp_floating_sel_anchor (gint32 floating_sel_ID)
"gimp-floating-sel-anchor",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-floating-sel-anchor",
args);
return_vals = gimp_run_procedure_array ("gimp-floating-sel-anchor",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -149,8 +149,8 @@ gimp_floating_sel_to_layer (gint32 floating_sel_ID)
"gimp-floating-sel-to-layer",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-floating-sel-to-layer",
args);
return_vals = gimp_run_procedure_array ("gimp-floating-sel-to-layer",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -192,8 +192,8 @@ gimp_floating_sel_attach (gint32 layer_ID,
"gimp-floating-sel-attach",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-floating-sel-attach",
args);
return_vals = gimp_run_procedure_array ("gimp-floating-sel-attach",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;

8
libgimp/gimpfonts_pdb.c
View File

@ -60,8 +60,8 @@ gimp_fonts_refresh (void)
"gimp-fonts-refresh",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-fonts-refresh",
args);
return_vals = gimp_run_procedure_array ("gimp-fonts-refresh",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -103,8 +103,8 @@ gimp_fonts_get_list (const gchar *filter,
"gimp-fonts-get-list",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-fonts-get-list",
args);
return_vals = gimp_run_procedure_array ("gimp-fonts-get-list",
args);
gimp_value_array_unref (args);
*num_fonts = 0;

12
libgimp/gimpfontselect_pdb.c
View File

@ -69,8 +69,8 @@ gimp_fonts_popup (const gchar *font_callback,
"gimp-fonts-popup",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-fonts-popup",
args);
return_vals = gimp_run_procedure_array ("gimp-fonts-popup",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -107,8 +107,8 @@ gimp_fonts_close_popup (const gchar *font_callback)
"gimp-fonts-close-popup",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-fonts-close-popup",
args);
return_vals = gimp_run_procedure_array ("gimp-fonts-close-popup",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -149,8 +149,8 @@ gimp_fonts_set_popup (const gchar *font_callback,
"gimp-fonts-set-popup",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-fonts-set-popup",
args);
return_vals = gimp_run_procedure_array ("gimp-fonts-set-popup",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;

28
libgimp/gimpgimprc_pdb.c
View File

@ -70,8 +70,8 @@ gimp_gimprc_query (const gchar *token)
"gimp-gimprc-query",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-gimprc-query",
args);
return_vals = gimp_run_procedure_array ("gimp-gimprc-query",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -117,8 +117,8 @@ gimp_gimprc_set (const gchar *token,
"gimp-gimprc-set",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-gimprc-set",
args);
return_vals = gimp_run_procedure_array ("gimp-gimprc-set",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -153,8 +153,8 @@ gimp_get_default_comment (void)
"gimp-get-default-comment",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-get-default-comment",
args);
return_vals = gimp_run_procedure_array ("gimp-get-default-comment",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -191,8 +191,8 @@ gimp_get_default_unit (void)
"gimp-get-default-unit",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-get-default-unit",
args);
return_vals = gimp_run_procedure_array ("gimp-get-default-unit",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -233,8 +233,8 @@ gimp_get_monitor_resolution (gdouble *xres,
"gimp-get-monitor-resolution",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-get-monitor-resolution",
args);
return_vals = gimp_run_procedure_array ("gimp-get-monitor-resolution",
args);
gimp_value_array_unref (args);
*xres = 0.0;
@ -281,8 +281,8 @@ _gimp_get_color_configuration (void)
"gimp-get-color-configuration",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-get-color-configuration",
args);
return_vals = gimp_run_procedure_array ("gimp-get-color-configuration",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -318,8 +318,8 @@ gimp_get_module_load_inhibit (void)
"gimp-get-module-load-inhibit",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-get-module-load-inhibit",
args);
return_vals = gimp_run_procedure_array ("gimp-get-module-load-inhibit",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)

124
libgimp/gimpgradient_pdb.c
View File

@ -64,8 +64,8 @@ gimp_gradient_new (const gchar *name)
"gimp-gradient-new",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-gradient-new",
args);
return_vals = gimp_run_procedure_array ("gimp-gradient-new",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -106,8 +106,8 @@ gimp_gradient_duplicate (const gchar *name)
"gimp-gradient-duplicate",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-gradient-duplicate",
args);
return_vals = gimp_run_procedure_array ("gimp-gradient-duplicate",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -147,8 +147,8 @@ gimp_gradient_is_editable (const gchar *name)
"gimp-gradient-is-editable",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-gradient-is-editable",
args);
return_vals = gimp_run_procedure_array ("gimp-gradient-is-editable",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -193,8 +193,8 @@ gimp_gradient_rename (const gchar *name,
"gimp-gradient-rename",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-gradient-rename",
args);
return_vals = gimp_run_procedure_array ("gimp-gradient-rename",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -234,8 +234,8 @@ gimp_gradient_delete (const gchar *name)
"gimp-gradient-delete",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-gradient-delete",
args);
return_vals = gimp_run_procedure_array ("gimp-gradient-delete",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -275,8 +275,8 @@ gimp_gradient_get_number_of_segments (const gchar *name)
"gimp-gradient-get-number-of-segments",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-gradient-get-number-of-segments",
args);
return_vals = gimp_run_procedure_array ("gimp-gradient-get-number-of-segments",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -334,8 +334,8 @@ gimp_gradient_get_uniform_samples (const gchar *name,
"gimp-gradient-get-uniform-samples",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-gradient-get-uniform-samples",
args);
return_vals = gimp_run_procedure_array ("gimp-gradient-get-uniform-samples",
args);
gimp_value_array_unref (args);
*num_color_samples = 0;
@ -404,8 +404,8 @@ gimp_gradient_get_custom_samples (const gchar *name,
"gimp-gradient-get-custom-samples",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-gradient-get-custom-samples",
args);
return_vals = gimp_run_procedure_array ("gimp-gradient-get-custom-samples",
args);
gimp_value_array_unref (args);
*num_color_samples = 0;
@ -462,8 +462,8 @@ gimp_gradient_segment_get_left_color (const gchar *name,
"gimp-gradient-segment-get-left-color",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-get-left-color",
args);
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-get-left-color",
args);
gimp_value_array_unref (args);
*opacity = 0.0;
@ -523,8 +523,8 @@ gimp_gradient_segment_set_left_color (const gchar *name,
"gimp-gradient-segment-set-left-color",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-set-left-color",
args);
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-set-left-color",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -572,8 +572,8 @@ gimp_gradient_segment_get_right_color (const gchar *name,
"gimp-gradient-segment-get-right-color",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-get-right-color",
args);
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-get-right-color",
args);
gimp_value_array_unref (args);
*opacity = 0.0;
@ -633,8 +633,8 @@ gimp_gradient_segment_set_right_color (const gchar *name,
"gimp-gradient-segment-set-right-color",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-set-right-color",
args);
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-set-right-color",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -680,8 +680,8 @@ gimp_gradient_segment_get_left_pos (const gchar *name,
"gimp-gradient-segment-get-left-pos",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-get-left-pos",
args);
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-get-left-pos",
args);
gimp_value_array_unref (args);
*pos = 0.0;
@ -739,8 +739,8 @@ gimp_gradient_segment_set_left_pos (const gchar *name,
"gimp-gradient-segment-set-left-pos",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-set-left-pos",
args);
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-set-left-pos",
args);
gimp_value_array_unref (args);
*final_pos = 0.0;
@ -791,8 +791,8 @@ gimp_gradient_segment_get_middle_pos (const gchar *name,
"gimp-gradient-segment-get-middle-pos",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-get-middle-pos",
args);
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-get-middle-pos",
args);
gimp_value_array_unref (args);
*pos = 0.0;
@ -849,8 +849,8 @@ gimp_gradient_segment_set_middle_pos (const gchar *name,
"gimp-gradient-segment-set-middle-pos",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-set-middle-pos",
args);
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-set-middle-pos",
args);
gimp_value_array_unref (args);
*final_pos = 0.0;
@ -901,8 +901,8 @@ gimp_gradient_segment_get_right_pos (const gchar *name,
"gimp-gradient-segment-get-right-pos",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-get-right-pos",
args);
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-get-right-pos",
args);
gimp_value_array_unref (args);
*pos = 0.0;
@ -960,8 +960,8 @@ gimp_gradient_segment_set_right_pos (const gchar *name,
"gimp-gradient-segment-set-right-pos",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-set-right-pos",
args);
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-set-right-pos",
args);
gimp_value_array_unref (args);
*final_pos = 0.0;
@ -1012,8 +1012,8 @@ gimp_gradient_segment_get_blending_function (const gchar *name,
"gimp-gradient-segment-get-blending-function",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-get-blending-function",
args);
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-get-blending-function",
args);
gimp_value_array_unref (args);
*blend_func = 0;
@ -1064,8 +1064,8 @@ gimp_gradient_segment_get_coloring_type (const gchar *name,
"gimp-gradient-segment-get-coloring-type",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-get-coloring-type",
args);
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-get-coloring-type",
args);
gimp_value_array_unref (args);
*coloring_type = 0;
@ -1122,8 +1122,8 @@ gimp_gradient_segment_range_set_blending_function (const gchar *name
"gimp-gradient-segment-range-set-blending-function",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-range-set-blending-function",
args);
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-range-set-blending-function",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1175,8 +1175,8 @@ gimp_gradient_segment_range_set_coloring_type (const gchar *name,
"gimp-gradient-segment-range-set-coloring-type",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-range-set-coloring-type",
args);
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-range-set-coloring-type",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1223,8 +1223,8 @@ gimp_gradient_segment_range_flip (const gchar *name,
"gimp-gradient-segment-range-flip",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-range-flip",
args);
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-range-flip",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1277,8 +1277,8 @@ gimp_gradient_segment_range_replicate (const gchar *name,
"gimp-gradient-segment-range-replicate",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-range-replicate",
args);
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-range-replicate",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1326,8 +1326,8 @@ gimp_gradient_segment_range_split_midpoint (const gchar *name,
"gimp-gradient-segment-range-split-midpoint",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-range-split-midpoint",
args);
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-range-split-midpoint",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1379,8 +1379,8 @@ gimp_gradient_segment_range_split_uniform (const gchar *name,
"gimp-gradient-segment-range-split-uniform",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-range-split-uniform",
args);
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-range-split-uniform",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1427,8 +1427,8 @@ gimp_gradient_segment_range_delete (const gchar *name,
"gimp-gradient-segment-range-delete",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-range-delete",
args);
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-range-delete",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1476,8 +1476,8 @@ gimp_gradient_segment_range_redistribute_handles (const gchar *name,
"gimp-gradient-segment-range-redistribute-handles",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-range-redistribute-handles",
args);
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-range-redistribute-handles",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1526,8 +1526,8 @@ gimp_gradient_segment_range_blend_colors (const gchar *name,
"gimp-gradient-segment-range-blend-colors",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-range-blend-colors",
args);
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-range-blend-colors",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1576,8 +1576,8 @@ gimp_gradient_segment_range_blend_opacity (const gchar *name,
"gimp-gradient-segment-range-blend-opacity",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-range-blend-opacity",
args);
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-range-blend-opacity",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1634,8 +1634,8 @@ gimp_gradient_segment_range_move (const gchar *name,
"gimp-gradient-segment-range-move",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-range-move",
args);
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-range-move",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)

8
libgimp/gimpgradients_pdb.c
View File

@ -59,8 +59,8 @@ gimp_gradients_refresh (void)
"gimp-gradients-refresh",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-gradients-refresh",
args);
return_vals = gimp_run_procedure_array ("gimp-gradients-refresh",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -103,8 +103,8 @@ gimp_gradients_get_list (const gchar *filter,
"gimp-gradients-get-list",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-gradients-get-list",
args);
return_vals = gimp_run_procedure_array ("gimp-gradients-get-list",
args);
gimp_value_array_unref (args);
*num_gradients = 0;

12
libgimp/gimpgradientselect_pdb.c
View File

@ -73,8 +73,8 @@ gimp_gradients_popup (const gchar *gradient_callback,
"gimp-gradients-popup",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-gradients-popup",
args);
return_vals = gimp_run_procedure_array ("gimp-gradients-popup",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -111,8 +111,8 @@ gimp_gradients_close_popup (const gchar *gradient_callback)
"gimp-gradients-close-popup",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-gradients-close-popup",
args);
return_vals = gimp_run_procedure_array ("gimp-gradients-close-popup",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -153,8 +153,8 @@ gimp_gradients_set_popup (const gchar *gradient_callback,
"gimp-gradients-set-popup",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-gradients-set-popup",
args);
return_vals = gimp_run_procedure_array ("gimp-gradients-set-popup",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;

4
libgimp/gimphelp_pdb.c
View File

@ -70,8 +70,8 @@ gimp_help (const gchar *help_domain,
"gimp-help",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-help",
args);
return_vals = gimp_run_procedure_array ("gimp-help",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;

328
libgimp/gimpimage_pdb.c
View File

@ -65,8 +65,8 @@ gimp_image_is_valid (gint32 image_ID)
"gimp-image-is-valid",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-is-valid",
args);
return_vals = gimp_run_procedure_array ("gimp-image-is-valid",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -104,8 +104,8 @@ gimp_image_list (gint *num_images)
"gimp-image-list",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-list",
args);
return_vals = gimp_run_procedure_array ("gimp-image-list",
args);
gimp_value_array_unref (args);
*num_images = 0;
@ -165,8 +165,8 @@ gimp_image_new (gint width,
"gimp-image-new",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-new",
args);
return_vals = gimp_run_procedure_array ("gimp-image-new",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -222,8 +222,8 @@ gimp_image_new_with_precision (gint width,
"gimp-image-new-with-precision",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-new-with-precision",
args);
return_vals = gimp_run_procedure_array ("gimp-image-new-with-precision",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -262,8 +262,8 @@ gimp_image_duplicate (gint32 image_ID)
"gimp-image-duplicate",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-duplicate",
args);
return_vals = gimp_run_procedure_array ("gimp-image-duplicate",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -306,8 +306,8 @@ gimp_image_delete (gint32 image_ID)
"gimp-image-delete",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-delete",
args);
return_vals = gimp_run_procedure_array ("gimp-image-delete",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -345,8 +345,8 @@ gimp_image_base_type (gint32 image_ID)
"gimp-image-base-type",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-base-type",
args);
return_vals = gimp_run_procedure_array ("gimp-image-base-type",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -386,8 +386,8 @@ gimp_image_get_precision (gint32 image_ID)
"gimp-image-get-precision",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-get-precision",
args);
return_vals = gimp_run_procedure_array ("gimp-image-get-precision",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -427,8 +427,8 @@ gimp_image_get_default_new_layer_mode (gint32 image_ID)
"gimp-image-get-default-new-layer-mode",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-get-default-new-layer-mode",
args);
return_vals = gimp_run_procedure_array ("gimp-image-get-default-new-layer-mode",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -467,8 +467,8 @@ gimp_image_width (gint32 image_ID)
"gimp-image-width",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-width",
args);
return_vals = gimp_run_procedure_array ("gimp-image-width",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -507,8 +507,8 @@ gimp_image_height (gint32 image_ID)
"gimp-image-height",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-height",
args);
return_vals = gimp_run_procedure_array ("gimp-image-height",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -551,8 +551,8 @@ gimp_image_get_layers (gint32 image_ID,
"gimp-image-get-layers",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-get-layers",
args);
return_vals = gimp_run_procedure_array ("gimp-image-get-layers",
args);
gimp_value_array_unref (args);
*num_layers = 0;
@ -603,8 +603,8 @@ gimp_image_get_channels (gint32 image_ID,
"gimp-image-get-channels",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-get-channels",
args);
return_vals = gimp_run_procedure_array ("gimp-image-get-channels",
args);
gimp_value_array_unref (args);
*num_channels = 0;
@ -654,8 +654,8 @@ gimp_image_get_vectors (gint32 image_ID,
"gimp-image-get-vectors",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-get-vectors",
args);
return_vals = gimp_run_procedure_array ("gimp-image-get-vectors",
args);
gimp_value_array_unref (args);
*num_vectors = 0;
@ -703,8 +703,8 @@ gimp_image_get_active_drawable (gint32 image_ID)
"gimp-image-get-active-drawable",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-get-active-drawable",
args);
return_vals = gimp_run_procedure_array ("gimp-image-get-active-drawable",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -745,8 +745,8 @@ gimp_image_unset_active_channel (gint32 image_ID)
"gimp-image-unset-active-channel",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-unset-active-channel",
args);
return_vals = gimp_run_procedure_array ("gimp-image-unset-active-channel",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -784,8 +784,8 @@ gimp_image_get_floating_sel (gint32 image_ID)
"gimp-image-get-floating-sel",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-get-floating-sel",
args);
return_vals = gimp_run_procedure_array ("gimp-image-get-floating-sel",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -825,8 +825,8 @@ gimp_image_floating_sel_attached_to (gint32 image_ID)
"gimp-image-floating-sel-attached-to",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-floating-sel-attached-to",
args);
return_vals = gimp_run_procedure_array ("gimp-image-floating-sel-attached-to",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -900,8 +900,8 @@ gimp_image_pick_color (gint32 image_ID,
"gimp-image-pick-color",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-pick-color",
args);
return_vals = gimp_run_procedure_array ("gimp-image-pick-color",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -953,8 +953,8 @@ gimp_image_pick_correlate_layer (gint32 image_ID,
"gimp-image-pick-correlate-layer",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-pick-correlate-layer",
args);
return_vals = gimp_run_procedure_array ("gimp-image-pick-correlate-layer",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -1014,8 +1014,8 @@ gimp_image_insert_layer (gint32 image_ID,
"gimp-image-insert-layer",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-insert-layer",
args);
return_vals = gimp_run_procedure_array ("gimp-image-insert-layer",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1060,8 +1060,8 @@ gimp_image_remove_layer (gint32 image_ID,
"gimp-image-remove-layer",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-remove-layer",
args);
return_vals = gimp_run_procedure_array ("gimp-image-remove-layer",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1106,8 +1106,8 @@ gimp_image_freeze_layers (gint32 image_ID)
"gimp-image-freeze-layers",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-freeze-layers",
args);
return_vals = gimp_run_procedure_array ("gimp-image-freeze-layers",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1150,8 +1150,8 @@ gimp_image_thaw_layers (gint32 image_ID)
"gimp-image-thaw-layers",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-thaw-layers",
args);
return_vals = gimp_run_procedure_array ("gimp-image-thaw-layers",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1205,8 +1205,8 @@ gimp_image_insert_channel (gint32 image_ID,
"gimp-image-insert-channel",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-insert-channel",
args);
return_vals = gimp_run_procedure_array ("gimp-image-insert-channel",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1248,8 +1248,8 @@ gimp_image_remove_channel (gint32 image_ID,
"gimp-image-remove-channel",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-remove-channel",
args);
return_vals = gimp_run_procedure_array ("gimp-image-remove-channel",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1295,8 +1295,8 @@ gimp_image_freeze_channels (gint32 image_ID)
"gimp-image-freeze-channels",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-freeze-channels",
args);
return_vals = gimp_run_procedure_array ("gimp-image-freeze-channels",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1339,8 +1339,8 @@ gimp_image_thaw_channels (gint32 image_ID)
"gimp-image-thaw-channels",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-thaw-channels",
args);
return_vals = gimp_run_procedure_array ("gimp-image-thaw-channels",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1394,8 +1394,8 @@ gimp_image_insert_vectors (gint32 image_ID,
"gimp-image-insert-vectors",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-insert-vectors",
args);
return_vals = gimp_run_procedure_array ("gimp-image-insert-vectors",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1439,8 +1439,8 @@ gimp_image_remove_vectors (gint32 image_ID,
"gimp-image-remove-vectors",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-remove-vectors",
args);
return_vals = gimp_run_procedure_array ("gimp-image-remove-vectors",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1486,8 +1486,8 @@ gimp_image_freeze_vectors (gint32 image_ID)
"gimp-image-freeze-vectors",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-freeze-vectors",
args);
return_vals = gimp_run_procedure_array ("gimp-image-freeze-vectors",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1530,8 +1530,8 @@ gimp_image_thaw_vectors (gint32 image_ID)
"gimp-image-thaw-vectors",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-thaw-vectors",
args);
return_vals = gimp_run_procedure_array ("gimp-image-thaw-vectors",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1577,8 +1577,8 @@ gimp_image_get_item_position (gint32 image_ID,
"gimp-image-get-item-position",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-get-item-position",
args);
return_vals = gimp_run_procedure_array ("gimp-image-get-item-position",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -1623,8 +1623,8 @@ gimp_image_raise_item (gint32 image_ID,
"gimp-image-raise-item",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-raise-item",
args);
return_vals = gimp_run_procedure_array ("gimp-image-raise-item",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1668,8 +1668,8 @@ gimp_image_lower_item (gint32 image_ID,
"gimp-image-lower-item",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-lower-item",
args);
return_vals = gimp_run_procedure_array ("gimp-image-lower-item",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1713,8 +1713,8 @@ gimp_image_raise_item_to_top (gint32 image_ID,
"gimp-image-raise-item-to-top",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-raise-item-to-top",
args);
return_vals = gimp_run_procedure_array ("gimp-image-raise-item-to-top",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1759,8 +1759,8 @@ gimp_image_lower_item_to_bottom (gint32 image_ID,
"gimp-image-lower-item-to-bottom",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-lower-item-to-bottom",
args);
return_vals = gimp_run_procedure_array ("gimp-image-lower-item-to-bottom",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1811,8 +1811,8 @@ gimp_image_reorder_item (gint32 image_ID,
"gimp-image-reorder-item",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-reorder-item",
args);
return_vals = gimp_run_procedure_array ("gimp-image-reorder-item",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1852,8 +1852,8 @@ gimp_image_flatten (gint32 image_ID)
"gimp-image-flatten",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-flatten",
args);
return_vals = gimp_run_procedure_array ("gimp-image-flatten",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -1900,8 +1900,8 @@ gimp_image_merge_visible_layers (gint32 image_ID,
"gimp-image-merge-visible-layers",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-merge-visible-layers",
args);
return_vals = gimp_run_procedure_array ("gimp-image-merge-visible-layers",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -1953,8 +1953,8 @@ gimp_image_merge_down (gint32 image_ID,
"gimp-image-merge-down",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-merge-down",
args);
return_vals = gimp_run_procedure_array ("gimp-image-merge-down",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -2000,8 +2000,8 @@ _gimp_image_get_colormap (gint32 image_ID,
"gimp-image-get-colormap",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-get-colormap",
args);
return_vals = gimp_run_procedure_array ("gimp-image-get-colormap",
args);
gimp_value_array_unref (args);
*num_bytes = 0;
@ -2056,8 +2056,8 @@ _gimp_image_set_colormap (gint32 image_ID,
"gimp-image-set-colormap",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-set-colormap",
args);
return_vals = gimp_run_procedure_array ("gimp-image-set-colormap",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -2095,8 +2095,8 @@ _gimp_image_get_metadata (gint32 image_ID)
"gimp-image-get-metadata",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-get-metadata",
args);
return_vals = gimp_run_procedure_array ("gimp-image-get-metadata",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -2138,8 +2138,8 @@ _gimp_image_set_metadata (gint32 image_ID,
"gimp-image-set-metadata",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-set-metadata",
args);
return_vals = gimp_run_procedure_array ("gimp-image-set-metadata",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -2181,8 +2181,8 @@ gimp_image_clean_all (gint32 image_ID)
"gimp-image-clean-all",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-clean-all",
args);
return_vals = gimp_run_procedure_array ("gimp-image-clean-all",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -2222,8 +2222,8 @@ gimp_image_is_dirty (gint32 image_ID)
"gimp-image-is-dirty",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-is-dirty",
args);
return_vals = gimp_run_procedure_array ("gimp-image-is-dirty",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -2282,8 +2282,8 @@ _gimp_image_thumbnail (gint32 image_ID,
"gimp-image-thumbnail",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-thumbnail",
args);
return_vals = gimp_run_procedure_array ("gimp-image-thumbnail",
args);
gimp_value_array_unref (args);
*actual_width = 0;
@ -2337,8 +2337,8 @@ gimp_image_get_active_layer (gint32 image_ID)
"gimp-image-get-active-layer",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-get-active-layer",
args);
return_vals = gimp_run_procedure_array ("gimp-image-get-active-layer",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -2383,8 +2383,8 @@ gimp_image_set_active_layer (gint32 image_ID,
"gimp-image-set-active-layer",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-set-active-layer",
args);
return_vals = gimp_run_procedure_array ("gimp-image-set-active-layer",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -2422,8 +2422,8 @@ gimp_image_get_active_channel (gint32 image_ID)
"gimp-image-get-active-channel",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-get-active-channel",
args);
return_vals = gimp_run_procedure_array ("gimp-image-get-active-channel",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -2468,8 +2468,8 @@ gimp_image_set_active_channel (gint32 image_ID,
"gimp-image-set-active-channel",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-set-active-channel",
args);
return_vals = gimp_run_procedure_array ("gimp-image-set-active-channel",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -2506,8 +2506,8 @@ gimp_image_get_active_vectors (gint32 image_ID)
"gimp-image-get-active-vectors",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-get-active-vectors",
args);
return_vals = gimp_run_procedure_array ("gimp-image-get-active-vectors",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -2549,8 +2549,8 @@ gimp_image_set_active_vectors (gint32 image_ID,
"gimp-image-set-active-vectors",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-set-active-vectors",
args);
return_vals = gimp_run_procedure_array ("gimp-image-set-active-vectors",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -2588,8 +2588,8 @@ gimp_image_get_selection (gint32 image_ID)
"gimp-image-get-selection",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-get-selection",
args);
return_vals = gimp_run_procedure_array ("gimp-image-get-selection",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -2634,8 +2634,8 @@ gimp_image_get_component_active (gint32 image_ID,
"gimp-image-get-component-active",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-get-component-active",
args);
return_vals = gimp_run_procedure_array ("gimp-image-get-component-active",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -2684,8 +2684,8 @@ gimp_image_set_component_active (gint32 image_ID,
"gimp-image-set-component-active",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-set-component-active",
args);
return_vals = gimp_run_procedure_array ("gimp-image-set-component-active",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -2730,8 +2730,8 @@ gimp_image_get_component_visible (gint32 image_ID,
"gimp-image-get-component-visible",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-get-component-visible",
args);
return_vals = gimp_run_procedure_array ("gimp-image-get-component-visible",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -2780,8 +2780,8 @@ gimp_image_set_component_visible (gint32 image_ID,
"gimp-image-set-component-visible",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-set-component-visible",
args);
return_vals = gimp_run_procedure_array ("gimp-image-set-component-visible",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -2823,8 +2823,8 @@ gimp_image_get_filename (gint32 image_ID)
"gimp-image-get-filename",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-get-filename",
args);
return_vals = gimp_run_procedure_array ("gimp-image-get-filename",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -2867,8 +2867,8 @@ gimp_image_set_filename (gint32 image_ID,
"gimp-image-set-filename",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-set-filename",
args);
return_vals = gimp_run_procedure_array ("gimp-image-set-filename",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -2914,8 +2914,8 @@ gimp_image_get_uri (gint32 image_ID)
"gimp-image-get-uri",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-get-uri",
args);
return_vals = gimp_run_procedure_array ("gimp-image-get-uri",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -2957,8 +2957,8 @@ gimp_image_get_xcf_uri (gint32 image_ID)
"gimp-image-get-xcf-uri",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-get-xcf-uri",
args);
return_vals = gimp_run_procedure_array ("gimp-image-get-xcf-uri",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -3002,8 +3002,8 @@ gimp_image_get_imported_uri (gint32 image_ID)
"gimp-image-get-imported-uri",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-get-imported-uri",
args);
return_vals = gimp_run_procedure_array ("gimp-image-get-imported-uri",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -3046,8 +3046,8 @@ gimp_image_get_exported_uri (gint32 image_ID)
"gimp-image-get-exported-uri",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-get-exported-uri",
args);
return_vals = gimp_run_procedure_array ("gimp-image-get-exported-uri",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -3092,8 +3092,8 @@ gimp_image_get_name (gint32 image_ID)
"gimp-image-get-name",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-get-name",
args);
return_vals = gimp_run_procedure_array ("gimp-image-get-name",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -3136,8 +3136,8 @@ gimp_image_get_resolution (gint32 image_ID,
"gimp-image-get-resolution",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-get-resolution",
args);
return_vals = gimp_run_procedure_array ("gimp-image-get-resolution",
args);
gimp_value_array_unref (args);
*xresolution = 0.0;
@ -3193,8 +3193,8 @@ gimp_image_set_resolution (gint32 image_ID,
"gimp-image-set-resolution",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-set-resolution",
args);
return_vals = gimp_run_procedure_array ("gimp-image-set-resolution",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -3234,8 +3234,8 @@ gimp_image_get_unit (gint32 image_ID)
"gimp-image-get-unit",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-get-unit",
args);
return_vals = gimp_run_procedure_array ("gimp-image-get-unit",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -3281,8 +3281,8 @@ gimp_image_set_unit (gint32 image_ID,
"gimp-image-set-unit",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-set-unit",
args);
return_vals = gimp_run_procedure_array ("gimp-image-set-unit",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -3321,8 +3321,8 @@ gimp_image_get_tattoo_state (gint32 image_ID)
"gimp-image-get-tattoo-state",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-get-tattoo-state",
args);
return_vals = gimp_run_procedure_array ("gimp-image-get-tattoo-state",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -3375,8 +3375,8 @@ gimp_image_set_tattoo_state (gint32 image_ID,
"gimp-image-set-tattoo-state",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-set-tattoo-state",
args);
return_vals = gimp_run_procedure_array ("gimp-image-set-tattoo-state",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -3418,8 +3418,8 @@ gimp_image_get_layer_by_tattoo (gint32 image_ID,
"gimp-image-get-layer-by-tattoo",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-get-layer-by-tattoo",
args);
return_vals = gimp_run_procedure_array ("gimp-image-get-layer-by-tattoo",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -3462,8 +3462,8 @@ gimp_image_get_channel_by_tattoo (gint32 image_ID,
"gimp-image-get-channel-by-tattoo",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-get-channel-by-tattoo",
args);
return_vals = gimp_run_procedure_array ("gimp-image-get-channel-by-tattoo",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -3508,8 +3508,8 @@ gimp_image_get_vectors_by_tattoo (gint32 image_ID,
"gimp-image-get-vectors-by-tattoo",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-get-vectors-by-tattoo",
args);
return_vals = gimp_run_procedure_array ("gimp-image-get-vectors-by-tattoo",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -3554,8 +3554,8 @@ gimp_image_get_layer_by_name (gint32 image_ID,
"gimp-image-get-layer-by-name",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-get-layer-by-name",
args);
return_vals = gimp_run_procedure_array ("gimp-image-get-layer-by-name",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -3600,8 +3600,8 @@ gimp_image_get_channel_by_name (gint32 image_ID,
"gimp-image-get-channel-by-name",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-get-channel-by-name",
args);
return_vals = gimp_run_procedure_array ("gimp-image-get-channel-by-name",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -3646,8 +3646,8 @@ gimp_image_get_vectors_by_name (gint32 image_ID,
"gimp-image-get-vectors-by-name",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-get-vectors-by-name",
args);
return_vals = gimp_run_procedure_array ("gimp-image-get-vectors-by-name",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -3692,8 +3692,8 @@ gimp_image_attach_parasite (gint32 image_ID,
"gimp-image-attach-parasite",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-attach-parasite",
args);
return_vals = gimp_run_procedure_array ("gimp-image-attach-parasite",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -3737,8 +3737,8 @@ gimp_image_detach_parasite (gint32 image_ID,
"gimp-image-detach-parasite",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-detach-parasite",
args);
return_vals = gimp_run_procedure_array ("gimp-image-detach-parasite",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -3782,8 +3782,8 @@ gimp_image_get_parasite (gint32 image_ID,
"gimp-image-get-parasite",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-get-parasite",
args);
return_vals = gimp_run_procedure_array ("gimp-image-get-parasite",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -3827,8 +3827,8 @@ gimp_image_get_parasite_list (gint32 image_ID,
"gimp-image-get-parasite-list",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-get-parasite-list",
args);
return_vals = gimp_run_procedure_array ("gimp-image-get-parasite-list",
args);
gimp_value_array_unref (args);
*num_parasites = 0;

24
libgimp/gimpimagecolorprofile_pdb.c
View File

@ -68,8 +68,8 @@ _gimp_image_get_color_profile (gint32 image_ID,
"gimp-image-get-color-profile",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-get-color-profile",
args);
return_vals = gimp_run_procedure_array ("gimp-image-get-color-profile",
args);
gimp_value_array_unref (args);
*num_bytes = 0;
@ -122,8 +122,8 @@ _gimp_image_get_effective_color_profile (gint32 image_ID,
"gimp-image-get-effective-color-profile",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-get-effective-color-profile",
args);
return_vals = gimp_run_procedure_array ("gimp-image-get-effective-color-profile",
args);
gimp_value_array_unref (args);
*num_bytes = 0;
@ -180,8 +180,8 @@ _gimp_image_set_color_profile (gint32 image_ID,
"gimp-image-set-color-profile",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-set-color-profile",
args);
return_vals = gimp_run_procedure_array ("gimp-image-set-color-profile",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -229,8 +229,8 @@ gimp_image_set_color_profile_from_file (gint32 image_ID,
"gimp-image-set-color-profile-from-file",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-set-color-profile-from-file",
args);
return_vals = gimp_run_procedure_array ("gimp-image-set-color-profile-from-file",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -288,8 +288,8 @@ _gimp_image_convert_color_profile (gint32 image_ID,
"gimp-image-convert-color-profile",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-convert-color-profile",
args);
return_vals = gimp_run_procedure_array ("gimp-image-convert-color-profile",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -343,8 +343,8 @@ gimp_image_convert_color_profile_from_file (gint32 image_ID,
"gimp-image-convert-color-profile-from-file",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-convert-color-profile-from-file",
args);
return_vals = gimp_run_procedure_array ("gimp-image-convert-color-profile-from-file",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;

20
libgimp/gimpimageconvert_pdb.c
View File

@ -64,8 +64,8 @@ gimp_image_convert_rgb (gint32 image_ID)
"gimp-image-convert-rgb",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-convert-rgb",
args);
return_vals = gimp_run_procedure_array ("gimp-image-convert-rgb",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -103,8 +103,8 @@ gimp_image_convert_grayscale (gint32 image_ID)
"gimp-image-convert-grayscale",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-convert-grayscale",
args);
return_vals = gimp_run_procedure_array ("gimp-image-convert-grayscale",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -177,8 +177,8 @@ gimp_image_convert_indexed (gint32 image_ID,
"gimp-image-convert-indexed",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-convert-indexed",
args);
return_vals = gimp_run_procedure_array ("gimp-image-convert-indexed",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -230,8 +230,8 @@ gimp_image_convert_set_dither_matrix (gint width,
"gimp-image-convert-set-dither-matrix",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-convert-set-dither-matrix",
args);
return_vals = gimp_run_procedure_array ("gimp-image-convert-set-dither-matrix",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -276,8 +276,8 @@ gimp_image_convert_precision (gint32 image_ID,
"gimp-image-convert-precision",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-convert-precision",
args);
return_vals = gimp_run_procedure_array ("gimp-image-convert-precision",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;

40
libgimp/gimpimagegrid_pdb.c
View File

@ -68,8 +68,8 @@ gimp_image_grid_get_spacing (gint32 image_ID,
"gimp-image-grid-get-spacing",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-grid-get-spacing",
args);
return_vals = gimp_run_procedure_array ("gimp-image-grid-get-spacing",
args);
gimp_value_array_unref (args);
*xspacing = 0.0;
@ -126,8 +126,8 @@ gimp_image_grid_set_spacing (gint32 image_ID,
"gimp-image-grid-set-spacing",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-grid-set-spacing",
args);
return_vals = gimp_run_procedure_array ("gimp-image-grid-set-spacing",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -171,8 +171,8 @@ gimp_image_grid_get_offset (gint32 image_ID,
"gimp-image-grid-get-offset",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-grid-get-offset",
args);
return_vals = gimp_run_procedure_array ("gimp-image-grid-get-offset",
args);
gimp_value_array_unref (args);
*xoffset = 0.0;
@ -229,8 +229,8 @@ gimp_image_grid_set_offset (gint32 image_ID,
"gimp-image-grid-set-offset",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-grid-set-offset",
args);
return_vals = gimp_run_procedure_array ("gimp-image-grid-set-offset",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -271,8 +271,8 @@ gimp_image_grid_get_foreground_color (gint32 image_ID,
"gimp-image-grid-get-foreground-color",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-grid-get-foreground-color",
args);
return_vals = gimp_run_procedure_array ("gimp-image-grid-get-foreground-color",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -318,8 +318,8 @@ gimp_image_grid_set_foreground_color (gint32 image_ID,
"gimp-image-grid-set-foreground-color",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-grid-set-foreground-color",
args);
return_vals = gimp_run_procedure_array ("gimp-image-grid-set-foreground-color",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -360,8 +360,8 @@ gimp_image_grid_get_background_color (gint32 image_ID,
"gimp-image-grid-get-background-color",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-grid-get-background-color",
args);
return_vals = gimp_run_procedure_array ("gimp-image-grid-get-background-color",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -407,8 +407,8 @@ gimp_image_grid_set_background_color (gint32 image_ID,
"gimp-image-grid-set-background-color",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-grid-set-background-color",
args);
return_vals = gimp_run_procedure_array ("gimp-image-grid-set-background-color",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -447,8 +447,8 @@ gimp_image_grid_get_style (gint32 image_ID)
"gimp-image-grid-get-style",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-grid-get-style",
args);
return_vals = gimp_run_procedure_array ("gimp-image-grid-get-style",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -493,8 +493,8 @@ gimp_image_grid_set_style (gint32 image_ID,
"gimp-image-grid-set-style",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-grid-set-style",
args);
return_vals = gimp_run_procedure_array ("gimp-image-grid-set-style",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;

24
libgimp/gimpimageguides_pdb.c
View File

@ -67,8 +67,8 @@ gimp_image_add_hguide (gint32 image_ID,
"gimp-image-add-hguide",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-add-hguide",
args);
return_vals = gimp_run_procedure_array ("gimp-image-add-hguide",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -112,8 +112,8 @@ gimp_image_add_vguide (gint32 image_ID,
"gimp-image-add-vguide",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-add-vguide",
args);
return_vals = gimp_run_procedure_array ("gimp-image-add-vguide",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -156,8 +156,8 @@ gimp_image_delete_guide (gint32 image_ID,
"gimp-image-delete-guide",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-delete-guide",
args);
return_vals = gimp_run_procedure_array ("gimp-image-delete-guide",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -202,8 +202,8 @@ gimp_image_find_next_guide (gint32 image_ID,
"gimp-image-find-next-guide",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-find-next-guide",
args);
return_vals = gimp_run_procedure_array ("gimp-image-find-next-guide",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -246,8 +246,8 @@ gimp_image_get_guide_orientation (gint32 image_ID,
"gimp-image-get-guide-orientation",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-get-guide-orientation",
args);
return_vals = gimp_run_procedure_array ("gimp-image-get-guide-orientation",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -290,8 +290,8 @@ gimp_image_get_guide_position (gint32 image_ID,
"gimp-image-get-guide-position",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-get-guide-position",
args);
return_vals = gimp_run_procedure_array ("gimp-image-get-guide-position",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)

16
libgimp/gimpimagesamplepoints_pdb.c
View File

@ -73,8 +73,8 @@ gimp_image_add_sample_point (gint32 image_ID,
"gimp-image-add-sample-point",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-add-sample-point",
args);
return_vals = gimp_run_procedure_array ("gimp-image-add-sample-point",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -119,8 +119,8 @@ gimp_image_delete_sample_point (gint32 image_ID,
"gimp-image-delete-sample-point",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-delete-sample-point",
args);
return_vals = gimp_run_procedure_array ("gimp-image-delete-sample-point",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -168,8 +168,8 @@ gimp_image_find_next_sample_point (gint32 image_ID,
"gimp-image-find-next-sample-point",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-find-next-sample-point",
args);
return_vals = gimp_run_procedure_array ("gimp-image-find-next-sample-point",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -217,8 +217,8 @@ gimp_image_get_sample_point_position (gint32 image_ID,
"gimp-image-get-sample-point-position",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-get-sample-point-position",
args);
return_vals = gimp_run_procedure_array ("gimp-image-get-sample-point-position",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)

28
libgimp/gimpimageselect_pdb.c
View File

@ -91,8 +91,8 @@ gimp_image_select_color (gint32 image_ID,
"gimp-image-select-color",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-select-color",
args);
return_vals = gimp_run_procedure_array ("gimp-image-select-color",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -172,8 +172,8 @@ gimp_image_select_contiguous_color (gint32 image_ID,
"gimp-image-select-contiguous-color",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-select-contiguous-color",
args);
return_vals = gimp_run_procedure_array ("gimp-image-select-contiguous-color",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -237,8 +237,8 @@ gimp_image_select_rectangle (gint32 image_ID,
"gimp-image-select-rectangle",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-select-rectangle",
args);
return_vals = gimp_run_procedure_array ("gimp-image-select-rectangle",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -313,8 +313,8 @@ gimp_image_select_round_rectangle (gint32 image_ID,
"gimp-image-select-round-rectangle",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-select-round-rectangle",
args);
return_vals = gimp_run_procedure_array ("gimp-image-select-round-rectangle",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -379,8 +379,8 @@ gimp_image_select_ellipse (gint32 image_ID,
"gimp-image-select-ellipse",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-select-ellipse",
args);
return_vals = gimp_run_procedure_array ("gimp-image-select-ellipse",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -442,8 +442,8 @@ gimp_image_select_polygon (gint32 image_ID,
"gimp-image-select-polygon",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-select-polygon",
args);
return_vals = gimp_run_procedure_array ("gimp-image-select-polygon",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -497,8 +497,8 @@ gimp_image_select_item (gint32 image_ID,
"gimp-image-select-item",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-select-item",
args);
return_vals = gimp_run_procedure_array ("gimp-image-select-item",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;

24
libgimp/gimpimagetransform_pdb.c
View File

@ -83,8 +83,8 @@ gimp_image_resize (gint32 image_ID,
"gimp-image-resize",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-resize",
args);
return_vals = gimp_run_procedure_array ("gimp-image-resize",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -126,8 +126,8 @@ gimp_image_resize_to_layers (gint32 image_ID)
"gimp-image-resize-to-layers",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-resize-to-layers",
args);
return_vals = gimp_run_procedure_array ("gimp-image-resize-to-layers",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -176,8 +176,8 @@ gimp_image_scale (gint32 image_ID,
"gimp-image-scale",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-scale",
args);
return_vals = gimp_run_procedure_array ("gimp-image-scale",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -235,8 +235,8 @@ gimp_image_crop (gint32 image_ID,
"gimp-image-crop",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-crop",
args);
return_vals = gimp_run_procedure_array ("gimp-image-crop",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -277,8 +277,8 @@ gimp_image_flip (gint32 image_ID,
"gimp-image-flip",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-flip",
args);
return_vals = gimp_run_procedure_array ("gimp-image-flip",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -319,8 +319,8 @@ gimp_image_rotate (gint32 image_ID,
"gimp-image-rotate",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-rotate",
args);
return_vals = gimp_run_procedure_array ("gimp-image-rotate",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;

28
libgimp/gimpimageundo_pdb.c
View File

@ -64,8 +64,8 @@ gimp_image_undo_group_start (gint32 image_ID)
"gimp-image-undo-group-start",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-undo-group-start",
args);
return_vals = gimp_run_procedure_array ("gimp-image-undo-group-start",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -103,8 +103,8 @@ gimp_image_undo_group_end (gint32 image_ID)
"gimp-image-undo-group-end",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-undo-group-end",
args);
return_vals = gimp_run_procedure_array ("gimp-image-undo-group-end",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -144,8 +144,8 @@ gimp_image_undo_is_enabled (gint32 image_ID)
"gimp-image-undo-is-enabled",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-undo-is-enabled",
args);
return_vals = gimp_run_procedure_array ("gimp-image-undo-is-enabled",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -187,8 +187,8 @@ gimp_image_undo_disable (gint32 image_ID)
"gimp-image-undo-disable",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-undo-disable",
args);
return_vals = gimp_run_procedure_array ("gimp-image-undo-disable",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -229,8 +229,8 @@ gimp_image_undo_enable (gint32 image_ID)
"gimp-image-undo-enable",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-undo-enable",
args);
return_vals = gimp_run_procedure_array ("gimp-image-undo-enable",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -278,8 +278,8 @@ gimp_image_undo_freeze (gint32 image_ID)
"gimp-image-undo-freeze",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-undo-freeze",
args);
return_vals = gimp_run_procedure_array ("gimp-image-undo-freeze",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -326,8 +326,8 @@ gimp_image_undo_thaw (gint32 image_ID)
"gimp-image-undo-thaw",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-image-undo-thaw",
args);
return_vals = gimp_run_procedure_array ("gimp-image-undo-thaw",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)

132
libgimp/gimpitem_pdb.c
View File

@ -64,8 +64,8 @@ gimp_item_is_valid (gint32 item_ID)
"gimp-item-is-valid",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-item-is-valid",
args);
return_vals = gimp_run_procedure_array ("gimp-item-is-valid",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -105,8 +105,8 @@ gimp_item_get_image (gint32 item_ID)
"gimp-item-get-image",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-item-get-image",
args);
return_vals = gimp_run_procedure_array ("gimp-item-get-image",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -150,8 +150,8 @@ gimp_item_delete (gint32 item_ID)
"gimp-item-delete",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-item-delete",
args);
return_vals = gimp_run_procedure_array ("gimp-item-delete",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -190,8 +190,8 @@ gimp_item_is_drawable (gint32 item_ID)
"gimp-item-is-drawable",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-item-is-drawable",
args);
return_vals = gimp_run_procedure_array ("gimp-item-is-drawable",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -231,8 +231,8 @@ gimp_item_is_layer (gint32 item_ID)
"gimp-item-is-layer",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-item-is-layer",
args);
return_vals = gimp_run_procedure_array ("gimp-item-is-layer",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -272,8 +272,8 @@ gimp_item_is_text_layer (gint32 item_ID)
"gimp-item-is-text-layer",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-item-is-text-layer",
args);
return_vals = gimp_run_procedure_array ("gimp-item-is-text-layer",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -313,8 +313,8 @@ gimp_item_is_channel (gint32 item_ID)
"gimp-item-is-channel",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-item-is-channel",
args);
return_vals = gimp_run_procedure_array ("gimp-item-is-channel",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -354,8 +354,8 @@ gimp_item_is_layer_mask (gint32 item_ID)
"gimp-item-is-layer-mask",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-item-is-layer-mask",
args);
return_vals = gimp_run_procedure_array ("gimp-item-is-layer-mask",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -395,8 +395,8 @@ gimp_item_is_selection (gint32 item_ID)
"gimp-item-is-selection",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-item-is-selection",
args);
return_vals = gimp_run_procedure_array ("gimp-item-is-selection",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -436,8 +436,8 @@ gimp_item_is_vectors (gint32 item_ID)
"gimp-item-is-vectors",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-item-is-vectors",
args);
return_vals = gimp_run_procedure_array ("gimp-item-is-vectors",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -478,8 +478,8 @@ gimp_item_is_group (gint32 item_ID)
"gimp-item-is-group",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-item-is-group",
args);
return_vals = gimp_run_procedure_array ("gimp-item-is-group",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -519,8 +519,8 @@ gimp_item_get_parent (gint32 item_ID)
"gimp-item-get-parent",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-item-get-parent",
args);
return_vals = gimp_run_procedure_array ("gimp-item-get-parent",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -565,8 +565,8 @@ gimp_item_get_children (gint32 item_ID,
"gimp-item-get-children",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-item-get-children",
args);
return_vals = gimp_run_procedure_array ("gimp-item-get-children",
args);
gimp_value_array_unref (args);
*num_children = 0;
@ -611,8 +611,8 @@ gimp_item_get_expanded (gint32 item_ID)
"gimp-item-get-expanded",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-item-get-expanded",
args);
return_vals = gimp_run_procedure_array ("gimp-item-get-expanded",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -656,8 +656,8 @@ gimp_item_set_expanded (gint32 item_ID,
"gimp-item-set-expanded",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-item-set-expanded",
args);
return_vals = gimp_run_procedure_array ("gimp-item-set-expanded",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -697,8 +697,8 @@ gimp_item_get_name (gint32 item_ID)
"gimp-item-get-name",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-item-get-name",
args);
return_vals = gimp_run_procedure_array ("gimp-item-get-name",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -742,8 +742,8 @@ gimp_item_set_name (gint32 item_ID,
"gimp-item-set-name",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-item-set-name",
args);
return_vals = gimp_run_procedure_array ("gimp-item-set-name",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -782,8 +782,8 @@ gimp_item_get_visible (gint32 item_ID)
"gimp-item-get-visible",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-item-get-visible",
args);
return_vals = gimp_run_procedure_array ("gimp-item-get-visible",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -827,8 +827,8 @@ gimp_item_set_visible (gint32 item_ID,
"gimp-item-set-visible",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-item-set-visible",
args);
return_vals = gimp_run_procedure_array ("gimp-item-set-visible",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -867,8 +867,8 @@ gimp_item_get_linked (gint32 item_ID)
"gimp-item-get-linked",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-item-get-linked",
args);
return_vals = gimp_run_procedure_array ("gimp-item-get-linked",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -912,8 +912,8 @@ gimp_item_set_linked (gint32 item_ID,
"gimp-item-set-linked",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-item-set-linked",
args);
return_vals = gimp_run_procedure_array ("gimp-item-set-linked",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -952,8 +952,8 @@ gimp_item_get_lock_content (gint32 item_ID)
"gimp-item-get-lock-content",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-item-get-lock-content",
args);
return_vals = gimp_run_procedure_array ("gimp-item-get-lock-content",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -997,8 +997,8 @@ gimp_item_set_lock_content (gint32 item_ID,
"gimp-item-set-lock-content",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-item-set-lock-content",
args);
return_vals = gimp_run_procedure_array ("gimp-item-set-lock-content",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1037,8 +1037,8 @@ gimp_item_get_lock_position (gint32 item_ID)
"gimp-item-get-lock-position",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-item-get-lock-position",
args);
return_vals = gimp_run_procedure_array ("gimp-item-get-lock-position",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -1082,8 +1082,8 @@ gimp_item_set_lock_position (gint32 item_ID,
"gimp-item-set-lock-position",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-item-set-lock-position",
args);
return_vals = gimp_run_procedure_array ("gimp-item-set-lock-position",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1122,8 +1122,8 @@ gimp_item_get_color_tag (gint32 item_ID)
"gimp-item-get-color-tag",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-item-get-color-tag",
args);
return_vals = gimp_run_procedure_array ("gimp-item-get-color-tag",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -1167,8 +1167,8 @@ gimp_item_set_color_tag (gint32 item_ID,
"gimp-item-set-color-tag",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-item-set-color-tag",
args);
return_vals = gimp_run_procedure_array ("gimp-item-set-color-tag",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1209,8 +1209,8 @@ gimp_item_get_tattoo (gint32 item_ID)
"gimp-item-get-tattoo",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-item-get-tattoo",
args);
return_vals = gimp_run_procedure_array ("gimp-item-get-tattoo",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -1256,8 +1256,8 @@ gimp_item_set_tattoo (gint32 item_ID,
"gimp-item-set-tattoo",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-item-set-tattoo",
args);
return_vals = gimp_run_procedure_array ("gimp-item-set-tattoo",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1301,8 +1301,8 @@ gimp_item_attach_parasite (gint32 item_ID,
"gimp-item-attach-parasite",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-item-attach-parasite",
args);
return_vals = gimp_run_procedure_array ("gimp-item-attach-parasite",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1346,8 +1346,8 @@ gimp_item_detach_parasite (gint32 item_ID,
"gimp-item-detach-parasite",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-item-detach-parasite",
args);
return_vals = gimp_run_procedure_array ("gimp-item-detach-parasite",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1390,8 +1390,8 @@ gimp_item_get_parasite (gint32 item_ID,
"gimp-item-get-parasite",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-item-get-parasite",
args);
return_vals = gimp_run_procedure_array ("gimp-item-get-parasite",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -1435,8 +1435,8 @@ gimp_item_get_parasite_list (gint32 item_ID,
"gimp-item-get-parasite-list",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-item-get-parasite-list",
args);
return_vals = gimp_run_procedure_array ("gimp-item-get-parasite-list",
args);
gimp_value_array_unref (args);
*num_parasites = 0;

40
libgimp/gimpitemtransform_pdb.c
View File

@ -79,8 +79,8 @@ gimp_item_transform_translate (gint32 item_ID,
"gimp-item-transform-translate",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-item-transform-translate",
args);
return_vals = gimp_run_procedure_array ("gimp-item-transform-translate",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -150,8 +150,8 @@ gimp_item_transform_flip_simple (gint32 item_ID,
"gimp-item-transform-flip-simple",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-item-transform-flip-simple",
args);
return_vals = gimp_run_procedure_array ("gimp-item-transform-flip-simple",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -225,8 +225,8 @@ gimp_item_transform_flip (gint32 item_ID,
"gimp-item-transform-flip",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-item-transform-flip",
args);
return_vals = gimp_run_procedure_array ("gimp-item-transform-flip",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -325,8 +325,8 @@ gimp_item_transform_perspective (gint32 item_ID,
"gimp-item-transform-perspective",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-item-transform-perspective",
args);
return_vals = gimp_run_procedure_array ("gimp-item-transform-perspective",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -403,8 +403,8 @@ gimp_item_transform_rotate_simple (gint32 item_ID,
"gimp-item-transform-rotate-simple",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-item-transform-rotate-simple",
args);
return_vals = gimp_run_procedure_array ("gimp-item-transform-rotate-simple",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -483,8 +483,8 @@ gimp_item_transform_rotate (gint32 item_ID,
"gimp-item-transform-rotate",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-item-transform-rotate",
args);
return_vals = gimp_run_procedure_array ("gimp-item-transform-rotate",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -560,8 +560,8 @@ gimp_item_transform_scale (gint32 item_ID,
"gimp-item-transform-scale",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-item-transform-scale",
args);
return_vals = gimp_run_procedure_array ("gimp-item-transform-scale",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -631,8 +631,8 @@ gimp_item_transform_shear (gint32 item_ID,
"gimp-item-transform-shear",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-item-transform-shear",
args);
return_vals = gimp_run_procedure_array ("gimp-item-transform-shear",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -723,8 +723,8 @@ gimp_item_transform_2d (gint32 item_ID,
"gimp-item-transform-2d",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-item-transform-2d",
args);
return_vals = gimp_run_procedure_array ("gimp-item-transform-2d",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -821,8 +821,8 @@ gimp_item_transform_matrix (gint32 item_ID,
"gimp-item-transform-matrix",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-item-transform-matrix",
args);
return_vals = gimp_run_procedure_array ("gimp-item-transform-matrix",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)

140
libgimp/gimplayer_pdb.c
View File

@ -90,8 +90,8 @@ _gimp_layer_new (gint32 image_ID,
"gimp-layer-new",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-layer-new",
args);
return_vals = gimp_run_procedure_array ("gimp-layer-new",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -143,8 +143,8 @@ gimp_layer_new_from_visible (gint32 image_ID,
"gimp-layer-new-from-visible",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-layer-new-from-visible",
args);
return_vals = gimp_run_procedure_array ("gimp-layer-new-from-visible",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -190,8 +190,8 @@ gimp_layer_new_from_drawable (gint32 drawable_ID,
"gimp-layer-new-from-drawable",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-layer-new-from-drawable",
args);
return_vals = gimp_run_procedure_array ("gimp-layer-new-from-drawable",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -237,8 +237,8 @@ gimp_layer_group_new (gint32 image_ID)
"gimp-layer-group-new",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-layer-group-new",
args);
return_vals = gimp_run_procedure_array ("gimp-layer-group-new",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -285,8 +285,8 @@ _gimp_layer_copy (gint32 layer_ID,
"gimp-layer-copy",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-layer-copy",
args);
return_vals = gimp_run_procedure_array ("gimp-layer-copy",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -328,8 +328,8 @@ gimp_layer_add_alpha (gint32 layer_ID)
"gimp-layer-add-alpha",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-layer-add-alpha",
args);
return_vals = gimp_run_procedure_array ("gimp-layer-add-alpha",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -371,8 +371,8 @@ gimp_layer_flatten (gint32 layer_ID)
"gimp-layer-flatten",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-layer-flatten",
args);
return_vals = gimp_run_procedure_array ("gimp-layer-flatten",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -426,8 +426,8 @@ gimp_layer_scale (gint32 layer_ID,
"gimp-layer-scale",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-layer-scale",
args);
return_vals = gimp_run_procedure_array ("gimp-layer-scale",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -483,8 +483,8 @@ gimp_layer_resize (gint32 layer_ID,
"gimp-layer-resize",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-layer-resize",
args);
return_vals = gimp_run_procedure_array ("gimp-layer-resize",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -522,8 +522,8 @@ gimp_layer_resize_to_image_size (gint32 layer_ID)
"gimp-layer-resize-to-image-size",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-layer-resize-to-image-size",
args);
return_vals = gimp_run_procedure_array ("gimp-layer-resize-to-image-size",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -570,8 +570,8 @@ gimp_layer_set_offsets (gint32 layer_ID,
"gimp-layer-set-offsets",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-layer-set-offsets",
args);
return_vals = gimp_run_procedure_array ("gimp-layer-set-offsets",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -631,8 +631,8 @@ gimp_layer_create_mask (gint32 layer_ID,
"gimp-layer-create-mask",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-layer-create-mask",
args);
return_vals = gimp_run_procedure_array ("gimp-layer-create-mask",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -671,8 +671,8 @@ gimp_layer_get_mask (gint32 layer_ID)
"gimp-layer-get-mask",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-layer-get-mask",
args);
return_vals = gimp_run_procedure_array ("gimp-layer-get-mask",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -713,8 +713,8 @@ gimp_layer_from_mask (gint32 mask_ID)
"gimp-layer-from-mask",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-layer-from-mask",
args);
return_vals = gimp_run_procedure_array ("gimp-layer-from-mask",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -762,8 +762,8 @@ gimp_layer_add_mask (gint32 layer_ID,
"gimp-layer-add-mask",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-layer-add-mask",
args);
return_vals = gimp_run_procedure_array ("gimp-layer-add-mask",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -805,8 +805,8 @@ gimp_layer_remove_mask (gint32 layer_ID,
"gimp-layer-remove-mask",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-layer-remove-mask",
args);
return_vals = gimp_run_procedure_array ("gimp-layer-remove-mask",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -845,8 +845,8 @@ gimp_layer_is_floating_sel (gint32 layer_ID)
"gimp-layer-is-floating-sel",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-layer-is-floating-sel",
args);
return_vals = gimp_run_procedure_array ("gimp-layer-is-floating-sel",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -885,8 +885,8 @@ gimp_layer_get_lock_alpha (gint32 layer_ID)
"gimp-layer-get-lock-alpha",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-layer-get-lock-alpha",
args);
return_vals = gimp_run_procedure_array ("gimp-layer-get-lock-alpha",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -929,8 +929,8 @@ gimp_layer_set_lock_alpha (gint32 layer_ID,
"gimp-layer-set-lock-alpha",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-layer-set-lock-alpha",
args);
return_vals = gimp_run_procedure_array ("gimp-layer-set-lock-alpha",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -969,8 +969,8 @@ gimp_layer_get_apply_mask (gint32 layer_ID)
"gimp-layer-get-apply-mask",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-layer-get-apply-mask",
args);
return_vals = gimp_run_procedure_array ("gimp-layer-get-apply-mask",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -1015,8 +1015,8 @@ gimp_layer_set_apply_mask (gint32 layer_ID,
"gimp-layer-set-apply-mask",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-layer-set-apply-mask",
args);
return_vals = gimp_run_procedure_array ("gimp-layer-set-apply-mask",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1056,8 +1056,8 @@ gimp_layer_get_show_mask (gint32 layer_ID)
"gimp-layer-get-show-mask",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-layer-get-show-mask",
args);
return_vals = gimp_run_procedure_array ("gimp-layer-get-show-mask",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -1102,8 +1102,8 @@ gimp_layer_set_show_mask (gint32 layer_ID,
"gimp-layer-set-show-mask",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-layer-set-show-mask",
args);
return_vals = gimp_run_procedure_array ("gimp-layer-set-show-mask",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1142,8 +1142,8 @@ gimp_layer_get_edit_mask (gint32 layer_ID)
"gimp-layer-get-edit-mask",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-layer-get-edit-mask",
args);
return_vals = gimp_run_procedure_array ("gimp-layer-get-edit-mask",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -1188,8 +1188,8 @@ gimp_layer_set_edit_mask (gint32 layer_ID,
"gimp-layer-set-edit-mask",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-layer-set-edit-mask",
args);
return_vals = gimp_run_procedure_array ("gimp-layer-set-edit-mask",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1226,8 +1226,8 @@ gimp_layer_get_opacity (gint32 layer_ID)
"gimp-layer-get-opacity",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-layer-get-opacity",
args);
return_vals = gimp_run_procedure_array ("gimp-layer-get-opacity",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -1269,8 +1269,8 @@ gimp_layer_set_opacity (gint32 layer_ID,
"gimp-layer-set-opacity",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-layer-set-opacity",
args);
return_vals = gimp_run_procedure_array ("gimp-layer-set-opacity",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1307,8 +1307,8 @@ gimp_layer_get_mode (gint32 layer_ID)
"gimp-layer-get-mode",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-layer-get-mode",
args);
return_vals = gimp_run_procedure_array ("gimp-layer-get-mode",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -1350,8 +1350,8 @@ gimp_layer_set_mode (gint32 layer_ID,
"gimp-layer-set-mode",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-layer-set-mode",
args);
return_vals = gimp_run_procedure_array ("gimp-layer-set-mode",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1390,8 +1390,8 @@ gimp_layer_get_blend_space (gint32 layer_ID)
"gimp-layer-get-blend-space",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-layer-get-blend-space",
args);
return_vals = gimp_run_procedure_array ("gimp-layer-get-blend-space",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -1435,8 +1435,8 @@ gimp_layer_set_blend_space (gint32 layer_ID,
"gimp-layer-set-blend-space",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-layer-set-blend-space",
args);
return_vals = gimp_run_procedure_array ("gimp-layer-set-blend-space",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1475,8 +1475,8 @@ gimp_layer_get_composite_space (gint32 layer_ID)
"gimp-layer-get-composite-space",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-layer-get-composite-space",
args);
return_vals = gimp_run_procedure_array ("gimp-layer-get-composite-space",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -1520,8 +1520,8 @@ gimp_layer_set_composite_space (gint32 layer_ID,
"gimp-layer-set-composite-space",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-layer-set-composite-space",
args);
return_vals = gimp_run_procedure_array ("gimp-layer-set-composite-space",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1560,8 +1560,8 @@ gimp_layer_get_composite_mode (gint32 layer_ID)
"gimp-layer-get-composite-mode",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-layer-get-composite-mode",
args);
return_vals = gimp_run_procedure_array ("gimp-layer-get-composite-mode",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -1605,8 +1605,8 @@ gimp_layer_set_composite_mode (gint32 layer_ID,
"gimp-layer-set-composite-mode",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-layer-set-composite-mode",
args);
return_vals = gimp_run_procedure_array ("gimp-layer-set-composite-mode",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;

40
libgimp/gimplegacy.c
View File

@ -731,7 +731,7 @@ gimp_run_procedure2 (const gchar *name,
arguments = _gimp_params_to_value_array (params, n_params, FALSE);
return_values = gimp_run_procedure_with_array (name, arguments);
return_values = gimp_run_procedure_array (name, arguments);
gimp_value_array_unref (arguments);
@ -743,6 +743,44 @@ gimp_run_procedure2 (const gchar *name,
return return_vals;
}
GimpValueArray *
gimp_run_procedure_array (const gchar *name,
GimpValueArray *arguments)
{
GPProcRun proc_run;
GPProcReturn *proc_return;
GimpWireMessage msg;
GimpValueArray *return_values;
ASSERT_NO_PLUG_IN_EXISTS (G_STRFUNC);
g_return_val_if_fail (name != NULL, NULL);
g_return_val_if_fail (arguments != NULL, NULL);
proc_run.name = (gchar *) name;
proc_run.nparams = gimp_value_array_length (arguments);
proc_run.params = _gimp_value_array_to_gp_params (arguments, FALSE);
if (! gp_proc_run_write (_gimp_writechannel, &proc_run, NULL))
gimp_quit ();
_gimp_read_expect_msg (&msg, GP_PROC_RETURN);
proc_return = msg.data;
return_values = _gimp_gp_params_to_value_array (NULL,
NULL, 0,
proc_return->params,
proc_return->nparams,
TRUE, FALSE);
gimp_wire_destroy (&msg);
_gimp_set_pdb_error (return_values);
return return_values;
}
/**
* gimp_destroy_params:
* @params: the #GimpParam array to destroy

6
libgimp/gimplegacy.h
View File

@ -265,6 +265,12 @@ GimpParam * gimp_run_procedure2 (const gchar *name,
gint n_params,
const GimpParam *params);
/* Run a procedure in the procedure database. The parameters are
* specified as a GimpValueArray, so are the return values.
*/
GimpValueArray * gimp_run_procedure_array (const gchar *name,
GimpValueArray *arguments);
/* Destroy the an array of parameters. This is useful for
* destroying the return values returned by a call to
* 'gimp_run_procedure'.

12
libgimp/gimpmessage_pdb.c
View File

@ -62,8 +62,8 @@ gimp_message (const gchar *message)
"gimp-message",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-message",
args);
return_vals = gimp_run_procedure_array ("gimp-message",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -99,8 +99,8 @@ gimp_message_get_handler (void)
"gimp-message-get-handler",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-message-get-handler",
args);
return_vals = gimp_run_procedure_array ("gimp-message-get-handler",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -140,8 +140,8 @@ gimp_message_set_handler (GimpMessageHandlerType handler)
"gimp-message-set-handler",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-message-set-handler",
args);
return_vals = gimp_run_procedure_array ("gimp-message-set-handler",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;

68
libgimp/gimppainttools_pdb.c
View File

@ -77,8 +77,8 @@ gimp_airbrush (gint32 drawable_ID,
"gimp-airbrush",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-airbrush",
args);
return_vals = gimp_run_procedure_array ("gimp-airbrush",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -127,8 +127,8 @@ gimp_airbrush_default (gint32 drawable_ID,
"gimp-airbrush-default",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-airbrush-default",
args);
return_vals = gimp_run_procedure_array ("gimp-airbrush-default",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -200,8 +200,8 @@ gimp_clone (gint32 drawable_ID,
"gimp-clone",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-clone",
args);
return_vals = gimp_run_procedure_array ("gimp-clone",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -251,8 +251,8 @@ gimp_clone_default (gint32 drawable_ID,
"gimp-clone-default",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-clone-default",
args);
return_vals = gimp_run_procedure_array ("gimp-clone-default",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -308,8 +308,8 @@ gimp_convolve (gint32 drawable_ID,
"gimp-convolve",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-convolve",
args);
return_vals = gimp_run_procedure_array ("gimp-convolve",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -358,8 +358,8 @@ gimp_convolve_default (gint32 drawable_ID,
"gimp-convolve-default",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-convolve-default",
args);
return_vals = gimp_run_procedure_array ("gimp-convolve-default",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -416,8 +416,8 @@ gimp_dodgeburn (gint32 drawable_ID,
"gimp-dodgeburn",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-dodgeburn",
args);
return_vals = gimp_run_procedure_array ("gimp-dodgeburn",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -465,8 +465,8 @@ gimp_dodgeburn_default (gint32 drawable_ID,
"gimp-dodgeburn-default",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-dodgeburn-default",
args);
return_vals = gimp_run_procedure_array ("gimp-dodgeburn-default",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -523,8 +523,8 @@ gimp_eraser (gint32 drawable_ID,
"gimp-eraser",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-eraser",
args);
return_vals = gimp_run_procedure_array ("gimp-eraser",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -573,8 +573,8 @@ gimp_eraser_default (gint32 drawable_ID,
"gimp-eraser-default",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-eraser-default",
args);
return_vals = gimp_run_procedure_array ("gimp-eraser-default",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -638,8 +638,8 @@ gimp_heal (gint32 drawable_ID,
"gimp-heal",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-heal",
args);
return_vals = gimp_run_procedure_array ("gimp-heal",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -691,8 +691,8 @@ gimp_heal_default (gint32 drawable_ID,
"gimp-heal-default",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-heal-default",
args);
return_vals = gimp_run_procedure_array ("gimp-heal-default",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -758,8 +758,8 @@ gimp_paintbrush (gint32 drawable_ID,
"gimp-paintbrush",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-paintbrush",
args);
return_vals = gimp_run_procedure_array ("gimp-paintbrush",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -817,8 +817,8 @@ gimp_paintbrush_default (gint32 drawable_ID,
"gimp-paintbrush-default",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-paintbrush-default",
args);
return_vals = gimp_run_procedure_array ("gimp-paintbrush-default",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -868,8 +868,8 @@ gimp_pencil (gint32 drawable_ID,
"gimp-pencil",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-pencil",
args);
return_vals = gimp_run_procedure_array ("gimp-pencil",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -920,8 +920,8 @@ gimp_smudge (gint32 drawable_ID,
"gimp-smudge",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-smudge",
args);
return_vals = gimp_run_procedure_array ("gimp-smudge",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -969,8 +969,8 @@ gimp_smudge_default (gint32 drawable_ID,
"gimp-smudge-default",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-smudge-default",
args);
return_vals = gimp_run_procedure_array ("gimp-smudge-default",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;

60
libgimp/gimppalette_pdb.c
View File

@ -64,8 +64,8 @@ gimp_palette_new (const gchar *name)
"gimp-palette-new",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-palette-new",
args);
return_vals = gimp_run_procedure_array ("gimp-palette-new",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -106,8 +106,8 @@ gimp_palette_duplicate (const gchar *name)
"gimp-palette-duplicate",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-palette-duplicate",
args);
return_vals = gimp_run_procedure_array ("gimp-palette-duplicate",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -152,8 +152,8 @@ gimp_palette_rename (const gchar *name,
"gimp-palette-rename",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-palette-rename",
args);
return_vals = gimp_run_procedure_array ("gimp-palette-rename",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -193,8 +193,8 @@ gimp_palette_delete (const gchar *name)
"gimp-palette-delete",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-palette-delete",
args);
return_vals = gimp_run_procedure_array ("gimp-palette-delete",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -233,8 +233,8 @@ gimp_palette_is_editable (const gchar *name)
"gimp-palette-is-editable",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-palette-is-editable",
args);
return_vals = gimp_run_procedure_array ("gimp-palette-is-editable",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -277,8 +277,8 @@ gimp_palette_get_info (const gchar *name,
"gimp-palette-get-info",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-palette-get-info",
args);
return_vals = gimp_run_procedure_array ("gimp-palette-get-info",
args);
gimp_value_array_unref (args);
*num_colors = 0;
@ -326,8 +326,8 @@ gimp_palette_get_colors (const gchar *name,
"gimp-palette-get-colors",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-palette-get-colors",
args);
return_vals = gimp_run_procedure_array ("gimp-palette-get-colors",
args);
gimp_value_array_unref (args);
*num_colors = 0;
@ -373,8 +373,8 @@ gimp_palette_get_columns (const gchar *name)
"gimp-palette-get-columns",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-palette-get-columns",
args);
return_vals = gimp_run_procedure_array ("gimp-palette-get-columns",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -420,8 +420,8 @@ gimp_palette_set_columns (const gchar *name,
"gimp-palette-set-columns",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-palette-set-columns",
args);
return_vals = gimp_run_procedure_array ("gimp-palette-set-columns",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -471,8 +471,8 @@ gimp_palette_add_entry (const gchar *name,
"gimp-palette-add-entry",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-palette-add-entry",
args);
return_vals = gimp_run_procedure_array ("gimp-palette-add-entry",
args);
gimp_value_array_unref (args);
*entry_num = 0;
@ -521,8 +521,8 @@ gimp_palette_delete_entry (const gchar *name,
"gimp-palette-delete-entry",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-palette-delete-entry",
args);
return_vals = gimp_run_procedure_array ("gimp-palette-delete-entry",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -569,8 +569,8 @@ gimp_palette_entry_get_color (const gchar *name,
"gimp-palette-entry-get-color",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-palette-entry-get-color",
args);
return_vals = gimp_run_procedure_array ("gimp-palette-entry-get-color",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -622,8 +622,8 @@ gimp_palette_entry_set_color (const gchar *name,
"gimp-palette-entry-set-color",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-palette-entry-set-color",
args);
return_vals = gimp_run_procedure_array ("gimp-palette-entry-set-color",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -670,8 +670,8 @@ gimp_palette_entry_get_name (const gchar *name,
"gimp-palette-entry-get-name",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-palette-entry-get-name",
args);
return_vals = gimp_run_procedure_array ("gimp-palette-entry-get-name",
args);
gimp_value_array_unref (args);
*entry_name = NULL;
@ -725,8 +725,8 @@ gimp_palette_entry_set_name (const gchar *name,
"gimp-palette-entry-set-name",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-palette-entry-set-name",
args);
return_vals = gimp_run_procedure_array ("gimp-palette-entry-set-name",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;

8
libgimp/gimppalettes_pdb.c
View File

@ -59,8 +59,8 @@ gimp_palettes_refresh (void)
"gimp-palettes-refresh",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-palettes-refresh",
args);
return_vals = gimp_run_procedure_array ("gimp-palettes-refresh",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -103,8 +103,8 @@ gimp_palettes_get_list (const gchar *filter,
"gimp-palettes-get-list",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-palettes-get-list",
args);
return_vals = gimp_run_procedure_array ("gimp-palettes-get-list",
args);
gimp_value_array_unref (args);
*num_palettes = 0;

12
libgimp/gimppaletteselect_pdb.c
View File

@ -69,8 +69,8 @@ gimp_palettes_popup (const gchar *palette_callback,
"gimp-palettes-popup",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-palettes-popup",
args);
return_vals = gimp_run_procedure_array ("gimp-palettes-popup",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -107,8 +107,8 @@ gimp_palettes_close_popup (const gchar *palette_callback)
"gimp-palettes-close-popup",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-palettes-close-popup",
args);
return_vals = gimp_run_procedure_array ("gimp-palettes-close-popup",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -149,8 +149,8 @@ gimp_palettes_set_popup (const gchar *palette_callback,
"gimp-palettes-set-popup",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-palettes-set-popup",
args);
return_vals = gimp_run_procedure_array ("gimp-palettes-set-popup",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;

8
libgimp/gimppattern_pdb.c
View File

@ -70,8 +70,8 @@ gimp_pattern_get_info (const gchar *name,
"gimp-pattern-get-info",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-pattern-get-info",
args);
return_vals = gimp_run_procedure_array ("gimp-pattern-get-info",
args);
gimp_value_array_unref (args);
*width = 0;
@ -133,8 +133,8 @@ gimp_pattern_get_pixels (const gchar *name,
"gimp-pattern-get-pixels",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-pattern-get-pixels",
args);
return_vals = gimp_run_procedure_array ("gimp-pattern-get-pixels",
args);
gimp_value_array_unref (args);
*width = 0;

8
libgimp/gimppatterns_pdb.c
View File

@ -59,8 +59,8 @@ gimp_patterns_refresh (void)
"gimp-patterns-refresh",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-patterns-refresh",
args);
return_vals = gimp_run_procedure_array ("gimp-patterns-refresh",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -103,8 +103,8 @@ gimp_patterns_get_list (const gchar *filter,
"gimp-patterns-get-list",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-patterns-get-list",
args);
return_vals = gimp_run_procedure_array ("gimp-patterns-get-list",
args);
gimp_value_array_unref (args);
*num_patterns = 0;

12
libgimp/gimppatternselect_pdb.c
View File

@ -69,8 +69,8 @@ gimp_patterns_popup (const gchar *pattern_callback,
"gimp-patterns-popup",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-patterns-popup",
args);
return_vals = gimp_run_procedure_array ("gimp-patterns-popup",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -107,8 +107,8 @@ gimp_patterns_close_popup (const gchar *pattern_callback)
"gimp-patterns-close-popup",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-patterns-close-popup",
args);
return_vals = gimp_run_procedure_array ("gimp-patterns-close-popup",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -149,8 +149,8 @@ gimp_patterns_set_popup (const gchar *pattern_callback,
"gimp-patterns-set-popup",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-patterns-set-popup",
args);
return_vals = gimp_run_procedure_array ("gimp-patterns-set-popup",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;

48
libgimp/gimppdb_pdb.c
View File

@ -50,8 +50,8 @@ gimp_pdb_temp_name (void)
"gimp-pdb-temp-name",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-pdb-temp-name",
args);
return_vals = gimp_run_procedure_array ("gimp-pdb-temp-name",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -91,8 +91,8 @@ gimp_pdb_dump (const gchar *filename)
"gimp-pdb-dump",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-pdb-dump",
args);
return_vals = gimp_run_procedure_array ("gimp-pdb-dump",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -169,8 +169,8 @@ gimp_pdb_query (const gchar *name,
"gimp-pdb-query",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-pdb-query",
args);
return_vals = gimp_run_procedure_array ("gimp-pdb-query",
args);
gimp_value_array_unref (args);
*num_matches = 0;
@ -219,8 +219,8 @@ _gimp_pdb_proc_exists (const gchar *procedure_name)
"gimp-pdb-proc-exists",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-pdb-proc-exists",
args);
return_vals = gimp_run_procedure_array ("gimp-pdb-proc-exists",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -280,8 +280,8 @@ _gimp_pdb_proc_info (const gchar *procedure_name,
"gimp-pdb-proc-info",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-pdb-proc-info",
args);
return_vals = gimp_run_procedure_array ("gimp-pdb-proc-info",
args);
gimp_value_array_unref (args);
*blurb = NULL;
@ -351,8 +351,8 @@ _gimp_pdb_proc_arg (const gchar *procedure_name,
"gimp-pdb-proc-arg",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-pdb-proc-arg",
args);
return_vals = gimp_run_procedure_array ("gimp-pdb-proc-arg",
args);
gimp_value_array_unref (args);
*arg_type = 0;
@ -413,8 +413,8 @@ _gimp_pdb_proc_val (const gchar *procedure_name,
"gimp-pdb-proc-val",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-pdb-proc-val",
args);
return_vals = gimp_run_procedure_array ("gimp-pdb-proc-val",
args);
gimp_value_array_unref (args);
*val_type = 0;
@ -470,8 +470,8 @@ gimp_pdb_proc_argument (const gchar *procedure_name,
"gimp-pdb-proc-argument",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-pdb-proc-argument",
args);
return_vals = gimp_run_procedure_array ("gimp-pdb-proc-argument",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -518,8 +518,8 @@ gimp_pdb_proc_return_value (const gchar *procedure_name,
"gimp-pdb-proc-return-value",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-pdb-proc-return-value",
args);
return_vals = gimp_run_procedure_array ("gimp-pdb-proc-return-value",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -564,8 +564,8 @@ _gimp_pdb_get_data (const gchar *identifier,
"gimp-pdb-get-data",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-pdb-get-data",
args);
return_vals = gimp_run_procedure_array ("gimp-pdb-get-data",
args);
gimp_value_array_unref (args);
*bytes = 0;
@ -613,8 +613,8 @@ _gimp_pdb_get_data_size (const gchar *identifier)
"gimp-pdb-get-data-size",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-pdb-get-data-size",
args);
return_vals = gimp_run_procedure_array ("gimp-pdb-get-data-size",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -662,8 +662,8 @@ _gimp_pdb_set_data (const gchar *identifier,
"gimp-pdb-set-data",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-pdb-set-data",
args);
return_vals = gimp_run_procedure_array ("gimp-pdb-set-data",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;

7
libgimp/gimppdbprocedure.c
View File

@ -59,8 +59,11 @@ static GimpValueArray *
gimp_pdb_procedure_run (GimpProcedure *procedure,
const GimpValueArray *args)
{
return gimp_run_procedure_with_array (gimp_procedure_get_name (procedure),
(GimpValueArray *) args);
GimpPDBProcedure *pdb_procedure = GIMP_PDB_PROCEDURE (procedure);
return gimp_pdb_run_procedure_array (pdb_procedure->priv->pdb,
gimp_procedure_get_name (procedure),
(GimpValueArray *) args);
}

28
libgimp/gimpplugin_pdb.c
View File

@ -62,8 +62,8 @@ _gimp_plugin_domain_register (const gchar *domain_name,
"gimp-plugin-domain-register",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-plugin-domain-register",
args);
return_vals = gimp_run_procedure_array ("gimp-plugin-domain-register",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -108,8 +108,8 @@ _gimp_plugin_help_register (const gchar *domain_name,
"gimp-plugin-help-register",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-plugin-help-register",
args);
return_vals = gimp_run_procedure_array ("gimp-plugin-help-register",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -155,8 +155,8 @@ _gimp_plugin_menu_branch_register (const gchar *menu_path,
"gimp-plugin-menu-branch-register",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-plugin-menu-branch-register",
args);
return_vals = gimp_run_procedure_array ("gimp-plugin-menu-branch-register",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -200,8 +200,8 @@ _gimp_plugin_menu_register (const gchar *procedure_name,
"gimp-plugin-menu-register",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-plugin-menu-register",
args);
return_vals = gimp_run_procedure_array ("gimp-plugin-menu-register",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -252,8 +252,8 @@ _gimp_plugin_icon_register (const gchar *procedure_name,
"gimp-plugin-icon-register",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-plugin-icon-register",
args);
return_vals = gimp_run_procedure_array ("gimp-plugin-icon-register",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -299,8 +299,8 @@ gimp_plugin_set_pdb_error_handler (GimpPDBErrorHandler handler)
"gimp-plugin-set-pdb-error-handler",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-plugin-set-pdb-error-handler",
args);
return_vals = gimp_run_procedure_array ("gimp-plugin-set-pdb-error-handler",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -338,8 +338,8 @@ gimp_plugin_get_pdb_error_handler (void)
"gimp-plugin-get-pdb-error-handler",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-plugin-get-pdb-error-handler",
args);
return_vals = gimp_run_procedure_array ("gimp-plugin-get-pdb-error-handler",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)

36
libgimp/gimpprogress_pdb.c
View File

@ -66,8 +66,8 @@ _gimp_progress_init (const gchar *message,
"gimp-progress-init",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-progress-init",
args);
return_vals = gimp_run_procedure_array ("gimp-progress-init",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -105,8 +105,8 @@ _gimp_progress_update (gdouble percentage)
"gimp-progress-update",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-progress-update",
args);
return_vals = gimp_run_procedure_array ("gimp-progress-update",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -146,8 +146,8 @@ gimp_progress_pulse (void)
"gimp-progress-pulse",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-progress-pulse",
args);
return_vals = gimp_run_procedure_array ("gimp-progress-pulse",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -188,8 +188,8 @@ gimp_progress_set_text (const gchar *message)
"gimp-progress-set-text",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-progress-set-text",
args);
return_vals = gimp_run_procedure_array ("gimp-progress-set-text",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -227,8 +227,8 @@ gimp_progress_end (void)
"gimp-progress-end",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-progress-end",
args);
return_vals = gimp_run_procedure_array ("gimp-progress-end",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -266,8 +266,8 @@ gimp_progress_get_window_handle (void)
"gimp-progress-get-window-handle",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-progress-get-window-handle",
args);
return_vals = gimp_run_procedure_array ("gimp-progress-get-window-handle",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -310,8 +310,8 @@ _gimp_progress_install (const gchar *progress_callback)
"gimp-progress-install",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-progress-install",
args);
return_vals = gimp_run_procedure_array ("gimp-progress-install",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -351,8 +351,8 @@ _gimp_progress_uninstall (const gchar *progress_callback)
"gimp-progress-uninstall",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-progress-uninstall",
args);
return_vals = gimp_run_procedure_array ("gimp-progress-uninstall",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -391,8 +391,8 @@ gimp_progress_cancel (const gchar *progress_callback)
"gimp-progress-cancel",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-progress-cancel",
args);
return_vals = gimp_run_procedure_array ("gimp-progress-cancel",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;

60
libgimp/gimpselection_pdb.c
View File

@ -78,8 +78,8 @@ gimp_selection_bounds (gint32 image_ID,
"gimp-selection-bounds",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-selection-bounds",
args);
return_vals = gimp_run_procedure_array ("gimp-selection-bounds",
args);
gimp_value_array_unref (args);
*non_empty = FALSE;
@ -140,8 +140,8 @@ gimp_selection_value (gint32 image_ID,
"gimp-selection-value",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-selection-value",
args);
return_vals = gimp_run_procedure_array ("gimp-selection-value",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -180,8 +180,8 @@ gimp_selection_is_empty (gint32 image_ID)
"gimp-selection-is-empty",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-selection-is-empty",
args);
return_vals = gimp_run_procedure_array ("gimp-selection-is-empty",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -231,8 +231,8 @@ gimp_selection_translate (gint32 image_ID,
"gimp-selection-translate",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-selection-translate",
args);
return_vals = gimp_run_procedure_array ("gimp-selection-translate",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -282,8 +282,8 @@ _gimp_selection_float (gint32 drawable_ID,
"gimp-selection-float",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-selection-float",
args);
return_vals = gimp_run_procedure_array ("gimp-selection-float",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -322,8 +322,8 @@ gimp_selection_invert (gint32 image_ID)
"gimp-selection-invert",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-selection-invert",
args);
return_vals = gimp_run_procedure_array ("gimp-selection-invert",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -363,8 +363,8 @@ gimp_selection_sharpen (gint32 image_ID)
"gimp-selection-sharpen",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-selection-sharpen",
args);
return_vals = gimp_run_procedure_array ("gimp-selection-sharpen",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -402,8 +402,8 @@ gimp_selection_all (gint32 image_ID)
"gimp-selection-all",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-selection-all",
args);
return_vals = gimp_run_procedure_array ("gimp-selection-all",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -441,8 +441,8 @@ gimp_selection_none (gint32 image_ID)
"gimp-selection-none",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-selection-none",
args);
return_vals = gimp_run_procedure_array ("gimp-selection-none",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -484,8 +484,8 @@ gimp_selection_feather (gint32 image_ID,
"gimp-selection-feather",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-selection-feather",
args);
return_vals = gimp_run_procedure_array ("gimp-selection-feather",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -528,8 +528,8 @@ gimp_selection_border (gint32 image_ID,
"gimp-selection-border",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-selection-border",
args);
return_vals = gimp_run_procedure_array ("gimp-selection-border",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -571,8 +571,8 @@ gimp_selection_grow (gint32 image_ID,
"gimp-selection-grow",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-selection-grow",
args);
return_vals = gimp_run_procedure_array ("gimp-selection-grow",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -615,8 +615,8 @@ gimp_selection_shrink (gint32 image_ID,
"gimp-selection-shrink",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-selection-shrink",
args);
return_vals = gimp_run_procedure_array ("gimp-selection-shrink",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -658,8 +658,8 @@ gimp_selection_flood (gint32 image_ID)
"gimp-selection-flood",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-selection-flood",
args);
return_vals = gimp_run_procedure_array ("gimp-selection-flood",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -698,8 +698,8 @@ gimp_selection_save (gint32 image_ID)
"gimp-selection-save",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-selection-save",
args);
return_vals = gimp_run_procedure_array ("gimp-selection-save",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)

116
libgimp/gimptextlayer_pdb.c
View File

@ -84,8 +84,8 @@ gimp_text_layer_new (gint32 image_ID,
"gimp-text-layer-new",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-text-layer-new",
args);
return_vals = gimp_run_procedure_array ("gimp-text-layer-new",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -126,8 +126,8 @@ gimp_text_layer_get_text (gint32 layer_ID)
"gimp-text-layer-get-text",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-text-layer-get-text",
args);
return_vals = gimp_run_procedure_array ("gimp-text-layer-get-text",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -171,8 +171,8 @@ gimp_text_layer_set_text (gint32 layer_ID,
"gimp-text-layer-set-text",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-text-layer-set-text",
args);
return_vals = gimp_run_procedure_array ("gimp-text-layer-set-text",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -217,8 +217,8 @@ gimp_text_layer_get_markup (gint32 layer_ID)
"gimp-text-layer-get-markup",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-text-layer-get-markup",
args);
return_vals = gimp_run_procedure_array ("gimp-text-layer-get-markup",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -260,8 +260,8 @@ gimp_text_layer_get_font (gint32 layer_ID)
"gimp-text-layer-get-font",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-text-layer-get-font",
args);
return_vals = gimp_run_procedure_array ("gimp-text-layer-get-font",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -305,8 +305,8 @@ gimp_text_layer_set_font (gint32 layer_ID,
"gimp-text-layer-set-font",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-text-layer-set-font",
args);
return_vals = gimp_run_procedure_array ("gimp-text-layer-set-font",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -349,8 +349,8 @@ gimp_text_layer_get_font_size (gint32 layer_ID,
"gimp-text-layer-get-font-size",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-text-layer-get-font-size",
args);
return_vals = gimp_run_procedure_array ("gimp-text-layer-get-font-size",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -402,8 +402,8 @@ gimp_text_layer_set_font_size (gint32 layer_ID,
"gimp-text-layer-set-font-size",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-text-layer-set-font-size",
args);
return_vals = gimp_run_procedure_array ("gimp-text-layer-set-font-size",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -443,8 +443,8 @@ gimp_text_layer_get_antialias (gint32 layer_ID)
"gimp-text-layer-get-antialias",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-text-layer-get-antialias",
args);
return_vals = gimp_run_procedure_array ("gimp-text-layer-get-antialias",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -489,8 +489,8 @@ gimp_text_layer_set_antialias (gint32 layer_ID,
"gimp-text-layer-set-antialias",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-text-layer-set-antialias",
args);
return_vals = gimp_run_procedure_array ("gimp-text-layer-set-antialias",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -531,8 +531,8 @@ gimp_text_layer_get_hint_style (gint32 layer_ID)
"gimp-text-layer-get-hint-style",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-text-layer-get-hint-style",
args);
return_vals = gimp_run_procedure_array ("gimp-text-layer-get-hint-style",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -578,8 +578,8 @@ gimp_text_layer_set_hint_style (gint32 layer_ID,
"gimp-text-layer-set-hint-style",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-text-layer-set-hint-style",
args);
return_vals = gimp_run_procedure_array ("gimp-text-layer-set-hint-style",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -619,8 +619,8 @@ gimp_text_layer_get_kerning (gint32 layer_ID)
"gimp-text-layer-get-kerning",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-text-layer-get-kerning",
args);
return_vals = gimp_run_procedure_array ("gimp-text-layer-get-kerning",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -664,8 +664,8 @@ gimp_text_layer_set_kerning (gint32 layer_ID,
"gimp-text-layer-set-kerning",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-text-layer-set-kerning",
args);
return_vals = gimp_run_procedure_array ("gimp-text-layer-set-kerning",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -706,8 +706,8 @@ gimp_text_layer_get_language (gint32 layer_ID)
"gimp-text-layer-get-language",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-text-layer-get-language",
args);
return_vals = gimp_run_procedure_array ("gimp-text-layer-get-language",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -752,8 +752,8 @@ gimp_text_layer_set_language (gint32 layer_ID,
"gimp-text-layer-set-language",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-text-layer-set-language",
args);
return_vals = gimp_run_procedure_array ("gimp-text-layer-set-language",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -793,8 +793,8 @@ gimp_text_layer_get_base_direction (gint32 layer_ID)
"gimp-text-layer-get-base-direction",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-text-layer-get-base-direction",
args);
return_vals = gimp_run_procedure_array ("gimp-text-layer-get-base-direction",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -839,8 +839,8 @@ gimp_text_layer_set_base_direction (gint32 layer_ID,
"gimp-text-layer-set-base-direction",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-text-layer-set-base-direction",
args);
return_vals = gimp_run_procedure_array ("gimp-text-layer-set-base-direction",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -880,8 +880,8 @@ gimp_text_layer_get_justification (gint32 layer_ID)
"gimp-text-layer-get-justification",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-text-layer-get-justification",
args);
return_vals = gimp_run_procedure_array ("gimp-text-layer-get-justification",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -926,8 +926,8 @@ gimp_text_layer_set_justification (gint32 layer_ID,
"gimp-text-layer-set-justification",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-text-layer-set-justification",
args);
return_vals = gimp_run_procedure_array ("gimp-text-layer-set-justification",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -968,8 +968,8 @@ gimp_text_layer_get_color (gint32 layer_ID,
"gimp-text-layer-get-color",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-text-layer-get-color",
args);
return_vals = gimp_run_procedure_array ("gimp-text-layer-get-color",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1015,8 +1015,8 @@ gimp_text_layer_set_color (gint32 layer_ID,
"gimp-text-layer-set-color",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-text-layer-set-color",
args);
return_vals = gimp_run_procedure_array ("gimp-text-layer-set-color",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1056,8 +1056,8 @@ gimp_text_layer_get_indent (gint32 layer_ID)
"gimp-text-layer-get-indent",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-text-layer-get-indent",
args);
return_vals = gimp_run_procedure_array ("gimp-text-layer-get-indent",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -1102,8 +1102,8 @@ gimp_text_layer_set_indent (gint32 layer_ID,
"gimp-text-layer-set-indent",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-text-layer-set-indent",
args);
return_vals = gimp_run_procedure_array ("gimp-text-layer-set-indent",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1143,8 +1143,8 @@ gimp_text_layer_get_line_spacing (gint32 layer_ID)
"gimp-text-layer-get-line-spacing",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-text-layer-get-line-spacing",
args);
return_vals = gimp_run_procedure_array ("gimp-text-layer-get-line-spacing",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -1189,8 +1189,8 @@ gimp_text_layer_set_line_spacing (gint32 layer_ID,
"gimp-text-layer-set-line-spacing",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-text-layer-set-line-spacing",
args);
return_vals = gimp_run_procedure_array ("gimp-text-layer-set-line-spacing",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1230,8 +1230,8 @@ gimp_text_layer_get_letter_spacing (gint32 layer_ID)
"gimp-text-layer-get-letter-spacing",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-text-layer-get-letter-spacing",
args);
return_vals = gimp_run_procedure_array ("gimp-text-layer-get-letter-spacing",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -1276,8 +1276,8 @@ gimp_text_layer_set_letter_spacing (gint32 layer_ID,
"gimp-text-layer-set-letter-spacing",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-text-layer-set-letter-spacing",
args);
return_vals = gimp_run_procedure_array ("gimp-text-layer-set-letter-spacing",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1326,8 +1326,8 @@ gimp_text_layer_resize (gint32 layer_ID,
"gimp-text-layer-resize",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-text-layer-resize",
args);
return_vals = gimp_run_procedure_array ("gimp-text-layer-resize",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;

8
libgimp/gimptexttool_pdb.c
View File

@ -110,8 +110,8 @@ gimp_text_fontname (gint32 image_ID,
"gimp-text-fontname",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-text-fontname",
args);
return_vals = gimp_run_procedure_array ("gimp-text-fontname",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -175,8 +175,8 @@ gimp_text_get_extents_fontname (const gchar *text,
"gimp-text-get-extents-fontname",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-text-get-extents-fontname",
args);
return_vals = gimp_run_procedure_array ("gimp-text-get-extents-fontname",
args);
gimp_value_array_unref (args);
*width = 0;

48
libgimp/gimpunit_pdb.c
View File

@ -48,8 +48,8 @@ _gimp_unit_get_number_of_units (void)
"gimp-unit-get-number-of-units",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-unit-get-number-of-units",
args);
return_vals = gimp_run_procedure_array ("gimp-unit-get-number-of-units",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -84,8 +84,8 @@ _gimp_unit_get_number_of_built_in_units (void)
"gimp-unit-get-number-of-built-in-units",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-unit-get-number-of-built-in-units",
args);
return_vals = gimp_run_procedure_array ("gimp-unit-get-number-of-built-in-units",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -150,8 +150,8 @@ _gimp_unit_new (const gchar *identifier,
"gimp-unit-new",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-unit-new",
args);
return_vals = gimp_run_procedure_array ("gimp-unit-new",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -191,8 +191,8 @@ _gimp_unit_get_deletion_flag (GimpUnit unit_id)
"gimp-unit-get-deletion-flag",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-unit-get-deletion-flag",
args);
return_vals = gimp_run_procedure_array ("gimp-unit-get-deletion-flag",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -236,8 +236,8 @@ _gimp_unit_set_deletion_flag (GimpUnit unit_id,
"gimp-unit-set-deletion-flag",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-unit-set-deletion-flag",
args);
return_vals = gimp_run_procedure_array ("gimp-unit-set-deletion-flag",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -277,8 +277,8 @@ _gimp_unit_get_identifier (GimpUnit unit_id)
"gimp-unit-get-identifier",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-unit-get-identifier",
args);
return_vals = gimp_run_procedure_array ("gimp-unit-get-identifier",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -318,8 +318,8 @@ _gimp_unit_get_factor (GimpUnit unit_id)
"gimp-unit-get-factor",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-unit-get-factor",
args);
return_vals = gimp_run_procedure_array ("gimp-unit-get-factor",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -360,8 +360,8 @@ _gimp_unit_get_digits (GimpUnit unit_id)
"gimp-unit-get-digits",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-unit-get-digits",
args);
return_vals = gimp_run_procedure_array ("gimp-unit-get-digits",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -400,8 +400,8 @@ _gimp_unit_get_symbol (GimpUnit unit_id)
"gimp-unit-get-symbol",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-unit-get-symbol",
args);
return_vals = gimp_run_procedure_array ("gimp-unit-get-symbol",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -441,8 +441,8 @@ _gimp_unit_get_abbreviation (GimpUnit unit_id)
"gimp-unit-get-abbreviation",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-unit-get-abbreviation",
args);
return_vals = gimp_run_procedure_array ("gimp-unit-get-abbreviation",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -481,8 +481,8 @@ _gimp_unit_get_singular (GimpUnit unit_id)
"gimp-unit-get-singular",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-unit-get-singular",
args);
return_vals = gimp_run_procedure_array ("gimp-unit-get-singular",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -521,8 +521,8 @@ _gimp_unit_get_plural (GimpUnit unit_id)
"gimp-unit-get-plural",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-unit-get-plural",
args);
return_vals = gimp_run_procedure_array ("gimp-unit-get-plural",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)

100
libgimp/gimpvectors_pdb.c
View File

@ -68,8 +68,8 @@ gimp_vectors_new (gint32 image_ID,
"gimp-vectors-new",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-vectors-new",
args);
return_vals = gimp_run_procedure_array ("gimp-vectors-new",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -114,8 +114,8 @@ gimp_vectors_new_from_text_layer (gint32 image_ID,
"gimp-vectors-new-from-text-layer",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-vectors-new-from-text-layer",
args);
return_vals = gimp_run_procedure_array ("gimp-vectors-new-from-text-layer",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -156,8 +156,8 @@ gimp_vectors_copy (gint32 vectors_ID)
"gimp-vectors-copy",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-vectors-copy",
args);
return_vals = gimp_run_procedure_array ("gimp-vectors-copy",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -202,8 +202,8 @@ gimp_vectors_get_strokes (gint32 vectors_ID,
"gimp-vectors-get-strokes",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-vectors-get-strokes",
args);
return_vals = gimp_run_procedure_array ("gimp-vectors-get-strokes",
args);
gimp_value_array_unref (args);
*num_strokes = 0;
@ -256,8 +256,8 @@ gimp_vectors_stroke_get_length (gint32 vectors_ID,
"gimp-vectors-stroke-get-length",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-vectors-stroke-get-length",
args);
return_vals = gimp_run_procedure_array ("gimp-vectors-stroke-get-length",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -322,8 +322,8 @@ gimp_vectors_stroke_get_point_at_dist (gint32 vectors_ID,
"gimp-vectors-stroke-get-point-at-dist",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-vectors-stroke-get-point-at-dist",
args);
return_vals = gimp_run_procedure_array ("gimp-vectors-stroke-get-point-at-dist",
args);
gimp_value_array_unref (args);
*x_point = 0.0;
@ -379,8 +379,8 @@ gimp_vectors_remove_stroke (gint32 vectors_ID,
"gimp-vectors-remove-stroke",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-vectors-remove-stroke",
args);
return_vals = gimp_run_procedure_array ("gimp-vectors-remove-stroke",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -423,8 +423,8 @@ gimp_vectors_stroke_close (gint32 vectors_ID,
"gimp-vectors-stroke-close",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-vectors-stroke-close",
args);
return_vals = gimp_run_procedure_array ("gimp-vectors-stroke-close",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -475,8 +475,8 @@ gimp_vectors_stroke_translate (gint32 vectors_ID,
"gimp-vectors-stroke-translate",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-vectors-stroke-translate",
args);
return_vals = gimp_run_procedure_array ("gimp-vectors-stroke-translate",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -527,8 +527,8 @@ gimp_vectors_stroke_scale (gint32 vectors_ID,
"gimp-vectors-stroke-scale",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-vectors-stroke-scale",
args);
return_vals = gimp_run_procedure_array ("gimp-vectors-stroke-scale",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -583,8 +583,8 @@ gimp_vectors_stroke_rotate (gint32 vectors_ID,
"gimp-vectors-stroke-rotate",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-vectors-stroke-rotate",
args);
return_vals = gimp_run_procedure_array ("gimp-vectors-stroke-rotate",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -635,8 +635,8 @@ gimp_vectors_stroke_flip (gint32 vectors_ID,
"gimp-vectors-stroke-flip",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-vectors-stroke-flip",
args);
return_vals = gimp_run_procedure_array ("gimp-vectors-stroke-flip",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -697,8 +697,8 @@ gimp_vectors_stroke_flip_free (gint32 vectors_ID,
"gimp-vectors-stroke-flip-free",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-vectors-stroke-flip-free",
args);
return_vals = gimp_run_procedure_array ("gimp-vectors-stroke-flip-free",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -750,8 +750,8 @@ gimp_vectors_stroke_get_points (gint32 vectors_ID,
"gimp-vectors-stroke-get-points",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-vectors-stroke-get-points",
args);
return_vals = gimp_run_procedure_array ("gimp-vectors-stroke-get-points",
args);
gimp_value_array_unref (args);
*num_points = 0;
@ -821,8 +821,8 @@ gimp_vectors_stroke_new_from_points (gint32 vectors_ID,
"gimp-vectors-stroke-new-from-points",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-vectors-stroke-new-from-points",
args);
return_vals = gimp_run_procedure_array ("gimp-vectors-stroke-new-from-points",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -876,8 +876,8 @@ gimp_vectors_stroke_interpolate (gint32 vectors_ID,
"gimp-vectors-stroke-interpolate",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-vectors-stroke-interpolate",
args);
return_vals = gimp_run_procedure_array ("gimp-vectors-stroke-interpolate",
args);
gimp_value_array_unref (args);
*num_coords = 0;
@ -931,8 +931,8 @@ gimp_vectors_bezier_stroke_new_moveto (gint32 vectors_ID,
"gimp-vectors-bezier-stroke-new-moveto",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-vectors-bezier-stroke-new-moveto",
args);
return_vals = gimp_run_procedure_array ("gimp-vectors-bezier-stroke-new-moveto",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -984,8 +984,8 @@ gimp_vectors_bezier_stroke_lineto (gint32 vectors_ID,
"gimp-vectors-bezier-stroke-lineto",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-vectors-bezier-stroke-lineto",
args);
return_vals = gimp_run_procedure_array ("gimp-vectors-bezier-stroke-lineto",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1046,8 +1046,8 @@ gimp_vectors_bezier_stroke_conicto (gint32 vectors_ID,
"gimp-vectors-bezier-stroke-conicto",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-vectors-bezier-stroke-conicto",
args);
return_vals = gimp_run_procedure_array ("gimp-vectors-bezier-stroke-conicto",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1114,8 +1114,8 @@ gimp_vectors_bezier_stroke_cubicto (gint32 vectors_ID,
"gimp-vectors-bezier-stroke-cubicto",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-vectors-bezier-stroke-cubicto",
args);
return_vals = gimp_run_procedure_array ("gimp-vectors-bezier-stroke-cubicto",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1174,8 +1174,8 @@ gimp_vectors_bezier_stroke_new_ellipse (gint32 vectors_ID,
"gimp-vectors-bezier-stroke-new-ellipse",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-vectors-bezier-stroke-new-ellipse",
args);
return_vals = gimp_run_procedure_array ("gimp-vectors-bezier-stroke-new-ellipse",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -1232,8 +1232,8 @@ gimp_vectors_import_from_file (gint32 image_ID,
"gimp-vectors-import-from-file",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-vectors-import-from-file",
args);
return_vals = gimp_run_procedure_array ("gimp-vectors-import-from-file",
args);
gimp_value_array_unref (args);
*num_vectors = 0;
@ -1303,8 +1303,8 @@ gimp_vectors_import_from_string (gint32 image_ID,
"gimp-vectors-import-from-string",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-vectors-import-from-string",
args);
return_vals = gimp_run_procedure_array ("gimp-vectors-import-from-string",
args);
gimp_value_array_unref (args);
*num_vectors = 0;
@ -1363,8 +1363,8 @@ gimp_vectors_export_to_file (gint32 image_ID,
"gimp-vectors-export-to-file",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-vectors-export-to-file",
args);
return_vals = gimp_run_procedure_array ("gimp-vectors-export-to-file",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1412,8 +1412,8 @@ gimp_vectors_export_to_string (gint32 image_ID,
"gimp-vectors-export-to-string",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-vectors-export-to-string",
args);
return_vals = gimp_run_procedure_array ("gimp-vectors-export-to-string",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)

4
pdb/lib.pl
View File

@ -539,8 +539,8 @@ $arg_array
"gimp-$proc->{canonical_name}",
args);
else
return_vals = gimp_run_procedure_with_array ("gimp-$proc->{canonical_name}",
args);
return_vals = gimp_run_procedure_array ("gimp-$proc->{canonical_name}",
args);
gimp_value_array_unref (args);
$return_marshal

12
plug-ins/help/help.c
View File

@ -339,7 +339,6 @@ help_load_idle (gpointer data)
if (uri)
{
GimpValueArray *args;
GimpValueArray *return_vals;
#ifdef GIMP_HELP_DEBUG
@ -347,13 +346,10 @@ help_load_idle (gpointer data)
idle_help->procedure, uri);
#endif
args = gimp_value_array_new_from_types (G_TYPE_STRING,
G_TYPE_NONE);
g_value_set_string (gimp_value_array_index (args, 0), uri);
return_vals = gimp_run_procedure_with_array (idle_help->procedure,
args);
gimp_value_array_unref (args);
return_vals = gimp_pdb_run_procedure (gimp_get_pdb (),
idle_help->procedure,
G_TYPE_STRING, uri,
G_TYPE_NONE);
gimp_value_array_unref (return_vals);
g_free (uri);