[gimp] libgimp*, pdb: gimp_value_array_new_from_types*() takes (type, value)



commit 30d63111c390e3c8447ed7f380bf51093aa3fcd8
Author: Michael Natterer <mitch gimp org>
Date:   Thu Aug 8 13:01:50 2019 +0200

    libgimp*, pdb: gimp_value_array_new_from_types*() takes (type, value)
    
    So a value array can now we created like this:
    
    array = gimp_value_array_new_from_types (&error_msg,
                                             G_TYPE_STRING, "foo",
                                             G_TYPE_INT,    23,
                                             G_TYPE_NONE);
    
    Change PDB generation to use this, which makes for much nicer code in
    the libgimp wrappers, and only set arrays separately instead of all
    values.

 libgimp/gimp_pdb.c                  |  25 +-
 libgimp/gimpbrush_pdb.c             | 112 ++++----
 libgimp/gimpbrushes_pdb.c           |   7 +-
 libgimp/gimpbrushselect_pdb.c       |  39 ++-
 libgimp/gimpbuffer_pdb.c            |  31 ++-
 libgimp/gimpchannel_pdb.c           |  82 +++---
 libgimp/gimpcontext_pdb.c           | 394 +++++++++++++++------------
 libgimp/gimpdebug_pdb.c             |   6 +-
 libgimp/gimpdisplay_pdb.c           |  26 +-
 libgimp/gimpdrawable_pdb.c          | 173 ++++++------
 libgimp/gimpdrawablecolor_pdb.c     | 171 +++++-------
 libgimp/gimpdrawableedit_pdb.c      |  69 ++---
 libgimp/gimpdynamics_pdb.c          |   7 +-
 libgimp/gimpedit_pdb.c              |  57 ++--
 libgimp/gimpfileops_pdb.c           | 115 ++++----
 libgimp/gimpfloatingsel_pdb.c       |  19 +-
 libgimp/gimpfonts_pdb.c             |   7 +-
 libgimp/gimpfontselect_pdb.c        |  21 +-
 libgimp/gimpgimprc_pdb.c            |  26 +-
 libgimp/gimpgradient_pdb.c          | 282 ++++++++------------
 libgimp/gimpgradients_pdb.c         |   7 +-
 libgimp/gimpgradientselect_pdb.c    |  24 +-
 libgimp/gimphelp_pdb.c              |   7 +-
 libgimp/gimpimage_pdb.c             | 518 ++++++++++++++++--------------------
 libgimp/gimpimagecolorprofile_pdb.c |  52 ++--
 libgimp/gimpimageconvert_pdb.c      |  49 ++--
 libgimp/gimpimagegrid_pdb.c         |  61 ++---
 libgimp/gimpimageguides_pdb.c       |  42 ++-
 libgimp/gimpimagesamplepoints_pdb.c |  31 +--
 libgimp/gimpimageselect_pdb.c       | 114 +++-----
 libgimp/gimpimagetransform_pdb.c    |  60 ++---
 libgimp/gimpimageundo_pdb.c         |  28 +-
 libgimp/gimpitem_pdb.c              | 165 ++++++------
 libgimp/gimpitemtransform_pdb.c     | 181 +++++--------
 libgimp/gimplayer_pdb.c             | 233 +++++++---------
 libgimp/gimpmessage_pdb.c           |  11 +-
 libgimp/gimppainttools_pdb.c        | 210 ++++++---------
 libgimp/gimppalette_pdb.c           |  93 +++----
 libgimp/gimppalettes_pdb.c          |   7 +-
 libgimp/gimppaletteselect_pdb.c     |  21 +-
 libgimp/gimppattern_pdb.c           |   8 +-
 libgimp/gimppatterns_pdb.c          |   7 +-
 libgimp/gimppatternselect_pdb.c     |  21 +-
 libgimp/gimppdb_pdb.c               |  82 +++---
 libgimp/gimpplugin_pdb.c            |  47 ++--
 libgimp/gimpprogress_pdb.c          |  36 +--
 libgimp/gimpselection_pdb.c         |  90 +++----
 libgimp/gimptextlayer_pdb.c         | 176 ++++++------
 libgimp/gimptexttool_pdb.c          |  44 ++-
 libgimp/gimpunit_pdb.c              |  67 +++--
 libgimp/gimpvectors_pdb.c           | 297 ++++++++-------------
 libgimpbase/gimpvaluearray.c        |  50 +++-
 libgimpbase/gimpvaluearray.h        |   6 +-
 pdb/lib.pl                          |  24 +-
 54 files changed, 2030 insertions(+), 2508 deletions(-)
---
diff --git a/libgimp/gimp_pdb.c b/libgimp/gimp_pdb.c
index eac0507143..945ff47c5e 100644
--- a/libgimp/gimp_pdb.c
+++ b/libgimp/gimp_pdb.c
@@ -57,7 +57,8 @@ gimp_version (void)
   GimpValueArray *return_vals;
   gchar *version = NULL;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -95,7 +96,8 @@ gimp_getpid (void)
   GimpValueArray *return_vals;
   gint pid = 0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -134,9 +136,9 @@ gimp_attach_parasite (const GimpParasite *parasite)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_PARASITE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_PARASITE, parasite,
                                           G_TYPE_NONE);
-  g_value_set_boxed (gimp_value_array_index (args, 0), parasite);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -175,9 +177,9 @@ gimp_detach_parasite (const gchar *name)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -215,9 +217,9 @@ gimp_get_parasite (const gchar *name)
   GimpValueArray *return_vals;
   GimpParasite *parasite = NULL;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -258,7 +260,8 @@ gimp_get_parasite_list (gint *num_parasites)
   GimpValueArray *return_vals;
   gchar **parasites = NULL;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -302,9 +305,9 @@ gimp_temp_name (const gchar *extension)
   GimpValueArray *return_vals;
   gchar *name = NULL;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, extension,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), extension);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimpbrush_pdb.c b/libgimp/gimpbrush_pdb.c
index 6e7219dcb9..cccbf67fab 100644
--- a/libgimp/gimpbrush_pdb.c
+++ b/libgimp/gimpbrush_pdb.c
@@ -55,9 +55,9 @@ gimp_brush_new (const gchar *name)
   GimpValueArray *return_vals;
   gchar *actual_name = NULL;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -97,9 +97,9 @@ gimp_brush_duplicate (const gchar *name)
   GimpValueArray *return_vals;
   gchar *copy_name = NULL;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -138,9 +138,9 @@ gimp_brush_is_generated (const gchar *name)
   GimpValueArray *return_vals;
   gboolean generated = FALSE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -182,11 +182,10 @@ gimp_brush_rename (const gchar *name,
   GimpValueArray *return_vals;
   gchar *actual_name = NULL;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
+                                          G_TYPE_STRING, new_name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
-  g_value_set_string (gimp_value_array_index (args, 1), new_name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -225,9 +224,9 @@ gimp_brush_delete (const gchar *name)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -265,9 +264,9 @@ gimp_brush_is_editable (const gchar *name)
   GimpValueArray *return_vals;
   gboolean editable = FALSE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -315,9 +314,9 @@ gimp_brush_get_info (const gchar *name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -385,9 +384,9 @@ gimp_brush_get_pixels (const gchar  *name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -450,9 +449,9 @@ gimp_brush_get_spacing (const gchar *name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -498,11 +497,10 @@ gimp_brush_set_spacing (const gchar *name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
+                                          GIMP_TYPE_INT32, spacing,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
-  g_value_set_int (gimp_value_array_index (args, 1), spacing);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -545,9 +543,9 @@ gimp_brush_get_shape (const gchar *name)
   GimpValueArray *return_vals;
   GimpBrushGeneratedShape shape = 0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -593,11 +591,10 @@ gimp_brush_set_shape (const gchar             *name,
   GimpValueArray *return_vals;
   GimpBrushGeneratedShape shape_out = 0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          GIMP_TYPE_BRUSH_GENERATED_SHAPE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
+                                          GIMP_TYPE_BRUSH_GENERATED_SHAPE, shape_in,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
-  g_value_set_enum (gimp_value_array_index (args, 1), shape_in);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -637,9 +634,9 @@ gimp_brush_get_radius (const gchar *name)
   GimpValueArray *return_vals;
   gdouble radius = 0.0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -681,11 +678,10 @@ gimp_brush_set_radius (const gchar *name,
   GimpValueArray *return_vals;
   gdouble radius_out = 0.0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
+                                          G_TYPE_DOUBLE, radius_in,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
-  g_value_set_double (gimp_value_array_index (args, 1), radius_in);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -725,9 +721,9 @@ gimp_brush_get_spikes (const gchar *name)
   GimpValueArray *return_vals;
   gint spikes = 0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -769,11 +765,10 @@ gimp_brush_set_spikes (const gchar *name,
   GimpValueArray *return_vals;
   gint spikes_out = 0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
+                                          GIMP_TYPE_INT32, spikes_in,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
-  g_value_set_int (gimp_value_array_index (args, 1), spikes_in);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -815,9 +810,9 @@ gimp_brush_get_hardness (const gchar *name)
   GimpValueArray *return_vals;
   gdouble hardness = 0.0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -860,11 +855,10 @@ gimp_brush_set_hardness (const gchar *name,
   GimpValueArray *return_vals;
   gdouble hardness_out = 0.0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
+                                          G_TYPE_DOUBLE, hardness_in,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
-  g_value_set_double (gimp_value_array_index (args, 1), hardness_in);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -905,9 +899,9 @@ gimp_brush_get_aspect_ratio (const gchar *name)
   GimpValueArray *return_vals;
   gdouble aspect_ratio = 0.0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -950,11 +944,10 @@ gimp_brush_set_aspect_ratio (const gchar *name,
   GimpValueArray *return_vals;
   gdouble aspect_ratio_out = 0.0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
+                                          G_TYPE_DOUBLE, aspect_ratio_in,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
-  g_value_set_double (gimp_value_array_index (args, 1), aspect_ratio_in);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -994,9 +987,9 @@ gimp_brush_get_angle (const gchar *name)
   GimpValueArray *return_vals;
   gdouble angle = 0.0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1038,11 +1031,10 @@ gimp_brush_set_angle (const gchar *name,
   GimpValueArray *return_vals;
   gdouble angle_out = 0.0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
+                                          G_TYPE_DOUBLE, angle_in,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
-  g_value_set_double (gimp_value_array_index (args, 1), angle_in);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimpbrushes_pdb.c b/libgimp/gimpbrushes_pdb.c
index 62c37e28a5..256773641b 100644
--- a/libgimp/gimpbrushes_pdb.c
+++ b/libgimp/gimpbrushes_pdb.c
@@ -52,7 +52,8 @@ gimp_brushes_refresh (void)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -94,9 +95,9 @@ gimp_brushes_get_list (const gchar *filter,
   GimpValueArray *return_vals;
   gchar **brush_list = NULL;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, filter,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), filter);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimpbrushselect_pdb.c b/libgimp/gimpbrushselect_pdb.c
index e4d29d09c7..32e9ebdb98 100644
--- a/libgimp/gimpbrushselect_pdb.c
+++ b/libgimp/gimpbrushselect_pdb.c
@@ -62,19 +62,14 @@ gimp_brushes_popup (const gchar   *brush_callback,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          G_TYPE_STRING,
-                                          G_TYPE_STRING,
-                                          G_TYPE_DOUBLE,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_LAYER_MODE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, brush_callback,
+                                          G_TYPE_STRING, popup_title,
+                                          G_TYPE_STRING, initial_brush,
+                                          G_TYPE_DOUBLE, opacity,
+                                          GIMP_TYPE_INT32, spacing,
+                                          GIMP_TYPE_LAYER_MODE, paint_mode,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), brush_callback);
-  g_value_set_string (gimp_value_array_index (args, 1), popup_title);
-  g_value_set_string (gimp_value_array_index (args, 2), initial_brush);
-  g_value_set_double (gimp_value_array_index (args, 3), opacity);
-  g_value_set_int (gimp_value_array_index (args, 4), spacing);
-  g_value_set_enum (gimp_value_array_index (args, 5), paint_mode);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -110,9 +105,9 @@ gimp_brushes_close_popup (const gchar *brush_callback)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, brush_callback,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), brush_callback);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -156,17 +151,13 @@ gimp_brushes_set_popup (const gchar   *brush_callback,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          G_TYPE_STRING,
-                                          G_TYPE_DOUBLE,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_LAYER_MODE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, brush_callback,
+                                          G_TYPE_STRING, brush_name,
+                                          G_TYPE_DOUBLE, opacity,
+                                          GIMP_TYPE_INT32, spacing,
+                                          GIMP_TYPE_LAYER_MODE, paint_mode,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), brush_callback);
-  g_value_set_string (gimp_value_array_index (args, 1), brush_name);
-  g_value_set_double (gimp_value_array_index (args, 2), opacity);
-  g_value_set_int (gimp_value_array_index (args, 3), spacing);
-  g_value_set_enum (gimp_value_array_index (args, 4), paint_mode);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimpbuffer_pdb.c b/libgimp/gimpbuffer_pdb.c
index e87be04337..1ae1a12a2a 100644
--- a/libgimp/gimpbuffer_pdb.c
+++ b/libgimp/gimpbuffer_pdb.c
@@ -59,9 +59,9 @@ gimp_buffers_get_list (const gchar *filter,
   GimpValueArray *return_vals;
   gchar **buffer_list = NULL;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, filter,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), filter);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -108,11 +108,10 @@ gimp_buffer_rename (const gchar *buffer_name,
   GimpValueArray *return_vals;
   gchar *real_name = NULL;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, buffer_name,
+                                          G_TYPE_STRING, new_name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), buffer_name);
-  g_value_set_string (gimp_value_array_index (args, 1), new_name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -151,9 +150,9 @@ gimp_buffer_delete (const gchar *buffer_name)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, buffer_name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), buffer_name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -191,9 +190,9 @@ gimp_buffer_get_width (const gchar *buffer_name)
   GimpValueArray *return_vals;
   gint width = 0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, buffer_name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), buffer_name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -232,9 +231,9 @@ gimp_buffer_get_height (const gchar *buffer_name)
   GimpValueArray *return_vals;
   gint height = 0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, buffer_name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), buffer_name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -273,9 +272,9 @@ gimp_buffer_get_bytes (const gchar *buffer_name)
   GimpValueArray *return_vals;
   gint bytes = 0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, buffer_name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), buffer_name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -314,9 +313,9 @@ gimp_buffer_get_image_type (const gchar *buffer_name)
   GimpValueArray *return_vals;
   GimpImageBaseType image_type = 0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, buffer_name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), buffer_name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimpchannel_pdb.c b/libgimp/gimpchannel_pdb.c
index ac4d861e99..8022d0c5f0 100644
--- a/libgimp/gimpchannel_pdb.c
+++ b/libgimp/gimpchannel_pdb.c
@@ -68,19 +68,14 @@ _gimp_channel_new (gint32         image_ID,
   GimpValueArray *return_vals;
   gint32 channel_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
-                                          G_TYPE_STRING,
-                                          G_TYPE_DOUBLE,
-                                          GIMP_TYPE_RGB,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_INT32, width,
+                                          GIMP_TYPE_INT32, height,
+                                          G_TYPE_STRING, name,
+                                          G_TYPE_DOUBLE, opacity,
+                                          GIMP_TYPE_RGB, color,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), width);
-  g_value_set_int (gimp_value_array_index (args, 2), height);
-  g_value_set_string (gimp_value_array_index (args, 3), name);
-  g_value_set_double (gimp_value_array_index (args, 4), opacity);
-  gimp_value_set_rgb (gimp_value_array_index (args, 5), color);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -127,13 +122,11 @@ gimp_channel_new_from_component (gint32           image_ID,
   GimpValueArray *return_vals;
   gint32 channel_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_CHANNEL_TYPE,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_CHANNEL_TYPE, component,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), component);
-  g_value_set_string (gimp_value_array_index (args, 2), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -172,9 +165,9 @@ gimp_channel_copy (gint32 channel_ID)
   GimpValueArray *return_vals;
   gint32 channel_copy_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_CHANNEL_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_CHANNEL_ID, channel_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_channel_id (gimp_value_array_index (args, 0), channel_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -220,17 +213,13 @@ gimp_channel_combine_masks (gint32         channel1_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_CHANNEL_ID,
-                                          GIMP_TYPE_CHANNEL_ID,
-                                          GIMP_TYPE_CHANNEL_OPS,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_CHANNEL_ID, channel1_ID,
+                                          GIMP_TYPE_CHANNEL_ID, channel2_ID,
+                                          GIMP_TYPE_CHANNEL_OPS, operation,
+                                          GIMP_TYPE_INT32, offx,
+                                          GIMP_TYPE_INT32, offy,
                                           G_TYPE_NONE);
-  gimp_value_set_channel_id (gimp_value_array_index (args, 0), channel1_ID);
-  gimp_value_set_channel_id (gimp_value_array_index (args, 1), channel2_ID);
-  g_value_set_enum (gimp_value_array_index (args, 2), operation);
-  g_value_set_int (gimp_value_array_index (args, 3), offx);
-  g_value_set_int (gimp_value_array_index (args, 4), offy);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -268,9 +257,9 @@ gimp_channel_get_show_masked (gint32 channel_ID)
   GimpValueArray *return_vals;
   gboolean show_masked = FALSE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_CHANNEL_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_CHANNEL_ID, channel_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_channel_id (gimp_value_array_index (args, 0), channel_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -311,11 +300,10 @@ gimp_channel_set_show_masked (gint32   channel_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_CHANNEL_ID,
-                                          G_TYPE_BOOLEAN,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_CHANNEL_ID, channel_ID,
+                                          G_TYPE_BOOLEAN, show_masked,
                                           G_TYPE_NONE);
-  gimp_value_set_channel_id (gimp_value_array_index (args, 0), channel_ID);
-  g_value_set_boolean (gimp_value_array_index (args, 1), show_masked);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -351,9 +339,9 @@ gimp_channel_get_opacity (gint32 channel_ID)
   GimpValueArray *return_vals;
   gdouble opacity = 0.0;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_CHANNEL_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_CHANNEL_ID, channel_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_channel_id (gimp_value_array_index (args, 0), channel_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -392,11 +380,10 @@ gimp_channel_set_opacity (gint32  channel_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_CHANNEL_ID,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_CHANNEL_ID, channel_ID,
+                                          G_TYPE_DOUBLE, opacity,
                                           G_TYPE_NONE);
-  gimp_value_set_channel_id (gimp_value_array_index (args, 0), channel_ID);
-  g_value_set_double (gimp_value_array_index (args, 1), opacity);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -434,9 +421,9 @@ gimp_channel_get_color (gint32   channel_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_CHANNEL_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_CHANNEL_ID, channel_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_channel_id (gimp_value_array_index (args, 0), channel_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -477,11 +464,10 @@ gimp_channel_set_color (gint32         channel_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_CHANNEL_ID,
-                                          GIMP_TYPE_RGB,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_CHANNEL_ID, channel_ID,
+                                          GIMP_TYPE_RGB, color,
                                           G_TYPE_NONE);
-  gimp_value_set_channel_id (gimp_value_array_index (args, 0), channel_ID);
-  gimp_value_set_rgb (gimp_value_array_index (args, 1), color);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimpcontext_pdb.c b/libgimp/gimpcontext_pdb.c
index 522822ed27..5100e1eb4b 100644
--- a/libgimp/gimpcontext_pdb.c
+++ b/libgimp/gimpcontext_pdb.c
@@ -55,7 +55,8 @@ gimp_context_push (void)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -95,7 +96,8 @@ gimp_context_pop (void)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -136,7 +138,8 @@ gimp_context_set_defaults (void)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -177,7 +180,8 @@ gimp_context_list_paint_methods (gint    *num_paint_methods,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -225,7 +229,8 @@ gimp_context_get_paint_method (void)
   GimpValueArray *return_vals;
   gchar *name = NULL;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -269,9 +274,9 @@ gimp_context_set_paint_method (const gchar *name)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -308,7 +313,8 @@ gimp_context_get_stroke_method (void)
   GimpValueArray *return_vals;
   GimpStrokeMethod stroke_method = 0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -349,9 +355,9 @@ gimp_context_set_stroke_method (GimpStrokeMethod stroke_method)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_STROKE_METHOD,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_STROKE_METHOD, stroke_method,
                                           G_TYPE_NONE);
-  g_value_set_enum (gimp_value_array_index (args, 0), stroke_method);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -391,7 +397,8 @@ gimp_context_get_foreground (GimpRGB *foreground)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -434,9 +441,9 @@ gimp_context_set_foreground (const GimpRGB *foreground)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_RGB,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_RGB, foreground,
                                           G_TYPE_NONE);
-  gimp_value_set_rgb (gimp_value_array_index (args, 0), foreground);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -476,7 +483,8 @@ gimp_context_get_background (GimpRGB *background)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -520,9 +528,9 @@ gimp_context_set_background (const GimpRGB *background)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_RGB,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_RGB, background,
                                           G_TYPE_NONE);
-  gimp_value_set_rgb (gimp_value_array_index (args, 0), background);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -561,7 +569,8 @@ gimp_context_set_default_colors (void)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -600,7 +609,8 @@ gimp_context_swap_colors (void)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -638,7 +648,8 @@ gimp_context_get_opacity (void)
   GimpValueArray *return_vals;
   gdouble opacity = 0.0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -678,9 +689,9 @@ gimp_context_set_opacity (gdouble opacity)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_DOUBLE, opacity,
                                           G_TYPE_NONE);
-  g_value_set_double (gimp_value_array_index (args, 0), opacity);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -719,7 +730,8 @@ gimp_context_get_paint_mode (void)
   GimpValueArray *return_vals;
   GimpLayerMode paint_mode = 0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -758,9 +770,9 @@ gimp_context_set_paint_mode (GimpLayerMode paint_mode)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_MODE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_MODE, paint_mode,
                                           G_TYPE_NONE);
-  g_value_set_enum (gimp_value_array_index (args, 0), paint_mode);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -797,7 +809,8 @@ gimp_context_get_line_width (void)
   GimpValueArray *return_vals;
   gdouble line_width = 0.0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -840,9 +853,9 @@ gimp_context_set_line_width (gdouble line_width)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_DOUBLE, line_width,
                                           G_TYPE_NONE);
-  g_value_set_double (gimp_value_array_index (args, 0), line_width);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -879,7 +892,8 @@ gimp_context_get_line_width_unit (void)
   GimpValueArray *return_vals;
   GimpUnit line_width_unit = 0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -923,9 +937,9 @@ gimp_context_set_line_width_unit (GimpUnit line_width_unit)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_UNIT,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_UNIT, line_width_unit,
                                           G_TYPE_NONE);
-  g_value_set_int (gimp_value_array_index (args, 0), line_width_unit);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -962,7 +976,8 @@ gimp_context_get_line_cap_style (void)
   GimpValueArray *return_vals;
   GimpCapStyle cap_style = 0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1006,9 +1021,9 @@ gimp_context_set_line_cap_style (GimpCapStyle cap_style)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_CAP_STYLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_CAP_STYLE, cap_style,
                                           G_TYPE_NONE);
-  g_value_set_enum (gimp_value_array_index (args, 0), cap_style);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1045,7 +1060,8 @@ gimp_context_get_line_join_style (void)
   GimpValueArray *return_vals;
   GimpJoinStyle join_style = 0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1089,9 +1105,9 @@ gimp_context_set_line_join_style (GimpJoinStyle join_style)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_JOIN_STYLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_JOIN_STYLE, join_style,
                                           G_TYPE_NONE);
-  g_value_set_enum (gimp_value_array_index (args, 0), join_style);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1128,7 +1144,8 @@ gimp_context_get_line_miter_limit (void)
   GimpValueArray *return_vals;
   gdouble miter_limit = 0.0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1175,9 +1192,9 @@ gimp_context_set_line_miter_limit (gdouble miter_limit)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_DOUBLE, miter_limit,
                                           G_TYPE_NONE);
-  g_value_set_double (gimp_value_array_index (args, 0), miter_limit);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1214,7 +1231,8 @@ gimp_context_get_line_dash_offset (void)
   GimpValueArray *return_vals;
   gdouble dash_offset = 0.0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1258,9 +1276,9 @@ gimp_context_set_line_dash_offset (gdouble dash_offset)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_DOUBLE, dash_offset,
                                           G_TYPE_NONE);
-  g_value_set_double (gimp_value_array_index (args, 0), dash_offset);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1300,7 +1318,8 @@ gimp_context_get_line_dash_pattern (gint     *num_dashes,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1358,10 +1377,10 @@ gimp_context_set_line_dash_pattern (gint           num_dashes,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_INT32,
-                                          GIMP_TYPE_FLOAT_ARRAY,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_INT32, num_dashes,
+                                          GIMP_TYPE_FLOAT_ARRAY, NULL,
                                           G_TYPE_NONE);
-  g_value_set_int (gimp_value_array_index (args, 0), num_dashes);
   gimp_value_set_float_array (gimp_value_array_index (args, 1), dashes, num_dashes);
 
   if (pdb)
@@ -1402,7 +1421,8 @@ gimp_context_get_brush (void)
   GimpValueArray *return_vals;
   gchar *name = NULL;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1445,9 +1465,9 @@ gimp_context_set_brush (const gchar *name)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1484,7 +1504,8 @@ gimp_context_get_brush_size (void)
   GimpValueArray *return_vals;
   gdouble size = 0.0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1523,9 +1544,9 @@ gimp_context_set_brush_size (gdouble size)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_DOUBLE, size,
                                           G_TYPE_NONE);
-  g_value_set_double (gimp_value_array_index (args, 0), size);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1563,7 +1584,8 @@ gimp_context_set_brush_default_size (void)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1600,7 +1622,8 @@ gimp_context_get_brush_aspect_ratio (void)
   GimpValueArray *return_vals;
   gdouble aspect = 0.0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1639,9 +1662,9 @@ gimp_context_set_brush_aspect_ratio (gdouble aspect)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_DOUBLE, aspect,
                                           G_TYPE_NONE);
