[gimp] libgimp, pdb: remove gimp_run_procedure_with_array() from gimp.[ch]
- From: Michael Natterer <mitch src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gimp] libgimp, pdb: remove gimp_run_procedure_with_array() from gimp.[ch]
- Date: Tue, 6 Aug 2019 19:45:41 +0000 (UTC)
commit caa61eef4f72ae623ce7b1d3a215257e5ca30110
Author: Michael Natterer <mitch gimp org>
Date: Tue Aug 6 21:44:26 2019 +0200
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.
libgimp/gimp.c | 47 ----
libgimp/gimp.def | 2 +-
libgimp/gimp.h | 8 -
libgimp/gimp_pdb.c | 28 +--
libgimp/gimpbrush_pdb.c | 88 +++----
libgimp/gimpbrushes_pdb.c | 8 +-
libgimp/gimpbrushselect_pdb.c | 12 +-
libgimp/gimpbuffer_pdb.c | 28 +--
libgimp/gimpchannel_pdb.c | 40 ++--
libgimp/gimpcontext_pdb.c | 452 ++++++++++++++++++------------------
libgimp/gimpdebug_pdb.c | 8 +-
libgimp/gimpdisplay_pdb.c | 24 +-
libgimp/gimpdrawable_pdb.c | 96 ++++----
libgimp/gimpdrawablecolor_pdb.c | 56 ++---
libgimp/gimpdrawableedit_pdb.c | 24 +-
libgimp/gimpdynamics_pdb.c | 8 +-
libgimp/gimpedit_pdb.c | 40 ++--
libgimp/gimpfileops_pdb.c | 52 ++---
libgimp/gimpfloatingsel_pdb.c | 16 +-
libgimp/gimpfonts_pdb.c | 8 +-
libgimp/gimpfontselect_pdb.c | 12 +-
libgimp/gimpgimprc_pdb.c | 28 +--
libgimp/gimpgradient_pdb.c | 124 +++++-----
libgimp/gimpgradients_pdb.c | 8 +-
libgimp/gimpgradientselect_pdb.c | 12 +-
libgimp/gimphelp_pdb.c | 4 +-
libgimp/gimpimage_pdb.c | 328 +++++++++++++-------------
libgimp/gimpimagecolorprofile_pdb.c | 24 +-
libgimp/gimpimageconvert_pdb.c | 20 +-
libgimp/gimpimagegrid_pdb.c | 40 ++--
libgimp/gimpimageguides_pdb.c | 24 +-
libgimp/gimpimagesamplepoints_pdb.c | 16 +-
libgimp/gimpimageselect_pdb.c | 28 +--
libgimp/gimpimagetransform_pdb.c | 24 +-
libgimp/gimpimageundo_pdb.c | 28 +--
libgimp/gimpitem_pdb.c | 132 +++++------
libgimp/gimpitemtransform_pdb.c | 40 ++--
libgimp/gimplayer_pdb.c | 140 +++++------
libgimp/gimplegacy.c | 40 +++-
libgimp/gimplegacy.h | 6 +
libgimp/gimpmessage_pdb.c | 12 +-
libgimp/gimppainttools_pdb.c | 68 +++---
libgimp/gimppalette_pdb.c | 60 ++---
libgimp/gimppalettes_pdb.c | 8 +-
libgimp/gimppaletteselect_pdb.c | 12 +-
libgimp/gimppattern_pdb.c | 8 +-
libgimp/gimppatterns_pdb.c | 8 +-
libgimp/gimppatternselect_pdb.c | 12 +-
libgimp/gimppdb_pdb.c | 48 ++--
libgimp/gimppdbprocedure.c | 7 +-
libgimp/gimpplugin_pdb.c | 28 +--
libgimp/gimpprogress_pdb.c | 36 +--
libgimp/gimpselection_pdb.c | 60 ++---
libgimp/gimptextlayer_pdb.c | 116 ++++-----
libgimp/gimptexttool_pdb.c | 8 +-
libgimp/gimpunit_pdb.c | 48 ++--
libgimp/gimpvectors_pdb.c | 100 ++++----
pdb/lib.pl | 4 +-
plug-ins/help/help.c | 12 +-
59 files changed, 1383 insertions(+), 1395 deletions(-)
---
diff --git a/libgimp/gimp.c b/libgimp/gimp.c
index 4f0dd90e5a..cc6935dd56 100644
--- a/libgimp/gimp.c
+++ b/libgimp/gimp.c
@@ -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:
*
diff --git a/libgimp/gimp.def b/libgimp/gimp.def
index 19479beefa..8f25790c75 100644
--- a/libgimp/gimp.def
+++ b/libgimp/gimp.def
@@ -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
diff --git a/libgimp/gimp.h b/libgimp/gimp.h
index 57852531a1..940607e875 100644
--- a/libgimp/gimp.h
+++ b/libgimp/gimp.h
@@ -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.
*/
diff --git a/libgimp/gimp_pdb.c b/libgimp/gimp_pdb.c
index 111ecd1b53..eac0507143 100644
--- a/libgimp/gimp_pdb.c
+++ b/libgimp/gimp_pdb.c
@@ -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)
diff --git a/libgimp/gimpbrush_pdb.c b/libgimp/gimpbrush_pdb.c
index 2e56332167..6e7219dcb9 100644
--- a/libgimp/gimpbrush_pdb.c
+++ b/libgimp/gimpbrush_pdb.c
@@ -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)
diff --git a/libgimp/gimpbrushes_pdb.c b/libgimp/gimpbrushes_pdb.c
index 55467c8e1c..62c37e28a5 100644
--- a/libgimp/gimpbrushes_pdb.c
+++ b/libgimp/gimpbrushes_pdb.c
@@ -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;
diff --git a/libgimp/gimpbrushselect_pdb.c b/libgimp/gimpbrushselect_pdb.c
index 6cfa764fa9..e4d29d09c7 100644
--- a/libgimp/gimpbrushselect_pdb.c
+++ b/libgimp/gimpbrushselect_pdb.c
@@ -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;
diff --git a/libgimp/gimpbuffer_pdb.c b/libgimp/gimpbuffer_pdb.c
index 7c3065bfd9..e87be04337 100644
--- a/libgimp/gimpbuffer_pdb.c
+++ b/libgimp/gimpbuffer_pdb.c
@@ -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)
diff --git a/libgimp/gimpchannel_pdb.c b/libgimp/gimpchannel_pdb.c
index 8fe3c34f9d..ac4d861e99 100644
--- a/libgimp/gimpchannel_pdb.c
+++ b/libgimp/gimpchannel_pdb.c
@@ -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;
diff --git a/libgimp/gimpcontext_pdb.c b/libgimp/gimpcontext_pdb.c
index 85511edcf0..522822ed27 100644
--- a/libgimp/gimpcontext_pdb.c
+++ b/libgimp/gimpcontext_pdb.c
@@ -62,8 +62,8 @@ gimp_context_push (void)
"gimp-context-push",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-push",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-push",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -102,8 +102,8 @@ gimp_context_pop (void)
"gimp-context-pop",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-pop",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-pop",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -143,8 +143,8 @@ gimp_context_set_defaults (void)
"gimp-context-set-defaults",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-defaults",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-defaults",
+ 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_context_list_paint_methods (gint *num_paint_methods,
"gimp-context-list-paint-methods",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-list-paint-methods",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-list-paint-methods",
+ args);
gimp_value_array_unref (args);
*num_paint_methods = 0;
@@ -232,8 +232,8 @@ gimp_context_get_paint_method (void)
"gimp-context-get-paint-method",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-paint-method",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-paint-method",
+ 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_context_set_paint_method (const gchar *name)
"gimp-context-set-paint-method",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-paint-method",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-paint-method",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -315,8 +315,8 @@ gimp_context_get_stroke_method (void)
"gimp-context-get-stroke-method",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-stroke-method",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-stroke-method",
+ 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_context_set_stroke_method (GimpStrokeMethod stroke_method)
"gimp-context-set-stroke-method",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-stroke-method",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-stroke-method",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -398,8 +398,8 @@ gimp_context_get_foreground (GimpRGB *foreground)
"gimp-context-get-foreground",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-foreground",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-foreground",
+ 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_context_set_foreground (const GimpRGB *foreground)
"gimp-context-set-foreground",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-foreground",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-foreground",
+ 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_context_get_background (GimpRGB *background)
"gimp-context-get-background",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-background",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-background",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -529,8 +529,8 @@ gimp_context_set_background (const GimpRGB *background)
"gimp-context-set-background",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-background",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-background",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -568,8 +568,8 @@ gimp_context_set_default_colors (void)
"gimp-context-set-default-colors",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-default-colors",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-default-colors",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -607,8 +607,8 @@ gimp_context_swap_colors (void)
"gimp-context-swap-colors",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-swap-colors",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-swap-colors",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -645,8 +645,8 @@ gimp_context_get_opacity (void)
"gimp-context-get-opacity",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-opacity",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-opacity",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -687,8 +687,8 @@ gimp_context_set_opacity (gdouble opacity)
"gimp-context-set-opacity",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-opacity",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-opacity",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -726,8 +726,8 @@ gimp_context_get_paint_mode (void)
"gimp-context-get-paint-mode",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-paint-mode",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-paint-mode",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -767,8 +767,8 @@ gimp_context_set_paint_mode (GimpLayerMode paint_mode)
"gimp-context-set-paint-mode",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-paint-mode",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-paint-mode",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -804,8 +804,8 @@ gimp_context_get_line_width (void)
"gimp-context-get-line-width",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-line-width",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-line-width",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -849,8 +849,8 @@ gimp_context_set_line_width (gdouble line_width)
"gimp-context-set-line-width",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-line-width",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-line-width",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -886,8 +886,8 @@ gimp_context_get_line_width_unit (void)
"gimp-context-get-line-width-unit",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-line-width-unit",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-line-width-unit",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -932,8 +932,8 @@ gimp_context_set_line_width_unit (GimpUnit line_width_unit)
"gimp-context-set-line-width-unit",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-line-width-unit",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-line-width-unit",
+ 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_context_get_line_cap_style (void)
"gimp-context-get-line-cap-style",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-line-cap-style",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-line-cap-style",
+ 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_context_set_line_cap_style (GimpCapStyle cap_style)
"gimp-context-set-line-cap-style",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-line-cap-style",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-line-cap-style",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1052,8 +1052,8 @@ gimp_context_get_line_join_style (void)
"gimp-context-get-line-join-style",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-line-join-style",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-line-join-style",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -1098,8 +1098,8 @@ gimp_context_set_line_join_style (GimpJoinStyle join_style)
"gimp-context-set-line-join-style",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-line-join-style",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-line-join-style",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1135,8 +1135,8 @@ gimp_context_get_line_miter_limit (void)
"gimp-context-get-line-miter-limit",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-line-miter-limit",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-line-miter-limit",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -1184,8 +1184,8 @@ gimp_context_set_line_miter_limit (gdouble miter_limit)
"gimp-context-set-line-miter-limit",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-line-miter-limit",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-line-miter-limit",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1221,8 +1221,8 @@ gimp_context_get_line_dash_offset (void)
"gimp-context-get-line-dash-offset",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-line-dash-offset",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-line-dash-offset",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -1267,8 +1267,8 @@ gimp_context_set_line_dash_offset (gdouble dash_offset)
"gimp-context-set-line-dash-offset",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-line-dash-offset",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-line-dash-offset",
+ 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_context_get_line_dash_pattern (gint *num_dashes,
"gimp-context-get-line-dash-pattern",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-line-dash-pattern",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-line-dash-pattern",
+ args);
gimp_value_array_unref (args);
*num_dashes = 0;
@@ -1369,8 +1369,8 @@ gimp_context_set_line_dash_pattern (gint num_dashes,
"gimp-context-set-line-dash-pattern",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-line-dash-pattern",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-line-dash-pattern",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1409,8 +1409,8 @@ gimp_context_get_brush (void)
"gimp-context-get-brush",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-brush",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-brush",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -1454,8 +1454,8 @@ gimp_context_set_brush (const gchar *name)
"gimp-context-set-brush",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-brush",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-brush",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1491,8 +1491,8 @@ gimp_context_get_brush_size (void)
"gimp-context-get-brush-size",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-brush-size",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-brush-size",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -1532,8 +1532,8 @@ gimp_context_set_brush_size (gdouble size)
"gimp-context-set-brush-size",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-brush-size",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-brush-size",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1570,8 +1570,8 @@ gimp_context_set_brush_default_size (void)
"gimp-context-set-brush-default-size",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-brush-default-size",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-brush-default-size",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1607,8 +1607,8 @@ gimp_context_get_brush_aspect_ratio (void)
"gimp-context-get-brush-aspect-ratio",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-brush-aspect-ratio",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-brush-aspect-ratio",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -1648,8 +1648,8 @@ gimp_context_set_brush_aspect_ratio (gdouble aspect)
"gimp-context-set-brush-aspect-ratio",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-brush-aspect-ratio",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-brush-aspect-ratio",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1685,8 +1685,8 @@ gimp_context_get_brush_angle (void)
"gimp-context-get-brush-angle",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-brush-angle",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-brush-angle",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -1726,8 +1726,8 @@ gimp_context_set_brush_angle (gdouble angle)
"gimp-context-set-brush-angle",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-brush-angle",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-brush-angle",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1764,8 +1764,8 @@ gimp_context_get_brush_spacing (void)
"gimp-context-get-brush-spacing",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-brush-spacing",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-brush-spacing",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -1806,8 +1806,8 @@ gimp_context_set_brush_spacing (gdouble spacing)
"gimp-context-set-brush-spacing",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-brush-spacing",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-brush-spacing",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1844,8 +1844,8 @@ gimp_context_set_brush_default_spacing (void)
"gimp-context-set-brush-default-spacing",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-brush-default-spacing",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-brush-default-spacing",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1881,8 +1881,8 @@ gimp_context_get_brush_hardness (void)
"gimp-context-get-brush-hardness",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-brush-hardness",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-brush-hardness",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -1922,8 +1922,8 @@ gimp_context_set_brush_hardness (gdouble hardness)
"gimp-context-set-brush-hardness",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-brush-hardness",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-brush-hardness",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1960,8 +1960,8 @@ gimp_context_set_brush_default_hardness (void)
"gimp-context-set-brush-default-hardness",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-brush-default-hardness",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-brush-default-hardness",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1997,8 +1997,8 @@ gimp_context_get_brush_force (void)
"gimp-context-get-brush-force",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-brush-force",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-brush-force",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -2038,8 +2038,8 @@ gimp_context_set_brush_force (gdouble force)
"gimp-context-set-brush-force",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-brush-force",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-brush-force",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -2078,8 +2078,8 @@ gimp_context_get_dynamics (void)
"gimp-context-get-dynamics",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-dynamics",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-dynamics",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -2124,8 +2124,8 @@ gimp_context_set_dynamics (const gchar *name)
"gimp-context-set-dynamics",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-dynamics",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-dynamics",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -2163,8 +2163,8 @@ gimp_context_get_mypaint_brush (void)
"gimp-context-get-mypaint-brush",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-mypaint-brush",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-mypaint-brush",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -2209,8 +2209,8 @@ gimp_context_set_mypaint_brush (const gchar *name)
"gimp-context-set-mypaint-brush",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-mypaint-brush",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-mypaint-brush",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -2249,8 +2249,8 @@ gimp_context_get_pattern (void)
"gimp-context-get-pattern",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-pattern",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-pattern",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -2295,8 +2295,8 @@ gimp_context_set_pattern (const gchar *name)
"gimp-context-set-pattern",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-pattern",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-pattern",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -2333,8 +2333,8 @@ gimp_context_get_gradient (void)
"gimp-context-get-gradient",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-gradient",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-gradient",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -2379,8 +2379,8 @@ gimp_context_set_gradient (const gchar *name)
"gimp-context-set-gradient",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-gradient",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-gradient",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -2418,8 +2418,8 @@ gimp_context_set_gradient_fg_bg_rgb (void)
"gimp-context-set-gradient-fg-bg-rgb",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-gradient-fg-bg-rgb",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-gradient-fg-bg-rgb",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -2457,8 +2457,8 @@ gimp_context_set_gradient_fg_bg_hsv_cw (void)
"gimp-context-set-gradient-fg-bg-hsv-cw",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-gradient-fg-bg-hsv-cw",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-gradient-fg-bg-hsv-cw",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -2496,8 +2496,8 @@ gimp_context_set_gradient_fg_bg_hsv_ccw (void)
"gimp-context-set-gradient-fg-bg-hsv-ccw",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-gradient-fg-bg-hsv-ccw",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-gradient-fg-bg-hsv-ccw",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -2535,8 +2535,8 @@ gimp_context_set_gradient_fg_transparent (void)
"gimp-context-set-gradient-fg-transparent",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-gradient-fg-transparent",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-gradient-fg-transparent",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -2573,8 +2573,8 @@ gimp_context_get_gradient_blend_color_space (void)
"gimp-context-get-gradient-blend-color-space",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-gradient-blend-color-space",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-gradient-blend-color-space",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -2615,8 +2615,8 @@ gimp_context_set_gradient_blend_color_space (GimpGradientBlendColorSpace blend_c
"gimp-context-set-gradient-blend-color-space",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-gradient-blend-color-space",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-gradient-blend-color-space",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -2652,8 +2652,8 @@ gimp_context_get_gradient_repeat_mode (void)
"gimp-context-get-gradient-repeat-mode",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-gradient-repeat-mode",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-gradient-repeat-mode",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -2693,8 +2693,8 @@ gimp_context_set_gradient_repeat_mode (GimpRepeatMode repeat_mode)
"gimp-context-set-gradient-repeat-mode",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-gradient-repeat-mode",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-gradient-repeat-mode",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -2731,8 +2731,8 @@ gimp_context_get_gradient_reverse (void)
"gimp-context-get-gradient-reverse",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-gradient-reverse",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-gradient-reverse",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -2773,8 +2773,8 @@ gimp_context_set_gradient_reverse (gboolean reverse)
"gimp-context-set-gradient-reverse",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-gradient-reverse",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-gradient-reverse",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -2811,8 +2811,8 @@ gimp_context_get_palette (void)
"gimp-context-get-palette",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-palette",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-palette",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -2857,8 +2857,8 @@ gimp_context_set_palette (const gchar *name)
"gimp-context-set-palette",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-palette",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-palette",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -2895,8 +2895,8 @@ gimp_context_get_font (void)
"gimp-context-get-font",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-font",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-font",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -2940,8 +2940,8 @@ gimp_context_set_font (const gchar *name)
"gimp-context-set-font",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-font",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-font",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -2977,8 +2977,8 @@ gimp_context_get_antialias (void)
"gimp-context-get-antialias",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-antialias",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-antialias",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -3029,8 +3029,8 @@ gimp_context_set_antialias (gboolean antialias)
"gimp-context-set-antialias",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-antialias",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-antialias",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -3066,8 +3066,8 @@ gimp_context_get_feather (void)
"gimp-context-get-feather",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-feather",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-feather",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -3116,8 +3116,8 @@ gimp_context_set_feather (gboolean feather)
"gimp-context-set-feather",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-feather",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-feather",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -3156,8 +3156,8 @@ gimp_context_get_feather_radius (gdouble *feather_radius_x,
"gimp-context-get-feather-radius",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-feather-radius",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-feather-radius",
+ args);
gimp_value_array_unref (args);
*feather_radius_x = 0.0;
@@ -3212,8 +3212,8 @@ gimp_context_set_feather_radius (gdouble feather_radius_x,
"gimp-context-set-feather-radius",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-feather-radius",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-feather-radius",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -3249,8 +3249,8 @@ gimp_context_get_sample_merged (void)
"gimp-context-get-sample-merged",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-sample-merged",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-sample-merged",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -3300,8 +3300,8 @@ gimp_context_set_sample_merged (gboolean sample_merged)
"gimp-context-set-sample-merged",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-sample-merged",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-sample-merged",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -3337,8 +3337,8 @@ gimp_context_get_sample_criterion (void)
"gimp-context-get-sample-criterion",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-sample-criterion",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-sample-criterion",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -3386,8 +3386,8 @@ gimp_context_set_sample_criterion (GimpSelectCriterion sample_criterion)
"gimp-context-set-sample-criterion",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-sample-criterion",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-sample-criterion",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -3423,8 +3423,8 @@ gimp_context_get_sample_threshold (void)
"gimp-context-get-sample-threshold",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-sample-threshold",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-sample-threshold",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -3473,8 +3473,8 @@ gimp_context_set_sample_threshold (gdouble sample_threshold)
"gimp-context-set-sample-threshold",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-sample-threshold",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-sample-threshold",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -3511,8 +3511,8 @@ gimp_context_get_sample_threshold_int (void)
"gimp-context-get-sample-threshold-int",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-sample-threshold-int",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-sample-threshold-int",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -3553,8 +3553,8 @@ gimp_context_set_sample_threshold_int (gint sample_threshold)
"gimp-context-set-sample-threshold-int",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-sample-threshold-int",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-sample-threshold-int",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -3590,8 +3590,8 @@ gimp_context_get_sample_transparent (void)
"gimp-context-get-sample-transparent",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-sample-transparent",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-sample-transparent",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -3639,8 +3639,8 @@ gimp_context_set_sample_transparent (gboolean sample_transparent)
"gimp-context-set-sample-transparent",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-sample-transparent",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-sample-transparent",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -3676,8 +3676,8 @@ gimp_context_get_diagonal_neighbors (void)
"gimp-context-get-diagonal-neighbors",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-diagonal-neighbors",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-diagonal-neighbors",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -3726,8 +3726,8 @@ gimp_context_set_diagonal_neighbors (gboolean diagonal_neighbors)
"gimp-context-set-diagonal-neighbors",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-diagonal-neighbors",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-diagonal-neighbors",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -3764,8 +3764,8 @@ gimp_context_get_distance_metric (void)
"gimp-context-get-distance-metric",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-distance-metric",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-distance-metric",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -3811,8 +3811,8 @@ gimp_context_set_distance_metric (GeglDistanceMetric metric)
"gimp-context-set-distance-metric",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-distance-metric",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-distance-metric",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -3852,8 +3852,8 @@ gimp_context_get_interpolation (void)
"gimp-context-get-interpolation",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-interpolation",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-interpolation",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -3900,8 +3900,8 @@ gimp_context_set_interpolation (GimpInterpolationType interpolation)
"gimp-context-set-interpolation",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-interpolation",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-interpolation",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -3939,8 +3939,8 @@ gimp_context_get_transform_direction (void)
"gimp-context-get-transform-direction",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-transform-direction",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-transform-direction",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -3986,8 +3986,8 @@ gimp_context_set_transform_direction (GimpTransformDirection transform_direction
"gimp-context-set-transform-direction",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-transform-direction",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-transform-direction",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -4025,8 +4025,8 @@ gimp_context_get_transform_resize (void)
"gimp-context-get-transform-resize",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-transform-resize",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-transform-resize",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -4076,8 +4076,8 @@ gimp_context_set_transform_resize (GimpTransformResize transform_resize)
"gimp-context-set-transform-resize",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-transform-resize",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-transform-resize",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -4113,8 +4113,8 @@ gimp_context_get_ink_size (void)
"gimp-context-get-ink-size",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-ink-size",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-ink-size",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -4154,8 +4154,8 @@ gimp_context_set_ink_size (gdouble size)
"gimp-context-set-ink-size",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-ink-size",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-ink-size",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -4191,8 +4191,8 @@ gimp_context_get_ink_angle (void)
"gimp-context-get-ink-angle",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-ink-angle",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-ink-angle",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -4232,8 +4232,8 @@ gimp_context_set_ink_angle (gdouble angle)
"gimp-context-set-ink-angle",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-ink-angle",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-ink-angle",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -4269,8 +4269,8 @@ gimp_context_get_ink_size_sensitivity (void)
"gimp-context-get-ink-size-sensitivity",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-ink-size-sensitivity",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-ink-size-sensitivity",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -4310,8 +4310,8 @@ gimp_context_set_ink_size_sensitivity (gdouble size)
"gimp-context-set-ink-size-sensitivity",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-ink-size-sensitivity",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-ink-size-sensitivity",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -4347,8 +4347,8 @@ gimp_context_get_ink_tilt_sensitivity (void)
"gimp-context-get-ink-tilt-sensitivity",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-ink-tilt-sensitivity",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-ink-tilt-sensitivity",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -4388,8 +4388,8 @@ gimp_context_set_ink_tilt_sensitivity (gdouble tilt)
"gimp-context-set-ink-tilt-sensitivity",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-ink-tilt-sensitivity",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-ink-tilt-sensitivity",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -4425,8 +4425,8 @@ gimp_context_get_ink_speed_sensitivity (void)
"gimp-context-get-ink-speed-sensitivity",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-ink-speed-sensitivity",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-ink-speed-sensitivity",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -4466,8 +4466,8 @@ gimp_context_set_ink_speed_sensitivity (gdouble speed)
"gimp-context-set-ink-speed-sensitivity",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-ink-speed-sensitivity",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-ink-speed-sensitivity",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -4503,8 +4503,8 @@ gimp_context_get_ink_blob_type (void)
"gimp-context-get-ink-blob-type",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-ink-blob-type",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-ink-blob-type",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -4544,8 +4544,8 @@ gimp_context_set_ink_blob_type (GimpInkBlobType type)
"gimp-context-set-ink-blob-type",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-ink-blob-type",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-ink-blob-type",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -4581,8 +4581,8 @@ gimp_context_get_ink_blob_aspect_ratio (void)
"gimp-context-get-ink-blob-aspect-ratio",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-ink-blob-aspect-ratio",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-ink-blob-aspect-ratio",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -4622,8 +4622,8 @@ gimp_context_set_ink_blob_aspect_ratio (gdouble aspect)
"gimp-context-set-ink-blob-aspect-ratio",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-ink-blob-aspect-ratio",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-ink-blob-aspect-ratio",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -4659,8 +4659,8 @@ gimp_context_get_ink_blob_angle (void)
"gimp-context-get-ink-blob-angle",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-ink-blob-angle",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-get-ink-blob-angle",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -4700,8 +4700,8 @@ gimp_context_set_ink_blob_angle (gdouble angle)
"gimp-context-set-ink-blob-angle",
args);
else
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-ink-blob-angle",
- args);
+ return_vals = gimp_run_procedure_array ("gimp-context-set-ink-blob-angle",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
diff --git a/libgimp/gimpdebug_pdb.c b/libgimp/gimpdebug_pdb.c
index 124d439ee1..a8f7e6744d 100644
--- a/libgimp/gimpdebug_pdb.c
+++ b/libgimp/gimpdebug_pdb.c
@@ -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)
diff --git a/libgimp/gimpdisplay_pdb.c b/libgimp/gimpdisplay_pdb.c
index 53fedc895f..202c6a03d1 100644
--- a/libgimp/gimpdisplay_pdb.c
+++ b/libgimp/gimpdisplay_pdb.c
@@ -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;
diff --git a/libgimp/gimpdrawable_pdb.c b/libgimp/gimpdrawable_pdb.c
index caa070bb85..c92f2b50de 100644
--- a/libgimp/gimpdrawable_pdb.c
+++ b/libgimp/gimpdrawable_pdb.c
@@ -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;
diff --git a/libgimp/gimpdrawablecolor_pdb.c b/libgimp/gimpdrawablecolor_pdb.c
index 60b4867b0d..5db2fbaa53 100644
--- a/libgimp/gimpdrawablecolor_pdb.c
+++ b/libgimp/gimpdrawablecolor_pdb.c
@@ -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;
diff --git a/libgimp/gimpdrawableedit_pdb.c b/libgimp/gimpdrawableedit_pdb.c
index a568a88a95..0b90e0f0d8 100644
--- a/libgimp/gimpdrawableedit_pdb.c
+++ b/libgimp/gimpdrawableedit_pdb.c
@@ -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;
diff --git a/libgimp/gimpdynamics_pdb.c b/libgimp/gimpdynamics_pdb.c
index 2e480db408..7367e9bcec 100644
--- a/libgimp/gimpdynamics_pdb.c
+++ b/libgimp/gimpdynamics_pdb.c
@@ -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;
diff --git a/libgimp/gimpedit_pdb.c b/libgimp/gimpedit_pdb.c
index 914a040b1f..37d2130a8f 100644
--- a/libgimp/gimpedit_pdb.c
+++ b/libgimp/gimpedit_pdb.c
@@ -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)
diff --git a/libgimp/gimpfileops_pdb.c b/libgimp/gimpfileops_pdb.c
index c16cbd2657..16de78cf60 100644
--- a/libgimp/gimpfileops_pdb.c
+++ b/libgimp/gimpfileops_pdb.c
@@ -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;
diff --git a/libgimp/gimpfloatingsel_pdb.c b/libgimp/gimpfloatingsel_pdb.c
index b8f043e592..c996210577 100644
--- a/libgimp/gimpfloatingsel_pdb.c
+++ b/libgimp/gimpfloatingsel_pdb.c
@@ -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;
diff --git a/libgimp/gimpfonts_pdb.c b/libgimp/gimpfonts_pdb.c
index aaf83c9fba..ee407238f9 100644
--- a/libgimp/gimpfonts_pdb.c
+++ b/libgimp/gimpfonts_pdb.c
@@ -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;
diff --git a/libgimp/gimpfontselect_pdb.c b/libgimp/gimpfontselect_pdb.c
index f86db99f79..159f26c227 100644
--- a/libgimp/gimpfontselect_pdb.c
+++ b/libgimp/gimpfontselect_pdb.c
@@ -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;
diff --git a/libgimp/gimpgimprc_pdb.c b/libgimp/gimpgimprc_pdb.c
index cf4684aef3..58f21e09cb 100644
--- a/libgimp/gimpgimprc_pdb.c
+++ b/libgimp/gimpgimprc_pdb.c
@@ -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)
diff --git a/libgimp/gimpgradient_pdb.c b/libgimp/gimpgradient_pdb.c
index 7ee72efa07..1d13f66e8b 100644
--- a/libgimp/gimpgradient_pdb.c
+++ b/libgimp/gimpgradient_pdb.c
@@ -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)
diff --git a/libgimp/gimpgradients_pdb.c b/libgimp/gimpgradients_pdb.c
index 02f8d0b89e..ad6331bcd6 100644
--- a/libgimp/gimpgradients_pdb.c
+++ b/libgimp/gimpgradients_pdb.c
@@ -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;
diff --git a/libgimp/gimpgradientselect_pdb.c b/libgimp/gimpgradientselect_pdb.c
index 11b47dfff6..8c9508c666 100644
--- a/libgimp/gimpgradientselect_pdb.c
+++ b/libgimp/gimpgradientselect_pdb.c
@@ -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;
diff --git a/libgimp/gimphelp_pdb.c b/libgimp/gimphelp_pdb.c
index 1f633c474f..a28187fde3 100644
--- a/libgimp/gimphelp_pdb.c
+++ b/libgimp/gimphelp_pdb.c
@@ -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;
diff --git a/libgimp/gimpimage_pdb.c b/libgimp/gimpimage_pdb.c
index 737011857a..bb291c7f3e 100644
--- a/libgimp/gimpimage_pdb.c
+++ b/libgimp/gimpimage_pdb.c
@@ -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;
diff --git a/libgimp/gimpimagecolorprofile_pdb.c b/libgimp/gimpimagecolorprofile_pdb.c
index 8ebcdd910a..bf9e5ad829 100644
--- a/libgimp/gimpimagecolorprofile_pdb.c
+++ b/libgimp/gimpimagecolorprofile_pdb.c
@@ -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;
diff --git a/libgimp/gimpimageconvert_pdb.c b/libgimp/gimpimageconvert_pdb.c
index 4539d2b87b..4e5a5283bc 100644
--- a/libgimp/gimpimageconvert_pdb.c
+++ b/libgimp/gimpimageconvert_pdb.c
@@ -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;
diff --git a/libgimp/gimpimagegrid_pdb.c b/libgimp/gimpimagegrid_pdb.c
index 1650af812d..b7ace87be7 100644
--- a/libgimp/gimpimagegrid_pdb.c
+++ b/libgimp/gimpimagegrid_pdb.c
@@ -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;
diff --git a/libgimp/gimpimageguides_pdb.c b/libgimp/gimpimageguides_pdb.c
index 8394fed6f1..0102ad8cb3 100644
--- a/libgimp/gimpimageguides_pdb.c
+++ b/libgimp/gimpimageguides_pdb.c
@@ -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)
diff --git a/libgimp/gimpimagesamplepoints_pdb.c b/libgimp/gimpimagesamplepoints_pdb.c
index 5855224e78..f1ece08171 100644
--- a/libgimp/gimpimagesamplepoints_pdb.c
+++ b/libgimp/gimpimagesamplepoints_pdb.c
@@ -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)
diff --git a/libgimp/gimpimageselect_pdb.c b/libgimp/gimpimageselect_pdb.c
index 5e5f90024c..6fbd40248c 100644
--- a/libgimp/gimpimageselect_pdb.c
+++ b/libgimp/gimpimageselect_pdb.c
@@ -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;
diff --git a/libgimp/gimpimagetransform_pdb.c b/libgimp/gimpimagetransform_pdb.c
index 7efbe2ab2b..8e9102f4d8 100644
--- a/libgimp/gimpimagetransform_pdb.c
+++ b/libgimp/gimpimagetransform_pdb.c
@@ -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;
diff --git a/libgimp/gimpimageundo_pdb.c b/libgimp/gimpimageundo_pdb.c
index 20202f25e3..2820476450 100644
--- a/libgimp/gimpimageundo_pdb.c
+++ b/libgimp/gimpimageundo_pdb.c
@@ -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)
diff --git a/libgimp/gimpitem_pdb.c b/libgimp/gimpitem_pdb.c
index e270fd181c..88bad36e80 100644
--- a/libgimp/gimpitem_pdb.c
+++ b/libgimp/gimpitem_pdb.c
@@ -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;
diff --git a/libgimp/gimpitemtransform_pdb.c b/libgimp/gimpitemtransform_pdb.c
index 34e49f9959..7d4f0c6bbe 100644
--- a/libgimp/gimpitemtransform_pdb.c
+++ b/libgimp/gimpitemtransform_pdb.c
@@ -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)
diff --git a/libgimp/gimplayer_pdb.c b/libgimp/gimplayer_pdb.c
index 412fa82327..80e453e474 100644
--- a/libgimp/gimplayer_pdb.c
+++ b/libgimp/gimplayer_pdb.c
@@ -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;
diff --git a/libgimp/gimplegacy.c b/libgimp/gimplegacy.c
index 2a3cd9e488..746f3fb84f 100644
--- a/libgimp/gimplegacy.c
+++ b/libgimp/gimplegacy.c
@@ -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
diff --git a/libgimp/gimplegacy.h b/libgimp/gimplegacy.h
index 76f61f0305..c55a8e60be 100644
--- a/libgimp/gimplegacy.h
+++ b/libgimp/gimplegacy.h
@@ -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'.
diff --git a/libgimp/gimpmessage_pdb.c b/libgimp/gimpmessage_pdb.c
index 6810c8d40b..ceec0ba38b 100644
--- a/libgimp/gimpmessage_pdb.c
+++ b/libgimp/gimpmessage_pdb.c
@@ -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;
diff --git a/libgimp/gimppainttools_pdb.c b/libgimp/gimppainttools_pdb.c
index 0e4c1d4483..a26e914736 100644
--- a/libgimp/gimppainttools_pdb.c
+++ b/libgimp/gimppainttools_pdb.c
@@ -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;
diff --git a/libgimp/gimppalette_pdb.c b/libgimp/gimppalette_pdb.c
index 529ac327b9..4c5c145e1e 100644
--- a/libgimp/gimppalette_pdb.c
+++ b/libgimp/gimppalette_pdb.c
@@ -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;
diff --git a/libgimp/gimppalettes_pdb.c b/libgimp/gimppalettes_pdb.c
index 1aa2a652a6..591957d41a 100644
--- a/libgimp/gimppalettes_pdb.c
+++ b/libgimp/gimppalettes_pdb.c
@@ -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;
diff --git a/libgimp/gimppaletteselect_pdb.c b/libgimp/gimppaletteselect_pdb.c
index f26c52398d..b0892d2192 100644
--- a/libgimp/gimppaletteselect_pdb.c
+++ b/libgimp/gimppaletteselect_pdb.c
@@ -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;
diff --git a/libgimp/gimppattern_pdb.c b/libgimp/gimppattern_pdb.c
index f27e92c865..c1a61df9a8 100644
--- a/libgimp/gimppattern_pdb.c
+++ b/libgimp/gimppattern_pdb.c
@@ -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;
diff --git a/libgimp/gimppatterns_pdb.c b/libgimp/gimppatterns_pdb.c
index 6aa5aa6f30..1a4efe7ede 100644
--- a/libgimp/gimppatterns_pdb.c
+++ b/libgimp/gimppatterns_pdb.c
@@ -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;
diff --git a/libgimp/gimppatternselect_pdb.c b/libgimp/gimppatternselect_pdb.c
index 2289720975..c30c186c79 100644
--- a/libgimp/gimppatternselect_pdb.c
+++ b/libgimp/gimppatternselect_pdb.c
@@ -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;
diff --git a/libgimp/gimppdb_pdb.c b/libgimp/gimppdb_pdb.c
index f8c1ea6c97..aacac1ebd1 100644
--- a/libgimp/gimppdb_pdb.c
+++ b/libgimp/gimppdb_pdb.c
@@ -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;
diff --git a/libgimp/gimppdbprocedure.c b/libgimp/gimppdbprocedure.c
index ac099ca4d4..c093e6f185 100644
--- a/libgimp/gimppdbprocedure.c
+++ b/libgimp/gimppdbprocedure.c
@@ -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);
}
diff --git a/libgimp/gimpplugin_pdb.c b/libgimp/gimpplugin_pdb.c
index c49e219161..8ddd4ee8d3 100644
--- a/libgimp/gimpplugin_pdb.c
+++ b/libgimp/gimpplugin_pdb.c
@@ -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)
diff --git a/libgimp/gimpprogress_pdb.c b/libgimp/gimpprogress_pdb.c
index ae7552b6ac..b0ea8a6698 100644
--- a/libgimp/gimpprogress_pdb.c
+++ b/libgimp/gimpprogress_pdb.c
@@ -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;
diff --git a/libgimp/gimpselection_pdb.c b/libgimp/gimpselection_pdb.c
index f10869f815..e8e0e28d7b 100644
--- a/libgimp/gimpselection_pdb.c
+++ b/libgimp/gimpselection_pdb.c
@@ -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)
diff --git a/libgimp/gimptextlayer_pdb.c b/libgimp/gimptextlayer_pdb.c
index e71562c3d8..aa878c7b4e 100644
--- a/libgimp/gimptextlayer_pdb.c
+++ b/libgimp/gimptextlayer_pdb.c
@@ -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;
diff --git a/libgimp/gimptexttool_pdb.c b/libgimp/gimptexttool_pdb.c
index 3121c647f0..be778d2939 100644
--- a/libgimp/gimptexttool_pdb.c
+++ b/libgimp/gimptexttool_pdb.c
@@ -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;
diff --git a/libgimp/gimpunit_pdb.c b/libgimp/gimpunit_pdb.c
index 1f2abc549a..cdd557a163 100644
--- a/libgimp/gimpunit_pdb.c
+++ b/libgimp/gimpunit_pdb.c
@@ -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)
diff --git a/libgimp/gimpvectors_pdb.c b/libgimp/gimpvectors_pdb.c
index aa41b59fd5..c6f3eb541a 100644
--- a/libgimp/gimpvectors_pdb.c
+++ b/libgimp/gimpvectors_pdb.c
@@ -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)
diff --git a/pdb/lib.pl b/pdb/lib.pl
index 2ab26c02d8..151e1e140e 100644
--- a/pdb/lib.pl
+++ b/pdb/lib.pl
@@ -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
diff --git a/plug-ins/help/help.c b/plug-ins/help/help.c
index dfa331b13b..1a2cc4275f 100644
--- a/plug-ins/help/help.c
+++ b/plug-ins/help/help.c
@@ -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);
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