-  g_value_set_double (gimp_value_array_index (args, 0), aspect);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1678,7 +1701,8 @@ gimp_context_get_brush_angle (void)
   GimpValueArray *return_vals;
   gdouble angle = 0.0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1717,9 +1741,9 @@ gimp_context_set_brush_angle (gdouble angle)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_DOUBLE, angle,
                                           G_TYPE_NONE);
-  g_value_set_double (gimp_value_array_index (args, 0), angle);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1757,7 +1781,8 @@ gimp_context_get_brush_spacing (void)
   GimpValueArray *return_vals;
   gdouble spacing = 0.0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1797,9 +1822,9 @@ gimp_context_set_brush_spacing (gdouble spacing)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_DOUBLE, spacing,
                                           G_TYPE_NONE);
-  g_value_set_double (gimp_value_array_index (args, 0), spacing);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1837,7 +1862,8 @@ gimp_context_set_brush_default_spacing (void)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1874,7 +1900,8 @@ gimp_context_get_brush_hardness (void)
   GimpValueArray *return_vals;
   gdouble hardness = 0.0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1913,9 +1940,9 @@ gimp_context_set_brush_hardness (gdouble hardness)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_DOUBLE, hardness,
                                           G_TYPE_NONE);
-  g_value_set_double (gimp_value_array_index (args, 0), hardness);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1953,7 +1980,8 @@ gimp_context_set_brush_default_hardness (void)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1990,7 +2018,8 @@ gimp_context_get_brush_force (void)
   GimpValueArray *return_vals;
   gdouble force = 0.0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2029,9 +2058,9 @@ gimp_context_set_brush_force (gdouble force)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_DOUBLE, force,
                                           G_TYPE_NONE);
-  g_value_set_double (gimp_value_array_index (args, 0), force);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2071,7 +2100,8 @@ gimp_context_get_dynamics (void)
   GimpValueArray *return_vals;
   gchar *name = NULL;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2115,9 +2145,9 @@ gimp_context_set_dynamics (const gchar *name)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2156,7 +2186,8 @@ gimp_context_get_mypaint_brush (void)
   GimpValueArray *return_vals;
   gchar *name = NULL;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2200,9 +2231,9 @@ gimp_context_set_mypaint_brush (const gchar *name)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2242,7 +2273,8 @@ gimp_context_get_pattern (void)
   GimpValueArray *return_vals;
   gchar *name = NULL;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2286,9 +2318,9 @@ gimp_context_set_pattern (const gchar *name)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2326,7 +2358,8 @@ gimp_context_get_gradient (void)
   GimpValueArray *return_vals;
   gchar *name = NULL;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2370,9 +2403,9 @@ gimp_context_set_gradient (const gchar *name)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2411,7 +2444,8 @@ gimp_context_set_gradient_fg_bg_rgb (void)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2450,7 +2484,8 @@ gimp_context_set_gradient_fg_bg_hsv_cw (void)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2489,7 +2524,8 @@ gimp_context_set_gradient_fg_bg_hsv_ccw (void)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2528,7 +2564,8 @@ gimp_context_set_gradient_fg_transparent (void)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2566,7 +2603,8 @@ gimp_context_get_gradient_blend_color_space (void)
   GimpValueArray *return_vals;
   GimpGradientBlendColorSpace blend_color_space = 0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2606,9 +2644,9 @@ gimp_context_set_gradient_blend_color_space (GimpGradientBlendColorSpace blend_c
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_GRADIENT_BLEND_COLOR_SPACE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_GRADIENT_BLEND_COLOR_SPACE, blend_color_space,
                                           G_TYPE_NONE);
-  g_value_set_enum (gimp_value_array_index (args, 0), blend_color_space);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2645,7 +2683,8 @@ gimp_context_get_gradient_repeat_mode (void)
   GimpValueArray *return_vals;
   GimpRepeatMode repeat_mode = 0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2684,9 +2723,9 @@ gimp_context_set_gradient_repeat_mode (GimpRepeatMode repeat_mode)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_REPEAT_MODE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_REPEAT_MODE, repeat_mode,
                                           G_TYPE_NONE);
-  g_value_set_enum (gimp_value_array_index (args, 0), repeat_mode);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2724,7 +2763,8 @@ gimp_context_get_gradient_reverse (void)
   GimpValueArray *return_vals;
   gboolean reverse = FALSE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2764,9 +2804,9 @@ gimp_context_set_gradient_reverse (gboolean reverse)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_BOOLEAN,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_BOOLEAN, reverse,
                                           G_TYPE_NONE);
-  g_value_set_boolean (gimp_value_array_index (args, 0), reverse);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2804,7 +2844,8 @@ gimp_context_get_palette (void)
   GimpValueArray *return_vals;
   gchar *name = NULL;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2848,9 +2889,9 @@ gimp_context_set_palette (const gchar *name)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2888,7 +2929,8 @@ gimp_context_get_font (void)
   GimpValueArray *return_vals;
   gchar *name = NULL;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2931,9 +2973,9 @@ gimp_context_set_font (const gchar *name)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2970,7 +3012,8 @@ gimp_context_get_antialias (void)
   GimpValueArray *return_vals;
   gboolean antialias = FALSE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -3020,9 +3063,9 @@ gimp_context_set_antialias (gboolean antialias)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_BOOLEAN,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_BOOLEAN, antialias,
                                           G_TYPE_NONE);
-  g_value_set_boolean (gimp_value_array_index (args, 0), antialias);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -3059,7 +3102,8 @@ gimp_context_get_feather (void)
   GimpValueArray *return_vals;
   gboolean feather = FALSE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -3107,9 +3151,9 @@ gimp_context_set_feather (gboolean feather)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_BOOLEAN,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_BOOLEAN, feather,
                                           G_TYPE_NONE);
-  g_value_set_boolean (gimp_value_array_index (args, 0), feather);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -3149,7 +3193,8 @@ gimp_context_get_feather_radius (gdouble *feather_radius_x,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -3201,11 +3246,10 @@ gimp_context_set_feather_radius (gdouble feather_radius_x,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_DOUBLE, feather_radius_x,
+                                          G_TYPE_DOUBLE, feather_radius_y,
                                           G_TYPE_NONE);
-  g_value_set_double (gimp_value_array_index (args, 0), feather_radius_x);
-  g_value_set_double (gimp_value_array_index (args, 1), feather_radius_y);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -3242,7 +3286,8 @@ gimp_context_get_sample_merged (void)
   GimpValueArray *return_vals;
   gboolean sample_merged = FALSE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -3291,9 +3336,9 @@ gimp_context_set_sample_merged (gboolean sample_merged)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_BOOLEAN,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_BOOLEAN, sample_merged,
                                           G_TYPE_NONE);
-  g_value_set_boolean (gimp_value_array_index (args, 0), sample_merged);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -3330,7 +3375,8 @@ gimp_context_get_sample_criterion (void)
   GimpValueArray *return_vals;
   GimpSelectCriterion sample_criterion = 0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -3377,9 +3423,9 @@ gimp_context_set_sample_criterion (GimpSelectCriterion sample_criterion)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_SELECT_CRITERION,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_SELECT_CRITERION, sample_criterion,
                                           G_TYPE_NONE);
-  g_value_set_enum (gimp_value_array_index (args, 0), sample_criterion);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -3416,7 +3462,8 @@ gimp_context_get_sample_threshold (void)
   GimpValueArray *return_vals;
   gdouble sample_threshold = 0.0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -3464,9 +3511,9 @@ gimp_context_set_sample_threshold (gdouble sample_threshold)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_DOUBLE, sample_threshold,
                                           G_TYPE_NONE);
-  g_value_set_double (gimp_value_array_index (args, 0), sample_threshold);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -3504,7 +3551,8 @@ gimp_context_get_sample_threshold_int (void)
   GimpValueArray *return_vals;
   gint sample_threshold = 0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -3544,9 +3592,9 @@ gimp_context_set_sample_threshold_int (gint sample_threshold)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_INT32, sample_threshold,
                                           G_TYPE_NONE);
-  g_value_set_int (gimp_value_array_index (args, 0), sample_threshold);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -3583,7 +3631,8 @@ gimp_context_get_sample_transparent (void)
   GimpValueArray *return_vals;
   gboolean sample_transparent = FALSE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -3630,9 +3679,9 @@ gimp_context_set_sample_transparent (gboolean sample_transparent)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_BOOLEAN,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_BOOLEAN, sample_transparent,
                                           G_TYPE_NONE);
-  g_value_set_boolean (gimp_value_array_index (args, 0), sample_transparent);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -3669,7 +3718,8 @@ gimp_context_get_diagonal_neighbors (void)
   GimpValueArray *return_vals;
   gboolean diagonal_neighbors = FALSE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -3717,9 +3767,9 @@ gimp_context_set_diagonal_neighbors (gboolean diagonal_neighbors)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_BOOLEAN,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_BOOLEAN, diagonal_neighbors,
                                           G_TYPE_NONE);
-  g_value_set_boolean (gimp_value_array_index (args, 0), diagonal_neighbors);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -3757,7 +3807,8 @@ gimp_context_get_distance_metric (void)
   GimpValueArray *return_vals;
   GeglDistanceMetric metric = 0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -3802,9 +3853,9 @@ gimp_context_set_distance_metric (GeglDistanceMetric metric)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GEGL_TYPE_DISTANCE_METRIC,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GEGL_TYPE_DISTANCE_METRIC, metric,
                                           G_TYPE_NONE);
-  g_value_set_enum (gimp_value_array_index (args, 0), metric);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -3845,7 +3896,8 @@ gimp_context_get_interpolation (void)
   GimpValueArray *return_vals;
   GimpInterpolationType interpolation = 0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -3891,9 +3943,9 @@ gimp_context_set_interpolation (GimpInterpolationType interpolation)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_INTERPOLATION_TYPE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_INTERPOLATION_TYPE, interpolation,
                                           G_TYPE_NONE);
-  g_value_set_enum (gimp_value_array_index (args, 0), interpolation);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -3932,7 +3984,8 @@ gimp_context_get_transform_direction (void)
   GimpValueArray *return_vals;
   GimpTransformDirection transform_direction = 0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -3977,9 +4030,9 @@ gimp_context_set_transform_direction (GimpTransformDirection transform_direction
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_TRANSFORM_DIRECTION,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_TRANSFORM_DIRECTION, transform_direction,
                                           G_TYPE_NONE);
-  g_value_set_enum (gimp_value_array_index (args, 0), transform_direction);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -4018,7 +4071,8 @@ gimp_context_get_transform_resize (void)
   GimpValueArray *return_vals;
   GimpTransformResize transform_resize = 0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -4067,9 +4121,9 @@ gimp_context_set_transform_resize (GimpTransformResize transform_resize)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_TRANSFORM_RESIZE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_TRANSFORM_RESIZE, transform_resize,
                                           G_TYPE_NONE);
-  g_value_set_enum (gimp_value_array_index (args, 0), transform_resize);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -4106,7 +4160,8 @@ gimp_context_get_ink_size (void)
   GimpValueArray *return_vals;
   gdouble size = 0.0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -4145,9 +4200,9 @@ gimp_context_set_ink_size (gdouble size)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_DOUBLE, size,
                                           G_TYPE_NONE);
-  g_value_set_double (gimp_value_array_index (args, 0), size);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -4184,7 +4239,8 @@ gimp_context_get_ink_angle (void)
   GimpValueArray *return_vals;
   gdouble angle = 0.0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -4223,9 +4279,9 @@ gimp_context_set_ink_angle (gdouble angle)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_DOUBLE, angle,
                                           G_TYPE_NONE);
-  g_value_set_double (gimp_value_array_index (args, 0), angle);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -4262,7 +4318,8 @@ gimp_context_get_ink_size_sensitivity (void)
   GimpValueArray *return_vals;
   gdouble size = 0.0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -4301,9 +4358,9 @@ gimp_context_set_ink_size_sensitivity (gdouble size)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_DOUBLE, size,
                                           G_TYPE_NONE);
-  g_value_set_double (gimp_value_array_index (args, 0), size);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -4340,7 +4397,8 @@ gimp_context_get_ink_tilt_sensitivity (void)
   GimpValueArray *return_vals;
   gdouble tilt = 0.0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -4379,9 +4437,9 @@ gimp_context_set_ink_tilt_sensitivity (gdouble tilt)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_DOUBLE, tilt,
                                           G_TYPE_NONE);
-  g_value_set_double (gimp_value_array_index (args, 0), tilt);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -4418,7 +4476,8 @@ gimp_context_get_ink_speed_sensitivity (void)
   GimpValueArray *return_vals;
   gdouble speed = 0.0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -4457,9 +4516,9 @@ gimp_context_set_ink_speed_sensitivity (gdouble speed)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_DOUBLE, speed,
                                           G_TYPE_NONE);
-  g_value_set_double (gimp_value_array_index (args, 0), speed);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -4496,7 +4555,8 @@ gimp_context_get_ink_blob_type (void)
   GimpValueArray *return_vals;
   GimpInkBlobType type = 0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -4535,9 +4595,9 @@ gimp_context_set_ink_blob_type (GimpInkBlobType type)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_INK_BLOB_TYPE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_INK_BLOB_TYPE, type,
                                           G_TYPE_NONE);
-  g_value_set_enum (gimp_value_array_index (args, 0), type);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -4574,7 +4634,8 @@ gimp_context_get_ink_blob_aspect_ratio (void)
   GimpValueArray *return_vals;
   gdouble aspect = 0.0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -4613,9 +4674,9 @@ gimp_context_set_ink_blob_aspect_ratio (gdouble aspect)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_DOUBLE, aspect,
                                           G_TYPE_NONE);
-  g_value_set_double (gimp_value_array_index (args, 0), aspect);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -4652,7 +4713,8 @@ gimp_context_get_ink_blob_angle (void)
   GimpValueArray *return_vals;
   gdouble angle = 0.0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -4691,9 +4753,9 @@ gimp_context_set_ink_blob_angle (gdouble angle)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_DOUBLE, angle,
                                           G_TYPE_NONE);
-  g_value_set_double (gimp_value_array_index (args, 0), angle);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimpdebug_pdb.c b/libgimp/gimpdebug_pdb.c
index a8f7e6744d..d546261aec 100644
--- a/libgimp/gimpdebug_pdb.c
+++ b/libgimp/gimpdebug_pdb.c
@@ -59,7 +59,8 @@ gimp_debug_timer_start (void)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -101,7 +102,8 @@ gimp_debug_timer_end (void)
   GimpValueArray *return_vals;
   gdouble elapsed = 0.0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimpdisplay_pdb.c b/libgimp/gimpdisplay_pdb.c
index 202c6a03d1..51469bc33c 100644
--- a/libgimp/gimpdisplay_pdb.c
+++ b/libgimp/gimpdisplay_pdb.c
@@ -55,9 +55,9 @@ gimp_display_is_valid (gint32 display_ID)
   GimpValueArray *return_vals;
   gboolean valid = FALSE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DISPLAY_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DISPLAY_ID, display_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_display_id (gimp_value_array_index (args, 0), display_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -99,9 +99,9 @@ gimp_display_new (gint32 image_ID)
   GimpValueArray *return_vals;
   gint32 display_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -142,9 +142,9 @@ gimp_display_delete (gint32 display_ID)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DISPLAY_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DISPLAY_ID, display_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_display_id (gimp_value_array_index (args, 0), display_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -186,9 +186,9 @@ gimp_display_get_window_handle (gint32 display_ID)
   GimpValueArray *return_vals;
   gint window = 0;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DISPLAY_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DISPLAY_ID, display_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_display_id (gimp_value_array_index (args, 0), display_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -227,7 +227,8 @@ gimp_displays_flush (void)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -268,11 +269,10 @@ gimp_displays_reconnect (gint32 old_image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, old_image_ID,
+                                          GIMP_TYPE_IMAGE_ID, new_image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), old_image_ID);
-  gimp_value_set_image_id (gimp_value_array_index (args, 1), new_image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimpdrawable_pdb.c b/libgimp/gimpdrawable_pdb.c
index c92f2b50de..ac372e760d 100644
--- a/libgimp/gimpdrawable_pdb.c
+++ b/libgimp/gimpdrawable_pdb.c
@@ -58,9 +58,9 @@ _gimp_drawable_get_format (gint32 drawable_ID)
   GimpValueArray *return_vals;
   gchar *format = NULL;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -102,9 +102,9 @@ _gimp_drawable_get_thumbnail_format (gint32 drawable_ID)
   GimpValueArray *return_vals;
   gchar *format = NULL;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -141,9 +141,9 @@ gimp_drawable_type (gint32 drawable_ID)
   GimpValueArray *return_vals;
   GimpImageType type = 0;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -183,9 +183,9 @@ gimp_drawable_type_with_alpha (gint32 drawable_ID)
   GimpValueArray *return_vals;
   GimpImageType type_with_alpha = 0;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -224,9 +224,9 @@ gimp_drawable_has_alpha (gint32 drawable_ID)
   GimpValueArray *return_vals;
   gboolean has_alpha = FALSE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -264,9 +264,9 @@ gimp_drawable_is_rgb (gint32 drawable_ID)
   GimpValueArray *return_vals;
   gboolean is_rgb = FALSE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -304,9 +304,9 @@ gimp_drawable_is_gray (gint32 drawable_ID)
   GimpValueArray *return_vals;
   gboolean is_gray = FALSE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -344,9 +344,9 @@ gimp_drawable_is_indexed (gint32 drawable_ID)
   GimpValueArray *return_vals;
   gboolean is_indexed = FALSE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -383,9 +383,9 @@ gimp_drawable_bpp (gint32 drawable_ID)
   GimpValueArray *return_vals;
   gint bpp = 0;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -422,9 +422,9 @@ gimp_drawable_width (gint32 drawable_ID)
   GimpValueArray *return_vals;
   gint width = 0;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -461,9 +461,9 @@ gimp_drawable_height (gint32 drawable_ID)
   GimpValueArray *return_vals;
   gint height = 0;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -506,9 +506,9 @@ gimp_drawable_offsets (gint32  drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -573,9 +573,9 @@ gimp_drawable_mask_bounds (gint32  drawable_ID,
   GimpValueArray *return_vals;
   gboolean non_empty = FALSE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -633,9 +633,9 @@ gimp_drawable_mask_intersect (gint32  drawable_ID,
   GimpValueArray *return_vals;
   gboolean non_empty = FALSE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -683,11 +683,10 @@ gimp_drawable_merge_shadow (gint32   drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          G_TYPE_BOOLEAN,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          G_TYPE_BOOLEAN, undo,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_boolean (gimp_value_array_index (args, 1), undo);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -728,9 +727,9 @@ gimp_drawable_free_shadow (gint32 drawable_ID)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -777,17 +776,13 @@ gimp_drawable_update (gint32 drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_INT32, x,
+                                          GIMP_TYPE_INT32, y,
+                                          GIMP_TYPE_INT32, width,
+                                          GIMP_TYPE_INT32, height,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), x);
-  g_value_set_int (gimp_value_array_index (args, 2), y);
-  g_value_set_int (gimp_value_array_index (args, 3), width);
-  g_value_set_int (gimp_value_array_index (args, 4), height);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -833,13 +828,11 @@ gimp_drawable_get_pixel (gint32  drawable_ID,
   GimpValueArray *return_vals;
   guint8 *pixel = NULL;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_INT32, x_coord,
+                                          GIMP_TYPE_INT32, y_coord,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), x_coord);
-  g_value_set_int (gimp_value_array_index (args, 2), y_coord);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -893,16 +886,13 @@ gimp_drawable_set_pixel (gint32        drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT8_ARRAY,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_INT32, x_coord,
+                                          GIMP_TYPE_INT32, y_coord,
+                                          GIMP_TYPE_INT32, num_channels,
+                                          GIMP_TYPE_INT8_ARRAY, NULL,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), x_coord);
-  g_value_set_int (gimp_value_array_index (args, 2), y_coord);
-  g_value_set_int (gimp_value_array_index (args, 3), num_channels);
   gimp_value_set_int8_array (gimp_value_array_index (args, 4), pixel, num_channels);
 
   if (pdb)
@@ -951,11 +941,10 @@ gimp_drawable_fill (gint32       drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          GIMP_TYPE_FILL_TYPE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_FILL_TYPE, fill_type,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), fill_type);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1005,17 +994,13 @@ gimp_drawable_offset (gint32         drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          G_TYPE_BOOLEAN,
-                                          GIMP_TYPE_OFFSET_TYPE,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          G_TYPE_BOOLEAN, wrap_around,
+                                          GIMP_TYPE_OFFSET_TYPE, fill_type,
+                                          GIMP_TYPE_INT32, offset_x,
+                                          GIMP_TYPE_INT32, offset_y,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_boolean (gimp_value_array_index (args, 1), wrap_around);
-  g_value_set_enum (gimp_value_array_index (args, 2), fill_type);
-  g_value_set_int (gimp_value_array_index (args, 3), offset_x);
-  g_value_set_int (gimp_value_array_index (args, 4), offset_y);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1068,13 +1053,11 @@ _gimp_drawable_thumbnail (gint32   drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_INT32, width,
+                                          GIMP_TYPE_INT32, height,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), width);
-  g_value_set_int (gimp_value_array_index (args, 2), height);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1152,21 +1135,15 @@ _gimp_drawable_sub_thumbnail (gint32   drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_INT32, src_x,
+                                          GIMP_TYPE_INT32, src_y,
+                                          GIMP_TYPE_INT32, src_width,
+                                          GIMP_TYPE_INT32, src_height,
+                                          GIMP_TYPE_INT32, dest_width,
+                                          GIMP_TYPE_INT32, dest_height,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), src_x);
-  g_value_set_int (gimp_value_array_index (args, 2), src_y);
-  g_value_set_int (gimp_value_array_index (args, 3), src_width);
-  g_value_set_int (gimp_value_array_index (args, 4), src_height);
-  g_value_set_int (gimp_value_array_index (args, 5), dest_width);
-  g_value_set_int (gimp_value_array_index (args, 6), dest_height);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1224,13 +1201,11 @@ gimp_drawable_foreground_extract (gint32                    drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          GIMP_TYPE_FOREGROUND_EXTRACT_MODE,
-                                          GIMP_TYPE_DRAWABLE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_FOREGROUND_EXTRACT_MODE, mode,
+                                          GIMP_TYPE_DRAWABLE_ID, mask_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), mode);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 2), mask_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimpdrawablecolor_pdb.c b/libgimp/gimpdrawablecolor_pdb.c
index 5db2fbaa53..cb5dbe7dd1 100644
--- a/libgimp/gimpdrawablecolor_pdb.c
+++ b/libgimp/gimpdrawablecolor_pdb.c
@@ -61,13 +61,11 @@ gimp_drawable_brightness_contrast (gint32  drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          G_TYPE_DOUBLE, brightness,
+                                          G_TYPE_DOUBLE, contrast,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_double (gimp_value_array_index (args, 1), brightness);
-  g_value_set_double (gimp_value_array_index (args, 2), contrast);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -122,19 +120,14 @@ gimp_drawable_color_balance (gint32           drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          GIMP_TYPE_TRANSFER_MODE,
-                                          G_TYPE_BOOLEAN,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_TRANSFER_MODE, transfer_mode,
+                                          G_TYPE_BOOLEAN, preserve_lum,
+                                          G_TYPE_DOUBLE, cyan_red,
+                                          G_TYPE_DOUBLE, magenta_green,
+                                          G_TYPE_DOUBLE, yellow_blue,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), transfer_mode);
-  g_value_set_boolean (gimp_value_array_index (args, 2), preserve_lum);
-  g_value_set_double (gimp_value_array_index (args, 3), cyan_red);
-  g_value_set_double (gimp_value_array_index (args, 4), magenta_green);
-  g_value_set_double (gimp_value_array_index (args, 5), yellow_blue);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -181,15 +174,12 @@ gimp_drawable_colorize_hsl (gint32  drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          G_TYPE_DOUBLE, hue,
+                                          G_TYPE_DOUBLE, saturation,
+                                          G_TYPE_DOUBLE, lightness,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_double (gimp_value_array_index (args, 1), hue);
-  g_value_set_double (gimp_value_array_index (args, 2), saturation);
-  g_value_set_double (gimp_value_array_index (args, 3), lightness);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -238,14 +228,12 @@ gimp_drawable_curves_explicit (gint32                drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          GIMP_TYPE_HISTOGRAM_CHANNEL,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_FLOAT_ARRAY,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_HISTOGRAM_CHANNEL, channel,
+                                          GIMP_TYPE_INT32, num_values,
+                                          GIMP_TYPE_FLOAT_ARRAY, NULL,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), channel);
-  g_value_set_int (gimp_value_array_index (args, 2), num_values);
   gimp_value_set_float_array (gimp_value_array_index (args, 3), values, num_values);
 
   if (pdb)
@@ -295,14 +283,12 @@ gimp_drawable_curves_spline (gint32                drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          GIMP_TYPE_HISTOGRAM_CHANNEL,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_FLOAT_ARRAY,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_HISTOGRAM_CHANNEL, channel,
+                                          GIMP_TYPE_INT32, num_points,
+                                          GIMP_TYPE_FLOAT_ARRAY, NULL,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), channel);
-  g_value_set_int (gimp_value_array_index (args, 2), num_points);
   gimp_value_set_float_array (gimp_value_array_index (args, 3), points, num_points);
 
   if (pdb)
@@ -346,11 +332,10 @@ gimp_drawable_desaturate (gint32             drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          GIMP_TYPE_DESATURATE_MODE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_DESATURATE_MODE, desaturate_mode,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), desaturate_mode);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -396,11 +381,10 @@ gimp_drawable_equalize (gint32   drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          G_TYPE_BOOLEAN,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          G_TYPE_BOOLEAN, mask_only,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_boolean (gimp_value_array_index (args, 1), mask_only);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -471,15 +455,12 @@ gimp_drawable_histogram (gint32                drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          GIMP_TYPE_HISTOGRAM_CHANNEL,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_HISTOGRAM_CHANNEL, channel,
+                                          G_TYPE_DOUBLE, start_range,
+                                          G_TYPE_DOUBLE, end_range,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), channel);
-  g_value_set_double (gimp_value_array_index (args, 2), start_range);
-  g_value_set_double (gimp_value_array_index (args, 3), end_range);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -548,19 +529,14 @@ gimp_drawable_hue_saturation (gint32       drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          GIMP_TYPE_HUE_RANGE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_HUE_RANGE, hue_range,
+                                          G_TYPE_DOUBLE, hue_offset,
+                                          G_TYPE_DOUBLE, lightness,
+                                          G_TYPE_DOUBLE, saturation,
+                                          G_TYPE_DOUBLE, overlap,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), hue_range);
-  g_value_set_double (gimp_value_array_index (args, 2), hue_offset);
-  g_value_set_double (gimp_value_array_index (args, 3), lightness);
-  g_value_set_double (gimp_value_array_index (args, 4), saturation);
-  g_value_set_double (gimp_value_array_index (args, 5), overlap);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -603,11 +579,10 @@ gimp_drawable_invert (gint32   drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          G_TYPE_BOOLEAN,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          G_TYPE_BOOLEAN, linear,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_boolean (gimp_value_array_index (args, 1), linear);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -672,25 +647,17 @@ gimp_drawable_levels (gint32               drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          GIMP_TYPE_HISTOGRAM_CHANNEL,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_BOOLEAN,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_BOOLEAN,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_HISTOGRAM_CHANNEL, channel,
+                                          G_TYPE_DOUBLE, low_input,
+                                          G_TYPE_DOUBLE, high_input,
+                                          G_TYPE_BOOLEAN, clamp_input,
+                                          G_TYPE_DOUBLE, gamma,
+                                          G_TYPE_DOUBLE, low_output,
+                                          G_TYPE_DOUBLE, high_output,
+                                          G_TYPE_BOOLEAN, clamp_output,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), channel);
-  g_value_set_double (gimp_value_array_index (args, 2), low_input);
-  g_value_set_double (gimp_value_array_index (args, 3), high_input);
-  g_value_set_boolean (gimp_value_array_index (args, 4), clamp_input);
-  g_value_set_double (gimp_value_array_index (args, 5), gamma);
-  g_value_set_double (gimp_value_array_index (args, 6), low_output);
-  g_value_set_double (gimp_value_array_index (args, 7), high_output);
-  g_value_set_boolean (gimp_value_array_index (args, 8), clamp_output);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -730,9 +697,9 @@ gimp_drawable_levels_stretch (gint32 drawable_ID)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -773,11 +740,10 @@ gimp_drawable_posterize (gint32 drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_INT32, levels,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), levels);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -824,15 +790,12 @@ gimp_drawable_threshold (gint32               drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          GIMP_TYPE_HISTOGRAM_CHANNEL,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_HISTOGRAM_CHANNEL, channel,
+                                          G_TYPE_DOUBLE, low_threshold,
+                                          G_TYPE_DOUBLE, high_threshold,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), channel);
-  g_value_set_double (gimp_value_array_index (args, 2), low_threshold);
-  g_value_set_double (gimp_value_array_index (args, 3), high_threshold);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimpdrawableedit_pdb.c b/libgimp/gimpdrawableedit_pdb.c
index 0b90e0f0d8..de60fbe5dc 100644
--- a/libgimp/gimpdrawableedit_pdb.c
+++ b/libgimp/gimpdrawableedit_pdb.c
@@ -59,9 +59,9 @@ gimp_drawable_edit_clear (gint32 drawable_ID)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -107,11 +107,10 @@ gimp_drawable_edit_fill (gint32       drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          GIMP_TYPE_FILL_TYPE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_FILL_TYPE, fill_type,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), fill_type);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -167,15 +166,12 @@ gimp_drawable_edit_bucket_fill (gint32       drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          GIMP_TYPE_FILL_TYPE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_FILL_TYPE, fill_type,
+                                          G_TYPE_DOUBLE, x,
+                                          G_TYPE_DOUBLE, y,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), fill_type);
-  g_value_set_double (gimp_value_array_index (args, 2), x);
-  g_value_set_double (gimp_value_array_index (args, 3), y);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -244,29 +240,19 @@ gimp_drawable_edit_gradient_fill (gint32           drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          GIMP_TYPE_GRADIENT_TYPE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_BOOLEAN,
-                                          GIMP_TYPE_INT32,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_BOOLEAN,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_GRADIENT_TYPE, gradient_type,
+                                          G_TYPE_DOUBLE, offset,
+                                          G_TYPE_BOOLEAN, supersample,
+                                          GIMP_TYPE_INT32, supersample_max_depth,
+                                          G_TYPE_DOUBLE, supersample_threshold,
+                                          G_TYPE_BOOLEAN, dither,
+                                          G_TYPE_DOUBLE, x1,
+                                          G_TYPE_DOUBLE, y1,
+                                          G_TYPE_DOUBLE, x2,
+                                          G_TYPE_DOUBLE, y2,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), gradient_type);
-  g_value_set_double (gimp_value_array_index (args, 2), offset);
-  g_value_set_boolean (gimp_value_array_index (args, 3), supersample);
-  g_value_set_int (gimp_value_array_index (args, 4), supersample_max_depth);
-  g_value_set_double (gimp_value_array_index (args, 5), supersample_threshold);
-  g_value_set_boolean (gimp_value_array_index (args, 6), dither);
-  g_value_set_double (gimp_value_array_index (args, 7), x1);
-  g_value_set_double (gimp_value_array_index (args, 8), y1);
-  g_value_set_double (gimp_value_array_index (args, 9), x2);
-  g_value_set_double (gimp_value_array_index (args, 10), y2);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -313,9 +299,9 @@ gimp_drawable_edit_stroke_selection (gint32 drawable_ID)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -366,11 +352,10 @@ gimp_drawable_edit_stroke_item (gint32 drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          GIMP_TYPE_ITEM_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  gimp_value_set_item_id (gimp_value_array_index (args, 1), item_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimpdynamics_pdb.c b/libgimp/gimpdynamics_pdb.c
index 7367e9bcec..749327e08b 100644
--- a/libgimp/gimpdynamics_pdb.c
+++ b/libgimp/gimpdynamics_pdb.c
@@ -55,7 +55,8 @@ gimp_dynamics_refresh (void)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -98,9 +99,9 @@ gimp_dynamics_get_list (const gchar *filter,
   GimpValueArray *return_vals;
   gchar **dynamics_list = NULL;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, filter,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), filter);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimpedit_pdb.c b/libgimp/gimpedit_pdb.c
index 37d2130a8f..3b33d07a4e 100644
--- a/libgimp/gimpedit_pdb.c
+++ b/libgimp/gimpedit_pdb.c
@@ -59,9 +59,9 @@ gimp_edit_cut (gint32 drawable_ID)
   GimpValueArray *return_vals;
   gboolean non_empty = FALSE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -105,9 +105,9 @@ gimp_edit_copy (gint32 drawable_ID)
   GimpValueArray *return_vals;
   gboolean non_empty = FALSE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -151,9 +151,9 @@ gimp_edit_copy_visible (gint32 image_ID)
   GimpValueArray *return_vals;
   gboolean non_empty = FALSE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -206,11 +206,10 @@ gimp_edit_paste (gint32   drawable_ID,
   GimpValueArray *return_vals;
   gint32 floating_sel_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          G_TYPE_BOOLEAN,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          G_TYPE_BOOLEAN, paste_into,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_boolean (gimp_value_array_index (args, 1), paste_into);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -251,7 +250,8 @@ gimp_edit_paste_as_new_image (void)
   GimpValueArray *return_vals;
   gint32 image_ID = -1;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -297,11 +297,10 @@ gimp_edit_named_cut (gint32       drawable_ID,
   GimpValueArray *return_vals;
   gchar *real_name = NULL;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          G_TYPE_STRING, buffer_name,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_string (gimp_value_array_index (args, 1), buffer_name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -347,11 +346,10 @@ gimp_edit_named_copy (gint32       drawable_ID,
   GimpValueArray *return_vals;
   gchar *real_name = NULL;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          G_TYPE_STRING, buffer_name,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_string (gimp_value_array_index (args, 1), buffer_name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -397,11 +395,10 @@ gimp_edit_named_copy_visible (gint32       image_ID,
   GimpValueArray *return_vals;
   gchar *real_name = NULL;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_STRING, buffer_name,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_string (gimp_value_array_index (args, 1), buffer_name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -445,13 +442,11 @@ gimp_edit_named_paste (gint32       drawable_ID,
   GimpValueArray *return_vals;
   gint32 floating_sel_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          G_TYPE_STRING,
-                                          G_TYPE_BOOLEAN,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          G_TYPE_STRING, buffer_name,
+                                          G_TYPE_BOOLEAN, paste_into,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_string (gimp_value_array_index (args, 1), buffer_name);
-  g_value_set_boolean (gimp_value_array_index (args, 2), paste_into);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -491,9 +486,9 @@ gimp_edit_named_paste_as_new_image (const gchar *buffer_name)
   GimpValueArray *return_vals;
   gint32 image_ID = -1;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, buffer_name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), buffer_name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimpfileops_pdb.c b/libgimp/gimpfileops_pdb.c
index 16de78cf60..2aa664f7bd 100644
--- a/libgimp/gimpfileops_pdb.c
+++ b/libgimp/gimpfileops_pdb.c
@@ -62,13 +62,11 @@ gimp_file_load (GimpRunMode  run_mode,
   GimpValueArray *return_vals;
   gint32 image_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_RUN_MODE,
-                                          G_TYPE_STRING,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_RUN_MODE, run_mode,
+                                          G_TYPE_STRING, filename,
+                                          G_TYPE_STRING, raw_filename,
                                           G_TYPE_NONE);
-  g_value_set_enum (gimp_value_array_index (args, 0), run_mode);
-  g_value_set_string (gimp_value_array_index (args, 1), filename);
-  g_value_set_string (gimp_value_array_index (args, 2), raw_filename);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -114,13 +112,11 @@ gimp_file_load_layer (GimpRunMode  run_mode,
   GimpValueArray *return_vals;
   gint32 layer_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_RUN_MODE,
-                                          GIMP_TYPE_IMAGE_ID,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_RUN_MODE, run_mode,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_STRING, filename,
                                           G_TYPE_NONE);
-  g_value_set_enum (gimp_value_array_index (args, 0), run_mode);
-  gimp_value_set_image_id (gimp_value_array_index (args, 1), image_ID);
-  g_value_set_string (gimp_value_array_index (args, 2), filename);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -170,13 +166,11 @@ gimp_file_load_layers (GimpRunMode  run_mode,
   GimpValueArray *return_vals;
   gint *layer_ids = NULL;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_RUN_MODE,
-                                          GIMP_TYPE_IMAGE_ID,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_RUN_MODE, run_mode,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_STRING, filename,
                                           G_TYPE_NONE);
-  g_value_set_enum (gimp_value_array_index (args, 0), run_mode);
-  gimp_value_set_image_id (gimp_value_array_index (args, 1), image_ID);
-  g_value_set_string (gimp_value_array_index (args, 2), filename);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -232,17 +226,13 @@ gimp_file_save (GimpRunMode  run_mode,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_RUN_MODE,
-                                          GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_DRAWABLE_ID,
-                                          G_TYPE_STRING,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_RUN_MODE, run_mode,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          G_TYPE_STRING, filename,
+                                          G_TYPE_STRING, raw_filename,
                                           G_TYPE_NONE);
-  g_value_set_enum (gimp_value_array_index (args, 0), run_mode);
-  gimp_value_set_image_id (gimp_value_array_index (args, 1), image_ID);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 2), drawable_ID);
-  g_value_set_string (gimp_value_array_index (args, 3), filename);
-  g_value_set_string (gimp_value_array_index (args, 4), raw_filename);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -285,11 +275,10 @@ gimp_file_save_thumbnail (gint32       image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_STRING, filename,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_string (gimp_value_array_index (args, 1), filename);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -332,15 +321,12 @@ gimp_register_magic_load_handler (const gchar *procedure_name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          G_TYPE_STRING,
-                                          G_TYPE_STRING,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, procedure_name,
+                                          G_TYPE_STRING, extensions,
+                                          G_TYPE_STRING, prefixes,
+                                          G_TYPE_STRING, magics,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), procedure_name);
-  g_value_set_string (gimp_value_array_index (args, 1), extensions);
-  g_value_set_string (gimp_value_array_index (args, 2), prefixes);
-  g_value_set_string (gimp_value_array_index (args, 3), magics);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -381,13 +367,11 @@ gimp_register_load_handler (const gchar *procedure_name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          G_TYPE_STRING,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, procedure_name,
+                                          G_TYPE_STRING, extensions,
+                                          G_TYPE_STRING, prefixes,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), procedure_name);
-  g_value_set_string (gimp_value_array_index (args, 1), extensions);
-  g_value_set_string (gimp_value_array_index (args, 2), prefixes);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -428,13 +412,11 @@ gimp_register_save_handler (const gchar *procedure_name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          G_TYPE_STRING,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, procedure_name,
+                                          G_TYPE_STRING, extensions,
+                                          G_TYPE_STRING, prefixes,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), procedure_name);
-  g_value_set_string (gimp_value_array_index (args, 1), extensions);
-  g_value_set_string (gimp_value_array_index (args, 2), prefixes);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -478,11 +460,10 @@ gimp_register_file_handler_priority (const gchar *procedure_name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, procedure_name,
+                                          GIMP_TYPE_INT32, priority,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), procedure_name);
-  g_value_set_int (gimp_value_array_index (args, 1), priority);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -527,11 +508,10 @@ gimp_register_file_handler_mime (const gchar *procedure_name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, procedure_name,
+                                          G_TYPE_STRING, mime_types,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), procedure_name);
-  g_value_set_string (gimp_value_array_index (args, 1), mime_types);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -572,9 +552,9 @@ gimp_register_file_handler_uri (const gchar *procedure_name)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, procedure_name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), procedure_name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -615,9 +595,9 @@ gimp_register_file_handler_raw (const gchar *procedure_name)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, procedure_name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), procedure_name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -662,11 +642,10 @@ gimp_register_thumbnail_loader (const gchar *load_proc,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, load_proc,
+                                          G_TYPE_STRING, thumb_proc,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), load_proc);
-  g_value_set_string (gimp_value_array_index (args, 1), thumb_proc);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimpfloatingsel_pdb.c b/libgimp/gimpfloatingsel_pdb.c
index c996210577..29c1b77ee3 100644
--- a/libgimp/gimpfloatingsel_pdb.c
+++ b/libgimp/gimpfloatingsel_pdb.c
@@ -54,9 +54,9 @@ gimp_floating_sel_remove (gint32 floating_sel_ID)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, floating_sel_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), floating_sel_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -95,9 +95,9 @@ gimp_floating_sel_anchor (gint32 floating_sel_ID)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, floating_sel_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), floating_sel_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -140,9 +140,9 @@ gimp_floating_sel_to_layer (gint32 floating_sel_ID)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, floating_sel_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), floating_sel_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -181,11 +181,10 @@ gimp_floating_sel_attach (gint32 layer_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
-                                          GIMP_TYPE_DRAWABLE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 1), drawable_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimpfonts_pdb.c b/libgimp/gimpfonts_pdb.c
index ee407238f9..99205b6558 100644
--- a/libgimp/gimpfonts_pdb.c
+++ b/libgimp/gimpfonts_pdb.c
@@ -53,7 +53,8 @@ gimp_fonts_refresh (void)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -94,9 +95,9 @@ gimp_fonts_get_list (const gchar *filter,
   GimpValueArray *return_vals;
   gchar **font_list = NULL;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, filter,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), filter);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimpfontselect_pdb.c b/libgimp/gimpfontselect_pdb.c
index 159f26c227..237bc8b705 100644
--- a/libgimp/gimpfontselect_pdb.c
+++ b/libgimp/gimpfontselect_pdb.c
@@ -56,13 +56,11 @@ gimp_fonts_popup (const gchar *font_callback,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          G_TYPE_STRING,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, font_callback,
+                                          G_TYPE_STRING, popup_title,
+                                          G_TYPE_STRING, initial_font,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), font_callback);
-  g_value_set_string (gimp_value_array_index (args, 1), popup_title);
-  g_value_set_string (gimp_value_array_index (args, 2), initial_font);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -98,9 +96,9 @@ gimp_fonts_close_popup (const gchar *font_callback)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, font_callback,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), font_callback);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -138,11 +136,10 @@ gimp_fonts_set_popup (const gchar *font_callback,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, font_callback,
+                                          G_TYPE_STRING, font_name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), font_callback);
-  g_value_set_string (gimp_value_array_index (args, 1), font_name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimpgimprc_pdb.c b/libgimp/gimpgimprc_pdb.c
index 58f21e09cb..a32594e311 100644
--- a/libgimp/gimpgimprc_pdb.c
+++ b/libgimp/gimpgimprc_pdb.c
@@ -61,9 +61,9 @@ gimp_gimprc_query (const gchar *token)
   GimpValueArray *return_vals;
   gchar *value = NULL;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, token,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), token);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -106,11 +106,10 @@ gimp_gimprc_set (const gchar *token,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, token,
+                                          G_TYPE_STRING, value,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), token);
-  g_value_set_string (gimp_value_array_index (args, 1), value);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -146,7 +145,8 @@ gimp_get_default_comment (void)
   GimpValueArray *return_vals;
   gchar *comment = NULL;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -184,7 +184,8 @@ gimp_get_default_unit (void)
   GimpValueArray *return_vals;
   GimpUnit unit_id = 0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -226,7 +227,8 @@ gimp_get_monitor_resolution (gdouble *xres,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -274,7 +276,8 @@ _gimp_get_color_configuration (void)
   GimpValueArray *return_vals;
   gchar *config = NULL;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -311,7 +314,8 @@ gimp_get_module_load_inhibit (void)
   GimpValueArray *return_vals;
   gchar *load_inhibit = NULL;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimpgradient_pdb.c b/libgimp/gimpgradient_pdb.c
index 1d13f66e8b..e2c9a201fd 100644
--- a/libgimp/gimpgradient_pdb.c
+++ b/libgimp/gimpgradient_pdb.c
@@ -55,9 +55,9 @@ gimp_gradient_new (const gchar *name)
   GimpValueArray *return_vals;
   gchar *actual_name = NULL;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -97,9 +97,9 @@ gimp_gradient_duplicate (const gchar *name)
   GimpValueArray *return_vals;
   gchar *copy_name = NULL;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -138,9 +138,9 @@ gimp_gradient_is_editable (const gchar *name)
   GimpValueArray *return_vals;
   gboolean editable = FALSE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -182,11 +182,10 @@ gimp_gradient_rename (const gchar *name,
   GimpValueArray *return_vals;
   gchar *actual_name = NULL;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
+                                          G_TYPE_STRING, new_name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
-  g_value_set_string (gimp_value_array_index (args, 1), new_name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -225,9 +224,9 @@ gimp_gradient_delete (const gchar *name)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -266,9 +265,9 @@ gimp_gradient_get_number_of_segments (const gchar *name)
   GimpValueArray *return_vals;
   gint num_segments = 0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -321,13 +320,11 @@ gimp_gradient_get_uniform_samples (const gchar  *name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          GIMP_TYPE_INT32,
-                                          G_TYPE_BOOLEAN,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
+                                          GIMP_TYPE_INT32, num_samples,
+                                          G_TYPE_BOOLEAN, reverse,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
-  g_value_set_int (gimp_value_array_index (args, 1), num_samples);
-  g_value_set_boolean (gimp_value_array_index (args, 2), reverse);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -389,15 +386,13 @@ gimp_gradient_get_custom_samples (const gchar    *name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_FLOAT_ARRAY,
-                                          G_TYPE_BOOLEAN,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
+                                          GIMP_TYPE_INT32, num_samples,
+                                          GIMP_TYPE_FLOAT_ARRAY, NULL,
+                                          G_TYPE_BOOLEAN, reverse,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
-  g_value_set_int (gimp_value_array_index (args, 1), num_samples);
   gimp_value_set_float_array (gimp_value_array_index (args, 2), positions, num_samples);
-  g_value_set_boolean (gimp_value_array_index (args, 3), reverse);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -451,11 +446,10 @@ gimp_gradient_segment_get_left_color (const gchar *name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
+                                          GIMP_TYPE_INT32, segment,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
-  g_value_set_int (gimp_value_array_index (args, 1), segment);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -508,15 +502,12 @@ gimp_gradient_segment_set_left_color (const gchar   *name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_RGB,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
+                                          GIMP_TYPE_INT32, segment,
+                                          GIMP_TYPE_RGB, color,
+                                          G_TYPE_DOUBLE, opacity,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
-  g_value_set_int (gimp_value_array_index (args, 1), segment);
-  gimp_value_set_rgb (gimp_value_array_index (args, 2), color);
-  g_value_set_double (gimp_value_array_index (args, 3), opacity);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -561,11 +552,10 @@ gimp_gradient_segment_get_right_color (const gchar *name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
+                                          GIMP_TYPE_INT32, segment,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
-  g_value_set_int (gimp_value_array_index (args, 1), segment);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -618,15 +608,12 @@ gimp_gradient_segment_set_right_color (const gchar   *name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_RGB,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
+                                          GIMP_TYPE_INT32, segment,
+                                          GIMP_TYPE_RGB, color,
+                                          G_TYPE_DOUBLE, opacity,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
-  g_value_set_int (gimp_value_array_index (args, 1), segment);
-  gimp_value_set_rgb (gimp_value_array_index (args, 2), color);
-  g_value_set_double (gimp_value_array_index (args, 3), opacity);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -669,11 +656,10 @@ gimp_gradient_segment_get_left_pos (const gchar *name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
+                                          GIMP_TYPE_INT32, segment,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
-  g_value_set_int (gimp_value_array_index (args, 1), segment);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -726,13 +712,11 @@ gimp_gradient_segment_set_left_pos (const gchar *name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          GIMP_TYPE_INT32,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
+                                          GIMP_TYPE_INT32, segment,
+                                          G_TYPE_DOUBLE, pos,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
-  g_value_set_int (gimp_value_array_index (args, 1), segment);
-  g_value_set_double (gimp_value_array_index (args, 2), pos);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -780,11 +764,10 @@ gimp_gradient_segment_get_middle_pos (const gchar *name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
+                                          GIMP_TYPE_INT32, segment,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
-  g_value_set_int (gimp_value_array_index (args, 1), segment);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -836,13 +819,11 @@ gimp_gradient_segment_set_middle_pos (const gchar *name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          GIMP_TYPE_INT32,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
+                                          GIMP_TYPE_INT32, segment,
+                                          G_TYPE_DOUBLE, pos,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
-  g_value_set_int (gimp_value_array_index (args, 1), segment);
-  g_value_set_double (gimp_value_array_index (args, 2), pos);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -890,11 +871,10 @@ gimp_gradient_segment_get_right_pos (const gchar *name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
+                                          GIMP_TYPE_INT32, segment,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
-  g_value_set_int (gimp_value_array_index (args, 1), segment);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -947,13 +927,11 @@ gimp_gradient_segment_set_right_pos (const gchar *name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          GIMP_TYPE_INT32,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
+                                          GIMP_TYPE_INT32, segment,
+                                          G_TYPE_DOUBLE, pos,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
-  g_value_set_int (gimp_value_array_index (args, 1), segment);
-  g_value_set_double (gimp_value_array_index (args, 2), pos);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1001,11 +979,10 @@ gimp_gradient_segment_get_blending_function (const gchar             *name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
+                                          GIMP_TYPE_INT32, segment,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
-  g_value_set_int (gimp_value_array_index (args, 1), segment);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1053,11 +1030,10 @@ gimp_gradient_segment_get_coloring_type (const gchar              *name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
+                                          GIMP_TYPE_INT32, segment,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
-  g_value_set_int (gimp_value_array_index (args, 1), segment);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1107,15 +1083,12 @@ gimp_gradient_segment_range_set_blending_function (const gchar             *name
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_GRADIENT_SEGMENT_TYPE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
+                                          GIMP_TYPE_INT32, start_segment,
+                                          GIMP_TYPE_INT32, end_segment,
+                                          GIMP_TYPE_GRADIENT_SEGMENT_TYPE, blending_function,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
-  g_value_set_int (gimp_value_array_index (args, 1), start_segment);
-  g_value_set_int (gimp_value_array_index (args, 2), end_segment);
-  g_value_set_enum (gimp_value_array_index (args, 3), blending_function);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1160,15 +1133,12 @@ gimp_gradient_segment_range_set_coloring_type (const gchar              *name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_GRADIENT_SEGMENT_COLOR,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
+                                          GIMP_TYPE_INT32, start_segment,
+                                          GIMP_TYPE_INT32, end_segment,
+                                          GIMP_TYPE_GRADIENT_SEGMENT_COLOR, coloring_type,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
-  g_value_set_int (gimp_value_array_index (args, 1), start_segment);
-  g_value_set_int (gimp_value_array_index (args, 2), end_segment);
-  g_value_set_enum (gimp_value_array_index (args, 3), coloring_type);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1210,13 +1180,11 @@ gimp_gradient_segment_range_flip (const gchar *name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
+                                          GIMP_TYPE_INT32, start_segment,
+                                          GIMP_TYPE_INT32, end_segment,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
-  g_value_set_int (gimp_value_array_index (args, 1), start_segment);
-  g_value_set_int (gimp_value_array_index (args, 2), end_segment);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1262,15 +1230,12 @@ gimp_gradient_segment_range_replicate (const gchar *name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
+                                          GIMP_TYPE_INT32, start_segment,
+                                          GIMP_TYPE_INT32, end_segment,
+                                          GIMP_TYPE_INT32, replicate_times,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
-  g_value_set_int (gimp_value_array_index (args, 1), start_segment);
-  g_value_set_int (gimp_value_array_index (args, 2), end_segment);
-  g_value_set_int (gimp_value_array_index (args, 3), replicate_times);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1313,13 +1278,11 @@ gimp_gradient_segment_range_split_midpoint (const gchar *name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
+                                          GIMP_TYPE_INT32, start_segment,
+                                          GIMP_TYPE_INT32, end_segment,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
-  g_value_set_int (gimp_value_array_index (args, 1), start_segment);
-  g_value_set_int (gimp_value_array_index (args, 2), end_segment);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1364,15 +1327,12 @@ gimp_gradient_segment_range_split_uniform (const gchar *name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
+                                          GIMP_TYPE_INT32, start_segment,
+                                          GIMP_TYPE_INT32, end_segment,
+                                          GIMP_TYPE_INT32, split_parts,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
-  g_value_set_int (gimp_value_array_index (args, 1), start_segment);
-  g_value_set_int (gimp_value_array_index (args, 2), end_segment);
-  g_value_set_int (gimp_value_array_index (args, 3), split_parts);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1414,13 +1374,11 @@ gimp_gradient_segment_range_delete (const gchar *name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
+                                          GIMP_TYPE_INT32, start_segment,
+                                          GIMP_TYPE_INT32, end_segment,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
-  g_value_set_int (gimp_value_array_index (args, 1), start_segment);
-  g_value_set_int (gimp_value_array_index (args, 2), end_segment);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1463,13 +1421,11 @@ gimp_gradient_segment_range_redistribute_handles (const gchar *name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
+                                          GIMP_TYPE_INT32, start_segment,
+                                          GIMP_TYPE_INT32, end_segment,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
-  g_value_set_int (gimp_value_array_index (args, 1), start_segment);
-  g_value_set_int (gimp_value_array_index (args, 2), end_segment);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1513,13 +1469,11 @@ gimp_gradient_segment_range_blend_colors (const gchar *name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
+                                          GIMP_TYPE_INT32, start_segment,
+                                          GIMP_TYPE_INT32, end_segment,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
-  g_value_set_int (gimp_value_array_index (args, 1), start_segment);
-  g_value_set_int (gimp_value_array_index (args, 2), end_segment);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1563,13 +1517,11 @@ gimp_gradient_segment_range_blend_opacity (const gchar *name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
+                                          GIMP_TYPE_INT32, start_segment,
+                                          GIMP_TYPE_INT32, end_segment,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
-  g_value_set_int (gimp_value_array_index (args, 1), start_segment);
-  g_value_set_int (gimp_value_array_index (args, 2), end_segment);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1617,17 +1569,13 @@ gimp_gradient_segment_range_move (const gchar *name,
   GimpValueArray *return_vals;
   gdouble final_delta = 0.0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_BOOLEAN,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
+                                          GIMP_TYPE_INT32, start_segment,
+                                          GIMP_TYPE_INT32, end_segment,
+                                          G_TYPE_DOUBLE, delta,
+                                          G_TYPE_BOOLEAN, control_compress,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
-  g_value_set_int (gimp_value_array_index (args, 1), start_segment);
-  g_value_set_int (gimp_value_array_index (args, 2), end_segment);
-  g_value_set_double (gimp_value_array_index (args, 3), delta);
-  g_value_set_boolean (gimp_value_array_index (args, 4), control_compress);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimpgradients_pdb.c b/libgimp/gimpgradients_pdb.c
index ad6331bcd6..683e879cd2 100644
--- a/libgimp/gimpgradients_pdb.c
+++ b/libgimp/gimpgradients_pdb.c
@@ -52,7 +52,8 @@ gimp_gradients_refresh (void)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -94,9 +95,9 @@ gimp_gradients_get_list (const gchar *filter,
   GimpValueArray *return_vals;
   gchar **gradient_list = NULL;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, filter,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), filter);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimpgradientselect_pdb.c b/libgimp/gimpgradientselect_pdb.c
index 8c9508c666..ee55d1ddbf 100644
--- a/libgimp/gimpgradientselect_pdb.c
+++ b/libgimp/gimpgradientselect_pdb.c
@@ -58,15 +58,12 @@ gimp_gradients_popup (const gchar *gradient_callback,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          G_TYPE_STRING,
-                                          G_TYPE_STRING,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, gradient_callback,
+                                          G_TYPE_STRING, popup_title,
+                                          G_TYPE_STRING, initial_gradient,
+                                          GIMP_TYPE_INT32, sample_size,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), gradient_callback);
-  g_value_set_string (gimp_value_array_index (args, 1), popup_title);
-  g_value_set_string (gimp_value_array_index (args, 2), initial_gradient);
-  g_value_set_int (gimp_value_array_index (args, 3), sample_size);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -102,9 +99,9 @@ gimp_gradients_close_popup (const gchar *gradient_callback)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, gradient_callback,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), gradient_callback);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -142,11 +139,10 @@ gimp_gradients_set_popup (const gchar *gradient_callback,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, gradient_callback,
+                                          G_TYPE_STRING, gradient_name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), gradient_callback);
-  g_value_set_string (gimp_value_array_index (args, 1), gradient_name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimphelp_pdb.c b/libgimp/gimphelp_pdb.c
index a28187fde3..66cb5d5f6e 100644
--- a/libgimp/gimphelp_pdb.c
+++ b/libgimp/gimphelp_pdb.c
@@ -59,11 +59,10 @@ gimp_help (const gchar *help_domain,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, help_domain,
+                                          G_TYPE_STRING, help_id,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), help_domain);
-  g_value_set_string (gimp_value_array_index (args, 1), help_id);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimpimage_pdb.c b/libgimp/gimpimage_pdb.c
index bb291c7f3e..4a81f6817d 100644
--- a/libgimp/gimpimage_pdb.c
+++ b/libgimp/gimpimage_pdb.c
@@ -56,9 +56,9 @@ gimp_image_is_valid (gint32 image_ID)
   GimpValueArray *return_vals;
   gboolean valid = FALSE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -97,7 +97,8 @@ gimp_image_list (gint *num_images)
   GimpValueArray *return_vals;
   gint *image_ids = NULL;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -152,13 +153,11 @@ gimp_image_new (gint              width,
   GimpValueArray *return_vals;
   gint32 image_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_IMAGE_BASE_TYPE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_INT32, width,
+                                          GIMP_TYPE_INT32, height,
+                                          GIMP_TYPE_IMAGE_BASE_TYPE, type,
                                           G_TYPE_NONE);
-  g_value_set_int (gimp_value_array_index (args, 0), width);
-  g_value_set_int (gimp_value_array_index (args, 1), height);
-  g_value_set_enum (gimp_value_array_index (args, 2), type);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -207,15 +206,12 @@ gimp_image_new_with_precision (gint              width,
   GimpValueArray *return_vals;
   gint32 image_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_IMAGE_BASE_TYPE,
-                                          GIMP_TYPE_PRECISION,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_INT32, width,
+                                          GIMP_TYPE_INT32, height,
+                                          GIMP_TYPE_IMAGE_BASE_TYPE, type,
+                                          GIMP_TYPE_PRECISION, precision,
                                           G_TYPE_NONE);
-  g_value_set_int (gimp_value_array_index (args, 0), width);
-  g_value_set_int (gimp_value_array_index (args, 1), height);
-  g_value_set_enum (gimp_value_array_index (args, 2), type);
-  g_value_set_enum (gimp_value_array_index (args, 3), precision);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -253,9 +249,9 @@ gimp_image_duplicate (gint32 image_ID)
   GimpValueArray *return_vals;
   gint32 new_image_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -297,9 +293,9 @@ gimp_image_delete (gint32 image_ID)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -336,9 +332,9 @@ gimp_image_base_type (gint32 image_ID)
   GimpValueArray *return_vals;
   GimpImageBaseType base_type = 0;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -377,9 +373,9 @@ gimp_image_get_precision (gint32 image_ID)
   GimpValueArray *return_vals;
   GimpPrecision precision = 0;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -418,9 +414,9 @@ gimp_image_get_default_new_layer_mode (gint32 image_ID)
   GimpValueArray *return_vals;
   GimpLayerMode mode = 0;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -458,9 +454,9 @@ gimp_image_width (gint32 image_ID)
   GimpValueArray *return_vals;
   gint width = 0;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -498,9 +494,9 @@ gimp_image_height (gint32 image_ID)
   GimpValueArray *return_vals;
   gint height = 0;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -542,9 +538,9 @@ gimp_image_get_layers (gint32  image_ID,
   GimpValueArray *return_vals;
   gint *layer_ids = NULL;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -594,9 +590,9 @@ gimp_image_get_channels (gint32  image_ID,
   GimpValueArray *return_vals;
   gint *channel_ids = NULL;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -645,9 +641,9 @@ gimp_image_get_vectors (gint32  image_ID,
   GimpValueArray *return_vals;
   gint *vector_ids = NULL;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -694,9 +690,9 @@ gimp_image_get_active_drawable (gint32 image_ID)
   GimpValueArray *return_vals;
   gint32 drawable_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -736,9 +732,9 @@ gimp_image_unset_active_channel (gint32 image_ID)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -775,9 +771,9 @@ gimp_image_get_floating_sel (gint32 image_ID)
   GimpValueArray *return_vals;
   gint32 floating_sel_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -816,9 +812,9 @@ gimp_image_floating_sel_attached_to (gint32 image_ID)
   GimpValueArray *return_vals;
   gint32 drawable_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -879,21 +875,15 @@ gimp_image_pick_color (gint32    image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_DRAWABLE_ID,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_BOOLEAN,
-                                          G_TYPE_BOOLEAN,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          G_TYPE_DOUBLE, x,
+                                          G_TYPE_DOUBLE, y,
+                                          G_TYPE_BOOLEAN, sample_merged,
+                                          G_TYPE_BOOLEAN, sample_average,
+                                          G_TYPE_DOUBLE, average_radius,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 1), drawable_ID);
-  g_value_set_double (gimp_value_array_index (args, 2), x);
-  g_value_set_double (gimp_value_array_index (args, 3), y);
-  g_value_set_boolean (gimp_value_array_index (args, 4), sample_merged);
-  g_value_set_boolean (gimp_value_array_index (args, 5), sample_average);
-  g_value_set_double (gimp_value_array_index (args, 6), average_radius);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -940,13 +930,11 @@ gimp_image_pick_correlate_layer (gint32 image_ID,
   GimpValueArray *return_vals;
   gint32 layer_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_INT32, x,
+                                          GIMP_TYPE_INT32, y,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), x);
-  g_value_set_int (gimp_value_array_index (args, 2), y);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -999,15 +987,12 @@ gimp_image_insert_layer (gint32 image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_LAYER_ID,
-                                          GIMP_TYPE_LAYER_ID,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          GIMP_TYPE_LAYER_ID, parent_ID,
+                                          GIMP_TYPE_INT32, position,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 1), layer_ID);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 2), parent_ID);
-  g_value_set_int (gimp_value_array_index (args, 3), position);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1049,11 +1034,10 @@ gimp_image_remove_layer (gint32 image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_LAYER_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 1), layer_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1097,9 +1081,9 @@ gimp_image_freeze_layers (gint32 image_ID)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1141,9 +1125,9 @@ gimp_image_thaw_layers (gint32 image_ID)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1190,15 +1174,12 @@ gimp_image_insert_channel (gint32 image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_CHANNEL_ID,
-                                          GIMP_TYPE_CHANNEL_ID,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_CHANNEL_ID, channel_ID,
+                                          GIMP_TYPE_CHANNEL_ID, parent_ID,
+                                          GIMP_TYPE_INT32, position,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  gimp_value_set_channel_id (gimp_value_array_index (args, 1), channel_ID);
-  gimp_value_set_channel_id (gimp_value_array_index (args, 2), parent_ID);
-  g_value_set_int (gimp_value_array_index (args, 3), position);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1237,11 +1218,10 @@ gimp_image_remove_channel (gint32 image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_CHANNEL_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_CHANNEL_ID, channel_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  gimp_value_set_channel_id (gimp_value_array_index (args, 1), channel_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1286,9 +1266,9 @@ gimp_image_freeze_channels (gint32 image_ID)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1330,9 +1310,9 @@ gimp_image_thaw_channels (gint32 image_ID)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1379,15 +1359,12 @@ gimp_image_insert_vectors (gint32 image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_VECTORS_ID,
-                                          GIMP_TYPE_VECTORS_ID,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_VECTORS_ID, vectors_ID,
+                                          GIMP_TYPE_VECTORS_ID, parent_ID,
+                                          GIMP_TYPE_INT32, position,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  gimp_value_set_vectors_id (gimp_value_array_index (args, 1), vectors_ID);
-  gimp_value_set_vectors_id (gimp_value_array_index (args, 2), parent_ID);
-  g_value_set_int (gimp_value_array_index (args, 3), position);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1428,11 +1405,10 @@ gimp_image_remove_vectors (gint32 image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_VECTORS_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_VECTORS_ID, vectors_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  gimp_value_set_vectors_id (gimp_value_array_index (args, 1), vectors_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1477,9 +1453,9 @@ gimp_image_freeze_vectors (gint32 image_ID)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1521,9 +1497,9 @@ gimp_image_thaw_vectors (gint32 image_ID)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1566,11 +1542,10 @@ gimp_image_get_item_position (gint32 image_ID,
   GimpValueArray *return_vals;
   gint position = 0;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_ITEM_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  gimp_value_set_item_id (gimp_value_array_index (args, 1), item_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1612,11 +1587,10 @@ gimp_image_raise_item (gint32 image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_ITEM_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  gimp_value_set_item_id (gimp_value_array_index (args, 1), item_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1657,11 +1631,10 @@ gimp_image_lower_item (gint32 image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_ITEM_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  gimp_value_set_item_id (gimp_value_array_index (args, 1), item_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1702,11 +1675,10 @@ gimp_image_raise_item_to_top (gint32 image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_ITEM_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  gimp_value_set_item_id (gimp_value_array_index (args, 1), item_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1748,11 +1720,10 @@ gimp_image_lower_item_to_bottom (gint32 image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_ITEM_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  gimp_value_set_item_id (gimp_value_array_index (args, 1), item_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1796,15 +1767,12 @@ gimp_image_reorder_item (gint32 image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_ITEM_ID,
-                                          GIMP_TYPE_ITEM_ID,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
+                                          GIMP_TYPE_ITEM_ID, parent_ID,
+                                          GIMP_TYPE_INT32, position,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  gimp_value_set_item_id (gimp_value_array_index (args, 1), item_ID);
-  gimp_value_set_item_id (gimp_value_array_index (args, 2), parent_ID);
-  g_value_set_int (gimp_value_array_index (args, 3), position);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1843,9 +1811,9 @@ gimp_image_flatten (gint32 image_ID)
   GimpValueArray *return_vals;
   gint32 layer_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1889,11 +1857,10 @@ gimp_image_merge_visible_layers (gint32        image_ID,
   GimpValueArray *return_vals;
   gint32 layer_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_MERGE_TYPE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_MERGE_TYPE, merge_type,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), merge_type);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1940,13 +1907,11 @@ gimp_image_merge_down (gint32        image_ID,
   GimpValueArray *return_vals;
   gint32 layer_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_LAYER_ID,
-                                          GIMP_TYPE_MERGE_TYPE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_LAYER_ID, merge_layer_ID,
+                                          GIMP_TYPE_MERGE_TYPE, merge_type,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 1), merge_layer_ID);
-  g_value_set_enum (gimp_value_array_index (args, 2), merge_type);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1991,9 +1956,9 @@ _gimp_image_get_colormap (gint32  image_ID,
   GimpValueArray *return_vals;
   guint8 *colormap = NULL;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2043,12 +2008,11 @@ _gimp_image_set_colormap (gint32        image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT8_ARRAY,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_INT32, num_bytes,
+                                          GIMP_TYPE_INT8_ARRAY, NULL,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), num_bytes);
   gimp_value_set_int8_array (gimp_value_array_index (args, 2), colormap, num_bytes);
 
   if (pdb)
@@ -2086,9 +2050,9 @@ _gimp_image_get_metadata (gint32 image_ID)
   GimpValueArray *return_vals;
   gchar *metadata_string = NULL;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2127,11 +2091,10 @@ _gimp_image_set_metadata (gint32       image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_STRING, metadata_string,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_string (gimp_value_array_index (args, 1), metadata_string);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2172,9 +2135,9 @@ gimp_image_clean_all (gint32 image_ID)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2213,9 +2176,9 @@ gimp_image_is_dirty (gint32 image_ID)
   GimpValueArray *return_vals;
   gboolean dirty = FALSE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2269,13 +2232,11 @@ _gimp_image_thumbnail (gint32   image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_INT32, width,
+                                          GIMP_TYPE_INT32, height,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), width);
-  g_value_set_int (gimp_value_array_index (args, 2), height);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2328,9 +2289,9 @@ gimp_image_get_active_layer (gint32 image_ID)
   GimpValueArray *return_vals;
   gint32 active_layer_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2372,11 +2333,10 @@ gimp_image_set_active_layer (gint32 image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_LAYER_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_LAYER_ID, active_layer_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 1), active_layer_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2413,9 +2373,9 @@ gimp_image_get_active_channel (gint32 image_ID)
   GimpValueArray *return_vals;
   gint32 active_channel_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2457,11 +2417,10 @@ gimp_image_set_active_channel (gint32 image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_CHANNEL_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_CHANNEL_ID, active_channel_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  gimp_value_set_channel_id (gimp_value_array_index (args, 1), active_channel_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2497,9 +2456,9 @@ gimp_image_get_active_vectors (gint32 image_ID)
   GimpValueArray *return_vals;
   gint32 active_vectors_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2538,11 +2497,10 @@ gimp_image_set_active_vectors (gint32 image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_VECTORS_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_VECTORS_ID, active_vectors_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  gimp_value_set_vectors_id (gimp_value_array_index (args, 1), active_vectors_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2579,9 +2537,9 @@ gimp_image_get_selection (gint32 image_ID)
   GimpValueArray *return_vals;
   gint32 selection_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2623,11 +2581,10 @@ gimp_image_get_component_active (gint32          image_ID,
   GimpValueArray *return_vals;
   gboolean active = FALSE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_CHANNEL_TYPE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_CHANNEL_TYPE, component,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), component);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2671,13 +2628,11 @@ gimp_image_set_component_active (gint32          image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_CHANNEL_TYPE,
-                                          G_TYPE_BOOLEAN,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_CHANNEL_TYPE, component,
+                                          G_TYPE_BOOLEAN, active,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), component);
-  g_value_set_boolean (gimp_value_array_index (args, 2), active);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2719,11 +2674,10 @@ gimp_image_get_component_visible (gint32          image_ID,
   GimpValueArray *return_vals;
   gboolean visible = FALSE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_CHANNEL_TYPE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_CHANNEL_TYPE, component,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), component);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2767,13 +2721,11 @@ gimp_image_set_component_visible (gint32          image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_CHANNEL_TYPE,
-                                          G_TYPE_BOOLEAN,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_CHANNEL_TYPE, component,
+                                          G_TYPE_BOOLEAN, visible,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), component);
-  g_value_set_boolean (gimp_value_array_index (args, 2), visible);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2814,9 +2766,9 @@ gimp_image_get_filename (gint32 image_ID)
   GimpValueArray *return_vals;
   gchar *filename = NULL;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2856,11 +2808,10 @@ gimp_image_set_filename (gint32       image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_STRING, filename,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_string (gimp_value_array_index (args, 1), filename);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2905,9 +2856,9 @@ gimp_image_get_uri (gint32 image_ID)
   GimpValueArray *return_vals;
   gchar *uri = NULL;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2948,9 +2899,9 @@ gimp_image_get_xcf_uri (gint32 image_ID)
   GimpValueArray *return_vals;
   gchar *uri = NULL;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -2993,9 +2944,9 @@ gimp_image_get_imported_uri (gint32 image_ID)
   GimpValueArray *return_vals;
   gchar *uri = NULL;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -3037,9 +2988,9 @@ gimp_image_get_exported_uri (gint32 image_ID)
   GimpValueArray *return_vals;
   gchar *uri = NULL;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -3083,9 +3034,9 @@ gimp_image_get_name (gint32 image_ID)
   GimpValueArray *return_vals;
   gchar *name = NULL;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -3127,9 +3078,9 @@ gimp_image_get_resolution (gint32   image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -3180,13 +3131,11 @@ gimp_image_set_resolution (gint32  image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_DOUBLE, xresolution,
+                                          G_TYPE_DOUBLE, yresolution,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_double (gimp_value_array_index (args, 1), xresolution);
-  g_value_set_double (gimp_value_array_index (args, 2), yresolution);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -3225,9 +3174,9 @@ gimp_image_get_unit (gint32 image_ID)
   GimpValueArray *return_vals;
   GimpUnit unit = 0;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -3270,11 +3219,10 @@ gimp_image_set_unit (gint32   image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_UNIT,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_UNIT, unit,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), unit);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -3312,9 +3260,9 @@ gimp_image_get_tattoo_state (gint32 image_ID)
   GimpValueArray *return_vals;
   gint tattoo_state = 0;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -3364,11 +3312,10 @@ gimp_image_set_tattoo_state (gint32 image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_INT32, tattoo_state,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_uint (gimp_value_array_index (args, 1), tattoo_state);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -3407,11 +3354,10 @@ gimp_image_get_layer_by_tattoo (gint32 image_ID,
   GimpValueArray *return_vals;
   gint32 layer_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_INT32, tattoo,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_uint (gimp_value_array_index (args, 1), tattoo);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -3451,11 +3397,10 @@ gimp_image_get_channel_by_tattoo (gint32 image_ID,
   GimpValueArray *return_vals;
   gint32 channel_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_INT32, tattoo,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_uint (gimp_value_array_index (args, 1), tattoo);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -3497,11 +3442,10 @@ gimp_image_get_vectors_by_tattoo (gint32 image_ID,
   GimpValueArray *return_vals;
   gint32 vectors_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_INT32, tattoo,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_uint (gimp_value_array_index (args, 1), tattoo);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -3543,11 +3487,10 @@ gimp_image_get_layer_by_name (gint32       image_ID,
   GimpValueArray *return_vals;
   gint32 layer_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_string (gimp_value_array_index (args, 1), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -3589,11 +3532,10 @@ gimp_image_get_channel_by_name (gint32       image_ID,
   GimpValueArray *return_vals;
   gint32 channel_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_string (gimp_value_array_index (args, 1), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -3635,11 +3577,10 @@ gimp_image_get_vectors_by_name (gint32       image_ID,
   GimpValueArray *return_vals;
   gint32 vectors_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_string (gimp_value_array_index (args, 1), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -3681,11 +3622,10 @@ gimp_image_attach_parasite (gint32              image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_PARASITE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_PARASITE, parasite,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_boxed (gimp_value_array_index (args, 1), parasite);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -3726,11 +3666,10 @@ gimp_image_detach_parasite (gint32       image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_string (gimp_value_array_index (args, 1), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -3771,11 +3710,10 @@ gimp_image_get_parasite (gint32       image_ID,
   GimpValueArray *return_vals;
   GimpParasite *parasite = NULL;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_string (gimp_value_array_index (args, 1), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -3818,9 +3756,9 @@ gimp_image_get_parasite_list (gint32  image_ID,
   GimpValueArray *return_vals;
   gchar **parasites = NULL;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimpimagecolorprofile_pdb.c b/libgimp/gimpimagecolorprofile_pdb.c
index bf9e5ad829..e450b6cab2 100644
--- a/libgimp/gimpimagecolorprofile_pdb.c
+++ b/libgimp/gimpimagecolorprofile_pdb.c
@@ -59,9 +59,9 @@ _gimp_image_get_color_profile (gint32  image_ID,
   GimpValueArray *return_vals;
   guint8 *profile_data = NULL;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -113,9 +113,9 @@ _gimp_image_get_effective_color_profile (gint32  image_ID,
   GimpValueArray *return_vals;
   guint8 *profile_data = NULL;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -167,12 +167,11 @@ _gimp_image_set_color_profile (gint32        image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT8_ARRAY,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_INT32, num_bytes,
+                                          GIMP_TYPE_INT8_ARRAY, NULL,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), num_bytes);
   gimp_value_set_int8_array (gimp_value_array_index (args, 2), color_profile, num_bytes);
 
   if (pdb)
@@ -218,11 +217,10 @@ gimp_image_set_color_profile_from_file (gint32       image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_STRING, uri,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_string (gimp_value_array_index (args, 1), uri);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -271,17 +269,14 @@ _gimp_image_convert_color_profile (gint32                    image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT8_ARRAY,
-                                          GIMP_TYPE_COLOR_RENDERING_INTENT,
-                                          G_TYPE_BOOLEAN,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_INT32, num_bytes,
+                                          GIMP_TYPE_INT8_ARRAY, NULL,
+                                          GIMP_TYPE_COLOR_RENDERING_INTENT, intent,
+                                          G_TYPE_BOOLEAN, bpc,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), num_bytes);
   gimp_value_set_int8_array (gimp_value_array_index (args, 2), color_profile, num_bytes);
-  g_value_set_enum (gimp_value_array_index (args, 3), intent);
-  g_value_set_boolean (gimp_value_array_index (args, 4), bpc);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -328,15 +323,12 @@ gimp_image_convert_color_profile_from_file (gint32                    image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          G_TYPE_STRING,
-                                          GIMP_TYPE_COLOR_RENDERING_INTENT,
-                                          G_TYPE_BOOLEAN,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_STRING, uri,
+                                          GIMP_TYPE_COLOR_RENDERING_INTENT, intent,
+                                          G_TYPE_BOOLEAN, bpc,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_string (gimp_value_array_index (args, 1), uri);
-  g_value_set_enum (gimp_value_array_index (args, 2), intent);
-  g_value_set_boolean (gimp_value_array_index (args, 3), bpc);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimpimageconvert_pdb.c b/libgimp/gimpimageconvert_pdb.c
index 4e5a5283bc..7dcf1e324e 100644
--- a/libgimp/gimpimageconvert_pdb.c
+++ b/libgimp/gimpimageconvert_pdb.c
@@ -55,9 +55,9 @@ gimp_image_convert_rgb (gint32 image_ID)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -94,9 +94,9 @@ gimp_image_convert_grayscale (gint32 image_ID)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -156,21 +156,15 @@ gimp_image_convert_indexed (gint32                  image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_CONVERT_DITHER_TYPE,
-                                          GIMP_TYPE_CONVERT_PALETTE_TYPE,
-                                          GIMP_TYPE_INT32,
-                                          G_TYPE_BOOLEAN,
-                                          G_TYPE_BOOLEAN,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_CONVERT_DITHER_TYPE, dither_type,
+                                          GIMP_TYPE_CONVERT_PALETTE_TYPE, palette_type,
+                                          GIMP_TYPE_INT32, num_cols,
+                                          G_TYPE_BOOLEAN, alpha_dither,
+                                          G_TYPE_BOOLEAN, remove_unused,
+                                          G_TYPE_STRING, palette,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), dither_type);
-  g_value_set_enum (gimp_value_array_index (args, 2), palette_type);
-  g_value_set_int (gimp_value_array_index (args, 3), num_cols);
-  g_value_set_boolean (gimp_value_array_index (args, 4), alpha_dither);
-  g_value_set_boolean (gimp_value_array_index (args, 5), remove_unused);
-  g_value_set_string (gimp_value_array_index (args, 6), palette);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -215,14 +209,12 @@ gimp_image_convert_set_dither_matrix (gint          width,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT8_ARRAY,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_INT32, width,
+                                          GIMP_TYPE_INT32, height,
+                                          GIMP_TYPE_INT32, matrix_length,
+                                          GIMP_TYPE_INT8_ARRAY, NULL,
                                           G_TYPE_NONE);
-  g_value_set_int (gimp_value_array_index (args, 0), width);
-  g_value_set_int (gimp_value_array_index (args, 1), height);
-  g_value_set_int (gimp_value_array_index (args, 2), matrix_length);
   gimp_value_set_int8_array (gimp_value_array_index (args, 3), matrix, matrix_length);
 
   if (pdb)
@@ -265,11 +257,10 @@ gimp_image_convert_precision (gint32        image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_PRECISION,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_PRECISION, precision,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), precision);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimpimagegrid_pdb.c b/libgimp/gimpimagegrid_pdb.c
index b7ace87be7..cea2447c18 100644
--- a/libgimp/gimpimagegrid_pdb.c
+++ b/libgimp/gimpimagegrid_pdb.c
@@ -59,9 +59,9 @@ gimp_image_grid_get_spacing (gint32   image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -113,13 +113,11 @@ gimp_image_grid_set_spacing (gint32  image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_DOUBLE, xspacing,
+                                          G_TYPE_DOUBLE, yspacing,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_double (gimp_value_array_index (args, 1), xspacing);
-  g_value_set_double (gimp_value_array_index (args, 2), yspacing);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -162,9 +160,9 @@ gimp_image_grid_get_offset (gint32   image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -216,13 +214,11 @@ gimp_image_grid_set_offset (gint32  image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_DOUBLE, xoffset,
+                                          G_TYPE_DOUBLE, yoffset,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_double (gimp_value_array_index (args, 1), xoffset);
-  g_value_set_double (gimp_value_array_index (args, 2), yoffset);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -262,9 +258,9 @@ gimp_image_grid_get_foreground_color (gint32   image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -307,11 +303,10 @@ gimp_image_grid_set_foreground_color (gint32         image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_RGB,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_RGB, fgcolor,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  gimp_value_set_rgb (gimp_value_array_index (args, 1), fgcolor);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -351,9 +346,9 @@ gimp_image_grid_get_background_color (gint32   image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -396,11 +391,10 @@ gimp_image_grid_set_background_color (gint32         image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_RGB,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_RGB, bgcolor,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  gimp_value_set_rgb (gimp_value_array_index (args, 1), bgcolor);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -438,9 +432,9 @@ gimp_image_grid_get_style (gint32 image_ID)
   GimpValueArray *return_vals;
   GimpGridStyle style = 0;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -482,11 +476,10 @@ gimp_image_grid_set_style (gint32        image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_GRID_STYLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_GRID_STYLE, style,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), style);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimpimageguides_pdb.c b/libgimp/gimpimageguides_pdb.c
index 0102ad8cb3..3fd2edfdd0 100644
--- a/libgimp/gimpimageguides_pdb.c
+++ b/libgimp/gimpimageguides_pdb.c
@@ -56,11 +56,10 @@ gimp_image_add_hguide (gint32 image_ID,
   GimpValueArray *return_vals;
   gint32 guide_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_INT32, yposition,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), yposition);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -101,11 +100,10 @@ gimp_image_add_vguide (gint32 image_ID,
   GimpValueArray *return_vals;
   gint32 guide_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_INT32, xposition,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), xposition);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -145,11 +143,10 @@ gimp_image_delete_guide (gint32 image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_INT32, guide_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_uint (gimp_value_array_index (args, 1), guide_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -191,11 +188,10 @@ gimp_image_find_next_guide (gint32 image_ID,
   GimpValueArray *return_vals;
   gint32 next_guide_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_INT32, guide_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_uint (gimp_value_array_index (args, 1), guide_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -235,11 +231,10 @@ gimp_image_get_guide_orientation (gint32 image_ID,
   GimpValueArray *return_vals;
   GimpOrientationType orientation = GIMP_ORIENTATION_UNKNOWN;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_INT32, guide_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_uint (gimp_value_array_index (args, 1), guide_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -279,11 +274,10 @@ gimp_image_get_guide_position (gint32 image_ID,
   GimpValueArray *return_vals;
   gint position = G_MININT /* GIMP_GUIDE_POSITION_UNDEFINED */;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_INT32, guide_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_uint (gimp_value_array_index (args, 1), guide_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimpimagesamplepoints_pdb.c b/libgimp/gimpimagesamplepoints_pdb.c
index f1ece08171..68d1090b82 100644
--- a/libgimp/gimpimagesamplepoints_pdb.c
+++ b/libgimp/gimpimagesamplepoints_pdb.c
@@ -60,13 +60,11 @@ gimp_image_add_sample_point (gint32 image_ID,
   GimpValueArray *return_vals;
   gint32 sample_point_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_INT32, position_x,
+                                          GIMP_TYPE_INT32, position_y,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), position_x);
-  g_value_set_int (gimp_value_array_index (args, 2), position_y);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -108,11 +106,10 @@ gimp_image_delete_sample_point (gint32 image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_INT32, sample_point_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_uint (gimp_value_array_index (args, 1), sample_point_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -157,11 +154,10 @@ gimp_image_find_next_sample_point (gint32 image_ID,
   GimpValueArray *return_vals;
   gint32 next_sample_point_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_INT32, sample_point_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_uint (gimp_value_array_index (args, 1), sample_point_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -206,11 +202,10 @@ gimp_image_get_sample_point_position (gint32  image_ID,
   GimpValueArray *return_vals;
   gint position_x = G_MININT;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_INT32, sample_point_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_uint (gimp_value_array_index (args, 1), sample_point_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimpimageselect_pdb.c b/libgimp/gimpimageselect_pdb.c
index 6fbd40248c..674c833658 100644
--- a/libgimp/gimpimageselect_pdb.c
+++ b/libgimp/gimpimageselect_pdb.c
@@ -76,15 +76,12 @@ gimp_image_select_color (gint32          image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_CHANNEL_OPS,
-                                          GIMP_TYPE_DRAWABLE_ID,
-                                          GIMP_TYPE_RGB,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_CHANNEL_OPS, operation,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_RGB, color,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), operation);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 2), drawable_ID);
-  gimp_value_set_rgb (gimp_value_array_index (args, 3), color);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -155,17 +152,13 @@ gimp_image_select_contiguous_color (gint32         image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_CHANNEL_OPS,
-                                          GIMP_TYPE_DRAWABLE_ID,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_CHANNEL_OPS, operation,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          G_TYPE_DOUBLE, x,
+                                          G_TYPE_DOUBLE, y,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), operation);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 2), drawable_ID);
-  g_value_set_double (gimp_value_array_index (args, 3), x);
-  g_value_set_double (gimp_value_array_index (args, 4), y);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -218,19 +211,14 @@ gimp_image_select_rectangle (gint32         image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_CHANNEL_OPS,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_CHANNEL_OPS, operation,
+                                          G_TYPE_DOUBLE, x,
+                                          G_TYPE_DOUBLE, y,
+                                          G_TYPE_DOUBLE, width,
+                                          G_TYPE_DOUBLE, height,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), operation);
-  g_value_set_double (gimp_value_array_index (args, 2), x);
-  g_value_set_double (gimp_value_array_index (args, 3), y);
-  g_value_set_double (gimp_value_array_index (args, 4), width);
-  g_value_set_double (gimp_value_array_index (args, 5), height);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -290,23 +278,16 @@ gimp_image_select_round_rectangle (gint32         image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_CHANNEL_OPS,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_CHANNEL_OPS, operation,
+                                          G_TYPE_DOUBLE, x,
+                                          G_TYPE_DOUBLE, y,
+                                          G_TYPE_DOUBLE, width,
+                                          G_TYPE_DOUBLE, height,
+                                          G_TYPE_DOUBLE, corner_radius_x,
+                                          G_TYPE_DOUBLE, corner_radius_y,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), operation);
-  g_value_set_double (gimp_value_array_index (args, 2), x);
-  g_value_set_double (gimp_value_array_index (args, 3), y);
-  g_value_set_double (gimp_value_array_index (args, 4), width);
-  g_value_set_double (gimp_value_array_index (args, 5), height);
-  g_value_set_double (gimp_value_array_index (args, 6), corner_radius_x);
-  g_value_set_double (gimp_value_array_index (args, 7), corner_radius_y);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -360,19 +341,14 @@ gimp_image_select_ellipse (gint32         image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_CHANNEL_OPS,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_CHANNEL_OPS, operation,
+                                          G_TYPE_DOUBLE, x,
+                                          G_TYPE_DOUBLE, y,
+                                          G_TYPE_DOUBLE, width,
+                                          G_TYPE_DOUBLE, height,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), operation);
-  g_value_set_double (gimp_value_array_index (args, 2), x);
-  g_value_set_double (gimp_value_array_index (args, 3), y);
-  g_value_set_double (gimp_value_array_index (args, 4), width);
-  g_value_set_double (gimp_value_array_index (args, 5), height);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -427,14 +403,12 @@ gimp_image_select_polygon (gint32          image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_CHANNEL_OPS,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_FLOAT_ARRAY,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_CHANNEL_OPS, operation,
+                                          GIMP_TYPE_INT32, num_segs,
+                                          GIMP_TYPE_FLOAT_ARRAY, NULL,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), operation);
-  g_value_set_int (gimp_value_array_index (args, 2), num_segs);
   gimp_value_set_float_array (gimp_value_array_index (args, 3), segs, num_segs);
 
   if (pdb)
@@ -484,13 +458,11 @@ gimp_image_select_item (gint32         image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_CHANNEL_OPS,
-                                          GIMP_TYPE_ITEM_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_CHANNEL_OPS, operation,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), operation);
-  gimp_value_set_item_id (gimp_value_array_index (args, 2), item_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimpimagetransform_pdb.c b/libgimp/gimpimagetransform_pdb.c
index 8e9102f4d8..d1133148bd 100644
--- a/libgimp/gimpimagetransform_pdb.c
+++ b/libgimp/gimpimagetransform_pdb.c
@@ -66,17 +66,13 @@ gimp_image_resize (gint32 image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_INT32, new_width,
+                                          GIMP_TYPE_INT32, new_height,
+                                          GIMP_TYPE_INT32, offx,
+                                          GIMP_TYPE_INT32, offy,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), new_width);
-  g_value_set_int (gimp_value_array_index (args, 2), new_height);
-  g_value_set_int (gimp_value_array_index (args, 3), offx);
-  g_value_set_int (gimp_value_array_index (args, 4), offy);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -117,9 +113,9 @@ gimp_image_resize_to_layers (gint32 image_ID)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -163,13 +159,11 @@ gimp_image_scale (gint32 image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_INT32, new_width,
+                                          GIMP_TYPE_INT32, new_height,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), new_width);
-  g_value_set_int (gimp_value_array_index (args, 2), new_height);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -218,17 +212,13 @@ gimp_image_crop (gint32 image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_INT32, new_width,
+                                          GIMP_TYPE_INT32, new_height,
+                                          GIMP_TYPE_INT32, offx,
+                                          GIMP_TYPE_INT32, offy,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), new_width);
-  g_value_set_int (gimp_value_array_index (args, 2), new_height);
-  g_value_set_int (gimp_value_array_index (args, 3), offx);
-  g_value_set_int (gimp_value_array_index (args, 4), offy);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -266,11 +256,10 @@ gimp_image_flip (gint32              image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_ORIENTATION_TYPE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_ORIENTATION_TYPE, flip_type,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), flip_type);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -308,11 +297,10 @@ gimp_image_rotate (gint32           image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_ROTATION_TYPE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_ROTATION_TYPE, rotate_type,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), rotate_type);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimpimageundo_pdb.c b/libgimp/gimpimageundo_pdb.c
index 2820476450..36fc6db96c 100644
--- a/libgimp/gimpimageundo_pdb.c
+++ b/libgimp/gimpimageundo_pdb.c
@@ -55,9 +55,9 @@ gimp_image_undo_group_start (gint32 image_ID)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -94,9 +94,9 @@ gimp_image_undo_group_end (gint32 image_ID)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -135,9 +135,9 @@ gimp_image_undo_is_enabled (gint32 image_ID)
   GimpValueArray *return_vals;
   gboolean enabled = FALSE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -178,9 +178,9 @@ gimp_image_undo_disable (gint32 image_ID)
   GimpValueArray *return_vals;
   gboolean disabled = FALSE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -220,9 +220,9 @@ gimp_image_undo_enable (gint32 image_ID)
   GimpValueArray *return_vals;
   gboolean enabled = FALSE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -269,9 +269,9 @@ gimp_image_undo_freeze (gint32 image_ID)
   GimpValueArray *return_vals;
   gboolean frozen = FALSE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -317,9 +317,9 @@ gimp_image_undo_thaw (gint32 image_ID)
   GimpValueArray *return_vals;
   gboolean thawed = FALSE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimpitem_pdb.c b/libgimp/gimpitem_pdb.c
index 88bad36e80..5f5f0b4641 100644
--- a/libgimp/gimpitem_pdb.c
+++ b/libgimp/gimpitem_pdb.c
@@ -55,9 +55,9 @@ gimp_item_is_valid (gint32 item_ID)
   GimpValueArray *return_vals;
   gboolean valid = FALSE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -96,9 +96,9 @@ gimp_item_get_image (gint32 item_ID)
   GimpValueArray *return_vals;
   gint32 image_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -141,9 +141,9 @@ gimp_item_delete (gint32 item_ID)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -181,9 +181,9 @@ gimp_item_is_drawable (gint32 item_ID)
   GimpValueArray *return_vals;
   gboolean drawable = FALSE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -222,9 +222,9 @@ gimp_item_is_layer (gint32 item_ID)
   GimpValueArray *return_vals;
   gboolean layer = FALSE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -263,9 +263,9 @@ gimp_item_is_text_layer (gint32 item_ID)
   GimpValueArray *return_vals;
   gboolean text_layer = FALSE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -304,9 +304,9 @@ gimp_item_is_channel (gint32 item_ID)
   GimpValueArray *return_vals;
   gboolean channel = FALSE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -345,9 +345,9 @@ gimp_item_is_layer_mask (gint32 item_ID)
   GimpValueArray *return_vals;
   gboolean layer_mask = FALSE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -386,9 +386,9 @@ gimp_item_is_selection (gint32 item_ID)
   GimpValueArray *return_vals;
   gboolean selection = FALSE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -427,9 +427,9 @@ gimp_item_is_vectors (gint32 item_ID)
   GimpValueArray *return_vals;
   gboolean vectors = FALSE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -469,9 +469,9 @@ gimp_item_is_group (gint32 item_ID)
   GimpValueArray *return_vals;
   gboolean group = FALSE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -510,9 +510,9 @@ gimp_item_get_parent (gint32 item_ID)
   GimpValueArray *return_vals;
   gint32 parent_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -556,9 +556,9 @@ gimp_item_get_children (gint32  item_ID,
   GimpValueArray *return_vals;
   gint *child_ids = NULL;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -602,9 +602,9 @@ gimp_item_get_expanded (gint32 item_ID)
   GimpValueArray *return_vals;
   gboolean expanded = FALSE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -645,11 +645,10 @@ gimp_item_set_expanded (gint32   item_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
-                                          G_TYPE_BOOLEAN,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
+                                          G_TYPE_BOOLEAN, expanded,
                                           G_TYPE_NONE);
-  gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
-  g_value_set_boolean (gimp_value_array_index (args, 1), expanded);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -688,9 +687,9 @@ gimp_item_get_name (gint32 item_ID)
   GimpValueArray *return_vals;
   gchar *name = NULL;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -731,11 +730,10 @@ gimp_item_set_name (gint32       item_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
-  g_value_set_string (gimp_value_array_index (args, 1), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -773,9 +771,9 @@ gimp_item_get_visible (gint32 item_ID)
   GimpValueArray *return_vals;
   gboolean visible = FALSE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -816,11 +814,10 @@ gimp_item_set_visible (gint32   item_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
-                                          G_TYPE_BOOLEAN,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
+                                          G_TYPE_BOOLEAN, visible,
                                           G_TYPE_NONE);
-  gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
-  g_value_set_boolean (gimp_value_array_index (args, 1), visible);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -858,9 +855,9 @@ gimp_item_get_linked (gint32 item_ID)
   GimpValueArray *return_vals;
   gboolean linked = FALSE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -901,11 +898,10 @@ gimp_item_set_linked (gint32   item_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
-                                          G_TYPE_BOOLEAN,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
+                                          G_TYPE_BOOLEAN, linked,
                                           G_TYPE_NONE);
-  gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
-  g_value_set_boolean (gimp_value_array_index (args, 1), linked);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -943,9 +939,9 @@ gimp_item_get_lock_content (gint32 item_ID)
   GimpValueArray *return_vals;
   gboolean lock_content = FALSE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -986,11 +982,10 @@ gimp_item_set_lock_content (gint32   item_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
-                                          G_TYPE_BOOLEAN,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
+                                          G_TYPE_BOOLEAN, lock_content,
                                           G_TYPE_NONE);
-  gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
-  g_value_set_boolean (gimp_value_array_index (args, 1), lock_content);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1028,9 +1023,9 @@ gimp_item_get_lock_position (gint32 item_ID)
   GimpValueArray *return_vals;
   gboolean lock_position = FALSE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1071,11 +1066,10 @@ gimp_item_set_lock_position (gint32   item_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
-                                          G_TYPE_BOOLEAN,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
+                                          G_TYPE_BOOLEAN, lock_position,
                                           G_TYPE_NONE);
-  gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
-  g_value_set_boolean (gimp_value_array_index (args, 1), lock_position);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1113,9 +1107,9 @@ gimp_item_get_color_tag (gint32 item_ID)
   GimpValueArray *return_vals;
   GimpColorTag color_tag = 0;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1156,11 +1150,10 @@ gimp_item_set_color_tag (gint32       item_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
-                                          GIMP_TYPE_COLOR_TAG,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
+                                          GIMP_TYPE_COLOR_TAG, color_tag,
                                           G_TYPE_NONE);
-  gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), color_tag);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1200,9 +1193,9 @@ gimp_item_get_tattoo (gint32 item_ID)
   GimpValueArray *return_vals;
   gint tattoo = 0;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1245,11 +1238,10 @@ gimp_item_set_tattoo (gint32 item_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
+                                          GIMP_TYPE_INT32, tattoo,
                                           G_TYPE_NONE);
-  gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
-  g_value_set_uint (gimp_value_array_index (args, 1), tattoo);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1290,11 +1282,10 @@ gimp_item_attach_parasite (gint32              item_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
-                                          GIMP_TYPE_PARASITE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
+                                          GIMP_TYPE_PARASITE, parasite,
                                           G_TYPE_NONE);
-  gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
-  g_value_set_boxed (gimp_value_array_index (args, 1), parasite);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1335,11 +1326,10 @@ gimp_item_detach_parasite (gint32       item_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
-  g_value_set_string (gimp_value_array_index (args, 1), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1379,11 +1369,10 @@ gimp_item_get_parasite (gint32       item_ID,
   GimpValueArray *return_vals;
   GimpParasite *parasite = NULL;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
-  g_value_set_string (gimp_value_array_index (args, 1), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1426,9 +1415,9 @@ gimp_item_get_parasite_list (gint32  item_ID,
   GimpValueArray *return_vals;
   gchar **parasites = NULL;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimpitemtransform_pdb.c b/libgimp/gimpitemtransform_pdb.c
index 7d4f0c6bbe..f7f3639400 100644
--- a/libgimp/gimpitemtransform_pdb.c
+++ b/libgimp/gimpitemtransform_pdb.c
@@ -66,13 +66,11 @@ gimp_item_transform_translate (gint32  item_ID,
   GimpValueArray *return_vals;
   gint32 ret_item_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
+                                          G_TYPE_DOUBLE, off_x,
+                                          G_TYPE_DOUBLE, off_y,
                                           G_TYPE_NONE);
-  gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
-  g_value_set_double (gimp_value_array_index (args, 1), off_x);
-  g_value_set_double (gimp_value_array_index (args, 2), off_y);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -135,15 +133,12 @@ gimp_item_transform_flip_simple (gint32              item_ID,
   GimpValueArray *return_vals;
   gint32 ret_item_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
-                                          GIMP_TYPE_ORIENTATION_TYPE,
-                                          G_TYPE_BOOLEAN,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
+                                          GIMP_TYPE_ORIENTATION_TYPE, flip_type,
+                                          G_TYPE_BOOLEAN, auto_center,
+                                          G_TYPE_DOUBLE, axis,
                                           G_TYPE_NONE);
-  gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), flip_type);
-  g_value_set_boolean (gimp_value_array_index (args, 2), auto_center);
-  g_value_set_double (gimp_value_array_index (args, 3), axis);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -208,17 +203,13 @@ gimp_item_transform_flip (gint32  item_ID,
   GimpValueArray *return_vals;
   gint32 ret_item_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
+                                          G_TYPE_DOUBLE, x0,
+                                          G_TYPE_DOUBLE, y0,
+                                          G_TYPE_DOUBLE, x1,
+                                          G_TYPE_DOUBLE, y1,
                                           G_TYPE_NONE);
-  gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
-  g_value_set_double (gimp_value_array_index (args, 1), x0);
-  g_value_set_double (gimp_value_array_index (args, 2), y0);
-  g_value_set_double (gimp_value_array_index (args, 3), x1);
-  g_value_set_double (gimp_value_array_index (args, 4), y1);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -300,25 +291,17 @@ gimp_item_transform_perspective (gint32  item_ID,
   GimpValueArray *return_vals;
   gint32 ret_item_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
+                                          G_TYPE_DOUBLE, x0,
+                                          G_TYPE_DOUBLE, y0,
+                                          G_TYPE_DOUBLE, x1,
+                                          G_TYPE_DOUBLE, y1,
+                                          G_TYPE_DOUBLE, x2,
+                                          G_TYPE_DOUBLE, y2,
+                                          G_TYPE_DOUBLE, x3,
+                                          G_TYPE_DOUBLE, y3,
                                           G_TYPE_NONE);
-  gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
-  g_value_set_double (gimp_value_array_index (args, 1), x0);
-  g_value_set_double (gimp_value_array_index (args, 2), y0);
-  g_value_set_double (gimp_value_array_index (args, 3), x1);
-  g_value_set_double (gimp_value_array_index (args, 4), y1);
-  g_value_set_double (gimp_value_array_index (args, 5), x2);
-  g_value_set_double (gimp_value_array_index (args, 6), y2);
-  g_value_set_double (gimp_value_array_index (args, 7), x3);
-  g_value_set_double (gimp_value_array_index (args, 8), y3);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -386,17 +369,13 @@ gimp_item_transform_rotate_simple (gint32           item_ID,
   GimpValueArray *return_vals;
   gint32 ret_item_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
-                                          GIMP_TYPE_ROTATION_TYPE,
-                                          G_TYPE_BOOLEAN,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
+                                          GIMP_TYPE_ROTATION_TYPE, rotate_type,
+                                          G_TYPE_BOOLEAN, auto_center,
+                                          G_TYPE_DOUBLE, center_x,
+                                          G_TYPE_DOUBLE, center_y,
                                           G_TYPE_NONE);
-  gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), rotate_type);
-  g_value_set_boolean (gimp_value_array_index (args, 2), auto_center);
-  g_value_set_double (gimp_value_array_index (args, 3), center_x);
-  g_value_set_double (gimp_value_array_index (args, 4), center_y);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -466,17 +445,13 @@ gimp_item_transform_rotate (gint32   item_ID,
   GimpValueArray *return_vals;
   gint32 ret_item_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_BOOLEAN,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
+                                          G_TYPE_DOUBLE, angle,
+                                          G_TYPE_BOOLEAN, auto_center,
+                                          G_TYPE_DOUBLE, center_x,
+                                          G_TYPE_DOUBLE, center_y,
                                           G_TYPE_NONE);
-  gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
-  g_value_set_double (gimp_value_array_index (args, 1), angle);
-  g_value_set_boolean (gimp_value_array_index (args, 2), auto_center);
-  g_value_set_double (gimp_value_array_index (args, 3), center_x);
-  g_value_set_double (gimp_value_array_index (args, 4), center_y);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -543,17 +518,13 @@ gimp_item_transform_scale (gint32  item_ID,
   GimpValueArray *return_vals;
   gint32 ret_item_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
+                                          G_TYPE_DOUBLE, x0,
+                                          G_TYPE_DOUBLE, y0,
+                                          G_TYPE_DOUBLE, x1,
+                                          G_TYPE_DOUBLE, y1,
                                           G_TYPE_NONE);
-  gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
-  g_value_set_double (gimp_value_array_index (args, 1), x0);
-  g_value_set_double (gimp_value_array_index (args, 2), y0);
-  g_value_set_double (gimp_value_array_index (args, 3), x1);
-  g_value_set_double (gimp_value_array_index (args, 4), y1);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -618,13 +589,11 @@ gimp_item_transform_shear (gint32              item_ID,
   GimpValueArray *return_vals;
   gint32 ret_item_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
-                                          GIMP_TYPE_ORIENTATION_TYPE,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
+                                          GIMP_TYPE_ORIENTATION_TYPE, shear_type,
+                                          G_TYPE_DOUBLE, magnitude,
                                           G_TYPE_NONE);
-  gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), shear_type);
-  g_value_set_double (gimp_value_array_index (args, 2), magnitude);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -700,23 +669,16 @@ gimp_item_transform_2d (gint32  item_ID,
   GimpValueArray *return_vals;
   gint32 ret_item_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
+                                          G_TYPE_DOUBLE, source_x,
+                                          G_TYPE_DOUBLE, source_y,
+                                          G_TYPE_DOUBLE, scale_x,
+                                          G_TYPE_DOUBLE, scale_y,
+                                          G_TYPE_DOUBLE, angle,
+                                          G_TYPE_DOUBLE, dest_x,
+                                          G_TYPE_DOUBLE, dest_y,
                                           G_TYPE_NONE);
-  gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
-  g_value_set_double (gimp_value_array_index (args, 1), source_x);
-  g_value_set_double (gimp_value_array_index (args, 2), source_y);
-  g_value_set_double (gimp_value_array_index (args, 3), scale_x);
-  g_value_set_double (gimp_value_array_index (args, 4), scale_y);
-  g_value_set_double (gimp_value_array_index (args, 5), angle);
-  g_value_set_double (gimp_value_array_index (args, 6), dest_x);
-  g_value_set_double (gimp_value_array_index (args, 7), dest_y);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -794,27 +756,18 @@ gimp_item_transform_matrix (gint32  item_ID,
   GimpValueArray *return_vals;
   gint32 ret_item_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_ITEM_ID, item_ID,
+                                          G_TYPE_DOUBLE, coeff_0_0,
+                                          G_TYPE_DOUBLE, coeff_0_1,
+                                          G_TYPE_DOUBLE, coeff_0_2,
+                                          G_TYPE_DOUBLE, coeff_1_0,
+                                          G_TYPE_DOUBLE, coeff_1_1,
+                                          G_TYPE_DOUBLE, coeff_1_2,
+                                          G_TYPE_DOUBLE, coeff_2_0,
+                                          G_TYPE_DOUBLE, coeff_2_1,
+                                          G_TYPE_DOUBLE, coeff_2_2,
                                           G_TYPE_NONE);
-  gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
-  g_value_set_double (gimp_value_array_index (args, 1), coeff_0_0);
-  g_value_set_double (gimp_value_array_index (args, 2), coeff_0_1);
-  g_value_set_double (gimp_value_array_index (args, 3), coeff_0_2);
-  g_value_set_double (gimp_value_array_index (args, 4), coeff_1_0);
-  g_value_set_double (gimp_value_array_index (args, 5), coeff_1_1);
-  g_value_set_double (gimp_value_array_index (args, 6), coeff_1_2);
-  g_value_set_double (gimp_value_array_index (args, 7), coeff_2_0);
-  g_value_set_double (gimp_value_array_index (args, 8), coeff_2_1);
-  g_value_set_double (gimp_value_array_index (args, 9), coeff_2_2);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimplayer_pdb.c b/libgimp/gimplayer_pdb.c
index 80e453e474..84aefecfda 100644
--- a/libgimp/gimplayer_pdb.c
+++ b/libgimp/gimplayer_pdb.c
@@ -69,21 +69,15 @@ _gimp_layer_new (gint32         image_ID,
   GimpValueArray *return_vals;
   gint32 layer_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_IMAGE_TYPE,
-                                          G_TYPE_STRING,
-                                          G_TYPE_DOUBLE,
-                                          GIMP_TYPE_LAYER_MODE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_INT32, width,
+                                          GIMP_TYPE_INT32, height,
+                                          GIMP_TYPE_IMAGE_TYPE, type,
+                                          G_TYPE_STRING, name,
+                                          G_TYPE_DOUBLE, opacity,
+                                          GIMP_TYPE_LAYER_MODE, mode,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), width);
-  g_value_set_int (gimp_value_array_index (args, 2), height);
-  g_value_set_enum (gimp_value_array_index (args, 3), type);
-  g_value_set_string (gimp_value_array_index (args, 4), name);
-  g_value_set_double (gimp_value_array_index (args, 5), opacity);
-  g_value_set_enum (gimp_value_array_index (args, 6), mode);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -130,13 +124,11 @@ gimp_layer_new_from_visible (gint32       image_ID,
   GimpValueArray *return_vals;
   gint32 layer_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_IMAGE_ID,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_IMAGE_ID, dest_image_ID,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  gimp_value_set_image_id (gimp_value_array_index (args, 1), dest_image_ID);
-  g_value_set_string (gimp_value_array_index (args, 2), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -179,11 +171,10 @@ gimp_layer_new_from_drawable (gint32 drawable_ID,
   GimpValueArray *return_vals;
   gint32 layer_copy_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_IMAGE_ID, dest_image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  gimp_value_set_image_id (gimp_value_array_index (args, 1), dest_image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -228,9 +219,9 @@ gimp_layer_group_new (gint32 image_ID)
   GimpValueArray *return_vals;
   gint32 layer_group_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -274,11 +265,10 @@ _gimp_layer_copy (gint32   layer_ID,
   GimpValueArray *return_vals;
   gint32 layer_copy_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
-                                          G_TYPE_BOOLEAN,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          G_TYPE_BOOLEAN, add_alpha,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
-  g_value_set_boolean (gimp_value_array_index (args, 1), add_alpha);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -319,9 +309,9 @@ gimp_layer_add_alpha (gint32 layer_ID)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -362,9 +352,9 @@ gimp_layer_flatten (gint32 layer_ID)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -411,15 +401,12 @@ gimp_layer_scale (gint32   layer_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
-                                          G_TYPE_BOOLEAN,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          GIMP_TYPE_INT32, new_width,
+                                          GIMP_TYPE_INT32, new_height,
+                                          G_TYPE_BOOLEAN, local_origin,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), new_width);
-  g_value_set_int (gimp_value_array_index (args, 2), new_height);
-  g_value_set_boolean (gimp_value_array_index (args, 3), local_origin);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -466,17 +453,13 @@ gimp_layer_resize (gint32 layer_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          GIMP_TYPE_INT32, new_width,
+                                          GIMP_TYPE_INT32, new_height,
+                                          GIMP_TYPE_INT32, offx,
+                                          GIMP_TYPE_INT32, offy,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), new_width);
-  g_value_set_int (gimp_value_array_index (args, 2), new_height);
-  g_value_set_int (gimp_value_array_index (args, 3), offx);
-  g_value_set_int (gimp_value_array_index (args, 4), offy);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -513,9 +496,9 @@ gimp_layer_resize_to_image_size (gint32 layer_ID)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -557,13 +540,11 @@ gimp_layer_set_offsets (gint32 layer_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          GIMP_TYPE_INT32, offx,
+                                          GIMP_TYPE_INT32, offy,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), offx);
-  g_value_set_int (gimp_value_array_index (args, 2), offy);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -620,11 +601,10 @@ gimp_layer_create_mask (gint32          layer_ID,
   GimpValueArray *return_vals;
   gint32 mask_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
-                                          GIMP_TYPE_ADD_MASK_TYPE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          GIMP_TYPE_ADD_MASK_TYPE, mask_type,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), mask_type);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -662,9 +642,9 @@ gimp_layer_get_mask (gint32 layer_ID)
   GimpValueArray *return_vals;
   gint32 mask_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -704,9 +684,9 @@ gimp_layer_from_mask (gint32 mask_ID)
   GimpValueArray *return_vals;
   gint32 layer_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_MASK_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_MASK_ID, mask_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_mask_id (gimp_value_array_index (args, 0), mask_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -751,11 +731,10 @@ gimp_layer_add_mask (gint32 layer_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
-                                          GIMP_TYPE_LAYER_MASK_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          GIMP_TYPE_LAYER_MASK_ID, mask_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
-  gimp_value_set_layer_mask_id (gimp_value_array_index (args, 1), mask_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -794,11 +773,10 @@ gimp_layer_remove_mask (gint32            layer_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
-                                          GIMP_TYPE_MASK_APPLY_MODE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          GIMP_TYPE_MASK_APPLY_MODE, mode,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), mode);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -836,9 +814,9 @@ gimp_layer_is_floating_sel (gint32 layer_ID)
   GimpValueArray *return_vals;
   gboolean is_floating_sel = FALSE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -876,9 +854,9 @@ gimp_layer_get_lock_alpha (gint32 layer_ID)
   GimpValueArray *return_vals;
   gboolean lock_alpha = FALSE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -918,11 +896,10 @@ gimp_layer_set_lock_alpha (gint32   layer_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
-                                          G_TYPE_BOOLEAN,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          G_TYPE_BOOLEAN, lock_alpha,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
-  g_value_set_boolean (gimp_value_array_index (args, 1), lock_alpha);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -960,9 +937,9 @@ gimp_layer_get_apply_mask (gint32 layer_ID)
   GimpValueArray *return_vals;
   gboolean apply_mask = FALSE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1004,11 +981,10 @@ gimp_layer_set_apply_mask (gint32   layer_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
-                                          G_TYPE_BOOLEAN,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          G_TYPE_BOOLEAN, apply_mask,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
-  g_value_set_boolean (gimp_value_array_index (args, 1), apply_mask);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1047,9 +1023,9 @@ gimp_layer_get_show_mask (gint32 layer_ID)
   GimpValueArray *return_vals;
   gboolean show_mask = FALSE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1091,11 +1067,10 @@ gimp_layer_set_show_mask (gint32   layer_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
-                                          G_TYPE_BOOLEAN,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          G_TYPE_BOOLEAN, show_mask,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
-  g_value_set_boolean (gimp_value_array_index (args, 1), show_mask);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1133,9 +1108,9 @@ gimp_layer_get_edit_mask (gint32 layer_ID)
   GimpValueArray *return_vals;
   gboolean edit_mask = FALSE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1177,11 +1152,10 @@ gimp_layer_set_edit_mask (gint32   layer_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
-                                          G_TYPE_BOOLEAN,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          G_TYPE_BOOLEAN, edit_mask,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
-  g_value_set_boolean (gimp_value_array_index (args, 1), edit_mask);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1217,9 +1191,9 @@ gimp_layer_get_opacity (gint32 layer_ID)
   GimpValueArray *return_vals;
   gdouble opacity = 0.0;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1258,11 +1232,10 @@ gimp_layer_set_opacity (gint32  layer_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          G_TYPE_DOUBLE, opacity,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
-  g_value_set_double (gimp_value_array_index (args, 1), opacity);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1298,9 +1271,9 @@ gimp_layer_get_mode (gint32 layer_ID)
   GimpValueArray *return_vals;
   GimpLayerMode mode = 0;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1339,11 +1312,10 @@ gimp_layer_set_mode (gint32        layer_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
-                                          GIMP_TYPE_LAYER_MODE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          GIMP_TYPE_LAYER_MODE, mode,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), mode);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1381,9 +1353,9 @@ gimp_layer_get_blend_space (gint32 layer_ID)
   GimpValueArray *return_vals;
   GimpLayerColorSpace blend_space = 0;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1424,11 +1396,10 @@ gimp_layer_set_blend_space (gint32              layer_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
-                                          GIMP_TYPE_LAYER_COLOR_SPACE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          GIMP_TYPE_LAYER_COLOR_SPACE, blend_space,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), blend_space);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1466,9 +1437,9 @@ gimp_layer_get_composite_space (gint32 layer_ID)
   GimpValueArray *return_vals;
   GimpLayerColorSpace composite_space = 0;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1509,11 +1480,10 @@ gimp_layer_set_composite_space (gint32              layer_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
-                                          GIMP_TYPE_LAYER_COLOR_SPACE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          GIMP_TYPE_LAYER_COLOR_SPACE, composite_space,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), composite_space);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1551,9 +1521,9 @@ gimp_layer_get_composite_mode (gint32 layer_ID)
   GimpValueArray *return_vals;
   GimpLayerCompositeMode composite_mode = 0;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1594,11 +1564,10 @@ gimp_layer_set_composite_mode (gint32                 layer_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
-                                          GIMP_TYPE_LAYER_COMPOSITE_MODE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          GIMP_TYPE_LAYER_COMPOSITE_MODE, composite_mode,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), composite_mode);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimpmessage_pdb.c b/libgimp/gimpmessage_pdb.c
index ceec0ba38b..cef7671ef1 100644
--- a/libgimp/gimpmessage_pdb.c
+++ b/libgimp/gimpmessage_pdb.c
@@ -53,9 +53,9 @@ gimp_message (const gchar *message)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, message,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), message);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -92,7 +92,8 @@ gimp_message_get_handler (void)
   GimpValueArray *return_vals;
   GimpMessageHandlerType handler = 0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -131,9 +132,9 @@ gimp_message_set_handler (GimpMessageHandlerType handler)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_MESSAGE_HANDLER_TYPE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_MESSAGE_HANDLER_TYPE, handler,
                                           G_TYPE_NONE);
-  g_value_set_enum (gimp_value_array_index (args, 0), handler);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimppainttools_pdb.c b/libgimp/gimppainttools_pdb.c
index a26e914736..e79d6e8357 100644
--- a/libgimp/gimppainttools_pdb.c
+++ b/libgimp/gimppainttools_pdb.c
@@ -62,14 +62,12 @@ gimp_airbrush (gint32         drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          G_TYPE_DOUBLE,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_FLOAT_ARRAY,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          G_TYPE_DOUBLE, pressure,
+                                          GIMP_TYPE_INT32, num_strokes,
+                                          GIMP_TYPE_FLOAT_ARRAY, NULL,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_double (gimp_value_array_index (args, 1), pressure);
-  g_value_set_int (gimp_value_array_index (args, 2), num_strokes);
   gimp_value_set_float_array (gimp_value_array_index (args, 3), strokes, num_strokes);
 
   if (pdb)
@@ -114,12 +112,11 @@ gimp_airbrush_default (gint32         drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_FLOAT_ARRAY,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_INT32, num_strokes,
+                                          GIMP_TYPE_FLOAT_ARRAY, NULL,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), num_strokes);
   gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes);
 
   if (pdb)
@@ -179,20 +176,15 @@ gimp_clone (gint32         drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          GIMP_TYPE_DRAWABLE_ID,
-                                          GIMP_TYPE_CLONE_TYPE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_FLOAT_ARRAY,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_DRAWABLE_ID, src_drawable_ID,
+                                          GIMP_TYPE_CLONE_TYPE, clone_type,
+                                          G_TYPE_DOUBLE, src_x,
+                                          G_TYPE_DOUBLE, src_y,
+                                          GIMP_TYPE_INT32, num_strokes,
+                                          GIMP_TYPE_FLOAT_ARRAY, NULL,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 1), src_drawable_ID);
-  g_value_set_enum (gimp_value_array_index (args, 2), clone_type);
-  g_value_set_double (gimp_value_array_index (args, 3), src_x);
-  g_value_set_double (gimp_value_array_index (args, 4), src_y);
-  g_value_set_int (gimp_value_array_index (args, 5), num_strokes);
   gimp_value_set_float_array (gimp_value_array_index (args, 6), strokes, num_strokes);
 
   if (pdb)
@@ -238,12 +230,11 @@ gimp_clone_default (gint32         drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_FLOAT_ARRAY,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_INT32, num_strokes,
+                                          GIMP_TYPE_FLOAT_ARRAY, NULL,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), num_strokes);
   gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes);
 
   if (pdb)
@@ -291,16 +282,13 @@ gimp_convolve (gint32            drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          G_TYPE_DOUBLE,
-                                          GIMP_TYPE_CONVOLVE_TYPE,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_FLOAT_ARRAY,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          G_TYPE_DOUBLE, pressure,
+                                          GIMP_TYPE_CONVOLVE_TYPE, convolve_type,
+                                          GIMP_TYPE_INT32, num_strokes,
+                                          GIMP_TYPE_FLOAT_ARRAY, NULL,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_double (gimp_value_array_index (args, 1), pressure);
-  g_value_set_enum (gimp_value_array_index (args, 2), convolve_type);
-  g_value_set_int (gimp_value_array_index (args, 3), num_strokes);
   gimp_value_set_float_array (gimp_value_array_index (args, 4), strokes, num_strokes);
 
   if (pdb)
@@ -345,12 +333,11 @@ gimp_convolve_default (gint32         drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_FLOAT_ARRAY,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_INT32, num_strokes,
+                                          GIMP_TYPE_FLOAT_ARRAY, NULL,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), num_strokes);
   gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes);
 
   if (pdb)
@@ -397,18 +384,14 @@ gimp_dodgeburn (gint32             drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          G_TYPE_DOUBLE,
-                                          GIMP_TYPE_DODGE_BURN_TYPE,
-                                          GIMP_TYPE_TRANSFER_MODE,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_FLOAT_ARRAY,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          G_TYPE_DOUBLE, exposure,
+                                          GIMP_TYPE_DODGE_BURN_TYPE, dodgeburn_type,
+                                          GIMP_TYPE_TRANSFER_MODE, dodgeburn_mode,
+                                          GIMP_TYPE_INT32, num_strokes,
+                                          GIMP_TYPE_FLOAT_ARRAY, NULL,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_double (gimp_value_array_index (args, 1), exposure);
-  g_value_set_enum (gimp_value_array_index (args, 2), dodgeburn_type);
-  g_value_set_enum (gimp_value_array_index (args, 3), dodgeburn_mode);
-  g_value_set_int (gimp_value_array_index (args, 4), num_strokes);
   gimp_value_set_float_array (gimp_value_array_index (args, 5), strokes, num_strokes);
 
   if (pdb)
@@ -452,12 +435,11 @@ gimp_dodgeburn_default (gint32         drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_FLOAT_ARRAY,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_INT32, num_strokes,
+                                          GIMP_TYPE_FLOAT_ARRAY, NULL,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), num_strokes);
   gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes);
 
   if (pdb)
@@ -506,17 +488,14 @@ gimp_eraser (gint32                    drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_FLOAT_ARRAY,
-                                          GIMP_TYPE_BRUSH_APPLICATION_MODE,
-                                          GIMP_TYPE_PAINT_APPLICATION_MODE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_INT32, num_strokes,
+                                          GIMP_TYPE_FLOAT_ARRAY, NULL,
+                                          GIMP_TYPE_BRUSH_APPLICATION_MODE, hardness,
+                                          GIMP_TYPE_PAINT_APPLICATION_MODE, method,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), num_strokes);
   gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes);
-  g_value_set_enum (gimp_value_array_index (args, 3), hardness);
-  g_value_set_enum (gimp_value_array_index (args, 4), method);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -560,12 +539,11 @@ gimp_eraser_default (gint32         drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_FLOAT_ARRAY,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_INT32, num_strokes,
+                                          GIMP_TYPE_FLOAT_ARRAY, NULL,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), num_strokes);
   gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes);
 
   if (pdb)
@@ -619,18 +597,14 @@ gimp_heal (gint32         drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          GIMP_TYPE_DRAWABLE_ID,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_FLOAT_ARRAY,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_DRAWABLE_ID, src_drawable_ID,
+                                          G_TYPE_DOUBLE, src_x,
+                                          G_TYPE_DOUBLE, src_y,
+                                          GIMP_TYPE_INT32, num_strokes,
+                                          GIMP_TYPE_FLOAT_ARRAY, NULL,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 1), src_drawable_ID);
-  g_value_set_double (gimp_value_array_index (args, 2), src_x);
-  g_value_set_double (gimp_value_array_index (args, 3), src_y);
-  g_value_set_int (gimp_value_array_index (args, 4), num_strokes);
   gimp_value_set_float_array (gimp_value_array_index (args, 5), strokes, num_strokes);
 
   if (pdb)
@@ -678,12 +652,11 @@ gimp_heal_default (gint32         drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_FLOAT_ARRAY,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_INT32, num_strokes,
+                                          GIMP_TYPE_FLOAT_ARRAY, NULL,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), num_strokes);
   gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes);
 
   if (pdb)
@@ -739,19 +712,15 @@ gimp_paintbrush (gint32                    drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          G_TYPE_DOUBLE,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_FLOAT_ARRAY,
-                                          GIMP_TYPE_PAINT_APPLICATION_MODE,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          G_TYPE_DOUBLE, fade_out,
+                                          GIMP_TYPE_INT32, num_strokes,
+                                          GIMP_TYPE_FLOAT_ARRAY, NULL,
+                                          GIMP_TYPE_PAINT_APPLICATION_MODE, method,
+                                          G_TYPE_DOUBLE, gradient_length,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_double (gimp_value_array_index (args, 1), fade_out);
-  g_value_set_int (gimp_value_array_index (args, 2), num_strokes);
   gimp_value_set_float_array (gimp_value_array_index (args, 3), strokes, num_strokes);
-  g_value_set_enum (gimp_value_array_index (args, 4), method);
-  g_value_set_double (gimp_value_array_index (args, 5), gradient_length);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -804,12 +773,11 @@ gimp_paintbrush_default (gint32         drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_FLOAT_ARRAY,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_INT32, num_strokes,
+                                          GIMP_TYPE_FLOAT_ARRAY, NULL,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), num_strokes);
   gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes);
 
   if (pdb)
@@ -855,12 +823,11 @@ gimp_pencil (gint32         drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_FLOAT_ARRAY,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_INT32, num_strokes,
+                                          GIMP_TYPE_FLOAT_ARRAY, NULL,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), num_strokes);
   gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes);
 
   if (pdb)
@@ -905,14 +872,12 @@ gimp_smudge (gint32         drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          G_TYPE_DOUBLE,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_FLOAT_ARRAY,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          G_TYPE_DOUBLE, pressure,
+                                          GIMP_TYPE_INT32, num_strokes,
+                                          GIMP_TYPE_FLOAT_ARRAY, NULL,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_double (gimp_value_array_index (args, 1), pressure);
-  g_value_set_int (gimp_value_array_index (args, 2), num_strokes);
   gimp_value_set_float_array (gimp_value_array_index (args, 3), strokes, num_strokes);
 
   if (pdb)
@@ -956,12 +921,11 @@ gimp_smudge_default (gint32         drawable_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_FLOAT_ARRAY,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_INT32, num_strokes,
+                                          GIMP_TYPE_FLOAT_ARRAY, NULL,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), num_strokes);
   gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes);
 
   if (pdb)
diff --git a/libgimp/gimppalette_pdb.c b/libgimp/gimppalette_pdb.c
index 4c5c145e1e..7cc84d9bf0 100644
--- a/libgimp/gimppalette_pdb.c
+++ b/libgimp/gimppalette_pdb.c
@@ -55,9 +55,9 @@ gimp_palette_new (const gchar *name)
   GimpValueArray *return_vals;
   gchar *actual_name = NULL;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -97,9 +97,9 @@ gimp_palette_duplicate (const gchar *name)
   GimpValueArray *return_vals;
   gchar *copy_name = NULL;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -141,11 +141,10 @@ gimp_palette_rename (const gchar *name,
   GimpValueArray *return_vals;
   gchar *actual_name = NULL;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
+                                          G_TYPE_STRING, new_name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
-  g_value_set_string (gimp_value_array_index (args, 1), new_name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -184,9 +183,9 @@ gimp_palette_delete (const gchar *name)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -224,9 +223,9 @@ gimp_palette_is_editable (const gchar *name)
   GimpValueArray *return_vals;
   gboolean editable = FALSE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -268,9 +267,9 @@ gimp_palette_get_info (const gchar *name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -317,9 +316,9 @@ gimp_palette_get_colors (const gchar *name,
   GimpValueArray *return_vals;
   GimpRGB *colors = NULL;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -364,9 +363,9 @@ gimp_palette_get_columns (const gchar *name)
   GimpValueArray *return_vals;
   gint num_columns = 0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -409,11 +408,10 @@ gimp_palette_set_columns (const gchar *name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
+                                          GIMP_TYPE_INT32, columns,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
-  g_value_set_int (gimp_value_array_index (args, 1), columns);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -458,13 +456,11 @@ gimp_palette_add_entry (const gchar   *name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          G_TYPE_STRING,
-                                          GIMP_TYPE_RGB,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
+                                          G_TYPE_STRING, entry_name,
+                                          GIMP_TYPE_RGB, color,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
-  g_value_set_string (gimp_value_array_index (args, 1), entry_name);
-  gimp_value_set_rgb (gimp_value_array_index (args, 2), color);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -510,11 +506,10 @@ gimp_palette_delete_entry (const gchar *name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
+                                          GIMP_TYPE_INT32, entry_num,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
-  g_value_set_int (gimp_value_array_index (args, 1), entry_num);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -558,11 +553,10 @@ gimp_palette_entry_get_color (const gchar *name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
+                                          GIMP_TYPE_INT32, entry_num,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
-  g_value_set_int (gimp_value_array_index (args, 1), entry_num);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -609,13 +603,11 @@ gimp_palette_entry_set_color (const gchar   *name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_RGB,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
+                                          GIMP_TYPE_INT32, entry_num,
+                                          GIMP_TYPE_RGB, color,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
-  g_value_set_int (gimp_value_array_index (args, 1), entry_num);
-  gimp_value_set_rgb (gimp_value_array_index (args, 2), color);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -659,11 +651,10 @@ gimp_palette_entry_get_name (const gchar  *name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
+                                          GIMP_TYPE_INT32, entry_num,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
-  g_value_set_int (gimp_value_array_index (args, 1), entry_num);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -712,13 +703,11 @@ gimp_palette_entry_set_name (const gchar *name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          GIMP_TYPE_INT32,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
+                                          GIMP_TYPE_INT32, entry_num,
+                                          G_TYPE_STRING, entry_name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
-  g_value_set_int (gimp_value_array_index (args, 1), entry_num);
-  g_value_set_string (gimp_value_array_index (args, 2), entry_name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimppalettes_pdb.c b/libgimp/gimppalettes_pdb.c
index 591957d41a..8614931b99 100644
--- a/libgimp/gimppalettes_pdb.c
+++ b/libgimp/gimppalettes_pdb.c
@@ -52,7 +52,8 @@ gimp_palettes_refresh (void)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -94,9 +95,9 @@ gimp_palettes_get_list (const gchar *filter,
   GimpValueArray *return_vals;
   gchar **palette_list = NULL;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, filter,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), filter);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimppaletteselect_pdb.c b/libgimp/gimppaletteselect_pdb.c
index b0892d2192..c7ac81c8ca 100644
--- a/libgimp/gimppaletteselect_pdb.c
+++ b/libgimp/gimppaletteselect_pdb.c
@@ -56,13 +56,11 @@ gimp_palettes_popup (const gchar *palette_callback,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          G_TYPE_STRING,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, palette_callback,
+                                          G_TYPE_STRING, popup_title,
+                                          G_TYPE_STRING, initial_palette,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), palette_callback);
-  g_value_set_string (gimp_value_array_index (args, 1), popup_title);
-  g_value_set_string (gimp_value_array_index (args, 2), initial_palette);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -98,9 +96,9 @@ gimp_palettes_close_popup (const gchar *palette_callback)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, palette_callback,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), palette_callback);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -138,11 +136,10 @@ gimp_palettes_set_popup (const gchar *palette_callback,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, palette_callback,
+                                          G_TYPE_STRING, palette_name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), palette_callback);
-  g_value_set_string (gimp_value_array_index (args, 1), palette_name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimppattern_pdb.c b/libgimp/gimppattern_pdb.c
index c1a61df9a8..cee2c5ae3a 100644
--- a/libgimp/gimppattern_pdb.c
+++ b/libgimp/gimppattern_pdb.c
@@ -61,9 +61,9 @@ gimp_pattern_get_info (const gchar *name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -124,9 +124,9 @@ gimp_pattern_get_pixels (const gchar  *name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimppatterns_pdb.c b/libgimp/gimppatterns_pdb.c
index 1a4efe7ede..b061297ecf 100644
--- a/libgimp/gimppatterns_pdb.c
+++ b/libgimp/gimppatterns_pdb.c
@@ -52,7 +52,8 @@ gimp_patterns_refresh (void)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -94,9 +95,9 @@ gimp_patterns_get_list (const gchar *filter,
   GimpValueArray *return_vals;
   gchar **pattern_list = NULL;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, filter,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), filter);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimppatternselect_pdb.c b/libgimp/gimppatternselect_pdb.c
index c30c186c79..6c2d4529fc 100644
--- a/libgimp/gimppatternselect_pdb.c
+++ b/libgimp/gimppatternselect_pdb.c
@@ -56,13 +56,11 @@ gimp_patterns_popup (const gchar *pattern_callback,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          G_TYPE_STRING,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, pattern_callback,
+                                          G_TYPE_STRING, popup_title,
+                                          G_TYPE_STRING, initial_pattern,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), pattern_callback);
-  g_value_set_string (gimp_value_array_index (args, 1), popup_title);
-  g_value_set_string (gimp_value_array_index (args, 2), initial_pattern);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -98,9 +96,9 @@ gimp_patterns_close_popup (const gchar *pattern_callback)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, pattern_callback,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), pattern_callback);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -138,11 +136,10 @@ gimp_patterns_set_popup (const gchar *pattern_callback,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, pattern_callback,
+                                          G_TYPE_STRING, pattern_name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), pattern_callback);
-  g_value_set_string (gimp_value_array_index (args, 1), pattern_name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimppdb_pdb.c b/libgimp/gimppdb_pdb.c
index 4dc28f618f..2462c943a0 100644
--- a/libgimp/gimppdb_pdb.c
+++ b/libgimp/gimppdb_pdb.c
@@ -43,7 +43,8 @@ _gimp_pdb_temp_name (void)
   GimpValueArray *return_vals;
   gchar *temp_name = NULL;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -82,9 +83,9 @@ _gimp_pdb_dump (const gchar *filename)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, filename,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), filename);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -148,21 +149,15 @@ _gimp_pdb_query (const gchar   *name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          G_TYPE_STRING,
-                                          G_TYPE_STRING,
-                                          G_TYPE_STRING,
-                                          G_TYPE_STRING,
-                                          G_TYPE_STRING,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, name,
+                                          G_TYPE_STRING, blurb,
+                                          G_TYPE_STRING, help,
+                                          G_TYPE_STRING, author,
+                                          G_TYPE_STRING, copyright,
+                                          G_TYPE_STRING, date,
+                                          G_TYPE_STRING, proc_type,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), name);
-  g_value_set_string (gimp_value_array_index (args, 1), blurb);
-  g_value_set_string (gimp_value_array_index (args, 2), help);
-  g_value_set_string (gimp_value_array_index (args, 3), author);
-  g_value_set_string (gimp_value_array_index (args, 4), copyright);
-  g_value_set_string (gimp_value_array_index (args, 5), date);
-  g_value_set_string (gimp_value_array_index (args, 6), proc_type);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -210,9 +205,9 @@ _gimp_pdb_proc_exists (const gchar *procedure_name)
   GimpValueArray *return_vals;
   gboolean exists = FALSE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, procedure_name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), procedure_name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -271,9 +266,9 @@ _gimp_pdb_proc_info (const gchar      *procedure_name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, procedure_name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), procedure_name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -340,11 +335,10 @@ _gimp_pdb_proc_arg (const gchar     *procedure_name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, procedure_name,
+                                          GIMP_TYPE_INT32, arg_num,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), procedure_name);
-  g_value_set_int (gimp_value_array_index (args, 1), arg_num);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -402,11 +396,10 @@ _gimp_pdb_proc_val (const gchar     *procedure_name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, procedure_name,
+                                          GIMP_TYPE_INT32, val_num,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), procedure_name);
-  g_value_set_int (gimp_value_array_index (args, 1), val_num);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -459,11 +452,10 @@ gimp_pdb_proc_argument (const gchar *procedure_name,
   GimpValueArray *return_vals;
   GParamSpec *param_spec = NULL;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, procedure_name,
+                                          GIMP_TYPE_INT32, arg_num,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), procedure_name);
-  g_value_set_int (gimp_value_array_index (args, 1), arg_num);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -507,11 +499,10 @@ gimp_pdb_proc_return_value (const gchar *procedure_name,
   GimpValueArray *return_vals;
   GParamSpec *param_spec = NULL;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, procedure_name,
+                                          GIMP_TYPE_INT32, val_num,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), procedure_name);
-  g_value_set_int (gimp_value_array_index (args, 1), val_num);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -555,9 +546,9 @@ _gimp_pdb_get_data (const gchar  *identifier,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, identifier,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), identifier);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -604,9 +595,9 @@ _gimp_pdb_get_data_size (const gchar *identifier)
   GimpValueArray *return_vals;
   gint bytes = 0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, identifier,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), identifier);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -649,12 +640,11 @@ _gimp_pdb_set_data (const gchar  *identifier,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT8_ARRAY,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, identifier,
+                                          GIMP_TYPE_INT32, bytes,
+                                          GIMP_TYPE_INT8_ARRAY, NULL,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), identifier);
-  g_value_set_int (gimp_value_array_index (args, 1), bytes);
   gimp_value_set_int8_array (gimp_value_array_index (args, 2), data, bytes);
 
   if (pdb)
diff --git a/libgimp/gimpplugin_pdb.c b/libgimp/gimpplugin_pdb.c
index 132b36e0f6..e60ed18ad9 100644
--- a/libgimp/gimpplugin_pdb.c
+++ b/libgimp/gimpplugin_pdb.c
@@ -52,11 +52,10 @@ _gimp_plugin_domain_register (const gchar *domain_name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, domain_name,
+                                          G_TYPE_STRING, domain_path,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), domain_name);
-  g_value_set_string (gimp_value_array_index (args, 1), domain_path);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -98,11 +97,10 @@ _gimp_plugin_help_register (const gchar *domain_name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, domain_name,
+                                          G_TYPE_STRING, domain_uri,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), domain_name);
-  g_value_set_string (gimp_value_array_index (args, 1), domain_uri);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -145,11 +143,10 @@ _gimp_plugin_menu_branch_register (const gchar *menu_path,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, menu_path,
+                                          G_TYPE_STRING, menu_name,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), menu_path);
-  g_value_set_string (gimp_value_array_index (args, 1), menu_name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -190,11 +187,10 @@ _gimp_plugin_menu_register (const gchar *procedure_name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, procedure_name,
+                                          G_TYPE_STRING, menu_path,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), procedure_name);
-  g_value_set_string (gimp_value_array_index (args, 1), menu_path);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -238,14 +234,12 @@ _gimp_plugin_icon_register (const gchar  *procedure_name,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          GIMP_TYPE_ICON_TYPE,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT8_ARRAY,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, procedure_name,
+                                          GIMP_TYPE_ICON_TYPE, icon_type,
+                                          GIMP_TYPE_INT32, icon_data_length,
+                                          GIMP_TYPE_INT8_ARRAY, NULL,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), procedure_name);
-  g_value_set_enum (gimp_value_array_index (args, 1), icon_type);
-  g_value_set_int (gimp_value_array_index (args, 2), icon_data_length);
   gimp_value_set_int8_array (gimp_value_array_index (args, 3), icon_data, icon_data_length);
 
   if (pdb)
@@ -291,9 +285,9 @@ _gimp_plugin_set_pdb_error_handler (GimpPDBErrorHandler handler)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_PDB_ERROR_HANDLER,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_PDB_ERROR_HANDLER, handler,
                                           G_TYPE_NONE);
-  g_value_set_enum (gimp_value_array_index (args, 0), handler);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -332,7 +326,8 @@ _gimp_plugin_get_pdb_error_handler (void)
   GimpValueArray *return_vals;
   GimpPDBErrorHandler handler = 0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimpprogress_pdb.c b/libgimp/gimpprogress_pdb.c
index b0ea8a6698..dc476a785c 100644
--- a/libgimp/gimpprogress_pdb.c
+++ b/libgimp/gimpprogress_pdb.c
@@ -55,11 +55,10 @@ _gimp_progress_init (const gchar *message,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          GIMP_TYPE_DISPLAY_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, message,
+                                          GIMP_TYPE_DISPLAY_ID, gdisplay_ID,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), message);
-  gimp_value_set_display_id (gimp_value_array_index (args, 1), gdisplay_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -96,9 +95,9 @@ _gimp_progress_update (gdouble percentage)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_DOUBLE, percentage,
                                           G_TYPE_NONE);
-  g_value_set_double (gimp_value_array_index (args, 0), percentage);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -139,7 +138,8 @@ gimp_progress_pulse (void)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -179,9 +179,9 @@ gimp_progress_set_text (const gchar *message)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, message,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), message);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -220,7 +220,8 @@ gimp_progress_end (void)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -259,7 +260,8 @@ gimp_progress_get_window_handle (void)
   GimpValueArray *return_vals;
   gint window = 0;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -301,9 +303,9 @@ _gimp_progress_install (const gchar *progress_callback)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, progress_callback,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), progress_callback);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -342,9 +344,9 @@ _gimp_progress_uninstall (const gchar *progress_callback)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, progress_callback,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), progress_callback);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -382,9 +384,9 @@ gimp_progress_cancel (const gchar *progress_callback)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, progress_callback,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), progress_callback);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimpselection_pdb.c b/libgimp/gimpselection_pdb.c
index e8e0e28d7b..4124561b4f 100644
--- a/libgimp/gimpselection_pdb.c
+++ b/libgimp/gimpselection_pdb.c
@@ -69,9 +69,9 @@ gimp_selection_bounds (gint32    image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -127,13 +127,11 @@ gimp_selection_value (gint32 image_ID,
   GimpValueArray *return_vals;
   gint value = 0;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_INT32, x,
+                                          GIMP_TYPE_INT32, y,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), x);
-  g_value_set_int (gimp_value_array_index (args, 2), y);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -171,9 +169,9 @@ gimp_selection_is_empty (gint32 image_ID)
   GimpValueArray *return_vals;
   gboolean is_empty = FALSE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -218,13 +216,11 @@ gimp_selection_translate (gint32 image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_INT32, offx,
+                                          GIMP_TYPE_INT32, offy,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), offx);
-  g_value_set_int (gimp_value_array_index (args, 2), offy);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -269,13 +265,11 @@ _gimp_selection_float (gint32 drawable_ID,
   GimpValueArray *return_vals;
   gint32 layer_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          GIMP_TYPE_INT32, offx,
+                                          GIMP_TYPE_INT32, offy,
                                           G_TYPE_NONE);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), offx);
-  g_value_set_int (gimp_value_array_index (args, 2), offy);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -313,9 +307,9 @@ gimp_selection_invert (gint32 image_ID)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -354,9 +348,9 @@ gimp_selection_sharpen (gint32 image_ID)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -393,9 +387,9 @@ gimp_selection_all (gint32 image_ID)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -432,9 +426,9 @@ gimp_selection_none (gint32 image_ID)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -473,11 +467,10 @@ gimp_selection_feather (gint32  image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_DOUBLE, radius,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_double (gimp_value_array_index (args, 1), radius);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -517,11 +510,10 @@ gimp_selection_border (gint32 image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_INT32, radius,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), radius);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -560,11 +552,10 @@ gimp_selection_grow (gint32 image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_INT32, steps,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), steps);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -604,11 +595,10 @@ gimp_selection_shrink (gint32 image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_INT32, steps,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), steps);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -649,9 +639,9 @@ gimp_selection_flood (gint32 image_ID)
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -689,9 +679,9 @@ gimp_selection_save (gint32 image_ID)
   GimpValueArray *return_vals;
   gint32 channel_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimptextlayer_pdb.c b/libgimp/gimptextlayer_pdb.c
index aa878c7b4e..c4102dbfc1 100644
--- a/libgimp/gimptextlayer_pdb.c
+++ b/libgimp/gimptextlayer_pdb.c
@@ -67,17 +67,13 @@ gimp_text_layer_new (gint32       image_ID,
   GimpValueArray *return_vals;
   gint32 layer_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          G_TYPE_STRING,
-                                          G_TYPE_STRING,
-                                          G_TYPE_DOUBLE,
-                                          GIMP_TYPE_UNIT,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_STRING, text,
+                                          G_TYPE_STRING, fontname,
+                                          G_TYPE_DOUBLE, size,
+                                          GIMP_TYPE_UNIT, unit,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_string (gimp_value_array_index (args, 1), text);
-  g_value_set_string (gimp_value_array_index (args, 2), fontname);
-  g_value_set_double (gimp_value_array_index (args, 3), size);
-  g_value_set_int (gimp_value_array_index (args, 4), unit);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -117,9 +113,9 @@ gimp_text_layer_get_text (gint32 layer_ID)
   GimpValueArray *return_vals;
   gchar *text = NULL;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -160,11 +156,10 @@ gimp_text_layer_set_text (gint32       layer_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          G_TYPE_STRING, text,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
-  g_value_set_string (gimp_value_array_index (args, 1), text);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -208,9 +203,9 @@ gimp_text_layer_get_markup (gint32 layer_ID)
   GimpValueArray *return_vals;
   gchar *markup = NULL;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -251,9 +246,9 @@ gimp_text_layer_get_font (gint32 layer_ID)
   GimpValueArray *return_vals;
   gchar *font = NULL;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -294,11 +289,10 @@ gimp_text_layer_set_font (gint32       layer_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          G_TYPE_STRING, font,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
-  g_value_set_string (gimp_value_array_index (args, 1), font);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -340,9 +334,9 @@ gimp_text_layer_get_font_size (gint32    layer_ID,
   GimpValueArray *return_vals;
   gdouble font_size = 0.0;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -389,13 +383,11 @@ gimp_text_layer_set_font_size (gint32   layer_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
-                                          G_TYPE_DOUBLE,
-                                          GIMP_TYPE_UNIT,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          G_TYPE_DOUBLE, font_size,
+                                          GIMP_TYPE_UNIT, unit,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
-  g_value_set_double (gimp_value_array_index (args, 1), font_size);
-  g_value_set_int (gimp_value_array_index (args, 2), unit);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -434,9 +426,9 @@ gimp_text_layer_get_antialias (gint32 layer_ID)
   GimpValueArray *return_vals;
   gboolean antialias = FALSE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -478,11 +470,10 @@ gimp_text_layer_set_antialias (gint32   layer_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
-                                          G_TYPE_BOOLEAN,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          G_TYPE_BOOLEAN, antialias,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
-  g_value_set_boolean (gimp_value_array_index (args, 1), antialias);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -522,9 +513,9 @@ gimp_text_layer_get_hint_style (gint32 layer_ID)
   GimpValueArray *return_vals;
   GimpTextHintStyle style = 0;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -567,11 +558,10 @@ gimp_text_layer_set_hint_style (gint32            layer_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
-                                          GIMP_TYPE_TEXT_HINT_STYLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          GIMP_TYPE_TEXT_HINT_STYLE, style,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), style);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -610,9 +600,9 @@ gimp_text_layer_get_kerning (gint32 layer_ID)
   GimpValueArray *return_vals;
   gboolean kerning = FALSE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -653,11 +643,10 @@ gimp_text_layer_set_kerning (gint32   layer_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
-                                          G_TYPE_BOOLEAN,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          G_TYPE_BOOLEAN, kerning,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
-  g_value_set_boolean (gimp_value_array_index (args, 1), kerning);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -697,9 +686,9 @@ gimp_text_layer_get_language (gint32 layer_ID)
   GimpValueArray *return_vals;
   gchar *language = NULL;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -741,11 +730,10 @@ gimp_text_layer_set_language (gint32       layer_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          G_TYPE_STRING, language,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
-  g_value_set_string (gimp_value_array_index (args, 1), language);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -784,9 +772,9 @@ gimp_text_layer_get_base_direction (gint32 layer_ID)
   GimpValueArray *return_vals;
   GimpTextDirection direction = 0;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -828,11 +816,10 @@ gimp_text_layer_set_base_direction (gint32            layer_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
-                                          GIMP_TYPE_TEXT_DIRECTION,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          GIMP_TYPE_TEXT_DIRECTION, direction,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), direction);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -871,9 +858,9 @@ gimp_text_layer_get_justification (gint32 layer_ID)
   GimpValueArray *return_vals;
   GimpTextJustification justify = 0;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -915,11 +902,10 @@ gimp_text_layer_set_justification (gint32                layer_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
-                                          GIMP_TYPE_TEXT_JUSTIFICATION,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          GIMP_TYPE_TEXT_JUSTIFICATION, justify,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), justify);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -959,9 +945,9 @@ gimp_text_layer_get_color (gint32   layer_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1004,11 +990,10 @@ gimp_text_layer_set_color (gint32         layer_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
-                                          GIMP_TYPE_RGB,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          GIMP_TYPE_RGB, color,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
-  gimp_value_set_rgb (gimp_value_array_index (args, 1), color);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1047,9 +1032,9 @@ gimp_text_layer_get_indent (gint32 layer_ID)
   GimpValueArray *return_vals;
   gdouble indent = 0.0;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1091,11 +1076,10 @@ gimp_text_layer_set_indent (gint32  layer_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          G_TYPE_DOUBLE, indent,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
-  g_value_set_double (gimp_value_array_index (args, 1), indent);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1134,9 +1118,9 @@ gimp_text_layer_get_line_spacing (gint32 layer_ID)
   GimpValueArray *return_vals;
   gdouble line_spacing = 0.0;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1178,11 +1162,10 @@ gimp_text_layer_set_line_spacing (gint32  layer_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          G_TYPE_DOUBLE, line_spacing,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
-  g_value_set_double (gimp_value_array_index (args, 1), line_spacing);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1221,9 +1204,9 @@ gimp_text_layer_get_letter_spacing (gint32 layer_ID)
   GimpValueArray *return_vals;
   gdouble letter_spacing = 0.0;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1265,11 +1248,10 @@ gimp_text_layer_set_letter_spacing (gint32  layer_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          G_TYPE_DOUBLE, letter_spacing,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
-  g_value_set_double (gimp_value_array_index (args, 1), letter_spacing);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1313,13 +1295,11 @@ gimp_text_layer_resize (gint32  layer_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
+                                          G_TYPE_DOUBLE, width,
+                                          G_TYPE_DOUBLE, height,
                                           G_TYPE_NONE);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
-  g_value_set_double (gimp_value_array_index (args, 1), width);
-  g_value_set_double (gimp_value_array_index (args, 2), height);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimptexttool_pdb.c b/libgimp/gimptexttool_pdb.c
index be778d2939..87fc632e2f 100644
--- a/libgimp/gimptexttool_pdb.c
+++ b/libgimp/gimptexttool_pdb.c
@@ -83,27 +83,18 @@ gimp_text_fontname (gint32        image_ID,
   GimpValueArray *return_vals;
   gint32 text_layer_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_DRAWABLE_ID,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_STRING,
-                                          GIMP_TYPE_INT32,
-                                          G_TYPE_BOOLEAN,
-                                          G_TYPE_DOUBLE,
-                                          GIMP_TYPE_SIZE_TYPE,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_DRAWABLE_ID, drawable_ID,
+                                          G_TYPE_DOUBLE, x,
+                                          G_TYPE_DOUBLE, y,
+                                          G_TYPE_STRING, text,
+                                          GIMP_TYPE_INT32, border,
+                                          G_TYPE_BOOLEAN, antialias,
+                                          G_TYPE_DOUBLE, size,
+                                          GIMP_TYPE_SIZE_TYPE, size_type,
+                                          G_TYPE_STRING, fontname,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  gimp_value_set_drawable_id (gimp_value_array_index (args, 1), drawable_ID);
-  g_value_set_double (gimp_value_array_index (args, 2), x);
-  g_value_set_double (gimp_value_array_index (args, 3), y);
-  g_value_set_string (gimp_value_array_index (args, 4), text);
-  g_value_set_int (gimp_value_array_index (args, 5), border);
-  g_value_set_boolean (gimp_value_array_index (args, 6), antialias);
-  g_value_set_double (gimp_value_array_index (args, 7), size);
-  g_value_set_enum (gimp_value_array_index (args, 8), size_type);
-  g_value_set_string (gimp_value_array_index (args, 9), fontname);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -160,15 +151,12 @@ gimp_text_get_extents_fontname (const gchar  *text,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          G_TYPE_DOUBLE,
-                                          GIMP_TYPE_SIZE_TYPE,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, text,
+                                          G_TYPE_DOUBLE, size,
+                                          GIMP_TYPE_SIZE_TYPE, size_type,
+                                          G_TYPE_STRING, fontname,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), text);
-  g_value_set_double (gimp_value_array_index (args, 1), size);
-  g_value_set_enum (gimp_value_array_index (args, 2), size_type);
-  g_value_set_string (gimp_value_array_index (args, 3), fontname);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimpunit_pdb.c b/libgimp/gimpunit_pdb.c
index 4c826a51d3..1c74f5f73a 100644
--- a/libgimp/gimpunit_pdb.c
+++ b/libgimp/gimpunit_pdb.c
@@ -42,7 +42,8 @@ _gimp_unit_get_number_of_units (void)
   GimpValueArray *return_vals;
   gint num_units = GIMP_UNIT_END;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -78,7 +79,8 @@ _gimp_unit_get_number_of_built_in_units (void)
   GimpValueArray *return_vals;
   gint num_units = GIMP_UNIT_END;
 
-  args = gimp_value_array_new_from_types (G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_NONE);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -130,21 +132,15 @@ _gimp_unit_new (const gchar *identifier,
   GimpValueArray *return_vals;
   GimpUnit unit_id = GIMP_UNIT_INCH;
 
-  args = gimp_value_array_new_from_types (G_TYPE_STRING,
-                                          G_TYPE_DOUBLE,
-                                          GIMP_TYPE_INT32,
-                                          G_TYPE_STRING,
-                                          G_TYPE_STRING,
-                                          G_TYPE_STRING,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          G_TYPE_STRING, identifier,
+                                          G_TYPE_DOUBLE, factor,
+                                          GIMP_TYPE_INT32, digits,
+                                          G_TYPE_STRING, symbol,
+                                          G_TYPE_STRING, abbreviation,
+                                          G_TYPE_STRING, singular,
+                                          G_TYPE_STRING, plural,
                                           G_TYPE_NONE);
-  g_value_set_string (gimp_value_array_index (args, 0), identifier);
-  g_value_set_double (gimp_value_array_index (args, 1), factor);
-  g_value_set_int (gimp_value_array_index (args, 2), digits);
-  g_value_set_string (gimp_value_array_index (args, 3), symbol);
-  g_value_set_string (gimp_value_array_index (args, 4), abbreviation);
-  g_value_set_string (gimp_value_array_index (args, 5), singular);
-  g_value_set_string (gimp_value_array_index (args, 6), plural);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -183,9 +179,9 @@ _gimp_unit_get_deletion_flag (GimpUnit unit_id)
   GimpValueArray *return_vals;
   gboolean deletion_flag = FALSE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_UNIT,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_UNIT, unit_id,
                                           G_TYPE_NONE);
-  g_value_set_int (gimp_value_array_index (args, 0), unit_id);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -226,11 +222,10 @@ _gimp_unit_set_deletion_flag (GimpUnit unit_id,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_UNIT,
-                                          G_TYPE_BOOLEAN,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_UNIT, unit_id,
+                                          G_TYPE_BOOLEAN, deletion_flag,
                                           G_TYPE_NONE);
-  g_value_set_int (gimp_value_array_index (args, 0), unit_id);
-  g_value_set_boolean (gimp_value_array_index (args, 1), deletion_flag);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -269,9 +264,9 @@ _gimp_unit_get_identifier (GimpUnit unit_id)
   GimpValueArray *return_vals;
   gchar *identifier = NULL;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_UNIT,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_UNIT, unit_id,
                                           G_TYPE_NONE);
-  g_value_set_int (gimp_value_array_index (args, 0), unit_id);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -310,9 +305,9 @@ _gimp_unit_get_factor (GimpUnit unit_id)
   GimpValueArray *return_vals;
   gdouble factor = 0.0;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_UNIT,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_UNIT, unit_id,
                                           G_TYPE_NONE);
-  g_value_set_int (gimp_value_array_index (args, 0), unit_id);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -352,9 +347,9 @@ _gimp_unit_get_digits (GimpUnit unit_id)
   GimpValueArray *return_vals;
   gint digits = 0;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_UNIT,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_UNIT, unit_id,
                                           G_TYPE_NONE);
-  g_value_set_int (gimp_value_array_index (args, 0), unit_id);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -392,9 +387,9 @@ _gimp_unit_get_symbol (GimpUnit unit_id)
   GimpValueArray *return_vals;
   gchar *symbol = NULL;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_UNIT,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_UNIT, unit_id,
                                           G_TYPE_NONE);
-  g_value_set_int (gimp_value_array_index (args, 0), unit_id);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -433,9 +428,9 @@ _gimp_unit_get_abbreviation (GimpUnit unit_id)
   GimpValueArray *return_vals;
   gchar *abbreviation = NULL;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_UNIT,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_UNIT, unit_id,
                                           G_TYPE_NONE);
-  g_value_set_int (gimp_value_array_index (args, 0), unit_id);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -473,9 +468,9 @@ _gimp_unit_get_singular (GimpUnit unit_id)
   GimpValueArray *return_vals;
   gchar *singular = NULL;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_UNIT,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_UNIT, unit_id,
                                           G_TYPE_NONE);
-  g_value_set_int (gimp_value_array_index (args, 0), unit_id);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -513,9 +508,9 @@ _gimp_unit_get_plural (GimpUnit unit_id)
   GimpValueArray *return_vals;
   gchar *plural = NULL;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_UNIT,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_UNIT, unit_id,
                                           G_TYPE_NONE);
-  g_value_set_int (gimp_value_array_index (args, 0), unit_id);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimp/gimpvectors_pdb.c b/libgimp/gimpvectors_pdb.c
index c6f3eb541a..b2bd3c2697 100644
--- a/libgimp/gimpvectors_pdb.c
+++ b/libgimp/gimpvectors_pdb.c
@@ -57,11 +57,10 @@ gimp_vectors_new (gint32       image_ID,
   GimpValueArray *return_vals;
   gint32 vectors_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          G_TYPE_STRING,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_STRING, name,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_string (gimp_value_array_index (args, 1), name);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -103,11 +102,10 @@ gimp_vectors_new_from_text_layer (gint32 image_ID,
   GimpValueArray *return_vals;
   gint32 vectors_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_LAYER_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_LAYER_ID, layer_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  gimp_value_set_layer_id (gimp_value_array_index (args, 1), layer_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -147,9 +145,9 @@ gimp_vectors_copy (gint32 vectors_ID)
   GimpValueArray *return_vals;
   gint32 vectors_copy_ID = -1;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_VECTORS_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_VECTORS_ID, vectors_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_vectors_id (gimp_value_array_index (args, 0), vectors_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -193,9 +191,9 @@ gimp_vectors_get_strokes (gint32  vectors_ID,
   GimpValueArray *return_vals;
   gint *stroke_ids = NULL;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_VECTORS_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_VECTORS_ID, vectors_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_vectors_id (gimp_value_array_index (args, 0), vectors_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -243,13 +241,11 @@ gimp_vectors_stroke_get_length (gint32  vectors_ID,
   GimpValueArray *return_vals;
   gdouble length = 0.0;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_VECTORS_ID,
-                                          GIMP_TYPE_INT32,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_VECTORS_ID, vectors_ID,
+                                          GIMP_TYPE_INT32, stroke_id,
+                                          G_TYPE_DOUBLE, precision,
                                           G_TYPE_NONE);
-  gimp_value_set_vectors_id (gimp_value_array_index (args, 0), vectors_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), stroke_id);
-  g_value_set_double (gimp_value_array_index (args, 2), precision);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -307,15 +303,12 @@ gimp_vectors_stroke_get_point_at_dist (gint32    vectors_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_VECTORS_ID,
-                                          GIMP_TYPE_INT32,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_VECTORS_ID, vectors_ID,
+                                          GIMP_TYPE_INT32, stroke_id,
+                                          G_TYPE_DOUBLE, dist,
+                                          G_TYPE_DOUBLE, precision,
                                           G_TYPE_NONE);
-  gimp_value_set_vectors_id (gimp_value_array_index (args, 0), vectors_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), stroke_id);
-  g_value_set_double (gimp_value_array_index (args, 2), dist);
-  g_value_set_double (gimp_value_array_index (args, 3), precision);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -368,11 +361,10 @@ gimp_vectors_remove_stroke (gint32 vectors_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_VECTORS_ID,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_VECTORS_ID, vectors_ID,
+                                          GIMP_TYPE_INT32, stroke_id,
                                           G_TYPE_NONE);
-  gimp_value_set_vectors_id (gimp_value_array_index (args, 0), vectors_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), stroke_id);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -412,11 +404,10 @@ gimp_vectors_stroke_close (gint32 vectors_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_VECTORS_ID,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_VECTORS_ID, vectors_ID,
+                                          GIMP_TYPE_INT32, stroke_id,
                                           G_TYPE_NONE);
-  gimp_value_set_vectors_id (gimp_value_array_index (args, 0), vectors_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), stroke_id);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -460,15 +451,12 @@ gimp_vectors_stroke_translate (gint32 vectors_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_VECTORS_ID,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_VECTORS_ID, vectors_ID,
+                                          GIMP_TYPE_INT32, stroke_id,
+                                          GIMP_TYPE_INT32, off_x,
+                                          GIMP_TYPE_INT32, off_y,
                                           G_TYPE_NONE);
-  gimp_value_set_vectors_id (gimp_value_array_index (args, 0), vectors_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), stroke_id);
-  g_value_set_int (gimp_value_array_index (args, 2), off_x);
-  g_value_set_int (gimp_value_array_index (args, 3), off_y);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -512,15 +500,12 @@ gimp_vectors_stroke_scale (gint32  vectors_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_VECTORS_ID,
-                                          GIMP_TYPE_INT32,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_VECTORS_ID, vectors_ID,
+                                          GIMP_TYPE_INT32, stroke_id,
+                                          G_TYPE_DOUBLE, scale_x,
+                                          G_TYPE_DOUBLE, scale_y,
                                           G_TYPE_NONE);
-  gimp_value_set_vectors_id (gimp_value_array_index (args, 0), vectors_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), stroke_id);
-  g_value_set_double (gimp_value_array_index (args, 2), scale_x);
-  g_value_set_double (gimp_value_array_index (args, 3), scale_y);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -566,17 +551,13 @@ gimp_vectors_stroke_rotate (gint32  vectors_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_VECTORS_ID,
-                                          GIMP_TYPE_INT32,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_VECTORS_ID, vectors_ID,
+                                          GIMP_TYPE_INT32, stroke_id,
+                                          G_TYPE_DOUBLE, center_x,
+                                          G_TYPE_DOUBLE, center_y,
+                                          G_TYPE_DOUBLE, angle,
                                           G_TYPE_NONE);
-  gimp_value_set_vectors_id (gimp_value_array_index (args, 0), vectors_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), stroke_id);
-  g_value_set_double (gimp_value_array_index (args, 2), center_x);
-  g_value_set_double (gimp_value_array_index (args, 3), center_y);
-  g_value_set_double (gimp_value_array_index (args, 4), angle);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -620,15 +601,12 @@ gimp_vectors_stroke_flip (gint32              vectors_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_VECTORS_ID,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_ORIENTATION_TYPE,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_VECTORS_ID, vectors_ID,
+                                          GIMP_TYPE_INT32, stroke_id,
+                                          GIMP_TYPE_ORIENTATION_TYPE, flip_type,
+                                          G_TYPE_DOUBLE, axis,
                                           G_TYPE_NONE);
-  gimp_value_set_vectors_id (gimp_value_array_index (args, 0), vectors_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), stroke_id);
-  g_value_set_enum (gimp_value_array_index (args, 2), flip_type);
-  g_value_set_double (gimp_value_array_index (args, 3), axis);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -678,19 +656,14 @@ gimp_vectors_stroke_flip_free (gint32  vectors_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_VECTORS_ID,
-                                          GIMP_TYPE_INT32,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_VECTORS_ID, vectors_ID,
+                                          GIMP_TYPE_INT32, stroke_id,
+                                          G_TYPE_DOUBLE, x1,
+                                          G_TYPE_DOUBLE, y1,
+                                          G_TYPE_DOUBLE, x2,
+                                          G_TYPE_DOUBLE, y2,
                                           G_TYPE_NONE);
-  gimp_value_set_vectors_id (gimp_value_array_index (args, 0), vectors_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), stroke_id);
-  g_value_set_double (gimp_value_array_index (args, 2), x1);
-  g_value_set_double (gimp_value_array_index (args, 3), y1);
-  g_value_set_double (gimp_value_array_index (args, 4), x2);
-  g_value_set_double (gimp_value_array_index (args, 5), y2);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -739,11 +712,10 @@ gimp_vectors_stroke_get_points (gint32     vectors_ID,
   GimpValueArray *return_vals;
   GimpVectorsStrokeType type = 0;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_VECTORS_ID,
-                                          GIMP_TYPE_INT32,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_VECTORS_ID, vectors_ID,
+                                          GIMP_TYPE_INT32, stroke_id,
                                           G_TYPE_NONE);
-  gimp_value_set_vectors_id (gimp_value_array_index (args, 0), vectors_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), stroke_id);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -804,17 +776,14 @@ gimp_vectors_stroke_new_from_points (gint32                 vectors_ID,
   GimpValueArray *return_vals;
   gint stroke_id = 0;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_VECTORS_ID,
-                                          GIMP_TYPE_VECTORS_STROKE_TYPE,
-                                          GIMP_TYPE_INT32,
-                                          GIMP_TYPE_FLOAT_ARRAY,
-                                          G_TYPE_BOOLEAN,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_VECTORS_ID, vectors_ID,
+                                          GIMP_TYPE_VECTORS_STROKE_TYPE, type,
+                                          GIMP_TYPE_INT32, num_points,
+                                          GIMP_TYPE_FLOAT_ARRAY, NULL,
+                                          G_TYPE_BOOLEAN, closed,
                                           G_TYPE_NONE);
-  gimp_value_set_vectors_id (gimp_value_array_index (args, 0), vectors_ID);
-  g_value_set_enum (gimp_value_array_index (args, 1), type);
-  g_value_set_int (gimp_value_array_index (args, 2), num_points);
   gimp_value_set_float_array (gimp_value_array_index (args, 3), controlpoints, num_points);
-  g_value_set_boolean (gimp_value_array_index (args, 4), closed);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -863,13 +832,11 @@ gimp_vectors_stroke_interpolate (gint32    vectors_ID,
   GimpValueArray *return_vals;
   gdouble *coords = NULL;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_VECTORS_ID,
-                                          GIMP_TYPE_INT32,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_VECTORS_ID, vectors_ID,
+                                          GIMP_TYPE_INT32, stroke_id,
+                                          G_TYPE_DOUBLE, precision,
                                           G_TYPE_NONE);
-  gimp_value_set_vectors_id (gimp_value_array_index (args, 0), vectors_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), stroke_id);
-  g_value_set_double (gimp_value_array_index (args, 2), precision);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -918,13 +885,11 @@ gimp_vectors_bezier_stroke_new_moveto (gint32  vectors_ID,
   GimpValueArray *return_vals;
   gint stroke_id = 0;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_VECTORS_ID,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_VECTORS_ID, vectors_ID,
+                                          G_TYPE_DOUBLE, x0,
+                                          G_TYPE_DOUBLE, y0,
                                           G_TYPE_NONE);
-  gimp_value_set_vectors_id (gimp_value_array_index (args, 0), vectors_ID);
-  g_value_set_double (gimp_value_array_index (args, 1), x0);
-  g_value_set_double (gimp_value_array_index (args, 2), y0);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -969,15 +934,12 @@ gimp_vectors_bezier_stroke_lineto (gint32  vectors_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_VECTORS_ID,
-                                          GIMP_TYPE_INT32,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_VECTORS_ID, vectors_ID,
+                                          GIMP_TYPE_INT32, stroke_id,
+                                          G_TYPE_DOUBLE, x0,
+                                          G_TYPE_DOUBLE, y0,
                                           G_TYPE_NONE);
-  gimp_value_set_vectors_id (gimp_value_array_index (args, 0), vectors_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), stroke_id);
-  g_value_set_double (gimp_value_array_index (args, 2), x0);
-  g_value_set_double (gimp_value_array_index (args, 3), y0);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1027,19 +989,14 @@ gimp_vectors_bezier_stroke_conicto (gint32  vectors_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_VECTORS_ID,
-                                          GIMP_TYPE_INT32,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_VECTORS_ID, vectors_ID,
+                                          GIMP_TYPE_INT32, stroke_id,
+                                          G_TYPE_DOUBLE, x0,
+                                          G_TYPE_DOUBLE, y0,
+                                          G_TYPE_DOUBLE, x1,
+                                          G_TYPE_DOUBLE, y1,
                                           G_TYPE_NONE);
-  gimp_value_set_vectors_id (gimp_value_array_index (args, 0), vectors_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), stroke_id);
-  g_value_set_double (gimp_value_array_index (args, 2), x0);
-  g_value_set_double (gimp_value_array_index (args, 3), y0);
-  g_value_set_double (gimp_value_array_index (args, 4), x1);
-  g_value_set_double (gimp_value_array_index (args, 5), y1);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1091,23 +1048,16 @@ gimp_vectors_bezier_stroke_cubicto (gint32  vectors_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_VECTORS_ID,
-                                          GIMP_TYPE_INT32,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_VECTORS_ID, vectors_ID,
+                                          GIMP_TYPE_INT32, stroke_id,
+                                          G_TYPE_DOUBLE, x0,
+                                          G_TYPE_DOUBLE, y0,
+                                          G_TYPE_DOUBLE, x1,
+                                          G_TYPE_DOUBLE, y1,
+                                          G_TYPE_DOUBLE, x2,
+                                          G_TYPE_DOUBLE, y2,
                                           G_TYPE_NONE);
-  gimp_value_set_vectors_id (gimp_value_array_index (args, 0), vectors_ID);
-  g_value_set_int (gimp_value_array_index (args, 1), stroke_id);
-  g_value_set_double (gimp_value_array_index (args, 2), x0);
-  g_value_set_double (gimp_value_array_index (args, 3), y0);
-  g_value_set_double (gimp_value_array_index (args, 4), x1);
-  g_value_set_double (gimp_value_array_index (args, 5), y1);
-  g_value_set_double (gimp_value_array_index (args, 6), x2);
-  g_value_set_double (gimp_value_array_index (args, 7), y2);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1155,19 +1105,14 @@ gimp_vectors_bezier_stroke_new_ellipse (gint32  vectors_ID,
   GimpValueArray *return_vals;
   gint stroke_id = 0;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_VECTORS_ID,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
-                                          G_TYPE_DOUBLE,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_VECTORS_ID, vectors_ID,
+                                          G_TYPE_DOUBLE, x0,
+                                          G_TYPE_DOUBLE, y0,
+                                          G_TYPE_DOUBLE, radius_x,
+                                          G_TYPE_DOUBLE, radius_y,
+                                          G_TYPE_DOUBLE, angle,
                                           G_TYPE_NONE);
-  gimp_value_set_vectors_id (gimp_value_array_index (args, 0), vectors_ID);
-  g_value_set_double (gimp_value_array_index (args, 1), x0);
-  g_value_set_double (gimp_value_array_index (args, 2), y0);
-  g_value_set_double (gimp_value_array_index (args, 3), radius_x);
-  g_value_set_double (gimp_value_array_index (args, 4), radius_y);
-  g_value_set_double (gimp_value_array_index (args, 5), angle);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1217,15 +1162,12 @@ gimp_vectors_import_from_file (gint32        image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          G_TYPE_STRING,
-                                          G_TYPE_BOOLEAN,
-                                          G_TYPE_BOOLEAN,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_STRING, filename,
+                                          G_TYPE_BOOLEAN, merge,
+                                          G_TYPE_BOOLEAN, scale,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_string (gimp_value_array_index (args, 1), filename);
-  g_value_set_boolean (gimp_value_array_index (args, 2), merge);
-  g_value_set_boolean (gimp_value_array_index (args, 3), scale);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1286,17 +1228,13 @@ gimp_vectors_import_from_string (gint32        image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          G_TYPE_STRING,
-                                          GIMP_TYPE_INT32,
-                                          G_TYPE_BOOLEAN,
-                                          G_TYPE_BOOLEAN,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_STRING, string,
+                                          GIMP_TYPE_INT32, length,
+                                          G_TYPE_BOOLEAN, merge,
+                                          G_TYPE_BOOLEAN, scale,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_string (gimp_value_array_index (args, 1), string);
-  g_value_set_int (gimp_value_array_index (args, 2), length);
-  g_value_set_boolean (gimp_value_array_index (args, 3), merge);
-  g_value_set_boolean (gimp_value_array_index (args, 4), scale);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1350,13 +1288,11 @@ gimp_vectors_export_to_file (gint32       image_ID,
   GimpValueArray *return_vals;
   gboolean success = TRUE;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          G_TYPE_STRING,
-                                          GIMP_TYPE_VECTORS_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          G_TYPE_STRING, filename,
+                                          GIMP_TYPE_VECTORS_ID, vectors_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  g_value_set_string (gimp_value_array_index (args, 1), filename);
-  gimp_value_set_vectors_id (gimp_value_array_index (args, 2), vectors_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
@@ -1401,11 +1337,10 @@ gimp_vectors_export_to_string (gint32 image_ID,
   GimpValueArray *return_vals;
   gchar *string = NULL;
 
-  args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
-                                          GIMP_TYPE_VECTORS_ID,
+  args = gimp_value_array_new_from_types (NULL,
+                                          GIMP_TYPE_IMAGE_ID, image_ID,
+                                          GIMP_TYPE_VECTORS_ID, vectors_ID,
                                           G_TYPE_NONE);
-  gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
-  gimp_value_set_vectors_id (gimp_value_array_index (args, 1), vectors_ID);
 
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,
diff --git a/libgimpbase/gimpvaluearray.c b/libgimpbase/gimpvaluearray.c
index 85905d0017..5079a87e46 100644
--- a/libgimpbase/gimpvaluearray.c
+++ b/libgimpbase/gimpvaluearray.c
@@ -23,6 +23,7 @@
 #include <string.h>
 
 #include <glib-object.h>
+#include <gobject/gvaluecollector.h>
 
 #include "gimpbasetypes.h"
 
@@ -147,18 +148,22 @@ gimp_value_array_new (gint n_prealloced)
 
 /**
  * gimp_value_array_new_from_types:
+ * @error_msg:  return location for an error message.
  * @first_type: first type in the array, or #G_TYPE_NONE.
  * @...:        the remaining types in the array, terminated by #G_TYPE_NONE
  *
  * Allocate and initialize a new #GimpValueArray, and fill it with
- * values that are initialized to the types passed.
+ * values that are given as a list of (#GType, value) pairs,
+ * terminated by #G_TYPE_NONE.
  *
- * Returns: a newly allocated #GimpValueArray
+ * Returns: (nullable): a newly allocated #GimpValueArray, or %NULL if
+ *          an error happened.
  *
  * Since: 3.0
  */
 GimpValueArray *
-gimp_value_array_new_from_types (GType first_type,
+gimp_value_array_new_from_types (gchar **error_msg,
+                                 GType   first_type,
                                  ...)
 {
   GimpValueArray *value_array;
@@ -166,7 +171,8 @@ gimp_value_array_new_from_types (GType first_type,
 
   va_start (va_args, first_type);
 
-  value_array = gimp_value_array_new_from_types_valist (first_type,
+  value_array = gimp_value_array_new_from_types_valist (error_msg,
+                                                        first_type,
                                                         va_args);
 
   va_end (va_args);
@@ -180,15 +186,18 @@ gimp_value_array_new_from_types (GType first_type,
  * @va_args:    a va_list of GTypes and values, terminated by #G_TYPE_NONE
  *
  * Allocate and initialize a new #GimpValueArray, and fill it with
- * values that are initialized to the types passed.
+ * @va_args given in the order as passed to
+ * gimp_value_array_new_from_types().
  *
- * Returns: a newly allocated #GimpValueArray
+ * Returns: (nullable): a newly allocated #GimpValueArray, or %NULL if
+ *          an error happened.
  *
  * Since: 3.0
  */
 GimpValueArray *
-gimp_value_array_new_from_types_valist (GType   first_type,
-                                        va_list va_args)
+gimp_value_array_new_from_types_valist (gchar   **error_msg,
+                                        GType     first_type,
+                                        va_list   va_args)
 {
   GimpValueArray *value_array = gimp_value_array_new (0);
   GType           type;
@@ -197,9 +206,32 @@ gimp_value_array_new_from_types_valist (GType   first_type,
 
   while (type != G_TYPE_NONE)
     {
-      GValue value = G_VALUE_INIT;
+      GValue value     = G_VALUE_INIT;
+      gchar  *my_error = NULL;
 
       g_value_init (&value, type);
+
+      G_VALUE_COLLECT (&value, va_args, G_VALUE_NOCOPY_CONTENTS, &my_error);
+
+      if (my_error)
+        {
+          if (error_msg)
+            {
+              *error_msg = my_error;
+            }
+          else
+            {
+              g_printerr ("%s: %s", G_STRFUNC, my_error);
+              g_free (my_error);
+            }
+
+          gimp_value_array_unref (value_array);
+
+          va_end (va_args);
+
+          return NULL;
+        }
+
       gimp_value_array_append (value_array, &value);
       g_value_unset (&value);
 
diff --git a/libgimpbase/gimpvaluearray.h b/libgimpbase/gimpvaluearray.h
index bc70424270..5c17eb6d1a 100644
--- a/libgimpbase/gimpvaluearray.h
+++ b/libgimpbase/gimpvaluearray.h
@@ -42,10 +42,12 @@ GType            gimp_value_array_get_type (void) G_GNUC_CONST;
 
 GimpValueArray * gimp_value_array_new      (gint                  n_prealloced);
 GimpValueArray * gimp_value_array_new_from_types
-                                           (GType                 first_type,
+                                           (gchar               **error_msg,
+                                            GType                 first_type,
                                             ...);
 GimpValueArray * gimp_value_array_new_from_types_valist
-                                           (GType                 first_type,
+                                           (gchar               **error_msg,
+                                            GType                 first_type,
                                             va_list               va_args);
 
 GimpValueArray * gimp_value_array_ref      (GimpValueArray       *value_array);
diff --git a/pdb/lib.pl b/pdb/lib.pl
index d9f1a94c53..7130dc112c 100644
--- a/pdb/lib.pl
+++ b/pdb/lib.pl
@@ -206,27 +206,36 @@ sub generate {
                $enum_type =~ s/^GIMP/GIMP_TYPE/;
                $enum_type =~ s/^GEGL/GEGL_TYPE/;
 
-               $value_array .= "$enum_type,\n" .  " " x 42;
+               $value_array .= "$enum_type, ";
            }
            else {
-               $value_array .= "$arg->{gtype},\n" . " " x 42;
+               $value_array .= "$arg->{gtype}, ";
            }
 
-           $value = "gimp_value_array_index (args, $argc)";
+           if (exists $_->{array}) {
+               $value_array .= "NULL";
+           }
+           else {
+               $value_array .= "$var";
+           }
+
+           $value_array .= ",\n" . " " x 42;
 
            if (exists $_->{array}) {
                my $arrayarg = $_->{array};
 
+               $value = "gimp_value_array_index (args, $argc)";
+
                if (exists $arrayarg->{name}) {
                    $var_len = $arrayarg->{name};
                }
                else {
                    $var_len = 'num_' . $_->{name};
                }
-           }
 
-           # This is the list of g_value_set_foo
-           $arg_array .= eval qq/"  $arg->{set_value_func};\n"/;
+               # This is the list of g_value_set_foo_array
+               $arg_array .= eval qq/"  $arg->{set_value_func};\n"/;
+           }
 
            $usednames{$_->{name}}++;
 
@@ -533,7 +542,8 @@ $wrapped$funcname ($clist)
   GimpValueArray *args;
   GimpValueArray *return_vals;$return_args
 
-  args = gimp_value_array_new_from_types (${value_array}G_TYPE_NONE);
+  args = gimp_value_array_new_from_types (NULL,
+                                          ${value_array}G_TYPE_NONE);
 $arg_array
   if (pdb)
     return_vals = gimp_pdb_run_procedure_array (pdb,


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]