[gimp] pdb, libgimp: port lib.pl to the new GType based libgimp API
- From: Michael Natterer <mitch src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gimp] pdb, libgimp: port lib.pl to the new GType based libgimp API
- Date: Tue, 30 Jul 2019 08:53:11 +0000 (UTC)
commit af5c587e21e63836ba8a4568df61803076069a2a
Author: Michael Natterer <mitch gimp org>
Date: Tue Jul 30 10:51:16 2019 +0200
pdb, libgimp: port lib.pl to the new GType based libgimp API
All foo_pdb.c functions in libgimp regenerated. I have reviewed this a
dozen times, but please have a look, there might well be glitches and
our public API is sortof important...
libgimp/gimp_pdb.c | 142 +--
libgimp/gimpbrush_pdb.c | 510 +++++----
libgimp/gimpbrushes_pdb.c | 45 +-
libgimp/gimpbrushselect_pdb.c | 88 +-
libgimp/gimpbuffer_pdb.c | 156 +--
libgimp/gimpchannel_pdb.c | 248 +++--
libgimp/gimpcontext_pdb.c | 2083 ++++++++++++++++++++---------------
libgimp/gimpdebug_pdb.c | 34 +-
libgimp/gimpdisplay_pdb.c | 120 +-
libgimp/gimpdrawable_pdb.c | 615 ++++++-----
libgimp/gimpdrawablecolor_pdb.c | 399 ++++---
libgimp/gimpdrawableedit_pdb.c | 163 +--
libgimp/gimpdynamics_pdb.c | 45 +-
libgimp/gimpedit_pdb.c | 225 ++--
libgimp/gimpfileops_pdb.c | 323 +++---
libgimp/gimpfloatingsel_pdb.c | 79 +-
libgimp/gimpfonts_pdb.c | 45 +-
libgimp/gimpfontselect_pdb.c | 66 +-
libgimp/gimpgimprc_pdb.c | 135 ++-
libgimp/gimpgradient_pdb.c | 804 ++++++++------
libgimp/gimpgradients_pdb.c | 45 +-
libgimp/gimpgradientselect_pdb.c | 69 +-
libgimp/gimphelp_pdb.c | 22 +-
libgimp/gimpimage_pdb.c | 1895 +++++++++++++++++--------------
libgimp/gimpimagecolorprofile_pdb.c | 160 +--
libgimp/gimpimageconvert_pdb.c | 125 ++-
libgimp/gimpimagegrid_pdb.c | 225 ++--
libgimp/gimpimageguides_pdb.c | 142 ++-
libgimp/gimpimagesamplepoints_pdb.c | 99 +-
libgimp/gimpimageselect_pdb.c | 224 ++--
libgimp/gimpimagetransform_pdb.c | 150 ++-
libgimp/gimpimageundo_pdb.c | 143 ++-
libgimp/gimpitem_pdb.c | 719 ++++++------
libgimp/gimpitemtransform_pdb.c | 363 +++---
libgimp/gimplayer_pdb.c | 798 ++++++++------
libgimp/gimpmessage_pdb.c | 56 +-
libgimp/gimppainttools_pdb.c | 486 ++++----
libgimp/gimppalette_pdb.c | 345 +++---
libgimp/gimppalettes_pdb.c | 45 +-
libgimp/gimppaletteselect_pdb.c | 66 +-
libgimp/gimppattern_pdb.c | 59 +-
libgimp/gimppatterns_pdb.c | 45 +-
libgimp/gimppatternselect_pdb.c | 66 +-
libgimp/gimpplugin_pdb.c | 153 +--
libgimp/gimpproceduraldb_pdb.c | 272 +++--
libgimp/gimpprogress_pdb.c | 167 +--
libgimp/gimpselection_pdb.c | 333 +++---
libgimp/gimptextlayer_pdb.c | 643 ++++++-----
libgimp/gimptexttool_pdb.c | 88 +-
libgimp/gimpunit_pdb.c | 269 +++--
libgimp/gimpvectors_pdb.c | 752 +++++++------
libgimp/gimpvectors_pdb.h | 4 +-
pdb/lib.pl | 182 ++-
53 files changed, 8922 insertions(+), 6613 deletions(-)
---
diff --git a/libgimp/gimp_pdb.c b/libgimp/gimp_pdb.c
index b041d766e7..74beecef96 100644
--- a/libgimp/gimp_pdb.c
+++ b/libgimp/gimp_pdb.c
@@ -47,18 +47,20 @@
gchar *
gimp_version (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *version = NULL;
- return_vals = gimp_run_procedure ("gimp-version",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- version = g_strdup (return_vals[1].data.d_string);
+ return_vals = gimp_run_procedure_with_array ("gimp-version",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ version = g_value_dup_string (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return version;
}
@@ -77,18 +79,20 @@ gimp_version (void)
gint
gimp_getpid (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint pid = 0;
- return_vals = gimp_run_procedure ("gimp-getpid",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-getpid",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- pid = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ pid = g_value_get_int (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return pid;
}
@@ -108,18 +112,21 @@ gimp_getpid (void)
gboolean
gimp_attach_parasite (const GimpParasite *parasite)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-attach-parasite",
- &nreturn_vals,
- GIMP_PDB_PARASITE, parasite,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_PARASITE,
+ G_TYPE_NONE);
+ g_value_set_boxed (gimp_value_array_index (args, 0), parasite);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-attach-parasite",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -140,18 +147,21 @@ gimp_attach_parasite (const GimpParasite *parasite)
gboolean
gimp_detach_parasite (const gchar *name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-detach-parasite",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), name);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-detach-parasite",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -171,19 +181,22 @@ gimp_detach_parasite (const gchar *name)
GimpParasite *
gimp_get_parasite (const gchar *name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
GimpParasite *parasite = NULL;
- return_vals = gimp_run_procedure ("gimp-get-parasite",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), name);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- parasite = gimp_parasite_copy (&return_vals[1].data.d_parasite);
+ return_vals = gimp_run_procedure_with_array ("gimp-get-parasite",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ parasite = g_value_dup_boxed (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return parasite;
}
@@ -204,29 +217,25 @@ gimp_get_parasite (const gchar *name)
gchar **
gimp_get_parasite_list (gint *num_parasites)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar **parasites = NULL;
- gint i;
- return_vals = gimp_run_procedure ("gimp-get-parasite-list",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-get-parasite-list",
+ args);
+ gimp_value_array_unref (args);
*num_parasites = 0;
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
{
- *num_parasites = return_vals[1].data.d_int32;
- if (*num_parasites > 0)
- {
- parasites = g_new0 (gchar *, *num_parasites + 1);
- for (i = 0; i < *num_parasites; i++)
- parasites[i] = g_strdup (return_vals[2].data.d_stringarray[i]);
- }
+ *num_parasites = g_value_get_int (gimp_value_array_index (return_vals, 1));
+ parasites = gimp_value_dup_string_array (gimp_value_array_index (return_vals, 2));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return parasites;
}
@@ -245,19 +254,22 @@ gimp_get_parasite_list (gint *num_parasites)
gchar *
gimp_temp_name (const gchar *extension)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *name = NULL;
- return_vals = gimp_run_procedure ("gimp-temp-name",
- &nreturn_vals,
- GIMP_PDB_STRING, extension,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), extension);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-temp-name",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- name = g_strdup (return_vals[1].data.d_string);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ name = g_value_dup_string (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return name;
}
diff --git a/libgimp/gimpbrush_pdb.c b/libgimp/gimpbrush_pdb.c
index 6cb5bc7a57..5928bc5e15 100644
--- a/libgimp/gimpbrush_pdb.c
+++ b/libgimp/gimpbrush_pdb.c
@@ -22,8 +22,6 @@
#include "config.h"
-#include <string.h>
-
#include "gimp.h"
@@ -52,19 +50,22 @@
gchar *
gimp_brush_new (const gchar *name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *actual_name = NULL;
- return_vals = gimp_run_procedure ("gimp-brush-new",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), name);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-brush-new",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- actual_name = g_strdup (return_vals[1].data.d_string);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ actual_name = g_value_dup_string (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return actual_name;
}
@@ -85,19 +86,22 @@ gimp_brush_new (const gchar *name)
gchar *
gimp_brush_duplicate (const gchar *name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *copy_name = NULL;
- return_vals = gimp_run_procedure ("gimp-brush-duplicate",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), name);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-brush-duplicate",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- copy_name = g_strdup (return_vals[1].data.d_string);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ copy_name = g_value_dup_string (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return copy_name;
}
@@ -117,19 +121,22 @@ gimp_brush_duplicate (const gchar *name)
gboolean
gimp_brush_is_generated (const gchar *name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean generated = FALSE;
- return_vals = gimp_run_procedure ("gimp-brush-is-generated",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), name);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- generated = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-brush-is-generated",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ generated = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return generated;
}
@@ -152,20 +159,24 @@ gchar *
gimp_brush_rename (const gchar *name,
const gchar *new_name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *actual_name = NULL;
- return_vals = gimp_run_procedure ("gimp-brush-rename",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_STRING, new_name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_STRING,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-brush-rename",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- actual_name = g_strdup (return_vals[1].data.d_string);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ actual_name = g_value_dup_string (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return actual_name;
}
@@ -185,18 +196,21 @@ gimp_brush_rename (const gchar *name,
gboolean
gimp_brush_delete (const gchar *name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-brush-delete",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), name);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-brush-delete",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -216,19 +230,22 @@ gimp_brush_delete (const gchar *name)
gboolean
gimp_brush_is_editable (const gchar *name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean editable = FALSE;
- return_vals = gimp_run_procedure ("gimp-brush-is-editable",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), name);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- editable = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-brush-is-editable",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ editable = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return editable;
}
@@ -257,31 +274,34 @@ gimp_brush_get_info (const gchar *name,
gint *mask_bpp,
gint *color_bpp)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-brush-get-info",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), name);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-brush-get-info",
+ args);
+ gimp_value_array_unref (args);
*width = 0;
*height = 0;
*mask_bpp = 0;
*color_bpp = 0;
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
{
- *width = return_vals[1].data.d_int32;
- *height = return_vals[2].data.d_int32;
- *mask_bpp = return_vals[3].data.d_int32;
- *color_bpp = return_vals[4].data.d_int32;
+ *width = g_value_get_int (gimp_value_array_index (return_vals, 1));
+ *height = g_value_get_int (gimp_value_array_index (return_vals, 2));
+ *mask_bpp = g_value_get_int (gimp_value_array_index (return_vals, 3));
+ *color_bpp = g_value_get_int (gimp_value_array_index (return_vals, 4));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -318,14 +338,17 @@ gimp_brush_get_pixels (const gchar *name,
gint *num_color_bytes,
guint8 **color_bytes)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-brush-get-pixels",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), name);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-brush-get-pixels",
+ args);
+ gimp_value_array_unref (args);
*width = 0;
*height = 0;
@@ -336,27 +359,21 @@ gimp_brush_get_pixels (const gchar *name,
*num_color_bytes = 0;
*color_bytes = NULL;
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
{
- *width = return_vals[1].data.d_int32;
- *height = return_vals[2].data.d_int32;
- *mask_bpp = return_vals[3].data.d_int32;
- *num_mask_bytes = return_vals[4].data.d_int32;
- *mask_bytes = g_new (guint8, *num_mask_bytes);
- memcpy (*mask_bytes,
- return_vals[5].data.d_int8array,
- *num_mask_bytes * sizeof (guint8));
- *color_bpp = return_vals[6].data.d_int32;
- *num_color_bytes = return_vals[7].data.d_int32;
- *color_bytes = g_new (guint8, *num_color_bytes);
- memcpy (*color_bytes,
- return_vals[8].data.d_int8array,
- *num_color_bytes * sizeof (guint8));
+ *width = g_value_get_int (gimp_value_array_index (return_vals, 1));
+ *height = g_value_get_int (gimp_value_array_index (return_vals, 2));
+ *mask_bpp = g_value_get_int (gimp_value_array_index (return_vals, 3));
+ *num_mask_bytes = g_value_get_int (gimp_value_array_index (return_vals, 4));
+ *mask_bytes = gimp_value_dup_int8_array (gimp_value_array_index (return_vals, 5));
+ *color_bpp = g_value_get_int (gimp_value_array_index (return_vals, 6));
+ *num_color_bytes = g_value_get_int (gimp_value_array_index (return_vals, 7));
+ *color_bytes = gimp_value_dup_int8_array (gimp_value_array_index (return_vals, 8));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -380,23 +397,26 @@ gboolean
gimp_brush_get_spacing (const gchar *name,
gint *spacing)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-brush-get-spacing",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), name);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-brush-get-spacing",
+ args);
+ gimp_value_array_unref (args);
*spacing = 0;
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
- *spacing = return_vals[1].data.d_int32;
+ *spacing = g_value_get_int (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -419,19 +439,23 @@ gboolean
gimp_brush_set_spacing (const gchar *name,
gint spacing)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-brush-set-spacing",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_INT32, spacing,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-brush-set-spacing",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -456,19 +480,22 @@ gimp_brush_set_spacing (const gchar *name,
GimpBrushGeneratedShape
gimp_brush_get_shape (const gchar *name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
GimpBrushGeneratedShape shape = 0;
- return_vals = gimp_run_procedure ("gimp-brush-get-shape",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), name);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-brush-get-shape",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- shape = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ shape = g_value_get_enum (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return shape;
}
@@ -495,20 +522,24 @@ GimpBrushGeneratedShape
gimp_brush_set_shape (const gchar *name,
GimpBrushGeneratedShape shape_in)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
GimpBrushGeneratedShape shape_out = 0;
- return_vals = gimp_run_procedure ("gimp-brush-set-shape",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_INT32, shape_in,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_ENUM,
+ 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 (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- shape_out = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-brush-set-shape",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ shape_out = g_value_get_enum (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return shape_out;
}
@@ -529,19 +560,22 @@ gimp_brush_set_shape (const gchar *name,
gdouble
gimp_brush_get_radius (const gchar *name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gdouble radius = 0.0;
- return_vals = gimp_run_procedure ("gimp-brush-get-radius",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), name);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-brush-get-radius",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- radius = return_vals[1].data.d_float;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ radius = g_value_get_double (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return radius;
}
@@ -564,20 +598,24 @@ gdouble
gimp_brush_set_radius (const gchar *name,
gdouble radius_in)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gdouble radius_out = 0.0;
- return_vals = gimp_run_procedure ("gimp-brush-set-radius",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_FLOAT, radius_in,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_DOUBLE,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-brush-set-radius",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- radius_out = return_vals[1].data.d_float;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ radius_out = g_value_get_double (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return radius_out;
}
@@ -598,19 +636,22 @@ gimp_brush_set_radius (const gchar *name,
gint
gimp_brush_get_spikes (const gchar *name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint spikes = 0;
- return_vals = gimp_run_procedure ("gimp-brush-get-spikes",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), name);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- spikes = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-brush-get-spikes",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ spikes = g_value_get_int (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return spikes;
}
@@ -633,20 +674,24 @@ gint
gimp_brush_set_spikes (const gchar *name,
gint spikes_in)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint spikes_out = 0;
- return_vals = gimp_run_procedure ("gimp-brush-set-spikes",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_INT32, spikes_in,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-brush-set-spikes",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- spikes_out = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ spikes_out = g_value_get_int (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return spikes_out;
}
@@ -669,19 +714,22 @@ gimp_brush_set_spikes (const gchar *name,
gdouble
gimp_brush_get_hardness (const gchar *name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gdouble hardness = 0.0;
- return_vals = gimp_run_procedure ("gimp-brush-get-hardness",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), name);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-brush-get-hardness",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- hardness = return_vals[1].data.d_float;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ hardness = g_value_get_double (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return hardness;
}
@@ -705,20 +753,24 @@ gdouble
gimp_brush_set_hardness (const gchar *name,
gdouble hardness_in)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gdouble hardness_out = 0.0;
- return_vals = gimp_run_procedure ("gimp-brush-set-hardness",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_FLOAT, hardness_in,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_DOUBLE,
+ 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 (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- hardness_out = return_vals[1].data.d_float;
+ return_vals = gimp_run_procedure_with_array ("gimp-brush-set-hardness",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ hardness_out = g_value_get_double (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return hardness_out;
}
@@ -740,19 +792,22 @@ gimp_brush_set_hardness (const gchar *name,
gdouble
gimp_brush_get_aspect_ratio (const gchar *name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gdouble aspect_ratio = 0.0;
- return_vals = gimp_run_procedure ("gimp-brush-get-aspect-ratio",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), name);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-brush-get-aspect-ratio",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- aspect_ratio = return_vals[1].data.d_float;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ aspect_ratio = g_value_get_double (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return aspect_ratio;
}
@@ -776,20 +831,24 @@ gdouble
gimp_brush_set_aspect_ratio (const gchar *name,
gdouble aspect_ratio_in)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gdouble aspect_ratio_out = 0.0;
- return_vals = gimp_run_procedure ("gimp-brush-set-aspect-ratio",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_FLOAT, aspect_ratio_in,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_DOUBLE,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-brush-set-aspect-ratio",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- aspect_ratio_out = return_vals[1].data.d_float;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ aspect_ratio_out = g_value_get_double (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return aspect_ratio_out;
}
@@ -810,19 +869,22 @@ gimp_brush_set_aspect_ratio (const gchar *name,
gdouble
gimp_brush_get_angle (const gchar *name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gdouble angle = 0.0;
- return_vals = gimp_run_procedure ("gimp-brush-get-angle",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), name);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- angle = return_vals[1].data.d_float;
+ return_vals = gimp_run_procedure_with_array ("gimp-brush-get-angle",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ angle = g_value_get_double (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return angle;
}
@@ -845,20 +907,24 @@ gdouble
gimp_brush_set_angle (const gchar *name,
gdouble angle_in)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gdouble angle_out = 0.0;
- return_vals = gimp_run_procedure ("gimp-brush-set-angle",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_FLOAT, angle_in,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_DOUBLE,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-brush-set-angle",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- angle_out = return_vals[1].data.d_float;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ angle_out = g_value_get_double (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return angle_out;
}
diff --git a/libgimp/gimpbrushes_pdb.c b/libgimp/gimpbrushes_pdb.c
index 1f6da40061..1391dfe278 100644
--- a/libgimp/gimpbrushes_pdb.c
+++ b/libgimp/gimpbrushes_pdb.c
@@ -47,17 +47,19 @@
gboolean
gimp_brushes_refresh (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-brushes-refresh",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-brushes-refresh",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -80,30 +82,27 @@ gchar **
gimp_brushes_get_list (const gchar *filter,
gint *num_brushes)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar **brush_list = NULL;
- gint i;
- return_vals = gimp_run_procedure ("gimp-brushes-get-list",
- &nreturn_vals,
- GIMP_PDB_STRING, filter,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), filter);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-brushes-get-list",
+ args);
+ gimp_value_array_unref (args);
*num_brushes = 0;
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
{
- *num_brushes = return_vals[1].data.d_int32;
- if (*num_brushes > 0)
- {
- brush_list = g_new0 (gchar *, *num_brushes + 1);
- for (i = 0; i < *num_brushes; i++)
- brush_list[i] = g_strdup (return_vals[2].data.d_stringarray[i]);
- }
+ *num_brushes = g_value_get_int (gimp_value_array_index (return_vals, 1));
+ brush_list = gimp_value_dup_string_array (gimp_value_array_index (return_vals, 2));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return brush_list;
}
diff --git a/libgimp/gimpbrushselect_pdb.c b/libgimp/gimpbrushselect_pdb.c
index 9a813f1ac4..afafc87b17 100644
--- a/libgimp/gimpbrushselect_pdb.c
+++ b/libgimp/gimpbrushselect_pdb.c
@@ -57,23 +57,31 @@ gimp_brushes_popup (const gchar *brush_callback,
gint spacing,
GimpLayerMode paint_mode)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-brushes-popup",
- &nreturn_vals,
- GIMP_PDB_STRING, brush_callback,
- GIMP_PDB_STRING, popup_title,
- GIMP_PDB_STRING, initial_brush,
- GIMP_PDB_FLOAT, opacity,
- GIMP_PDB_INT32, spacing,
- GIMP_PDB_INT32, paint_mode,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_STRING,
+ G_TYPE_STRING,
+ G_TYPE_DOUBLE,
+ GIMP_TYPE_INT32,
+ G_TYPE_ENUM,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-brushes-popup",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -91,18 +99,21 @@ gimp_brushes_popup (const gchar *brush_callback,
gboolean
gimp_brushes_close_popup (const gchar *brush_callback)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-brushes-close-popup",
- &nreturn_vals,
- GIMP_PDB_STRING, brush_callback,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), brush_callback);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-brushes-close-popup",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -128,22 +139,29 @@ gimp_brushes_set_popup (const gchar *brush_callback,
gint spacing,
GimpLayerMode paint_mode)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-brushes-set-popup",
- &nreturn_vals,
- GIMP_PDB_STRING, brush_callback,
- GIMP_PDB_STRING, brush_name,
- GIMP_PDB_FLOAT, opacity,
- GIMP_PDB_INT32, spacing,
- GIMP_PDB_INT32, paint_mode,
- GIMP_PDB_END);
-
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
-
- gimp_destroy_params (return_vals, nreturn_vals);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_STRING,
+ G_TYPE_DOUBLE,
+ GIMP_TYPE_INT32,
+ G_TYPE_ENUM,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-brushes-set-popup",
+ args);
+ gimp_value_array_unref (args);
+
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
diff --git a/libgimp/gimpbuffer_pdb.c b/libgimp/gimpbuffer_pdb.c
index afe8ee09b3..c34d10a68a 100644
--- a/libgimp/gimpbuffer_pdb.c
+++ b/libgimp/gimpbuffer_pdb.c
@@ -53,30 +53,27 @@ gchar **
gimp_buffers_get_list (const gchar *filter,
gint *num_buffers)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar **buffer_list = NULL;
- gint i;
- return_vals = gimp_run_procedure ("gimp-buffers-get-list",
- &nreturn_vals,
- GIMP_PDB_STRING, filter,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), filter);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-buffers-get-list",
+ args);
+ gimp_value_array_unref (args);
*num_buffers = 0;
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
{
- *num_buffers = return_vals[1].data.d_int32;
- if (*num_buffers > 0)
- {
- buffer_list = g_new0 (gchar *, *num_buffers + 1);
- for (i = 0; i < *num_buffers; i++)
- buffer_list[i] = g_strdup (return_vals[2].data.d_stringarray[i]);
- }
+ *num_buffers = g_value_get_int (gimp_value_array_index (return_vals, 1));
+ buffer_list = gimp_value_dup_string_array (gimp_value_array_index (return_vals, 2));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return buffer_list;
}
@@ -98,20 +95,24 @@ gchar *
gimp_buffer_rename (const gchar *buffer_name,
const gchar *new_name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *real_name = NULL;
- return_vals = gimp_run_procedure ("gimp-buffer-rename",
- &nreturn_vals,
- GIMP_PDB_STRING, buffer_name,
- GIMP_PDB_STRING, new_name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_STRING,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-buffer-rename",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- real_name = g_strdup (return_vals[1].data.d_string);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ real_name = g_value_dup_string (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return real_name;
}
@@ -131,18 +132,21 @@ gimp_buffer_rename (const gchar *buffer_name,
gboolean
gimp_buffer_delete (const gchar *buffer_name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-buffer-delete",
- &nreturn_vals,
- GIMP_PDB_STRING, buffer_name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), buffer_name);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-buffer-delete",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -162,19 +166,22 @@ gimp_buffer_delete (const gchar *buffer_name)
gint
gimp_buffer_get_width (const gchar *buffer_name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint width = 0;
- return_vals = gimp_run_procedure ("gimp-buffer-get-width",
- &nreturn_vals,
- GIMP_PDB_STRING, buffer_name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), buffer_name);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-buffer-get-width",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- width = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ width = g_value_get_int (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return width;
}
@@ -194,19 +201,22 @@ gimp_buffer_get_width (const gchar *buffer_name)
gint
gimp_buffer_get_height (const gchar *buffer_name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint height = 0;
- return_vals = gimp_run_procedure ("gimp-buffer-get-height",
- &nreturn_vals,
- GIMP_PDB_STRING, buffer_name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), buffer_name);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- height = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-buffer-get-height",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ height = g_value_get_int (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return height;
}
@@ -226,19 +236,22 @@ gimp_buffer_get_height (const gchar *buffer_name)
gint
gimp_buffer_get_bytes (const gchar *buffer_name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint bytes = 0;
- return_vals = gimp_run_procedure ("gimp-buffer-get-bytes",
- &nreturn_vals,
- GIMP_PDB_STRING, buffer_name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), buffer_name);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-buffer-get-bytes",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- bytes = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ bytes = g_value_get_int (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return bytes;
}
@@ -258,19 +271,22 @@ gimp_buffer_get_bytes (const gchar *buffer_name)
GimpImageBaseType
gimp_buffer_get_image_type (const gchar *buffer_name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
GimpImageBaseType image_type = 0;
- return_vals = gimp_run_procedure ("gimp-buffer-get-image-type",
- &nreturn_vals,
- GIMP_PDB_STRING, buffer_name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), buffer_name);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-buffer-get-image-type",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- image_type = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ image_type = g_value_get_enum (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return image_type;
}
diff --git a/libgimp/gimpchannel_pdb.c b/libgimp/gimpchannel_pdb.c
index a1b1a85896..0c62ca291e 100644
--- a/libgimp/gimpchannel_pdb.c
+++ b/libgimp/gimpchannel_pdb.c
@@ -63,24 +63,32 @@ _gimp_channel_new (gint32 image_ID,
gdouble opacity,
const GimpRGB *color)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 channel_ID = -1;
- return_vals = gimp_run_procedure ("gimp-channel-new",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, width,
- GIMP_PDB_INT32, height,
- GIMP_PDB_STRING, name,
- GIMP_PDB_FLOAT, opacity,
- GIMP_PDB_COLOR, color,
- GIMP_PDB_END);
-
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- channel_ID = return_vals[1].data.d_channel;
-
- gimp_destroy_params (return_vals, nreturn_vals);
+ 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,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-channel-new",
+ args);
+ gimp_value_array_unref (args);
+
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ channel_ID = gimp_value_get_channel_id (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return channel_ID;
}
@@ -108,21 +116,26 @@ gimp_channel_new_from_component (gint32 image_ID,
GimpChannelType component,
const gchar *name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 channel_ID = -1;
- return_vals = gimp_run_procedure ("gimp-channel-new-from-component",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, component,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_ENUM,
+ G_TYPE_STRING,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-channel-new-from-component",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- channel_ID = return_vals[1].data.d_channel;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ channel_ID = gimp_value_get_channel_id (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return channel_ID;
}
@@ -142,19 +155,22 @@ gimp_channel_new_from_component (gint32 image_ID,
gint32
gimp_channel_copy (gint32 channel_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 channel_copy_ID = -1;
- return_vals = gimp_run_procedure ("gimp-channel-copy",
- &nreturn_vals,
- GIMP_PDB_CHANNEL, channel_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_CHANNEL_ID,
+ G_TYPE_NONE);
+ gimp_value_set_channel_id (gimp_value_array_index (args, 0), channel_ID);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- channel_copy_ID = return_vals[1].data.d_channel;
+ return_vals = gimp_run_procedure_with_array ("gimp-channel-copy",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ channel_copy_ID = gimp_value_get_channel_id (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return channel_copy_ID;
}
@@ -181,22 +197,29 @@ gimp_channel_combine_masks (gint32 channel1_ID,
gint offx,
gint offy)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-channel-combine-masks",
- &nreturn_vals,
- GIMP_PDB_CHANNEL, channel1_ID,
- GIMP_PDB_CHANNEL, channel2_ID,
- GIMP_PDB_INT32, operation,
- GIMP_PDB_INT32, offx,
- GIMP_PDB_INT32, offy,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_CHANNEL_ID,
+ GIMP_TYPE_CHANNEL_ID,
+ G_TYPE_ENUM,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-channel-combine-masks",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -216,19 +239,22 @@ gimp_channel_combine_masks (gint32 channel1_ID,
gboolean
gimp_channel_get_show_masked (gint32 channel_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean show_masked = FALSE;
- return_vals = gimp_run_procedure ("gimp-channel-get-show-masked",
- &nreturn_vals,
- GIMP_PDB_CHANNEL, channel_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_CHANNEL_ID,
+ G_TYPE_NONE);
+ gimp_value_set_channel_id (gimp_value_array_index (args, 0), channel_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-channel-get-show-masked",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- show_masked = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ show_masked = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return show_masked;
}
@@ -250,19 +276,23 @@ gboolean
gimp_channel_set_show_masked (gint32 channel_ID,
gboolean show_masked)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-channel-set-show-masked",
- &nreturn_vals,
- GIMP_PDB_CHANNEL, channel_ID,
- GIMP_PDB_INT32, show_masked,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_CHANNEL_ID,
+ G_TYPE_BOOLEAN,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-channel-set-show-masked",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -280,19 +310,22 @@ gimp_channel_set_show_masked (gint32 channel_ID,
gdouble
gimp_channel_get_opacity (gint32 channel_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gdouble opacity = 0.0;
- return_vals = gimp_run_procedure ("gimp-channel-get-opacity",
- &nreturn_vals,
- GIMP_PDB_CHANNEL, channel_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_CHANNEL_ID,
+ G_TYPE_NONE);
+ gimp_value_set_channel_id (gimp_value_array_index (args, 0), channel_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-channel-get-opacity",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- opacity = return_vals[1].data.d_float;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ opacity = g_value_get_double (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return opacity;
}
@@ -312,19 +345,23 @@ gboolean
gimp_channel_set_opacity (gint32 channel_ID,
gdouble opacity)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-channel-set-opacity",
- &nreturn_vals,
- GIMP_PDB_CHANNEL, channel_ID,
- GIMP_PDB_FLOAT, opacity,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_CHANNEL_ID,
+ G_TYPE_DOUBLE,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-channel-set-opacity",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -344,21 +381,24 @@ gboolean
gimp_channel_get_color (gint32 channel_ID,
GimpRGB *color)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-channel-get-color",
- &nreturn_vals,
- GIMP_PDB_CHANNEL, channel_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_CHANNEL_ID,
+ G_TYPE_NONE);
+ gimp_value_set_channel_id (gimp_value_array_index (args, 0), channel_ID);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-channel-get-color",
+ args);
+ gimp_value_array_unref (args);
+
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
- *color = return_vals[1].data.d_color;
+ gimp_value_get_rgb (gimp_value_array_index (return_vals, 1), &*color);
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -378,19 +418,23 @@ gboolean
gimp_channel_set_color (gint32 channel_ID,
const GimpRGB *color)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-channel-set-color",
- &nreturn_vals,
- GIMP_PDB_CHANNEL, channel_ID,
- GIMP_PDB_COLOR, color,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_CHANNEL_ID,
+ GIMP_TYPE_RGB,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-channel-set-color",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
diff --git a/libgimp/gimpcontext_pdb.c b/libgimp/gimpcontext_pdb.c
index a61e9b686d..5ef3ddd92c 100644
--- a/libgimp/gimpcontext_pdb.c
+++ b/libgimp/gimpcontext_pdb.c
@@ -22,8 +22,6 @@
#include "config.h"
-#include <string.h>
-
#include "gimp.h"
@@ -52,17 +50,19 @@
gboolean
gimp_context_push (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-push",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-push",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -84,17 +84,19 @@ gimp_context_push (void)
gboolean
gimp_context_pop (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-pop",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-context-pop",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -117,17 +119,19 @@ gimp_context_pop (void)
gboolean
gimp_context_set_defaults (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-defaults",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-defaults",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -150,32 +154,28 @@ gboolean
gimp_context_list_paint_methods (gint *num_paint_methods,
gchar ***paint_methods)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- gint i;
- return_vals = gimp_run_procedure ("gimp-context-list-paint-methods",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-list-paint-methods",
+ args);
+ gimp_value_array_unref (args);
*num_paint_methods = 0;
*paint_methods = NULL;
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
{
- *num_paint_methods = return_vals[1].data.d_int32;
- if (*num_paint_methods > 0)
- {
- *paint_methods = g_new0 (gchar *, *num_paint_methods + 1);
- for (i = 0; i < *num_paint_methods; i++)
- (*paint_methods)[i] = g_strdup (return_vals[2].data.d_stringarray[i]);
- }
+ *num_paint_methods = g_value_get_int (gimp_value_array_index (return_vals, 1));
+ *paint_methods = gimp_value_dup_string_array (gimp_value_array_index (return_vals, 2));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -195,18 +195,20 @@ gimp_context_list_paint_methods (gint *num_paint_methods,
gchar *
gimp_context_get_paint_method (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *name = NULL;
- return_vals = gimp_run_procedure ("gimp-context-get-paint-method",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-paint-method",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- name = g_strdup (return_vals[1].data.d_string);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ name = g_value_dup_string (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return name;
}
@@ -231,18 +233,21 @@ gimp_context_get_paint_method (void)
gboolean
gimp_context_set_paint_method (const gchar *name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-paint-method",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), name);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-paint-method",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -261,18 +266,20 @@ gimp_context_set_paint_method (const gchar *name)
GimpStrokeMethod
gimp_context_get_stroke_method (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
GimpStrokeMethod stroke_method = 0;
- return_vals = gimp_run_procedure ("gimp-context-get-stroke-method",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-stroke-method",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- stroke_method = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ stroke_method = g_value_get_enum (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return stroke_method;
}
@@ -294,18 +301,21 @@ gimp_context_get_stroke_method (void)
gboolean
gimp_context_set_stroke_method (GimpStrokeMethod stroke_method)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-stroke-method",
- &nreturn_vals,
- GIMP_PDB_INT32, stroke_method,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_ENUM,
+ G_TYPE_NONE);
+ g_value_set_enum (gimp_value_array_index (args, 0), stroke_method);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-stroke-method",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -327,20 +337,22 @@ gimp_context_set_stroke_method (GimpStrokeMethod stroke_method)
gboolean
gimp_context_get_foreground (GimpRGB *foreground)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-get-foreground",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-foreground",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
- *foreground = return_vals[1].data.d_color;
+ gimp_value_get_rgb (gimp_value_array_index (return_vals, 1), &*foreground);
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -362,18 +374,21 @@ gimp_context_get_foreground (GimpRGB *foreground)
gboolean
gimp_context_set_foreground (const GimpRGB *foreground)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-foreground",
- &nreturn_vals,
- GIMP_PDB_COLOR, foreground,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_RGB,
+ G_TYPE_NONE);
+ gimp_value_set_rgb (gimp_value_array_index (args, 0), foreground);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-foreground",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -395,20 +410,22 @@ gimp_context_set_foreground (const GimpRGB *foreground)
gboolean
gimp_context_get_background (GimpRGB *background)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-get-background",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-background",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
- *background = return_vals[1].data.d_color;
+ gimp_value_get_rgb (gimp_value_array_index (return_vals, 1), &*background);
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -431,18 +448,21 @@ gimp_context_get_background (GimpRGB *background)
gboolean
gimp_context_set_background (const GimpRGB *background)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-background",
- &nreturn_vals,
- GIMP_PDB_COLOR, background,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_RGB,
+ G_TYPE_NONE);
+ gimp_value_set_rgb (gimp_value_array_index (args, 0), background);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-background",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -463,17 +483,19 @@ gimp_context_set_background (const GimpRGB *background)
gboolean
gimp_context_set_default_colors (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-default-colors",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-default-colors",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -494,17 +516,19 @@ gimp_context_set_default_colors (void)
gboolean
gimp_context_swap_colors (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-swap-colors",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-swap-colors",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -524,18 +548,20 @@ gimp_context_swap_colors (void)
gdouble
gimp_context_get_opacity (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gdouble opacity = 0.0;
- return_vals = gimp_run_procedure ("gimp-context-get-opacity",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- opacity = return_vals[1].data.d_float;
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-opacity",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ opacity = g_value_get_double (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return opacity;
}
@@ -556,18 +582,21 @@ gimp_context_get_opacity (void)
gboolean
gimp_context_set_opacity (gdouble opacity)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-opacity",
- &nreturn_vals,
- GIMP_PDB_FLOAT, opacity,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_DOUBLE,
+ G_TYPE_NONE);
+ g_value_set_double (gimp_value_array_index (args, 0), opacity);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-opacity",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -588,18 +617,20 @@ gimp_context_set_opacity (gdouble opacity)
GimpLayerMode
gimp_context_get_paint_mode (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
GimpLayerMode paint_mode = 0;
- return_vals = gimp_run_procedure ("gimp-context-get-paint-mode",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- paint_mode = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-paint-mode",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ paint_mode = g_value_get_enum (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return paint_mode;
}
@@ -619,18 +650,21 @@ gimp_context_get_paint_mode (void)
gboolean
gimp_context_set_paint_mode (GimpLayerMode paint_mode)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-paint-mode",
- &nreturn_vals,
- GIMP_PDB_INT32, paint_mode,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_ENUM,
+ G_TYPE_NONE);
+ g_value_set_enum (gimp_value_array_index (args, 0), paint_mode);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-paint-mode",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -649,18 +683,20 @@ gimp_context_set_paint_mode (GimpLayerMode paint_mode)
gdouble
gimp_context_get_line_width (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gdouble line_width = 0.0;
- return_vals = gimp_run_procedure ("gimp-context-get-line-width",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- line_width = return_vals[1].data.d_float;
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-line-width",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ line_width = g_value_get_double (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return line_width;
}
@@ -684,18 +720,21 @@ gimp_context_get_line_width (void)
gboolean
gimp_context_set_line_width (gdouble line_width)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-line-width",
- &nreturn_vals,
- GIMP_PDB_FLOAT, line_width,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_DOUBLE,
+ G_TYPE_NONE);
+ g_value_set_double (gimp_value_array_index (args, 0), line_width);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-line-width",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -714,18 +753,20 @@ gimp_context_set_line_width (gdouble line_width)
GimpUnit
gimp_context_get_line_width_unit (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
GimpUnit line_width_unit = 0;
- return_vals = gimp_run_procedure ("gimp-context-get-line-width-unit",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-line-width-unit",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- line_width_unit = return_vals[1].data.d_unit;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ line_width_unit = g_value_get_int (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return line_width_unit;
}
@@ -750,18 +791,21 @@ gimp_context_get_line_width_unit (void)
gboolean
gimp_context_set_line_width_unit (GimpUnit line_width_unit)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-line-width-unit",
- &nreturn_vals,
- GIMP_PDB_INT32, line_width_unit,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_UNIT,
+ G_TYPE_NONE);
+ g_value_set_int (gimp_value_array_index (args, 0), line_width_unit);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-line-width-unit",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -780,18 +824,20 @@ gimp_context_set_line_width_unit (GimpUnit line_width_unit)
GimpCapStyle
gimp_context_get_line_cap_style (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
GimpCapStyle cap_style = 0;
- return_vals = gimp_run_procedure ("gimp-context-get-line-cap-style",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-line-cap-style",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- cap_style = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ cap_style = g_value_get_enum (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return cap_style;
}
@@ -816,18 +862,21 @@ gimp_context_get_line_cap_style (void)
gboolean
gimp_context_set_line_cap_style (GimpCapStyle cap_style)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-line-cap-style",
- &nreturn_vals,
- GIMP_PDB_INT32, cap_style,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_ENUM,
+ G_TYPE_NONE);
+ g_value_set_enum (gimp_value_array_index (args, 0), cap_style);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-line-cap-style",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -846,18 +895,20 @@ gimp_context_set_line_cap_style (GimpCapStyle cap_style)
GimpJoinStyle
gimp_context_get_line_join_style (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
GimpJoinStyle join_style = 0;
- return_vals = gimp_run_procedure ("gimp-context-get-line-join-style",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-line-join-style",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- join_style = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ join_style = g_value_get_enum (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return join_style;
}
@@ -882,18 +933,21 @@ gimp_context_get_line_join_style (void)
gboolean
gimp_context_set_line_join_style (GimpJoinStyle join_style)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-line-join-style",
- &nreturn_vals,
- GIMP_PDB_INT32, join_style,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_ENUM,
+ G_TYPE_NONE);
+ g_value_set_enum (gimp_value_array_index (args, 0), join_style);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-line-join-style",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -912,18 +966,20 @@ gimp_context_set_line_join_style (GimpJoinStyle join_style)
gdouble
gimp_context_get_line_miter_limit (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gdouble miter_limit = 0.0;
- return_vals = gimp_run_procedure ("gimp-context-get-line-miter-limit",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-line-miter-limit",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- miter_limit = return_vals[1].data.d_float;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ miter_limit = g_value_get_double (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return miter_limit;
}
@@ -951,18 +1007,21 @@ gimp_context_get_line_miter_limit (void)
gboolean
gimp_context_set_line_miter_limit (gdouble miter_limit)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-line-miter-limit",
- &nreturn_vals,
- GIMP_PDB_FLOAT, miter_limit,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_DOUBLE,
+ G_TYPE_NONE);
+ g_value_set_double (gimp_value_array_index (args, 0), miter_limit);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-line-miter-limit",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -981,18 +1040,20 @@ gimp_context_set_line_miter_limit (gdouble miter_limit)
gdouble
gimp_context_get_line_dash_offset (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gdouble dash_offset = 0.0;
- return_vals = gimp_run_procedure ("gimp-context-get-line-dash-offset",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- dash_offset = return_vals[1].data.d_float;
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-line-dash-offset",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ dash_offset = g_value_get_double (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return dash_offset;
}
@@ -1017,18 +1078,21 @@ gimp_context_get_line_dash_offset (void)
gboolean
gimp_context_set_line_dash_offset (gdouble dash_offset)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-line-dash-offset",
- &nreturn_vals,
- GIMP_PDB_FLOAT, dash_offset,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_DOUBLE,
+ G_TYPE_NONE);
+ g_value_set_double (gimp_value_array_index (args, 0), dash_offset);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-line-dash-offset",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1050,29 +1114,28 @@ gboolean
gimp_context_get_line_dash_pattern (gint *num_dashes,
gdouble **dashes)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-get-line-dash-pattern",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-line-dash-pattern",
+ args);
+ gimp_value_array_unref (args);
*num_dashes = 0;
*dashes = NULL;
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
{
- *num_dashes = return_vals[1].data.d_int32;
- *dashes = g_new (gdouble, *num_dashes);
- memcpy (*dashes,
- return_vals[2].data.d_floatarray,
- *num_dashes * sizeof (gdouble));
+ *num_dashes = g_value_get_int (gimp_value_array_index (return_vals, 1));
+ *dashes = gimp_value_dup_float_array (gimp_value_array_index (return_vals, 2));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1103,19 +1166,23 @@ gboolean
gimp_context_set_line_dash_pattern (gint num_dashes,
const gdouble *dashes)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-line-dash-pattern",
- &nreturn_vals,
- GIMP_PDB_INT32, num_dashes,
- GIMP_PDB_FLOATARRAY, dashes,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_INT32,
+ GIMP_TYPE_FLOAT_ARRAY,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-line-dash-pattern",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1136,18 +1203,20 @@ gimp_context_set_line_dash_pattern (gint num_dashes,
gchar *
gimp_context_get_brush (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *name = NULL;
- return_vals = gimp_run_procedure ("gimp-context-get-brush",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- name = g_strdup (return_vals[1].data.d_string);
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-brush",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ name = g_value_dup_string (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return name;
}
@@ -1171,18 +1240,21 @@ gimp_context_get_brush (void)
gboolean
gimp_context_set_brush (const gchar *name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-brush",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), name);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-brush",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1201,18 +1273,20 @@ gimp_context_set_brush (const gchar *name)
gdouble
gimp_context_get_brush_size (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gdouble size = 0.0;
- return_vals = gimp_run_procedure ("gimp-context-get-brush-size",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-brush-size",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- size = return_vals[1].data.d_float;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ size = g_value_get_double (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return size;
}
@@ -1232,18 +1306,21 @@ gimp_context_get_brush_size (void)
gboolean
gimp_context_set_brush_size (gdouble size)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-brush-size",
- &nreturn_vals,
- GIMP_PDB_FLOAT, size,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_DOUBLE,
+ G_TYPE_NONE);
+ g_value_set_double (gimp_value_array_index (args, 0), size);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-brush-size",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1263,17 +1340,19 @@ gimp_context_set_brush_size (gdouble size)
gboolean
gimp_context_set_brush_default_size (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-brush-default-size",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-brush-default-size",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1292,18 +1371,20 @@ gimp_context_set_brush_default_size (void)
gdouble
gimp_context_get_brush_aspect_ratio (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gdouble aspect = 0.0;
- return_vals = gimp_run_procedure ("gimp-context-get-brush-aspect-ratio",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- aspect = return_vals[1].data.d_float;
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-brush-aspect-ratio",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ aspect = g_value_get_double (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return aspect;
}
@@ -1323,18 +1404,21 @@ gimp_context_get_brush_aspect_ratio (void)
gboolean
gimp_context_set_brush_aspect_ratio (gdouble aspect)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-brush-aspect-ratio",
- &nreturn_vals,
- GIMP_PDB_FLOAT, aspect,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_DOUBLE,
+ G_TYPE_NONE);
+ g_value_set_double (gimp_value_array_index (args, 0), aspect);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-brush-aspect-ratio",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1353,18 +1437,20 @@ gimp_context_set_brush_aspect_ratio (gdouble aspect)
gdouble
gimp_context_get_brush_angle (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gdouble angle = 0.0;
- return_vals = gimp_run_procedure ("gimp-context-get-brush-angle",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- angle = return_vals[1].data.d_float;
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-brush-angle",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ angle = g_value_get_double (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return angle;
}
@@ -1384,18 +1470,21 @@ gimp_context_get_brush_angle (void)
gboolean
gimp_context_set_brush_angle (gdouble angle)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-brush-angle",
- &nreturn_vals,
- GIMP_PDB_FLOAT, angle,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_DOUBLE,
+ G_TYPE_NONE);
+ g_value_set_double (gimp_value_array_index (args, 0), angle);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-brush-angle",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1415,18 +1504,20 @@ gimp_context_set_brush_angle (gdouble angle)
gdouble
gimp_context_get_brush_spacing (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gdouble spacing = 0.0;
- return_vals = gimp_run_procedure ("gimp-context-get-brush-spacing",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-brush-spacing",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- spacing = return_vals[1].data.d_float;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ spacing = g_value_get_double (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return spacing;
}
@@ -1447,18 +1538,21 @@ gimp_context_get_brush_spacing (void)
gboolean
gimp_context_set_brush_spacing (gdouble spacing)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-brush-spacing",
- &nreturn_vals,
- GIMP_PDB_FLOAT, spacing,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_DOUBLE,
+ G_TYPE_NONE);
+ g_value_set_double (gimp_value_array_index (args, 0), spacing);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-brush-spacing",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1478,17 +1572,19 @@ gimp_context_set_brush_spacing (gdouble spacing)
gboolean
gimp_context_set_brush_default_spacing (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-brush-default-spacing",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-brush-default-spacing",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1507,18 +1603,20 @@ gimp_context_set_brush_default_spacing (void)
gdouble
gimp_context_get_brush_hardness (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gdouble hardness = 0.0;
- return_vals = gimp_run_procedure ("gimp-context-get-brush-hardness",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- hardness = return_vals[1].data.d_float;
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-brush-hardness",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ hardness = g_value_get_double (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return hardness;
}
@@ -1538,18 +1636,21 @@ gimp_context_get_brush_hardness (void)
gboolean
gimp_context_set_brush_hardness (gdouble hardness)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-brush-hardness",
- &nreturn_vals,
- GIMP_PDB_FLOAT, hardness,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_DOUBLE,
+ G_TYPE_NONE);
+ g_value_set_double (gimp_value_array_index (args, 0), hardness);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-brush-hardness",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1569,17 +1670,19 @@ gimp_context_set_brush_hardness (gdouble hardness)
gboolean
gimp_context_set_brush_default_hardness (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-brush-default-hardness",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-brush-default-hardness",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1598,18 +1701,20 @@ gimp_context_set_brush_default_hardness (void)
gdouble
gimp_context_get_brush_force (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gdouble force = 0.0;
- return_vals = gimp_run_procedure ("gimp-context-get-brush-force",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-brush-force",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- force = return_vals[1].data.d_float;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ force = g_value_get_double (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return force;
}
@@ -1629,18 +1734,21 @@ gimp_context_get_brush_force (void)
gboolean
gimp_context_set_brush_force (gdouble force)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-brush-force",
- &nreturn_vals,
- GIMP_PDB_FLOAT, force,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_DOUBLE,
+ G_TYPE_NONE);
+ g_value_set_double (gimp_value_array_index (args, 0), force);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-brush-force",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1661,18 +1769,20 @@ gimp_context_set_brush_force (gdouble force)
gchar *
gimp_context_get_dynamics (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *name = NULL;
- return_vals = gimp_run_procedure ("gimp-context-get-dynamics",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- name = g_strdup (return_vals[1].data.d_string);
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-dynamics",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ name = g_value_dup_string (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return name;
}
@@ -1697,18 +1807,21 @@ gimp_context_get_dynamics (void)
gboolean
gimp_context_set_dynamics (const gchar *name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-dynamics",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), name);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-dynamics",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1728,18 +1841,20 @@ gimp_context_set_dynamics (const gchar *name)
gchar *
gimp_context_get_mypaint_brush (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *name = NULL;
- return_vals = gimp_run_procedure ("gimp-context-get-mypaint-brush",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- name = g_strdup (return_vals[1].data.d_string);
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-mypaint-brush",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ name = g_value_dup_string (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return name;
}
@@ -1764,18 +1879,21 @@ gimp_context_get_mypaint_brush (void)
gboolean
gimp_context_set_mypaint_brush (const gchar *name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-mypaint-brush",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), name);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-mypaint-brush",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1796,18 +1914,20 @@ gimp_context_set_mypaint_brush (const gchar *name)
gchar *
gimp_context_get_pattern (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *name = NULL;
- return_vals = gimp_run_procedure ("gimp-context-get-pattern",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- name = g_strdup (return_vals[1].data.d_string);
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-pattern",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ name = g_value_dup_string (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return name;
}
@@ -1832,18 +1952,21 @@ gimp_context_get_pattern (void)
gboolean
gimp_context_set_pattern (const gchar *name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-pattern",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), name);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-pattern",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1862,18 +1985,20 @@ gimp_context_set_pattern (const gchar *name)
gchar *
gimp_context_get_gradient (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *name = NULL;
- return_vals = gimp_run_procedure ("gimp-context-get-gradient",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-gradient",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- name = g_strdup (return_vals[1].data.d_string);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ name = g_value_dup_string (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return name;
}
@@ -1898,18 +2023,21 @@ gimp_context_get_gradient (void)
gboolean
gimp_context_set_gradient (const gchar *name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-gradient",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), name);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-gradient",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1930,17 +2058,19 @@ gimp_context_set_gradient (const gchar *name)
gboolean
gimp_context_set_gradient_fg_bg_rgb (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-gradient-fg-bg-rgb",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-gradient-fg-bg-rgb",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1961,17 +2091,19 @@ gimp_context_set_gradient_fg_bg_rgb (void)
gboolean
gimp_context_set_gradient_fg_bg_hsv_cw (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-gradient-fg-bg-hsv-cw",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-gradient-fg-bg-hsv-cw",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1992,17 +2124,19 @@ gimp_context_set_gradient_fg_bg_hsv_cw (void)
gboolean
gimp_context_set_gradient_fg_bg_hsv_ccw (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-gradient-fg-bg-hsv-ccw",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-gradient-fg-bg-hsv-ccw",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -2023,17 +2157,19 @@ gimp_context_set_gradient_fg_bg_hsv_ccw (void)
gboolean
gimp_context_set_gradient_fg_transparent (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-gradient-fg-transparent",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-gradient-fg-transparent",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -2053,18 +2189,20 @@ gimp_context_set_gradient_fg_transparent (void)
GimpGradientBlendColorSpace
gimp_context_get_gradient_blend_color_space (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
GimpGradientBlendColorSpace blend_color_space = 0;
- return_vals = gimp_run_procedure ("gimp-context-get-gradient-blend-color-space",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-gradient-blend-color-space",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- blend_color_space = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ blend_color_space = g_value_get_enum (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return blend_color_space;
}
@@ -2085,18 +2223,21 @@ gimp_context_get_gradient_blend_color_space (void)
gboolean
gimp_context_set_gradient_blend_color_space (GimpGradientBlendColorSpace blend_color_space)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-gradient-blend-color-space",
- &nreturn_vals,
- GIMP_PDB_INT32, blend_color_space,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_ENUM,
+ G_TYPE_NONE);
+ g_value_set_enum (gimp_value_array_index (args, 0), blend_color_space);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-gradient-blend-color-space",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -2115,18 +2256,20 @@ gimp_context_set_gradient_blend_color_space (GimpGradientBlendColorSpace blend_c
GimpRepeatMode
gimp_context_get_gradient_repeat_mode (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
GimpRepeatMode repeat_mode = 0;
- return_vals = gimp_run_procedure ("gimp-context-get-gradient-repeat-mode",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-gradient-repeat-mode",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- repeat_mode = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ repeat_mode = g_value_get_enum (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return repeat_mode;
}
@@ -2146,18 +2289,21 @@ gimp_context_get_gradient_repeat_mode (void)
gboolean
gimp_context_set_gradient_repeat_mode (GimpRepeatMode repeat_mode)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-gradient-repeat-mode",
- &nreturn_vals,
- GIMP_PDB_INT32, repeat_mode,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_ENUM,
+ G_TYPE_NONE);
+ g_value_set_enum (gimp_value_array_index (args, 0), repeat_mode);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-gradient-repeat-mode",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -2177,18 +2323,20 @@ gimp_context_set_gradient_repeat_mode (GimpRepeatMode repeat_mode)
gboolean
gimp_context_get_gradient_reverse (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean reverse = FALSE;
- return_vals = gimp_run_procedure ("gimp-context-get-gradient-reverse",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-gradient-reverse",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- reverse = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ reverse = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return reverse;
}
@@ -2209,18 +2357,21 @@ gimp_context_get_gradient_reverse (void)
gboolean
gimp_context_set_gradient_reverse (gboolean reverse)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-gradient-reverse",
- &nreturn_vals,
- GIMP_PDB_INT32, reverse,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_BOOLEAN,
+ G_TYPE_NONE);
+ g_value_set_boolean (gimp_value_array_index (args, 0), reverse);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-gradient-reverse",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -2239,18 +2390,20 @@ gimp_context_set_gradient_reverse (gboolean reverse)
gchar *
gimp_context_get_palette (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *name = NULL;
- return_vals = gimp_run_procedure ("gimp-context-get-palette",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-palette",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- name = g_strdup (return_vals[1].data.d_string);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ name = g_value_dup_string (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return name;
}
@@ -2275,18 +2428,21 @@ gimp_context_get_palette (void)
gboolean
gimp_context_set_palette (const gchar *name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-palette",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), name);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-palette",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -2305,18 +2461,20 @@ gimp_context_set_palette (const gchar *name)
gchar *
gimp_context_get_font (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *name = NULL;
- return_vals = gimp_run_procedure ("gimp-context-get-font",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-font",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- name = g_strdup (return_vals[1].data.d_string);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ name = g_value_dup_string (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return name;
}
@@ -2340,18 +2498,21 @@ gimp_context_get_font (void)
gboolean
gimp_context_set_font (const gchar *name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-font",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), name);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-font",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -2370,18 +2531,20 @@ gimp_context_set_font (const gchar *name)
gboolean
gimp_context_get_antialias (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean antialias = FALSE;
- return_vals = gimp_run_procedure ("gimp-context-get-antialias",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- antialias = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-antialias",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ antialias = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return antialias;
}
@@ -2412,18 +2575,21 @@ gimp_context_get_antialias (void)
gboolean
gimp_context_set_antialias (gboolean antialias)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-antialias",
- &nreturn_vals,
- GIMP_PDB_INT32, antialias,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_BOOLEAN,
+ G_TYPE_NONE);
+ g_value_set_boolean (gimp_value_array_index (args, 0), antialias);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-antialias",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -2442,18 +2608,20 @@ gimp_context_set_antialias (gboolean antialias)
gboolean
gimp_context_get_feather (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean feather = FALSE;
- return_vals = gimp_run_procedure ("gimp-context-get-feather",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- feather = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-feather",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ feather = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return feather;
}
@@ -2482,18 +2650,21 @@ gimp_context_get_feather (void)
gboolean
gimp_context_set_feather (gboolean feather)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-feather",
- &nreturn_vals,
- GIMP_PDB_INT32, feather,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_BOOLEAN,
+ G_TYPE_NONE);
+ g_value_set_boolean (gimp_value_array_index (args, 0), feather);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-feather",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -2515,26 +2686,28 @@ gboolean
gimp_context_get_feather_radius (gdouble *feather_radius_x,
gdouble *feather_radius_y)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-get-feather-radius",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-feather-radius",
+ args);
+ gimp_value_array_unref (args);
*feather_radius_x = 0.0;
*feather_radius_y = 0.0;
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
{
- *feather_radius_x = return_vals[1].data.d_float;
- *feather_radius_y = return_vals[2].data.d_float;
+ *feather_radius_x = g_value_get_double (gimp_value_array_index (return_vals, 1));
+ *feather_radius_y = g_value_get_double (gimp_value_array_index (return_vals, 2));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -2559,19 +2732,23 @@ gboolean
gimp_context_set_feather_radius (gdouble feather_radius_x,
gdouble feather_radius_y)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-feather-radius",
- &nreturn_vals,
- GIMP_PDB_FLOAT, feather_radius_x,
- GIMP_PDB_FLOAT, feather_radius_y,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_DOUBLE,
+ G_TYPE_DOUBLE,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-feather-radius",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -2590,18 +2767,20 @@ gimp_context_set_feather_radius (gdouble feather_radius_x,
gboolean
gimp_context_get_sample_merged (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean sample_merged = FALSE;
- return_vals = gimp_run_procedure ("gimp-context-get-sample-merged",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-sample-merged",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- sample_merged = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ sample_merged = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return sample_merged;
}
@@ -2631,18 +2810,21 @@ gimp_context_get_sample_merged (void)
gboolean
gimp_context_set_sample_merged (gboolean sample_merged)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-sample-merged",
- &nreturn_vals,
- GIMP_PDB_INT32, sample_merged,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_BOOLEAN,
+ G_TYPE_NONE);
+ g_value_set_boolean (gimp_value_array_index (args, 0), sample_merged);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-sample-merged",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -2661,18 +2843,20 @@ gimp_context_set_sample_merged (gboolean sample_merged)
GimpSelectCriterion
gimp_context_get_sample_criterion (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
GimpSelectCriterion sample_criterion = 0;
- return_vals = gimp_run_procedure ("gimp-context-get-sample-criterion",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-sample-criterion",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- sample_criterion = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ sample_criterion = g_value_get_enum (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return sample_criterion;
}
@@ -2700,18 +2884,21 @@ gimp_context_get_sample_criterion (void)
gboolean
gimp_context_set_sample_criterion (GimpSelectCriterion sample_criterion)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-sample-criterion",
- &nreturn_vals,
- GIMP_PDB_INT32, sample_criterion,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_ENUM,
+ G_TYPE_NONE);
+ g_value_set_enum (gimp_value_array_index (args, 0), sample_criterion);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-sample-criterion",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -2730,18 +2917,20 @@ gimp_context_set_sample_criterion (GimpSelectCriterion sample_criterion)
gdouble
gimp_context_get_sample_threshold (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gdouble sample_threshold = 0.0;
- return_vals = gimp_run_procedure ("gimp-context-get-sample-threshold",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-sample-threshold",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- sample_threshold = return_vals[1].data.d_float;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ sample_threshold = g_value_get_double (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return sample_threshold;
}
@@ -2770,18 +2959,21 @@ gimp_context_get_sample_threshold (void)
gboolean
gimp_context_set_sample_threshold (gdouble sample_threshold)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-sample-threshold",
- &nreturn_vals,
- GIMP_PDB_FLOAT, sample_threshold,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_DOUBLE,
+ G_TYPE_NONE);
+ g_value_set_double (gimp_value_array_index (args, 0), sample_threshold);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-sample-threshold",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -2801,18 +2993,20 @@ gimp_context_set_sample_threshold (gdouble sample_threshold)
gint
gimp_context_get_sample_threshold_int (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint sample_threshold = 0;
- return_vals = gimp_run_procedure ("gimp-context-get-sample-threshold-int",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-sample-threshold-int",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- sample_threshold = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ sample_threshold = g_value_get_int (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return sample_threshold;
}
@@ -2833,18 +3027,21 @@ gimp_context_get_sample_threshold_int (void)
gboolean
gimp_context_set_sample_threshold_int (gint sample_threshold)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-sample-threshold-int",
- &nreturn_vals,
- GIMP_PDB_INT32, sample_threshold,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_INT32,
+ G_TYPE_NONE);
+ g_value_set_int (gimp_value_array_index (args, 0), sample_threshold);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-sample-threshold-int",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -2863,18 +3060,20 @@ gimp_context_set_sample_threshold_int (gint sample_threshold)
gboolean
gimp_context_get_sample_transparent (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean sample_transparent = FALSE;
- return_vals = gimp_run_procedure ("gimp-context-get-sample-transparent",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- sample_transparent = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-sample-transparent",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ sample_transparent = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return sample_transparent;
}
@@ -2902,18 +3101,21 @@ gimp_context_get_sample_transparent (void)
gboolean
gimp_context_set_sample_transparent (gboolean sample_transparent)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-sample-transparent",
- &nreturn_vals,
- GIMP_PDB_INT32, sample_transparent,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_BOOLEAN,
+ G_TYPE_NONE);
+ g_value_set_boolean (gimp_value_array_index (args, 0), sample_transparent);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-sample-transparent",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -2932,18 +3134,20 @@ gimp_context_set_sample_transparent (gboolean sample_transparent)
gboolean
gimp_context_get_diagonal_neighbors (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean diagonal_neighbors = FALSE;
- return_vals = gimp_run_procedure ("gimp-context-get-diagonal-neighbors",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- diagonal_neighbors = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-diagonal-neighbors",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ diagonal_neighbors = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return diagonal_neighbors;
}
@@ -2972,18 +3176,21 @@ gimp_context_get_diagonal_neighbors (void)
gboolean
gimp_context_set_diagonal_neighbors (gboolean diagonal_neighbors)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-diagonal-neighbors",
- &nreturn_vals,
- GIMP_PDB_INT32, diagonal_neighbors,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_BOOLEAN,
+ G_TYPE_NONE);
+ g_value_set_boolean (gimp_value_array_index (args, 0), diagonal_neighbors);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-diagonal-neighbors",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -3003,18 +3210,20 @@ gimp_context_set_diagonal_neighbors (gboolean diagonal_neighbors)
GeglDistanceMetric
gimp_context_get_distance_metric (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
GeglDistanceMetric metric = 0;
- return_vals = gimp_run_procedure ("gimp-context-get-distance-metric",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- metric = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-distance-metric",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ metric = g_value_get_enum (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return metric;
}
@@ -3040,18 +3249,21 @@ gimp_context_get_distance_metric (void)
gboolean
gimp_context_set_distance_metric (GeglDistanceMetric metric)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-distance-metric",
- &nreturn_vals,
- GIMP_PDB_INT32, metric,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_ENUM,
+ G_TYPE_NONE);
+ g_value_set_enum (gimp_value_array_index (args, 0), metric);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-distance-metric",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -3074,18 +3286,20 @@ gimp_context_set_distance_metric (GeglDistanceMetric metric)
GimpInterpolationType
gimp_context_get_interpolation (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
GimpInterpolationType interpolation = 0;
- return_vals = gimp_run_procedure ("gimp-context-get-interpolation",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-interpolation",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- interpolation = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ interpolation = g_value_get_enum (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return interpolation;
}
@@ -3112,18 +3326,21 @@ gimp_context_get_interpolation (void)
gboolean
gimp_context_set_interpolation (GimpInterpolationType interpolation)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-interpolation",
- &nreturn_vals,
- GIMP_PDB_INT32, interpolation,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_ENUM,
+ G_TYPE_NONE);
+ g_value_set_enum (gimp_value_array_index (args, 0), interpolation);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-interpolation",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -3144,18 +3361,20 @@ gimp_context_set_interpolation (GimpInterpolationType interpolation)
GimpTransformDirection
gimp_context_get_transform_direction (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
GimpTransformDirection transform_direction = 0;
- return_vals = gimp_run_procedure ("gimp-context-get-transform-direction",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-transform-direction",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- transform_direction = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ transform_direction = g_value_get_enum (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return transform_direction;
}
@@ -3181,18 +3400,21 @@ gimp_context_get_transform_direction (void)
gboolean
gimp_context_set_transform_direction (GimpTransformDirection transform_direction)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-transform-direction",
- &nreturn_vals,
- GIMP_PDB_INT32, transform_direction,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_ENUM,
+ G_TYPE_NONE);
+ g_value_set_enum (gimp_value_array_index (args, 0), transform_direction);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-transform-direction",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -3213,18 +3435,20 @@ gimp_context_set_transform_direction (GimpTransformDirection transform_direction
GimpTransformResize
gimp_context_get_transform_resize (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
GimpTransformResize transform_resize = 0;
- return_vals = gimp_run_procedure ("gimp-context-get-transform-resize",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-transform-resize",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- transform_resize = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ transform_resize = g_value_get_enum (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return transform_resize;
}
@@ -3254,18 +3478,21 @@ gimp_context_get_transform_resize (void)
gboolean
gimp_context_set_transform_resize (GimpTransformResize transform_resize)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-transform-resize",
- &nreturn_vals,
- GIMP_PDB_INT32, transform_resize,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_ENUM,
+ G_TYPE_NONE);
+ g_value_set_enum (gimp_value_array_index (args, 0), transform_resize);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-transform-resize",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -3284,18 +3511,20 @@ gimp_context_set_transform_resize (GimpTransformResize transform_resize)
gdouble
gimp_context_get_ink_size (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gdouble size = 0.0;
- return_vals = gimp_run_procedure ("gimp-context-get-ink-size",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-ink-size",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- size = return_vals[1].data.d_float;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ size = g_value_get_double (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return size;
}
@@ -3315,18 +3544,21 @@ gimp_context_get_ink_size (void)
gboolean
gimp_context_set_ink_size (gdouble size)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-ink-size",
- &nreturn_vals,
- GIMP_PDB_FLOAT, size,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_DOUBLE,
+ G_TYPE_NONE);
+ g_value_set_double (gimp_value_array_index (args, 0), size);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-ink-size",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -3345,18 +3577,20 @@ gimp_context_set_ink_size (gdouble size)
gdouble
gimp_context_get_ink_angle (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gdouble angle = 0.0;
- return_vals = gimp_run_procedure ("gimp-context-get-ink-angle",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- angle = return_vals[1].data.d_float;
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-ink-angle",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ angle = g_value_get_double (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return angle;
}
@@ -3376,18 +3610,21 @@ gimp_context_get_ink_angle (void)
gboolean
gimp_context_set_ink_angle (gdouble angle)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-ink-angle",
- &nreturn_vals,
- GIMP_PDB_FLOAT, angle,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_DOUBLE,
+ G_TYPE_NONE);
+ g_value_set_double (gimp_value_array_index (args, 0), angle);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-ink-angle",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -3406,18 +3643,20 @@ gimp_context_set_ink_angle (gdouble angle)
gdouble
gimp_context_get_ink_size_sensitivity (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gdouble size = 0.0;
- return_vals = gimp_run_procedure ("gimp-context-get-ink-size-sensitivity",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- size = return_vals[1].data.d_float;
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-ink-size-sensitivity",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ size = g_value_get_double (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return size;
}
@@ -3437,18 +3676,21 @@ gimp_context_get_ink_size_sensitivity (void)
gboolean
gimp_context_set_ink_size_sensitivity (gdouble size)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-ink-size-sensitivity",
- &nreturn_vals,
- GIMP_PDB_FLOAT, size,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_DOUBLE,
+ G_TYPE_NONE);
+ g_value_set_double (gimp_value_array_index (args, 0), size);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-ink-size-sensitivity",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -3467,18 +3709,20 @@ gimp_context_set_ink_size_sensitivity (gdouble size)
gdouble
gimp_context_get_ink_tilt_sensitivity (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gdouble tilt = 0.0;
- return_vals = gimp_run_procedure ("gimp-context-get-ink-tilt-sensitivity",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- tilt = return_vals[1].data.d_float;
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-ink-tilt-sensitivity",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ tilt = g_value_get_double (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return tilt;
}
@@ -3498,18 +3742,21 @@ gimp_context_get_ink_tilt_sensitivity (void)
gboolean
gimp_context_set_ink_tilt_sensitivity (gdouble tilt)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-ink-tilt-sensitivity",
- &nreturn_vals,
- GIMP_PDB_FLOAT, tilt,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_DOUBLE,
+ G_TYPE_NONE);
+ g_value_set_double (gimp_value_array_index (args, 0), tilt);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-ink-tilt-sensitivity",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -3528,18 +3775,20 @@ gimp_context_set_ink_tilt_sensitivity (gdouble tilt)
gdouble
gimp_context_get_ink_speed_sensitivity (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gdouble speed = 0.0;
- return_vals = gimp_run_procedure ("gimp-context-get-ink-speed-sensitivity",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-ink-speed-sensitivity",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- speed = return_vals[1].data.d_float;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ speed = g_value_get_double (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return speed;
}
@@ -3559,18 +3808,21 @@ gimp_context_get_ink_speed_sensitivity (void)
gboolean
gimp_context_set_ink_speed_sensitivity (gdouble speed)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-ink-speed-sensitivity",
- &nreturn_vals,
- GIMP_PDB_FLOAT, speed,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_DOUBLE,
+ G_TYPE_NONE);
+ g_value_set_double (gimp_value_array_index (args, 0), speed);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-ink-speed-sensitivity",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -3589,18 +3841,20 @@ gimp_context_set_ink_speed_sensitivity (gdouble speed)
GimpInkBlobType
gimp_context_get_ink_blob_type (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
GimpInkBlobType type = 0;
- return_vals = gimp_run_procedure ("gimp-context-get-ink-blob-type",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-ink-blob-type",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- type = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ type = g_value_get_enum (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return type;
}
@@ -3620,18 +3874,21 @@ gimp_context_get_ink_blob_type (void)
gboolean
gimp_context_set_ink_blob_type (GimpInkBlobType type)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-ink-blob-type",
- &nreturn_vals,
- GIMP_PDB_INT32, type,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_ENUM,
+ G_TYPE_NONE);
+ g_value_set_enum (gimp_value_array_index (args, 0), type);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-ink-blob-type",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -3650,18 +3907,20 @@ gimp_context_set_ink_blob_type (GimpInkBlobType type)
gdouble
gimp_context_get_ink_blob_aspect_ratio (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gdouble aspect = 0.0;
- return_vals = gimp_run_procedure ("gimp-context-get-ink-blob-aspect-ratio",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-ink-blob-aspect-ratio",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- aspect = return_vals[1].data.d_float;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ aspect = g_value_get_double (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return aspect;
}
@@ -3681,18 +3940,21 @@ gimp_context_get_ink_blob_aspect_ratio (void)
gboolean
gimp_context_set_ink_blob_aspect_ratio (gdouble aspect)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-ink-blob-aspect-ratio",
- &nreturn_vals,
- GIMP_PDB_FLOAT, aspect,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_DOUBLE,
+ G_TYPE_NONE);
+ g_value_set_double (gimp_value_array_index (args, 0), aspect);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-ink-blob-aspect-ratio",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -3711,18 +3973,20 @@ gimp_context_set_ink_blob_aspect_ratio (gdouble aspect)
gdouble
gimp_context_get_ink_blob_angle (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gdouble angle = 0.0;
- return_vals = gimp_run_procedure ("gimp-context-get-ink-blob-angle",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-ink-blob-angle",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- angle = return_vals[1].data.d_float;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ angle = g_value_get_double (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return angle;
}
@@ -3742,18 +4006,21 @@ gimp_context_get_ink_blob_angle (void)
gboolean
gimp_context_set_ink_blob_angle (gdouble angle)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-context-set-ink-blob-angle",
- &nreturn_vals,
- GIMP_PDB_FLOAT, angle,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_DOUBLE,
+ G_TYPE_NONE);
+ g_value_set_double (gimp_value_array_index (args, 0), angle);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-ink-blob-angle",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
diff --git a/libgimp/gimpdebug_pdb.c b/libgimp/gimpdebug_pdb.c
index 64c165b085..621f5a11c4 100644
--- a/libgimp/gimpdebug_pdb.c
+++ b/libgimp/gimpdebug_pdb.c
@@ -54,17 +54,19 @@
gboolean
gimp_debug_timer_start (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-debug-timer-start",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-debug-timer-start",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -88,18 +90,20 @@ gimp_debug_timer_start (void)
gdouble
gimp_debug_timer_end (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gdouble elapsed = 0.0;
- return_vals = gimp_run_procedure ("gimp-debug-timer-end",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-debug-timer-end",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- elapsed = return_vals[1].data.d_float;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ elapsed = g_value_get_double (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return elapsed;
}
diff --git a/libgimp/gimpdisplay_pdb.c b/libgimp/gimpdisplay_pdb.c
index 9f1eba048b..b5fd724b9c 100644
--- a/libgimp/gimpdisplay_pdb.c
+++ b/libgimp/gimpdisplay_pdb.c
@@ -50,19 +50,22 @@
gboolean
gimp_display_is_valid (gint32 display_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean valid = FALSE;
- return_vals = gimp_run_procedure ("gimp-display-is-valid",
- &nreturn_vals,
- GIMP_PDB_DISPLAY, display_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DISPLAY_ID,
+ G_TYPE_NONE);
+ gimp_value_set_display_id (gimp_value_array_index (args, 0), display_ID);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- valid = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-display-is-valid",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ valid = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return valid;
}
@@ -85,19 +88,22 @@ gimp_display_is_valid (gint32 display_ID)
gint32
gimp_display_new (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 display_ID = -1;
- return_vals = gimp_run_procedure ("gimp-display-new",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-display-new",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- display_ID = return_vals[1].data.d_display;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ display_ID = gimp_value_get_display_id (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return display_ID;
}
@@ -119,18 +125,21 @@ gimp_display_new (gint32 image_ID)
gboolean
gimp_display_delete (gint32 display_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-display-delete",
- &nreturn_vals,
- GIMP_PDB_DISPLAY, display_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DISPLAY_ID,
+ G_TYPE_NONE);
+ gimp_value_set_display_id (gimp_value_array_index (args, 0), display_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-display-delete",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -154,19 +163,22 @@ gimp_display_delete (gint32 display_ID)
gint
gimp_display_get_window_handle (gint32 display_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint window = 0;
- return_vals = gimp_run_procedure ("gimp-display-get-window-handle",
- &nreturn_vals,
- GIMP_PDB_DISPLAY, display_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DISPLAY_ID,
+ G_TYPE_NONE);
+ gimp_value_set_display_id (gimp_value_array_index (args, 0), display_ID);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- window = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-display-get-window-handle",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ window = g_value_get_int (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return window;
}
@@ -186,17 +198,19 @@ gimp_display_get_window_handle (gint32 display_ID)
gboolean
gimp_displays_flush (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-displays-flush",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-displays-flush",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -219,19 +233,23 @@ gboolean
gimp_displays_reconnect (gint32 old_image_ID,
gint32 new_image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-displays-reconnect",
- &nreturn_vals,
- GIMP_PDB_IMAGE, old_image_ID,
- GIMP_PDB_IMAGE, new_image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-displays-reconnect",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
diff --git a/libgimp/gimpdrawable_pdb.c b/libgimp/gimpdrawable_pdb.c
index 61e736b249..21f2d2ec51 100644
--- a/libgimp/gimpdrawable_pdb.c
+++ b/libgimp/gimpdrawable_pdb.c
@@ -22,8 +22,6 @@
#include "config.h"
-#include <string.h>
-
#include "gimp.h"
@@ -54,19 +52,22 @@
gchar *
_gimp_drawable_get_format (gint32 drawable_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *format = NULL;
- return_vals = gimp_run_procedure ("gimp-drawable-get-format",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-get-format",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- format = g_strdup (return_vals[1].data.d_string);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ format = g_value_dup_string (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return format;
}
@@ -88,19 +89,22 @@ _gimp_drawable_get_format (gint32 drawable_ID)
gchar *
_gimp_drawable_get_thumbnail_format (gint32 drawable_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *format = NULL;
- return_vals = gimp_run_procedure ("gimp-drawable-get-thumbnail-format",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-get-thumbnail-format",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- format = g_strdup (return_vals[1].data.d_string);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ format = g_value_dup_string (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return format;
}
@@ -118,19 +122,22 @@ _gimp_drawable_get_thumbnail_format (gint32 drawable_ID)
GimpImageType
gimp_drawable_type (gint32 drawable_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
GimpImageType type = 0;
- return_vals = gimp_run_procedure ("gimp-drawable-type",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- type = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-type",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ type = g_value_get_enum (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return type;
}
@@ -151,19 +158,22 @@ gimp_drawable_type (gint32 drawable_ID)
GimpImageType
gimp_drawable_type_with_alpha (gint32 drawable_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
GimpImageType type_with_alpha = 0;
- return_vals = gimp_run_procedure ("gimp-drawable-type-with-alpha",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-type-with-alpha",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- type_with_alpha = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ type_with_alpha = g_value_get_enum (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return type_with_alpha;
}
@@ -183,19 +193,22 @@ gimp_drawable_type_with_alpha (gint32 drawable_ID)
gboolean
gimp_drawable_has_alpha (gint32 drawable_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean has_alpha = FALSE;
- return_vals = gimp_run_procedure ("gimp-drawable-has-alpha",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-has-alpha",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- has_alpha = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ has_alpha = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return has_alpha;
}
@@ -214,19 +227,22 @@ gimp_drawable_has_alpha (gint32 drawable_ID)
gboolean
gimp_drawable_is_rgb (gint32 drawable_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean is_rgb = FALSE;
- return_vals = gimp_run_procedure ("gimp-drawable-is-rgb",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- is_rgb = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-is-rgb",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ is_rgb = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return is_rgb;
}
@@ -245,19 +261,22 @@ gimp_drawable_is_rgb (gint32 drawable_ID)
gboolean
gimp_drawable_is_gray (gint32 drawable_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean is_gray = FALSE;
- return_vals = gimp_run_procedure ("gimp-drawable-is-gray",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-is-gray",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- is_gray = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ is_gray = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return is_gray;
}
@@ -276,19 +295,22 @@ gimp_drawable_is_gray (gint32 drawable_ID)
gboolean
gimp_drawable_is_indexed (gint32 drawable_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean is_indexed = FALSE;
- return_vals = gimp_run_procedure ("gimp-drawable-is-indexed",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-is-indexed",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- is_indexed = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ is_indexed = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return is_indexed;
}
@@ -306,19 +328,22 @@ gimp_drawable_is_indexed (gint32 drawable_ID)
gint
gimp_drawable_bpp (gint32 drawable_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint bpp = 0;
- return_vals = gimp_run_procedure ("gimp-drawable-bpp",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- bpp = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-bpp",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ bpp = g_value_get_int (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return bpp;
}
@@ -336,19 +361,22 @@ gimp_drawable_bpp (gint32 drawable_ID)
gint
gimp_drawable_width (gint32 drawable_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint width = 0;
- return_vals = gimp_run_procedure ("gimp-drawable-width",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-width",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- width = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ width = g_value_get_int (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return width;
}
@@ -366,19 +394,22 @@ gimp_drawable_width (gint32 drawable_ID)
gint
gimp_drawable_height (gint32 drawable_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint height = 0;
- return_vals = gimp_run_procedure ("gimp-drawable-height",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-height",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- height = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ height = g_value_get_int (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return height;
}
@@ -402,27 +433,30 @@ gimp_drawable_offsets (gint32 drawable_ID,
gint *offset_x,
gint *offset_y)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-drawable-offsets",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-offsets",
+ args);
+ gimp_value_array_unref (args);
*offset_x = 0;
*offset_y = 0;
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
{
- *offset_x = return_vals[1].data.d_int32;
- *offset_y = return_vals[2].data.d_int32;
+ *offset_x = g_value_get_int (gimp_value_array_index (return_vals, 1));
+ *offset_y = g_value_get_int (gimp_value_array_index (return_vals, 2));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -460,25 +494,28 @@ gimp_drawable_mask_bounds (gint32 drawable_ID,
gint *x2,
gint *y2)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean non_empty = FALSE;
- return_vals = gimp_run_procedure ("gimp-drawable-mask-bounds",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-mask-bounds",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
{
- non_empty = return_vals[1].data.d_int32;
- *x1 = return_vals[2].data.d_int32;
- *y1 = return_vals[3].data.d_int32;
- *x2 = return_vals[4].data.d_int32;
- *y2 = return_vals[5].data.d_int32;
+ non_empty = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+ *x1 = g_value_get_int (gimp_value_array_index (return_vals, 2));
+ *y1 = g_value_get_int (gimp_value_array_index (return_vals, 3));
+ *x2 = g_value_get_int (gimp_value_array_index (return_vals, 4));
+ *y2 = g_value_get_int (gimp_value_array_index (return_vals, 5));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return non_empty;
}
@@ -511,25 +548,28 @@ gimp_drawable_mask_intersect (gint32 drawable_ID,
gint *width,
gint *height)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean non_empty = FALSE;
- return_vals = gimp_run_procedure ("gimp-drawable-mask-intersect",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-mask-intersect",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
{
- non_empty = return_vals[1].data.d_int32;
- *x = return_vals[2].data.d_int32;
- *y = return_vals[3].data.d_int32;
- *width = return_vals[4].data.d_int32;
- *height = return_vals[5].data.d_int32;
+ non_empty = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+ *x = g_value_get_int (gimp_value_array_index (return_vals, 2));
+ *y = g_value_get_int (gimp_value_array_index (return_vals, 3));
+ *width = g_value_get_int (gimp_value_array_index (return_vals, 4));
+ *height = g_value_get_int (gimp_value_array_index (return_vals, 5));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return non_empty;
}
@@ -552,19 +592,23 @@ gboolean
gimp_drawable_merge_shadow (gint32 drawable_ID,
gboolean undo)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-drawable-merge-shadow",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_INT32, undo,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_BOOLEAN,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-merge-shadow",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -587,18 +631,21 @@ gimp_drawable_merge_shadow (gint32 drawable_ID,
gboolean
gimp_drawable_free_shadow (gint32 drawable_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-drawable-free-shadow",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-free-shadow",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -627,22 +674,29 @@ gimp_drawable_update (gint32 drawable_ID,
gint width,
gint height)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-drawable-update",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_INT32, x,
- GIMP_PDB_INT32, y,
- GIMP_PDB_INT32, width,
- GIMP_PDB_INT32, height,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-update",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -668,29 +722,31 @@ gimp_drawable_get_pixel (gint32 drawable_ID,
gint y_coord,
gint *num_channels)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
guint8 *pixel = NULL;
- return_vals = gimp_run_procedure ("gimp-drawable-get-pixel",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_INT32, x_coord,
- GIMP_PDB_INT32, y_coord,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-get-pixel",
+ args);
+ gimp_value_array_unref (args);
*num_channels = 0;
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
{
- *num_channels = return_vals[1].data.d_int32;
- pixel = g_new (guint8, *num_channels);
- memcpy (pixel,
- return_vals[2].data.d_int8array,
- *num_channels * sizeof (guint8));
+ *num_channels = g_value_get_int (gimp_value_array_index (return_vals, 1));
+ pixel = gimp_value_dup_int8_array (gimp_value_array_index (return_vals, 2));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return pixel;
}
@@ -720,22 +776,29 @@ gimp_drawable_set_pixel (gint32 drawable_ID,
gint num_channels,
const guint8 *pixel)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-drawable-set-pixel",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_INT32, x_coord,
- GIMP_PDB_INT32, y_coord,
- GIMP_PDB_INT32, num_channels,
- GIMP_PDB_INT8ARRAY, pixel,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT8_ARRAY,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-set-pixel",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -765,19 +828,23 @@ gboolean
gimp_drawable_fill (gint32 drawable_ID,
GimpFillType fill_type)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-drawable-fill",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_INT32, fill_type,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_ENUM,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-fill",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -809,22 +876,29 @@ gimp_drawable_offset (gint32 drawable_ID,
gint offset_x,
gint offset_y)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-drawable-offset",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_INT32, wrap_around,
- GIMP_PDB_INT32, fill_type,
- GIMP_PDB_INT32, offset_x,
- GIMP_PDB_INT32, offset_y,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_BOOLEAN,
+ G_TYPE_ENUM,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-offset",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -859,16 +933,21 @@ _gimp_drawable_thumbnail (gint32 drawable_ID,
gint *thumbnail_data_count,
guint8 **thumbnail_data)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-drawable-thumbnail",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_INT32, width,
- GIMP_PDB_INT32, height,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-thumbnail",
+ args);
+ gimp_value_array_unref (args);
*actual_width = 0;
*actual_height = 0;
@@ -876,21 +955,18 @@ _gimp_drawable_thumbnail (gint32 drawable_ID,
*thumbnail_data_count = 0;
*thumbnail_data = NULL;
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
{
- *actual_width = return_vals[1].data.d_int32;
- *actual_height = return_vals[2].data.d_int32;
- *bpp = return_vals[3].data.d_int32;
- *thumbnail_data_count = return_vals[4].data.d_int32;
- *thumbnail_data = g_new (guint8, *thumbnail_data_count);
- memcpy (*thumbnail_data,
- return_vals[5].data.d_int8array,
- *thumbnail_data_count * sizeof (guint8));
+ *actual_width = g_value_get_int (gimp_value_array_index (return_vals, 1));
+ *actual_height = g_value_get_int (gimp_value_array_index (return_vals, 2));
+ *bpp = g_value_get_int (gimp_value_array_index (return_vals, 3));
+ *thumbnail_data_count = g_value_get_int (gimp_value_array_index (return_vals, 4));
+ *thumbnail_data = gimp_value_dup_int8_array (gimp_value_array_index (return_vals, 5));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -935,20 +1011,29 @@ _gimp_drawable_sub_thumbnail (gint32 drawable_ID,
gint *thumbnail_data_count,
guint8 **thumbnail_data)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-drawable-sub-thumbnail",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_INT32, src_x,
- GIMP_PDB_INT32, src_y,
- GIMP_PDB_INT32, src_width,
- GIMP_PDB_INT32, src_height,
- GIMP_PDB_INT32, dest_width,
- GIMP_PDB_INT32, dest_height,
- GIMP_PDB_END);
+ 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,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-sub-thumbnail",
+ args);
+ gimp_value_array_unref (args);
*width = 0;
*height = 0;
@@ -956,21 +1041,18 @@ _gimp_drawable_sub_thumbnail (gint32 drawable_ID,
*thumbnail_data_count = 0;
*thumbnail_data = NULL;
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
{
- *width = return_vals[1].data.d_int32;
- *height = return_vals[2].data.d_int32;
- *bpp = return_vals[3].data.d_int32;
- *thumbnail_data_count = return_vals[4].data.d_int32;
- *thumbnail_data = g_new (guint8, *thumbnail_data_count);
- memcpy (*thumbnail_data,
- return_vals[5].data.d_int8array,
- *thumbnail_data_count * sizeof (guint8));
+ *width = g_value_get_int (gimp_value_array_index (return_vals, 1));
+ *height = g_value_get_int (gimp_value_array_index (return_vals, 2));
+ *bpp = g_value_get_int (gimp_value_array_index (return_vals, 3));
+ *thumbnail_data_count = g_value_get_int (gimp_value_array_index (return_vals, 4));
+ *thumbnail_data = gimp_value_dup_int8_array (gimp_value_array_index (return_vals, 5));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -995,20 +1077,25 @@ gimp_drawable_foreground_extract (gint32 drawable_ID,
GimpForegroundExtractMode mode,
gint32 mask_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-drawable-foreground-extract",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_INT32, mode,
- GIMP_PDB_DRAWABLE, mask_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_ENUM,
+ GIMP_TYPE_DRAWABLE_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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-foreground-extract",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
diff --git a/libgimp/gimpdrawablecolor_pdb.c b/libgimp/gimpdrawablecolor_pdb.c
index dcc12e3794..79eca99012 100644
--- a/libgimp/gimpdrawablecolor_pdb.c
+++ b/libgimp/gimpdrawablecolor_pdb.c
@@ -56,20 +56,25 @@ gimp_drawable_brightness_contrast (gint32 drawable_ID,
gdouble brightness,
gdouble contrast)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-drawable-brightness-contrast",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_FLOAT, brightness,
- GIMP_PDB_FLOAT, contrast,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_DOUBLE,
+ G_TYPE_DOUBLE,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-brightness-contrast",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -106,23 +111,31 @@ gimp_drawable_color_balance (gint32 drawable_ID,
gdouble magenta_green,
gdouble yellow_blue)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-drawable-color-balance",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_INT32, transfer_mode,
- GIMP_PDB_INT32, preserve_lum,
- GIMP_PDB_FLOAT, cyan_red,
- GIMP_PDB_FLOAT, magenta_green,
- GIMP_PDB_FLOAT, yellow_blue,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_ENUM,
+ G_TYPE_BOOLEAN,
+ G_TYPE_DOUBLE,
+ G_TYPE_DOUBLE,
+ G_TYPE_DOUBLE,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-color-balance",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -151,21 +164,27 @@ gimp_drawable_colorize_hsl (gint32 drawable_ID,
gdouble saturation,
gdouble lightness)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-drawable-colorize-hsl",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_FLOAT, hue,
- GIMP_PDB_FLOAT, saturation,
- GIMP_PDB_FLOAT, lightness,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_DOUBLE,
+ G_TYPE_DOUBLE,
+ G_TYPE_DOUBLE,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-colorize-hsl",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -196,21 +215,27 @@ gimp_drawable_curves_explicit (gint32 drawable_ID,
gint num_values,
const gdouble *values)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-drawable-curves-explicit",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_INT32, channel,
- GIMP_PDB_INT32, num_values,
- GIMP_PDB_FLOATARRAY, values,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_ENUM,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_FLOAT_ARRAY,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-curves-explicit",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -241,21 +266,27 @@ gimp_drawable_curves_spline (gint32 drawable_ID,
gint num_points,
const gdouble *points)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-drawable-curves-spline",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_INT32, channel,
- GIMP_PDB_INT32, num_points,
- GIMP_PDB_FLOATARRAY, points,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_ENUM,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_FLOAT_ARRAY,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-curves-spline",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -280,19 +311,23 @@ gboolean
gimp_drawable_desaturate (gint32 drawable_ID,
GimpDesaturateMode desaturate_mode)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-drawable-desaturate",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_INT32, desaturate_mode,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_ENUM,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-desaturate",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -320,19 +355,23 @@ gboolean
gimp_drawable_equalize (gint32 drawable_ID,
gboolean mask_only)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-drawable-equalize",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_INT32, mask_only,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_BOOLEAN,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-equalize",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -385,17 +424,23 @@ gimp_drawable_histogram (gint32 drawable_ID,
gdouble *count,
gdouble *percentile)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-drawable-histogram",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_INT32, channel,
- GIMP_PDB_FLOAT, start_range,
- GIMP_PDB_FLOAT, end_range,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_ENUM,
+ G_TYPE_DOUBLE,
+ G_TYPE_DOUBLE,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-histogram",
+ args);
+ gimp_value_array_unref (args);
*mean = 0.0;
*std_dev = 0.0;
@@ -404,19 +449,19 @@ gimp_drawable_histogram (gint32 drawable_ID,
*count = 0.0;
*percentile = 0.0;
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
{
- *mean = return_vals[1].data.d_float;
- *std_dev = return_vals[2].data.d_float;
- *median = return_vals[3].data.d_float;
- *pixels = return_vals[4].data.d_float;
- *count = return_vals[5].data.d_float;
- *percentile = return_vals[6].data.d_float;
+ *mean = g_value_get_double (gimp_value_array_index (return_vals, 1));
+ *std_dev = g_value_get_double (gimp_value_array_index (return_vals, 2));
+ *median = g_value_get_double (gimp_value_array_index (return_vals, 3));
+ *pixels = g_value_get_double (gimp_value_array_index (return_vals, 4));
+ *count = g_value_get_double (gimp_value_array_index (return_vals, 5));
+ *percentile = g_value_get_double (gimp_value_array_index (return_vals, 6));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -450,23 +495,31 @@ gimp_drawable_hue_saturation (gint32 drawable_ID,
gdouble saturation,
gdouble overlap)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-drawable-hue-saturation",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_INT32, hue_range,
- GIMP_PDB_FLOAT, hue_offset,
- GIMP_PDB_FLOAT, lightness,
- GIMP_PDB_FLOAT, saturation,
- GIMP_PDB_FLOAT, overlap,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_ENUM,
+ G_TYPE_DOUBLE,
+ G_TYPE_DOUBLE,
+ G_TYPE_DOUBLE,
+ G_TYPE_DOUBLE,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-hue-saturation",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -491,19 +544,23 @@ gboolean
gimp_drawable_invert (gint32 drawable_ID,
gboolean linear)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-drawable-invert",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_INT32, linear,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_BOOLEAN,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-invert",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -550,26 +607,37 @@ gimp_drawable_levels (gint32 drawable_ID,
gdouble high_output,
gboolean clamp_output)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-drawable-levels",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_INT32, channel,
- GIMP_PDB_FLOAT, low_input,
- GIMP_PDB_FLOAT, high_input,
- GIMP_PDB_INT32, clamp_input,
- GIMP_PDB_FLOAT, gamma,
- GIMP_PDB_FLOAT, low_output,
- GIMP_PDB_FLOAT, high_output,
- GIMP_PDB_INT32, clamp_output,
- GIMP_PDB_END);
-
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
-
- gimp_destroy_params (return_vals, nreturn_vals);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_ENUM,
+ G_TYPE_DOUBLE,
+ G_TYPE_DOUBLE,
+ G_TYPE_BOOLEAN,
+ G_TYPE_DOUBLE,
+ G_TYPE_DOUBLE,
+ G_TYPE_DOUBLE,
+ G_TYPE_BOOLEAN,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-levels",
+ args);
+ gimp_value_array_unref (args);
+
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -591,18 +659,21 @@ gimp_drawable_levels (gint32 drawable_ID,
gboolean
gimp_drawable_levels_stretch (gint32 drawable_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-drawable-levels-stretch",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-levels-stretch",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -625,19 +696,23 @@ gboolean
gimp_drawable_posterize (gint32 drawable_ID,
gint levels)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-drawable-posterize",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_INT32, levels,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-posterize",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -666,21 +741,27 @@ gimp_drawable_threshold (gint32 drawable_ID,
gdouble low_threshold,
gdouble high_threshold)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-drawable-threshold",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_INT32, channel,
- GIMP_PDB_FLOAT, low_threshold,
- GIMP_PDB_FLOAT, high_threshold,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_ENUM,
+ G_TYPE_DOUBLE,
+ G_TYPE_DOUBLE,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-threshold",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
diff --git a/libgimp/gimpdrawableedit_pdb.c b/libgimp/gimpdrawableedit_pdb.c
index f8eb93b220..75424aec3b 100644
--- a/libgimp/gimpdrawableedit_pdb.c
+++ b/libgimp/gimpdrawableedit_pdb.c
@@ -54,18 +54,21 @@
gboolean
gimp_drawable_edit_clear (gint32 drawable_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-drawable-edit-clear",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-edit-clear",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -93,19 +96,23 @@ gboolean
gimp_drawable_edit_fill (gint32 drawable_ID,
GimpFillType fill_type)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-drawable-edit-fill",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_INT32, fill_type,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_ENUM,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-edit-fill",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -143,21 +150,27 @@ gimp_drawable_edit_bucket_fill (gint32 drawable_ID,
gdouble x,
gdouble y)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-drawable-edit-bucket-fill",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_INT32, fill_type,
- GIMP_PDB_FLOAT, x,
- GIMP_PDB_FLOAT, y,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_ENUM,
+ G_TYPE_DOUBLE,
+ G_TYPE_DOUBLE,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-edit-bucket-fill",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -208,28 +221,41 @@ gimp_drawable_edit_gradient_fill (gint32 drawable_ID,
gdouble x2,
gdouble y2)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-drawable-edit-gradient-fill",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_INT32, gradient_type,
- GIMP_PDB_FLOAT, offset,
- GIMP_PDB_INT32, supersample,
- GIMP_PDB_INT32, supersample_max_depth,
- GIMP_PDB_FLOAT, supersample_threshold,
- GIMP_PDB_INT32, dither,
- GIMP_PDB_FLOAT, x1,
- GIMP_PDB_FLOAT, y1,
- GIMP_PDB_FLOAT, x2,
- GIMP_PDB_FLOAT, y2,
- GIMP_PDB_END);
-
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
-
- gimp_destroy_params (return_vals, nreturn_vals);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_ENUM,
+ 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,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-edit-gradient-fill",
+ args);
+ gimp_value_array_unref (args);
+
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -258,18 +284,21 @@ gimp_drawable_edit_gradient_fill (gint32 drawable_ID,
gboolean
gimp_drawable_edit_stroke_selection (gint32 drawable_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-drawable-edit-stroke-selection",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-edit-stroke-selection",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -302,19 +331,23 @@ gboolean
gimp_drawable_edit_stroke_item (gint32 drawable_ID,
gint32 item_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-drawable-edit-stroke-item",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ GIMP_TYPE_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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-edit-stroke-item",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
diff --git a/libgimp/gimpdynamics_pdb.c b/libgimp/gimpdynamics_pdb.c
index 929ce35585..ea4f30756a 100644
--- a/libgimp/gimpdynamics_pdb.c
+++ b/libgimp/gimpdynamics_pdb.c
@@ -50,17 +50,19 @@
gboolean
gimp_dynamics_refresh (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-dynamics-refresh",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-dynamics-refresh",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -84,30 +86,27 @@ gchar **
gimp_dynamics_get_list (const gchar *filter,
gint *num_dynamics)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar **dynamics_list = NULL;
- gint i;
- return_vals = gimp_run_procedure ("gimp-dynamics-get-list",
- &nreturn_vals,
- GIMP_PDB_STRING, filter,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), filter);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-dynamics-get-list",
+ args);
+ gimp_value_array_unref (args);
*num_dynamics = 0;
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
{
- *num_dynamics = return_vals[1].data.d_int32;
- if (*num_dynamics > 0)
- {
- dynamics_list = g_new0 (gchar *, *num_dynamics + 1);
- for (i = 0; i < *num_dynamics; i++)
- dynamics_list[i] = g_strdup (return_vals[2].data.d_stringarray[i]);
- }
+ *num_dynamics = g_value_get_int (gimp_value_array_index (return_vals, 1));
+ dynamics_list = gimp_value_dup_string_array (gimp_value_array_index (return_vals, 2));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return dynamics_list;
}
diff --git a/libgimp/gimpedit_pdb.c b/libgimp/gimpedit_pdb.c
index fcb0eab389..5114a29537 100644
--- a/libgimp/gimpedit_pdb.c
+++ b/libgimp/gimpedit_pdb.c
@@ -55,19 +55,22 @@
gboolean
gimp_edit_cut (gint32 drawable_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean non_empty = FALSE;
- return_vals = gimp_run_procedure ("gimp-edit-cut",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- non_empty = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-edit-cut",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ non_empty = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return non_empty;
}
@@ -93,19 +96,22 @@ gimp_edit_cut (gint32 drawable_ID)
gboolean
gimp_edit_copy (gint32 drawable_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean non_empty = FALSE;
- return_vals = gimp_run_procedure ("gimp-edit-copy",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-edit-copy",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- non_empty = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ non_empty = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return non_empty;
}
@@ -130,19 +136,22 @@ gimp_edit_copy (gint32 drawable_ID)
gboolean
gimp_edit_copy_visible (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean non_empty = FALSE;
- return_vals = gimp_run_procedure ("gimp-edit-copy-visible",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-edit-copy-visible",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- non_empty = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ non_empty = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return non_empty;
}
@@ -176,20 +185,24 @@ gint32
gimp_edit_paste (gint32 drawable_ID,
gboolean paste_into)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 floating_sel_ID = -1;
- return_vals = gimp_run_procedure ("gimp-edit-paste",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_INT32, paste_into,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_BOOLEAN,
+ 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 (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- floating_sel_ID = return_vals[1].data.d_layer;
+ return_vals = gimp_run_procedure_with_array ("gimp-edit-paste",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ floating_sel_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return floating_sel_ID;
}
@@ -211,18 +224,20 @@ gimp_edit_paste (gint32 drawable_ID,
gint32
gimp_edit_paste_as_new_image (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 image_ID = -1;
- return_vals = gimp_run_procedure ("gimp-edit-paste-as-new-image",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-edit-paste-as-new-image",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- image_ID = return_vals[1].data.d_image;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ image_ID = gimp_value_get_image_id (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return image_ID;
}
@@ -248,20 +263,24 @@ gchar *
gimp_edit_named_cut (gint32 drawable_ID,
const gchar *buffer_name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *real_name = NULL;
- return_vals = gimp_run_procedure ("gimp-edit-named-cut",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_STRING, buffer_name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_STRING,
+ 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 (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- real_name = g_strdup (return_vals[1].data.d_string);
+ return_vals = gimp_run_procedure_with_array ("gimp-edit-named-cut",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ real_name = g_value_dup_string (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return real_name;
}
@@ -287,20 +306,24 @@ gchar *
gimp_edit_named_copy (gint32 drawable_ID,
const gchar *buffer_name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *real_name = NULL;
- return_vals = gimp_run_procedure ("gimp-edit-named-copy",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_STRING, buffer_name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_STRING,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-edit-named-copy",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- real_name = g_strdup (return_vals[1].data.d_string);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ real_name = g_value_dup_string (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return real_name;
}
@@ -326,20 +349,24 @@ gchar *
gimp_edit_named_copy_visible (gint32 image_ID,
const gchar *buffer_name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *real_name = NULL;
- return_vals = gimp_run_procedure ("gimp-edit-named-copy-visible",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_STRING, buffer_name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_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), buffer_name);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-edit-named-copy-visible",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- real_name = g_strdup (return_vals[1].data.d_string);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ real_name = g_value_dup_string (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return real_name;
}
@@ -364,21 +391,26 @@ gimp_edit_named_paste (gint32 drawable_ID,
const gchar *buffer_name,
gboolean paste_into)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 floating_sel_ID = -1;
- return_vals = gimp_run_procedure ("gimp-edit-named-paste",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_STRING, buffer_name,
- GIMP_PDB_INT32, paste_into,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_STRING,
+ G_TYPE_BOOLEAN,
+ 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 (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- floating_sel_ID = return_vals[1].data.d_layer;
+ return_vals = gimp_run_procedure_with_array ("gimp-edit-named-paste",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ floating_sel_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return floating_sel_ID;
}
@@ -399,19 +431,22 @@ gimp_edit_named_paste (gint32 drawable_ID,
gint32
gimp_edit_named_paste_as_new_image (const gchar *buffer_name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 image_ID = -1;
- return_vals = gimp_run_procedure ("gimp-edit-named-paste-as-new-image",
- &nreturn_vals,
- GIMP_PDB_STRING, buffer_name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), buffer_name);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-edit-named-paste-as-new-image",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- image_ID = return_vals[1].data.d_image;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ image_ID = gimp_value_get_image_id (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return image_ID;
}
diff --git a/libgimp/gimpfileops_pdb.c b/libgimp/gimpfileops_pdb.c
index 4e5d8aefaf..a77456eea1 100644
--- a/libgimp/gimpfileops_pdb.c
+++ b/libgimp/gimpfileops_pdb.c
@@ -22,8 +22,6 @@
#include "config.h"
-#include <string.h>
-
#include "gimp.h"
@@ -59,21 +57,26 @@ gimp_file_load (GimpRunMode run_mode,
const gchar *filename,
const gchar *raw_filename)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 image_ID = -1;
- return_vals = gimp_run_procedure ("gimp-file-load",
- &nreturn_vals,
- GIMP_PDB_INT32, run_mode,
- GIMP_PDB_STRING, filename,
- GIMP_PDB_STRING, raw_filename,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_ENUM,
+ G_TYPE_STRING,
+ G_TYPE_STRING,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-file-load",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- image_ID = return_vals[1].data.d_image;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ image_ID = gimp_value_get_image_id (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return image_ID;
}
@@ -100,21 +103,26 @@ gimp_file_load_layer (GimpRunMode run_mode,
gint32 image_ID,
const gchar *filename)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 layer_ID = -1;
- return_vals = gimp_run_procedure ("gimp-file-load-layer",
- &nreturn_vals,
- GIMP_PDB_INT32, run_mode,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_STRING, filename,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_ENUM,
+ GIMP_TYPE_IMAGE_ID,
+ G_TYPE_STRING,
+ 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 (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- layer_ID = return_vals[1].data.d_layer;
+ return_vals = gimp_run_procedure_with_array ("gimp-file-load-layer",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return layer_ID;
}
@@ -143,29 +151,31 @@ gimp_file_load_layers (GimpRunMode run_mode,
const gchar *filename,
gint *num_layers)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint *layer_ids = NULL;
- return_vals = gimp_run_procedure ("gimp-file-load-layers",
- &nreturn_vals,
- GIMP_PDB_INT32, run_mode,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_STRING, filename,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_ENUM,
+ GIMP_TYPE_IMAGE_ID,
+ G_TYPE_STRING,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-file-load-layers",
+ args);
+ gimp_value_array_unref (args);
*num_layers = 0;
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
{
- *num_layers = return_vals[1].data.d_int32;
- layer_ids = g_new (gint32, *num_layers);
- memcpy (layer_ids,
- return_vals[2].data.d_int32array,
- *num_layers * sizeof (gint32));
+ *num_layers = g_value_get_int (gimp_value_array_index (return_vals, 1));
+ layer_ids = gimp_value_dup_int32_array (gimp_value_array_index (return_vals, 2));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return layer_ids;
}
@@ -197,22 +207,29 @@ gimp_file_save (GimpRunMode run_mode,
const gchar *filename,
const gchar *raw_filename)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-file-save",
- &nreturn_vals,
- GIMP_PDB_INT32, run_mode,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_STRING, filename,
- GIMP_PDB_STRING, raw_filename,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_ENUM,
+ GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_STRING,
+ G_TYPE_STRING,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-file-save",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -237,19 +254,23 @@ gboolean
gimp_file_save_thumbnail (gint32 image_ID,
const gchar *filename)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-file-save-thumbnail",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_STRING, filename,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_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), filename);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-file-save-thumbnail",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -274,21 +295,27 @@ gimp_register_magic_load_handler (const gchar *procedure_name,
const gchar *prefixes,
const gchar *magics)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-register-magic-load-handler",
- &nreturn_vals,
- GIMP_PDB_STRING, procedure_name,
- GIMP_PDB_STRING, extensions,
- GIMP_PDB_STRING, prefixes,
- GIMP_PDB_STRING, magics,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_STRING,
+ G_TYPE_STRING,
+ G_TYPE_STRING,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-register-magic-load-handler",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -311,20 +338,25 @@ gimp_register_load_handler (const gchar *procedure_name,
const gchar *extensions,
const gchar *prefixes)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-register-load-handler",
- &nreturn_vals,
- GIMP_PDB_STRING, procedure_name,
- GIMP_PDB_STRING, extensions,
- GIMP_PDB_STRING, prefixes,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_STRING,
+ G_TYPE_STRING,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-register-load-handler",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -347,20 +379,25 @@ gimp_register_save_handler (const gchar *procedure_name,
const gchar *extensions,
const gchar *prefixes)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-register-save-handler",
- &nreturn_vals,
- GIMP_PDB_STRING, procedure_name,
- GIMP_PDB_STRING, extensions,
- GIMP_PDB_STRING, prefixes,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_STRING,
+ G_TYPE_STRING,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-register-save-handler",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -386,19 +423,23 @@ gboolean
gimp_register_file_handler_priority (const gchar *procedure_name,
gint priority)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-register-file-handler-priority",
- &nreturn_vals,
- GIMP_PDB_STRING, procedure_name,
- GIMP_PDB_INT32, priority,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ GIMP_TYPE_INT32,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-register-file-handler-priority",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -425,19 +466,23 @@ gboolean
gimp_register_file_handler_mime (const gchar *procedure_name,
const gchar *mime_types)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-register-file-handler-mime",
- &nreturn_vals,
- GIMP_PDB_STRING, procedure_name,
- GIMP_PDB_STRING, mime_types,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_STRING,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-register-file-handler-mime",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -460,18 +505,21 @@ gimp_register_file_handler_mime (const gchar *procedure_name,
gboolean
gimp_register_file_handler_uri (const gchar *procedure_name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-register-file-handler-uri",
- &nreturn_vals,
- GIMP_PDB_STRING, procedure_name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), procedure_name);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-register-file-handler-uri",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -494,18 +542,21 @@ gimp_register_file_handler_uri (const gchar *procedure_name)
gboolean
gimp_register_file_handler_raw (const gchar *procedure_name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-register-file-handler-raw",
- &nreturn_vals,
- GIMP_PDB_STRING, procedure_name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), procedure_name);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-register-file-handler-raw",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -532,19 +583,23 @@ gboolean
gimp_register_thumbnail_loader (const gchar *load_proc,
const gchar *thumb_proc)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-register-thumbnail-loader",
- &nreturn_vals,
- GIMP_PDB_STRING, load_proc,
- GIMP_PDB_STRING, thumb_proc,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_STRING,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-register-thumbnail-loader",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
diff --git a/libgimp/gimpfloatingsel_pdb.c b/libgimp/gimpfloatingsel_pdb.c
index 370de7dae0..6d0382eb0e 100644
--- a/libgimp/gimpfloatingsel_pdb.c
+++ b/libgimp/gimpfloatingsel_pdb.c
@@ -49,18 +49,21 @@
gboolean
gimp_floating_sel_remove (gint32 floating_sel_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-floating-sel-remove",
- &nreturn_vals,
- GIMP_PDB_LAYER, floating_sel_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_NONE);
+ gimp_value_set_layer_id (gimp_value_array_index (args, 0), floating_sel_ID);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-floating-sel-remove",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -81,18 +84,21 @@ gimp_floating_sel_remove (gint32 floating_sel_ID)
gboolean
gimp_floating_sel_anchor (gint32 floating_sel_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-floating-sel-anchor",
- &nreturn_vals,
- GIMP_PDB_LAYER, floating_sel_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_NONE);
+ gimp_value_set_layer_id (gimp_value_array_index (args, 0), floating_sel_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-floating-sel-anchor",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -117,18 +123,21 @@ gimp_floating_sel_anchor (gint32 floating_sel_ID)
gboolean
gimp_floating_sel_to_layer (gint32 floating_sel_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-floating-sel-to-layer",
- &nreturn_vals,
- GIMP_PDB_LAYER, floating_sel_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_NONE);
+ gimp_value_set_layer_id (gimp_value_array_index (args, 0), floating_sel_ID);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-floating-sel-to-layer",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -149,19 +158,23 @@ gboolean
gimp_floating_sel_attach (gint32 layer_ID,
gint32 drawable_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-floating-sel-attach",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ GIMP_TYPE_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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-floating-sel-attach",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
diff --git a/libgimp/gimpfonts_pdb.c b/libgimp/gimpfonts_pdb.c
index c84b2bd9ab..e75a8f1565 100644
--- a/libgimp/gimpfonts_pdb.c
+++ b/libgimp/gimpfonts_pdb.c
@@ -48,17 +48,19 @@
gboolean
gimp_fonts_refresh (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-fonts-refresh",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-fonts-refresh",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -80,30 +82,27 @@ gchar **
gimp_fonts_get_list (const gchar *filter,
gint *num_fonts)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar **font_list = NULL;
- gint i;
- return_vals = gimp_run_procedure ("gimp-fonts-get-list",
- &nreturn_vals,
- GIMP_PDB_STRING, filter,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), filter);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-fonts-get-list",
+ args);
+ gimp_value_array_unref (args);
*num_fonts = 0;
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
{
- *num_fonts = return_vals[1].data.d_int32;
- if (*num_fonts > 0)
- {
- font_list = g_new0 (gchar *, *num_fonts + 1);
- for (i = 0; i < *num_fonts; i++)
- font_list[i] = g_strdup (return_vals[2].data.d_stringarray[i]);
- }
+ *num_fonts = g_value_get_int (gimp_value_array_index (return_vals, 1));
+ font_list = gimp_value_dup_string_array (gimp_value_array_index (return_vals, 2));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return font_list;
}
diff --git a/libgimp/gimpfontselect_pdb.c b/libgimp/gimpfontselect_pdb.c
index 14c121804e..b1dee3b839 100644
--- a/libgimp/gimpfontselect_pdb.c
+++ b/libgimp/gimpfontselect_pdb.c
@@ -51,20 +51,25 @@ gimp_fonts_popup (const gchar *font_callback,
const gchar *popup_title,
const gchar *initial_font)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-fonts-popup",
- &nreturn_vals,
- GIMP_PDB_STRING, font_callback,
- GIMP_PDB_STRING, popup_title,
- GIMP_PDB_STRING, initial_font,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_STRING,
+ G_TYPE_STRING,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-fonts-popup",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -82,18 +87,21 @@ gimp_fonts_popup (const gchar *font_callback,
gboolean
gimp_fonts_close_popup (const gchar *font_callback)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-fonts-close-popup",
- &nreturn_vals,
- GIMP_PDB_STRING, font_callback,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), font_callback);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-fonts-close-popup",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -113,19 +121,23 @@ gboolean
gimp_fonts_set_popup (const gchar *font_callback,
const gchar *font_name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-fonts-set-popup",
- &nreturn_vals,
- GIMP_PDB_STRING, font_callback,
- GIMP_PDB_STRING, font_name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_STRING,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-fonts-set-popup",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
diff --git a/libgimp/gimpgimprc_pdb.c b/libgimp/gimpgimprc_pdb.c
index 7363567ec0..2c41a72728 100644
--- a/libgimp/gimpgimprc_pdb.c
+++ b/libgimp/gimpgimprc_pdb.c
@@ -55,19 +55,22 @@
gchar *
gimp_gimprc_query (const gchar *token)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *value = NULL;
- return_vals = gimp_run_procedure ("gimp-gimprc-query",
- &nreturn_vals,
- GIMP_PDB_STRING, token,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), token);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- value = g_strdup (return_vals[1].data.d_string);
+ return_vals = gimp_run_procedure_with_array ("gimp-gimprc-query",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ value = g_value_dup_string (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return value;
}
@@ -91,19 +94,23 @@ gboolean
gimp_gimprc_set (const gchar *token,
const gchar *value)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-gimprc-set",
- &nreturn_vals,
- GIMP_PDB_STRING, token,
- GIMP_PDB_STRING, value,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_STRING,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-gimprc-set",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -120,18 +127,20 @@ gimp_gimprc_set (const gchar *token,
gchar *
gimp_get_default_comment (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *comment = NULL;
- return_vals = gimp_run_procedure ("gimp-get-default-comment",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- comment = g_strdup (return_vals[1].data.d_string);
+ return_vals = gimp_run_procedure_with_array ("gimp-get-default-comment",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ comment = g_value_dup_string (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return comment;
}
@@ -150,18 +159,20 @@ gimp_get_default_comment (void)
GimpUnit
gimp_get_default_unit (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
GimpUnit unit_id = 0;
- return_vals = gimp_run_procedure ("gimp-get-default-unit",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-get-default-unit",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- unit_id = return_vals[1].data.d_unit;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ unit_id = g_value_get_int (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return unit_id;
}
@@ -184,26 +195,28 @@ gboolean
gimp_get_monitor_resolution (gdouble *xres,
gdouble *yres)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-get-monitor-resolution",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-get-monitor-resolution",
+ args);
+ gimp_value_array_unref (args);
*xres = 0.0;
*yres = 0.0;
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
{
- *xres = return_vals[1].data.d_float;
- *yres = return_vals[2].data.d_float;
+ *xres = g_value_get_double (gimp_value_array_index (return_vals, 1));
+ *yres = g_value_get_double (gimp_value_array_index (return_vals, 2));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -223,18 +236,20 @@ gimp_get_monitor_resolution (gdouble *xres,
gchar *
_gimp_get_color_configuration (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *config = NULL;
- return_vals = gimp_run_procedure ("gimp-get-color-configuration",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-get-color-configuration",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- config = g_strdup (return_vals[1].data.d_string);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ config = g_value_dup_string (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return config;
}
@@ -251,18 +266,20 @@ _gimp_get_color_configuration (void)
gchar *
gimp_get_module_load_inhibit (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *load_inhibit = NULL;
- return_vals = gimp_run_procedure ("gimp-get-module-load-inhibit",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-get-module-load-inhibit",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- load_inhibit = g_strdup (return_vals[1].data.d_string);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ load_inhibit = g_value_dup_string (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return load_inhibit;
}
diff --git a/libgimp/gimpgradient_pdb.c b/libgimp/gimpgradient_pdb.c
index f47ee8f48c..656eb03a1c 100644
--- a/libgimp/gimpgradient_pdb.c
+++ b/libgimp/gimpgradient_pdb.c
@@ -22,8 +22,6 @@
#include "config.h"
-#include <string.h>
-
#include "gimp.h"
@@ -51,19 +49,22 @@
gchar *
gimp_gradient_new (const gchar *name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *actual_name = NULL;
- return_vals = gimp_run_procedure ("gimp-gradient-new",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), name);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-new",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- actual_name = g_strdup (return_vals[1].data.d_string);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ actual_name = g_value_dup_string (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return actual_name;
}
@@ -83,19 +84,22 @@ gimp_gradient_new (const gchar *name)
gchar *
gimp_gradient_duplicate (const gchar *name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *copy_name = NULL;
- return_vals = gimp_run_procedure ("gimp-gradient-duplicate",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), name);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-duplicate",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- copy_name = g_strdup (return_vals[1].data.d_string);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ copy_name = g_value_dup_string (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return copy_name;
}
@@ -115,19 +119,22 @@ gimp_gradient_duplicate (const gchar *name)
gboolean
gimp_gradient_is_editable (const gchar *name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean editable = FALSE;
- return_vals = gimp_run_procedure ("gimp-gradient-is-editable",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), name);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- editable = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-is-editable",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ editable = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return editable;
}
@@ -149,20 +156,24 @@ gchar *
gimp_gradient_rename (const gchar *name,
const gchar *new_name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *actual_name = NULL;
- return_vals = gimp_run_procedure ("gimp-gradient-rename",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_STRING, new_name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_STRING,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-rename",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- actual_name = g_strdup (return_vals[1].data.d_string);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ actual_name = g_value_dup_string (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return actual_name;
}
@@ -182,18 +193,21 @@ gimp_gradient_rename (const gchar *name,
gboolean
gimp_gradient_delete (const gchar *name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-gradient-delete",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), name);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-delete",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -214,19 +228,22 @@ gimp_gradient_delete (const gchar *name)
gint
gimp_gradient_get_number_of_segments (const gchar *name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint num_segments = 0;
- return_vals = gimp_run_procedure ("gimp-gradient-get-number-of-segments",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), name);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-get-number-of-segments",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- num_segments = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ num_segments = g_value_get_int (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return num_segments;
}
@@ -260,32 +277,34 @@ gimp_gradient_get_uniform_samples (const gchar *name,
gint *num_color_samples,
gdouble **color_samples)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-gradient-get-uniform-samples",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_INT32, num_samples,
- GIMP_PDB_INT32, reverse,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ GIMP_TYPE_INT32,
+ G_TYPE_BOOLEAN,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-get-uniform-samples",
+ args);
+ gimp_value_array_unref (args);
*num_color_samples = 0;
*color_samples = NULL;
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
{
- *num_color_samples = return_vals[1].data.d_int32;
- *color_samples = g_new (gdouble, *num_color_samples);
- memcpy (*color_samples,
- return_vals[2].data.d_floatarray,
- *num_color_samples * sizeof (gdouble));
+ *num_color_samples = g_value_get_int (gimp_value_array_index (return_vals, 1));
+ *color_samples = gimp_value_dup_float_array (gimp_value_array_index (return_vals, 2));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -320,33 +339,36 @@ gimp_gradient_get_custom_samples (const gchar *name,
gint *num_color_samples,
gdouble **color_samples)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-gradient-get-custom-samples",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_INT32, num_samples,
- GIMP_PDB_FLOATARRAY, positions,
- GIMP_PDB_INT32, reverse,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_FLOAT_ARRAY,
+ G_TYPE_BOOLEAN,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-get-custom-samples",
+ args);
+ gimp_value_array_unref (args);
*num_color_samples = 0;
*color_samples = NULL;
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
{
- *num_color_samples = return_vals[1].data.d_int32;
- *color_samples = g_new (gdouble, *num_color_samples);
- memcpy (*color_samples,
- return_vals[2].data.d_floatarray,
- *num_color_samples * sizeof (gdouble));
+ *num_color_samples = g_value_get_int (gimp_value_array_index (return_vals, 1));
+ *color_samples = gimp_value_dup_float_array (gimp_value_array_index (return_vals, 2));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -373,27 +395,31 @@ gimp_gradient_segment_get_left_color (const gchar *name,
GimpRGB *color,
gdouble *opacity)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-gradient-segment-get-left-color",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_INT32, segment,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-get-left-color",
+ args);
+ gimp_value_array_unref (args);
*opacity = 0.0;
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
{
- *color = return_vals[1].data.d_color;
- *opacity = return_vals[2].data.d_float;
+ gimp_value_get_rgb (gimp_value_array_index (return_vals, 1), &*color);
+ *opacity = g_value_get_double (gimp_value_array_index (return_vals, 2));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -420,21 +446,27 @@ gimp_gradient_segment_set_left_color (const gchar *name,
const GimpRGB *color,
gdouble opacity)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-gradient-segment-set-left-color",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_INT32, segment,
- GIMP_PDB_COLOR, color,
- GIMP_PDB_FLOAT, opacity,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_RGB,
+ G_TYPE_DOUBLE,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-set-left-color",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -461,27 +493,31 @@ gimp_gradient_segment_get_right_color (const gchar *name,
GimpRGB *color,
gdouble *opacity)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-gradient-segment-get-right-color",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_INT32, segment,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-get-right-color",
+ args);
+ gimp_value_array_unref (args);
*opacity = 0.0;
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
{
- *color = return_vals[1].data.d_color;
- *opacity = return_vals[2].data.d_float;
+ gimp_value_get_rgb (gimp_value_array_index (return_vals, 1), &*color);
+ *opacity = g_value_get_double (gimp_value_array_index (return_vals, 2));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -508,21 +544,27 @@ gimp_gradient_segment_set_right_color (const gchar *name,
const GimpRGB *color,
gdouble opacity)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-gradient-segment-set-right-color",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_INT32, segment,
- GIMP_PDB_COLOR, color,
- GIMP_PDB_FLOAT, opacity,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_RGB,
+ G_TYPE_DOUBLE,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-set-right-color",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -547,24 +589,28 @@ gimp_gradient_segment_get_left_pos (const gchar *name,
gint segment,
gdouble *pos)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-gradient-segment-get-left-pos",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_INT32, segment,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-get-left-pos",
+ args);
+ gimp_value_array_unref (args);
*pos = 0.0;
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
- *pos = return_vals[1].data.d_float;
+ *pos = g_value_get_double (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -594,25 +640,30 @@ gimp_gradient_segment_set_left_pos (const gchar *name,
gdouble pos,
gdouble *final_pos)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-gradient-segment-set-left-pos",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_INT32, segment,
- GIMP_PDB_FLOAT, pos,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ GIMP_TYPE_INT32,
+ G_TYPE_DOUBLE,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-set-left-pos",
+ args);
+ gimp_value_array_unref (args);
*final_pos = 0.0;
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
- *final_pos = return_vals[1].data.d_float;
+ *final_pos = g_value_get_double (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -637,24 +688,28 @@ gimp_gradient_segment_get_middle_pos (const gchar *name,
gint segment,
gdouble *pos)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-gradient-segment-get-middle-pos",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_INT32, segment,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-get-middle-pos",
+ args);
+ gimp_value_array_unref (args);
*pos = 0.0;
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
- *pos = return_vals[1].data.d_float;
+ *pos = g_value_get_double (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -683,25 +738,30 @@ gimp_gradient_segment_set_middle_pos (const gchar *name,
gdouble pos,
gdouble *final_pos)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-gradient-segment-set-middle-pos",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_INT32, segment,
- GIMP_PDB_FLOAT, pos,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ GIMP_TYPE_INT32,
+ G_TYPE_DOUBLE,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-set-middle-pos",
+ args);
+ gimp_value_array_unref (args);
*final_pos = 0.0;
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
- *final_pos = return_vals[1].data.d_float;
+ *final_pos = g_value_get_double (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -726,24 +786,28 @@ gimp_gradient_segment_get_right_pos (const gchar *name,
gint segment,
gdouble *pos)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-gradient-segment-get-right-pos",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_INT32, segment,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-get-right-pos",
+ args);
+ gimp_value_array_unref (args);
*pos = 0.0;
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
- *pos = return_vals[1].data.d_float;
+ *pos = g_value_get_double (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -773,25 +837,30 @@ gimp_gradient_segment_set_right_pos (const gchar *name,
gdouble pos,
gdouble *final_pos)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-gradient-segment-set-right-pos",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_INT32, segment,
- GIMP_PDB_FLOAT, pos,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ GIMP_TYPE_INT32,
+ G_TYPE_DOUBLE,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-set-right-pos",
+ args);
+ gimp_value_array_unref (args);
*final_pos = 0.0;
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
- *final_pos = return_vals[1].data.d_float;
+ *final_pos = g_value_get_double (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -816,24 +885,28 @@ gimp_gradient_segment_get_blending_function (const gchar *name,
gint segment,
GimpGradientSegmentType *blend_func)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-gradient-segment-get-blending-function",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_INT32, segment,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-get-blending-function",
+ args);
+ gimp_value_array_unref (args);
*blend_func = 0;
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
- *blend_func = return_vals[1].data.d_int32;
+ *blend_func = g_value_get_enum (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -858,24 +931,28 @@ gimp_gradient_segment_get_coloring_type (const gchar *name,
gint segment,
GimpGradientSegmentColor *coloring_type)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-gradient-segment-get-coloring-type",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_INT32, segment,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-get-coloring-type",
+ args);
+ gimp_value_array_unref (args);
*coloring_type = 0;
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
- *coloring_type = return_vals[1].data.d_int32;
+ *coloring_type = g_value_get_enum (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -902,21 +979,27 @@ gimp_gradient_segment_range_set_blending_function (const gchar *name
gint end_segment,
GimpGradientSegmentType blending_function)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-gradient-segment-range-set-blending-function",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_INT32, start_segment,
- GIMP_PDB_INT32, end_segment,
- GIMP_PDB_INT32, blending_function,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ G_TYPE_ENUM,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-range-set-blending-function",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -943,21 +1026,27 @@ gimp_gradient_segment_range_set_coloring_type (const gchar *name,
gint end_segment,
GimpGradientSegmentColor coloring_type)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-gradient-segment-range-set-coloring-type",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_INT32, start_segment,
- GIMP_PDB_INT32, end_segment,
- GIMP_PDB_INT32, coloring_type,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ G_TYPE_ENUM,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-range-set-coloring-type",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -981,20 +1070,25 @@ gimp_gradient_segment_range_flip (const gchar *name,
gint start_segment,
gint end_segment)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-gradient-segment-range-flip",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_INT32, start_segment,
- GIMP_PDB_INT32, end_segment,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-range-flip",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1022,21 +1116,27 @@ gimp_gradient_segment_range_replicate (const gchar *name,
gint end_segment,
gint replicate_times)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-gradient-segment-range-replicate",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_INT32, start_segment,
- GIMP_PDB_INT32, end_segment,
- GIMP_PDB_INT32, replicate_times,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-range-replicate",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1061,20 +1161,25 @@ gimp_gradient_segment_range_split_midpoint (const gchar *name,
gint start_segment,
gint end_segment)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-gradient-segment-range-split-midpoint",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_INT32, start_segment,
- GIMP_PDB_INT32, end_segment,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-range-split-midpoint",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1101,21 +1206,27 @@ gimp_gradient_segment_range_split_uniform (const gchar *name,
gint end_segment,
gint split_parts)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-gradient-segment-range-split-uniform",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_INT32, start_segment,
- GIMP_PDB_INT32, end_segment,
- GIMP_PDB_INT32, split_parts,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-range-split-uniform",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1139,20 +1250,25 @@ gimp_gradient_segment_range_delete (const gchar *name,
gint start_segment,
gint end_segment)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-gradient-segment-range-delete",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_INT32, start_segment,
- GIMP_PDB_INT32, end_segment,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-range-delete",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1177,20 +1293,25 @@ gimp_gradient_segment_range_redistribute_handles (const gchar *name,
gint start_segment,
gint end_segment)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-gradient-segment-range-redistribute-handles",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_INT32, start_segment,
- GIMP_PDB_INT32, end_segment,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-range-redistribute-handles",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1216,20 +1337,25 @@ gimp_gradient_segment_range_blend_colors (const gchar *name,
gint start_segment,
gint end_segment)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-gradient-segment-range-blend-colors",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_INT32, start_segment,
- GIMP_PDB_INT32, end_segment,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-range-blend-colors",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1255,20 +1381,25 @@ gimp_gradient_segment_range_blend_opacity (const gchar *name,
gint start_segment,
gint end_segment)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-gradient-segment-range-blend-opacity",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_INT32, start_segment,
- GIMP_PDB_INT32, end_segment,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-range-blend-opacity",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1298,23 +1429,30 @@ gimp_gradient_segment_range_move (const gchar *name,
gdouble delta,
gboolean control_compress)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gdouble final_delta = 0.0;
- return_vals = gimp_run_procedure ("gimp-gradient-segment-range-move",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_INT32, start_segment,
- GIMP_PDB_INT32, end_segment,
- GIMP_PDB_FLOAT, delta,
- GIMP_PDB_INT32, control_compress,
- GIMP_PDB_END);
-
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- final_delta = return_vals[1].data.d_float;
-
- gimp_destroy_params (return_vals, nreturn_vals);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ G_TYPE_DOUBLE,
+ G_TYPE_BOOLEAN,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-range-move",
+ args);
+ gimp_value_array_unref (args);
+
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ final_delta = g_value_get_double (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return final_delta;
}
diff --git a/libgimp/gimpgradients_pdb.c b/libgimp/gimpgradients_pdb.c
index 71f17b8e29..098267525f 100644
--- a/libgimp/gimpgradients_pdb.c
+++ b/libgimp/gimpgradients_pdb.c
@@ -47,17 +47,19 @@
gboolean
gimp_gradients_refresh (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-gradients-refresh",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-gradients-refresh",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -80,30 +82,27 @@ gchar **
gimp_gradients_get_list (const gchar *filter,
gint *num_gradients)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar **gradient_list = NULL;
- gint i;
- return_vals = gimp_run_procedure ("gimp-gradients-get-list",
- &nreturn_vals,
- GIMP_PDB_STRING, filter,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), filter);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-gradients-get-list",
+ args);
+ gimp_value_array_unref (args);
*num_gradients = 0;
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
{
- *num_gradients = return_vals[1].data.d_int32;
- if (*num_gradients > 0)
- {
- gradient_list = g_new0 (gchar *, *num_gradients + 1);
- for (i = 0; i < *num_gradients; i++)
- gradient_list[i] = g_strdup (return_vals[2].data.d_stringarray[i]);
- }
+ *num_gradients = g_value_get_int (gimp_value_array_index (return_vals, 1));
+ gradient_list = gimp_value_dup_string_array (gimp_value_array_index (return_vals, 2));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return gradient_list;
}
diff --git a/libgimp/gimpgradientselect_pdb.c b/libgimp/gimpgradientselect_pdb.c
index 86720d1e13..d054091dfa 100644
--- a/libgimp/gimpgradientselect_pdb.c
+++ b/libgimp/gimpgradientselect_pdb.c
@@ -53,21 +53,27 @@ gimp_gradients_popup (const gchar *gradient_callback,
const gchar *initial_gradient,
gint sample_size)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-gradients-popup",
- &nreturn_vals,
- GIMP_PDB_STRING, gradient_callback,
- GIMP_PDB_STRING, popup_title,
- GIMP_PDB_STRING, initial_gradient,
- GIMP_PDB_INT32, sample_size,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_STRING,
+ G_TYPE_STRING,
+ GIMP_TYPE_INT32,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-gradients-popup",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -85,18 +91,21 @@ gimp_gradients_popup (const gchar *gradient_callback,
gboolean
gimp_gradients_close_popup (const gchar *gradient_callback)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-gradients-close-popup",
- &nreturn_vals,
- GIMP_PDB_STRING, gradient_callback,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), gradient_callback);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-gradients-close-popup",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -116,19 +125,23 @@ gboolean
gimp_gradients_set_popup (const gchar *gradient_callback,
const gchar *gradient_name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-gradients-set-popup",
- &nreturn_vals,
- GIMP_PDB_STRING, gradient_callback,
- GIMP_PDB_STRING, gradient_name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_STRING,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-gradients-set-popup",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
diff --git a/libgimp/gimphelp_pdb.c b/libgimp/gimphelp_pdb.c
index 38e2be5c1b..4c7088d1e4 100644
--- a/libgimp/gimphelp_pdb.c
+++ b/libgimp/gimphelp_pdb.c
@@ -54,19 +54,23 @@ gboolean
gimp_help (const gchar *help_domain,
const gchar *help_id)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-help",
- &nreturn_vals,
- GIMP_PDB_STRING, help_domain,
- GIMP_PDB_STRING, help_id,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_STRING,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-help",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
diff --git a/libgimp/gimpimage_pdb.c b/libgimp/gimpimage_pdb.c
index 82548ef9b8..21547b8139 100644
--- a/libgimp/gimpimage_pdb.c
+++ b/libgimp/gimpimage_pdb.c
@@ -22,8 +22,6 @@
#include "config.h"
-#include <string.h>
-
#include "gimp.h"
@@ -53,19 +51,22 @@
gboolean
gimp_image_is_valid (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean valid = FALSE;
- return_vals = gimp_run_procedure ("gimp-image-is-valid",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-is-valid",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- valid = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ valid = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return valid;
}
@@ -84,26 +85,25 @@ gimp_image_is_valid (gint32 image_ID)
gint *
gimp_image_list (gint *num_images)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint *image_ids = NULL;
- return_vals = gimp_run_procedure ("gimp-image-list",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-list",
+ args);
+ gimp_value_array_unref (args);
*num_images = 0;
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
{
- *num_images = return_vals[1].data.d_int32;
- image_ids = g_new (gint32, *num_images);
- memcpy (image_ids,
- return_vals[2].data.d_int32array,
- *num_images * sizeof (gint32));
+ *num_images = g_value_get_int (gimp_value_array_index (return_vals, 1));
+ image_ids = gimp_value_dup_int32_array (gimp_value_array_index (return_vals, 2));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return image_ids;
}
@@ -134,21 +134,26 @@ gimp_image_new (gint width,
gint height,
GimpImageBaseType type)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 image_ID = -1;
- return_vals = gimp_run_procedure ("gimp-image-new",
- &nreturn_vals,
- GIMP_PDB_INT32, width,
- GIMP_PDB_INT32, height,
- GIMP_PDB_INT32, type,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ G_TYPE_ENUM,
+ 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 (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- image_ID = return_vals[1].data.d_image;
+ return_vals = gimp_run_procedure_with_array ("gimp-image-new",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ image_ID = gimp_value_get_image_id (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return image_ID;
}
@@ -178,22 +183,28 @@ gimp_image_new_with_precision (gint width,
GimpImageBaseType type,
GimpPrecision precision)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 image_ID = -1;
- return_vals = gimp_run_procedure ("gimp-image-new-with-precision",
- &nreturn_vals,
- GIMP_PDB_INT32, width,
- GIMP_PDB_INT32, height,
- GIMP_PDB_INT32, type,
- GIMP_PDB_INT32, precision,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ G_TYPE_ENUM,
+ G_TYPE_ENUM,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-new-with-precision",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- image_ID = return_vals[1].data.d_image;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ image_ID = gimp_value_get_image_id (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return image_ID;
}
@@ -212,19 +223,22 @@ gimp_image_new_with_precision (gint width,
gint32
gimp_image_duplicate (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 new_image_ID = -1;
- return_vals = gimp_run_procedure ("gimp-image-duplicate",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-duplicate",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- new_image_ID = return_vals[1].data.d_image;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ new_image_ID = gimp_value_get_image_id (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return new_image_ID;
}
@@ -247,18 +261,21 @@ gimp_image_duplicate (gint32 image_ID)
gboolean
gimp_image_delete (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-delete",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-image-delete",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -277,19 +294,22 @@ gimp_image_delete (gint32 image_ID)
GimpImageBaseType
gimp_image_base_type (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
GimpImageBaseType base_type = 0;
- return_vals = gimp_run_procedure ("gimp-image-base-type",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-base-type",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- base_type = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ base_type = g_value_get_enum (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return base_type;
}
@@ -309,19 +329,22 @@ gimp_image_base_type (gint32 image_ID)
GimpPrecision
gimp_image_get_precision (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
GimpPrecision precision = 0;
- return_vals = gimp_run_procedure ("gimp-image-get-precision",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-precision",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- precision = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ precision = g_value_get_enum (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return precision;
}
@@ -341,19 +364,22 @@ gimp_image_get_precision (gint32 image_ID)
GimpLayerMode
gimp_image_get_default_new_layer_mode (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
GimpLayerMode mode = 0;
- return_vals = gimp_run_procedure ("gimp-image-get-default-new-layer-mode",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- mode = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-default-new-layer-mode",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ mode = g_value_get_enum (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return mode;
}
@@ -372,19 +398,22 @@ gimp_image_get_default_new_layer_mode (gint32 image_ID)
gint
gimp_image_width (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint width = 0;
- return_vals = gimp_run_procedure ("gimp-image-width",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-width",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- width = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ width = g_value_get_int (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return width;
}
@@ -403,19 +432,22 @@ gimp_image_width (gint32 image_ID)
gint
gimp_image_height (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint height = 0;
- return_vals = gimp_run_procedure ("gimp-image-height",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- height = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-image-height",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ height = g_value_get_int (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return height;
}
@@ -437,27 +469,27 @@ gint *
gimp_image_get_layers (gint32 image_ID,
gint *num_layers)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint *layer_ids = NULL;
- return_vals = gimp_run_procedure ("gimp-image-get-layers",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-layers",
+ args);
+ gimp_value_array_unref (args);
*num_layers = 0;
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
{
- *num_layers = return_vals[1].data.d_int32;
- layer_ids = g_new (gint32, *num_layers);
- memcpy (layer_ids,
- return_vals[2].data.d_int32array,
- *num_layers * sizeof (gint32));
+ *num_layers = g_value_get_int (gimp_value_array_index (return_vals, 1));
+ layer_ids = gimp_value_dup_int32_array (gimp_value_array_index (return_vals, 2));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return layer_ids;
}
@@ -482,27 +514,27 @@ gint *
gimp_image_get_channels (gint32 image_ID,
gint *num_channels)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint *channel_ids = NULL;
- return_vals = gimp_run_procedure ("gimp-image-get-channels",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-channels",
+ args);
+ gimp_value_array_unref (args);
*num_channels = 0;
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
{
- *num_channels = return_vals[1].data.d_int32;
- channel_ids = g_new (gint32, *num_channels);
- memcpy (channel_ids,
- return_vals[2].data.d_int32array,
- *num_channels * sizeof (gint32));
+ *num_channels = g_value_get_int (gimp_value_array_index (return_vals, 1));
+ channel_ids = gimp_value_dup_int32_array (gimp_value_array_index (return_vals, 2));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return channel_ids;
}
@@ -526,27 +558,27 @@ gint *
gimp_image_get_vectors (gint32 image_ID,
gint *num_vectors)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint *vector_ids = NULL;
- return_vals = gimp_run_procedure ("gimp-image-get-vectors",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-vectors",
+ args);
+ gimp_value_array_unref (args);
*num_vectors = 0;
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
{
- *num_vectors = return_vals[1].data.d_int32;
- vector_ids = g_new (gint32, *num_vectors);
- memcpy (vector_ids,
- return_vals[2].data.d_int32array,
- *num_vectors * sizeof (gint32));
+ *num_vectors = g_value_get_int (gimp_value_array_index (return_vals, 1));
+ vector_ids = gimp_value_dup_int32_array (gimp_value_array_index (return_vals, 2));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return vector_ids;
}
@@ -569,19 +601,22 @@ gimp_image_get_vectors (gint32 image_ID,
gint32
gimp_image_get_active_drawable (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 drawable_ID = -1;
- return_vals = gimp_run_procedure ("gimp-image-get-active-drawable",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-active-drawable",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- drawable_ID = return_vals[1].data.d_drawable;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ drawable_ID = gimp_value_get_drawable_id (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return drawable_ID;
}
@@ -602,18 +637,21 @@ gimp_image_get_active_drawable (gint32 image_ID)
gboolean
gimp_image_unset_active_channel (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-unset-active-channel",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-image-unset-active-channel",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -632,19 +670,22 @@ gimp_image_unset_active_channel (gint32 image_ID)
gint32
gimp_image_get_floating_sel (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 floating_sel_ID = -1;
- return_vals = gimp_run_procedure ("gimp-image-get-floating-sel",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-floating-sel",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- floating_sel_ID = return_vals[1].data.d_layer;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ floating_sel_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return floating_sel_ID;
}
@@ -664,19 +705,22 @@ gimp_image_get_floating_sel (gint32 image_ID)
gint32
gimp_image_floating_sel_attached_to (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 drawable_ID = -1;
- return_vals = gimp_run_procedure ("gimp-image-floating-sel-attached-to",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-floating-sel-attached-to",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- drawable_ID = return_vals[1].data.d_drawable;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ drawable_ID = gimp_value_get_drawable_id (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return drawable_ID;
}
@@ -718,27 +762,36 @@ gimp_image_pick_color (gint32 image_ID,
gdouble average_radius,
GimpRGB *color)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-pick-color",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_FLOAT, x,
- GIMP_PDB_FLOAT, y,
- GIMP_PDB_INT32, sample_merged,
- GIMP_PDB_INT32, sample_average,
- GIMP_PDB_FLOAT, average_radius,
- GIMP_PDB_END);
-
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ 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,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-pick-color",
+ args);
+ gimp_value_array_unref (args);
+
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
- *color = return_vals[1].data.d_color;
+ gimp_value_get_rgb (gimp_value_array_index (return_vals, 1), &*color);
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -764,21 +817,26 @@ gimp_image_pick_correlate_layer (gint32 image_ID,
gint x,
gint y)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 layer_ID = -1;
- return_vals = gimp_run_procedure ("gimp-image-pick-correlate-layer",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, x,
- GIMP_PDB_INT32, y,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-pick-correlate-layer",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- layer_ID = return_vals[1].data.d_layer;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return layer_ID;
}
@@ -812,21 +870,27 @@ gimp_image_insert_layer (gint32 image_ID,
gint32 parent_ID,
gint position)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-insert-layer",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_LAYER, parent_ID,
- GIMP_PDB_INT32, position,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_LAYER_ID,
+ GIMP_TYPE_LAYER_ID,
+ GIMP_TYPE_INT32,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-image-insert-layer",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -850,19 +914,23 @@ gboolean
gimp_image_remove_layer (gint32 image_ID,
gint32 layer_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-remove-layer",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-remove-layer",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -888,18 +956,21 @@ gimp_image_remove_layer (gint32 image_ID,
gboolean
gimp_image_freeze_layers (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-freeze-layers",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-freeze-layers",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -923,18 +994,21 @@ gimp_image_freeze_layers (gint32 image_ID)
gboolean
gimp_image_thaw_layers (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-thaw-layers",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-image-thaw-layers",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -963,21 +1037,27 @@ gimp_image_insert_channel (gint32 image_ID,
gint32 parent_ID,
gint position)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-insert-channel",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_CHANNEL, channel_ID,
- GIMP_PDB_CHANNEL, parent_ID,
- GIMP_PDB_INT32, position,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_CHANNEL_ID,
+ GIMP_TYPE_CHANNEL_ID,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-insert-channel",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -998,19 +1078,23 @@ gboolean
gimp_image_remove_channel (gint32 image_ID,
gint32 channel_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-remove-channel",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_CHANNEL, channel_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-remove-channel",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1037,18 +1121,21 @@ gimp_image_remove_channel (gint32 image_ID,
gboolean
gimp_image_freeze_channels (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-freeze-channels",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-image-freeze-channels",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1072,18 +1159,21 @@ gimp_image_freeze_channels (gint32 image_ID)
gboolean
gimp_image_thaw_channels (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-thaw-channels",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-thaw-channels",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1112,21 +1202,27 @@ gimp_image_insert_vectors (gint32 image_ID,
gint32 parent_ID,
gint position)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-insert-vectors",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_VECTORS, vectors_ID,
- GIMP_PDB_VECTORS, parent_ID,
- GIMP_PDB_INT32, position,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_VECTORS_ID,
+ GIMP_TYPE_VECTORS_ID,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-insert-vectors",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1149,19 +1245,23 @@ gboolean
gimp_image_remove_vectors (gint32 image_ID,
gint32 vectors_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-remove-vectors",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_VECTORS, vectors_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-image-remove-vectors",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1188,18 +1288,21 @@ gimp_image_remove_vectors (gint32 image_ID,
gboolean
gimp_image_freeze_vectors (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-freeze-vectors",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-freeze-vectors",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1223,18 +1326,21 @@ gimp_image_freeze_vectors (gint32 image_ID)
gboolean
gimp_image_thaw_vectors (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-thaw-vectors",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-image-thaw-vectors",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1259,20 +1365,24 @@ gint
gimp_image_get_item_position (gint32 image_ID,
gint32 item_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint position = 0;
- return_vals = gimp_run_procedure ("gimp-image-get-item-position",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-item-position",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- position = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ position = g_value_get_int (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return position;
}
@@ -1295,19 +1405,23 @@ gboolean
gimp_image_raise_item (gint32 image_ID,
gint32 item_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-raise-item",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-raise-item",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1330,19 +1444,23 @@ gboolean
gimp_image_lower_item (gint32 image_ID,
gint32 item_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-lower-item",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-image-lower-item",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1365,19 +1483,23 @@ gboolean
gimp_image_raise_item_to_top (gint32 image_ID,
gint32 item_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-raise-item-to-top",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-raise-item-to-top",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1401,19 +1523,23 @@ gboolean
gimp_image_lower_item_to_bottom (gint32 image_ID,
gint32 item_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-lower-item-to-bottom",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-image-lower-item-to-bottom",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1439,21 +1565,27 @@ gimp_image_reorder_item (gint32 image_ID,
gint32 parent_ID,
gint position)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-reorder-item",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_ITEM, parent_ID,
- GIMP_PDB_INT32, position,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_ITEM_ID,
+ GIMP_TYPE_ITEM_ID,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-reorder-item",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1474,19 +1606,22 @@ gimp_image_reorder_item (gint32 image_ID,
gint32
gimp_image_flatten (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 layer_ID = -1;
- return_vals = gimp_run_procedure ("gimp-image-flatten",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-flatten",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- layer_ID = return_vals[1].data.d_layer;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return layer_ID;
}
@@ -1511,20 +1646,24 @@ gint32
gimp_image_merge_visible_layers (gint32 image_ID,
GimpMergeType merge_type)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 layer_ID = -1;
- return_vals = gimp_run_procedure ("gimp-image-merge-visible-layers",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, merge_type,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_ENUM,
+ 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 (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- layer_ID = return_vals[1].data.d_layer;
+ return_vals = gimp_run_procedure_with_array ("gimp-image-merge-visible-layers",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return layer_ID;
}
@@ -1552,21 +1691,26 @@ gimp_image_merge_down (gint32 image_ID,
gint32 merge_layer_ID,
GimpMergeType merge_type)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 layer_ID = -1;
- return_vals = gimp_run_procedure ("gimp-image-merge-down",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_LAYER, merge_layer_ID,
- GIMP_PDB_INT32, merge_type,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_LAYER_ID,
+ G_TYPE_ENUM,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-merge-down",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- layer_ID = return_vals[1].data.d_layer;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return layer_ID;
}
@@ -1591,27 +1735,27 @@ guint8 *
_gimp_image_get_colormap (gint32 image_ID,
gint *num_bytes)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
guint8 *colormap = NULL;
- return_vals = gimp_run_procedure ("gimp-image-get-colormap",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-colormap",
+ args);
+ gimp_value_array_unref (args);
*num_bytes = 0;
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
{
- *num_bytes = return_vals[1].data.d_int32;
- colormap = g_new (guint8, *num_bytes);
- memcpy (colormap,
- return_vals[2].data.d_int8array,
- *num_bytes * sizeof (guint8));
+ *num_bytes = g_value_get_int (gimp_value_array_index (return_vals, 1));
+ colormap = gimp_value_dup_int8_array (gimp_value_array_index (return_vals, 2));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return colormap;
}
@@ -1637,20 +1781,25 @@ _gimp_image_set_colormap (gint32 image_ID,
gint num_bytes,
const guint8 *colormap)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-set-colormap",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, num_bytes,
- GIMP_PDB_INT8ARRAY, colormap,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT8_ARRAY,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-set-colormap",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1668,19 +1817,22 @@ _gimp_image_set_colormap (gint32 image_ID,
gchar *
_gimp_image_get_metadata (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *metadata_string = NULL;
- return_vals = gimp_run_procedure ("gimp-image-get-metadata",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-metadata",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- metadata_string = g_strdup (return_vals[1].data.d_string);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ metadata_string = g_value_dup_string (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return metadata_string;
}
@@ -1700,19 +1852,23 @@ gboolean
_gimp_image_set_metadata (gint32 image_ID,
const gchar *metadata_string)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-set-metadata",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_STRING, metadata_string,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-image-set-metadata",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1735,18 +1891,21 @@ _gimp_image_set_metadata (gint32 image_ID,
gboolean
gimp_image_clean_all (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-clean-all",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-clean-all",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1767,19 +1926,22 @@ gimp_image_clean_all (gint32 image_ID)
gboolean
gimp_image_is_dirty (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean dirty = FALSE;
- return_vals = gimp_run_procedure ("gimp-image-is-dirty",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-is-dirty",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- dirty = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ dirty = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return dirty;
}
@@ -1814,16 +1976,21 @@ _gimp_image_thumbnail (gint32 image_ID,
gint *thumbnail_data_count,
guint8 **thumbnail_data)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-thumbnail",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, width,
- GIMP_PDB_INT32, height,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-thumbnail",
+ args);
+ gimp_value_array_unref (args);
*actual_width = 0;
*actual_height = 0;
@@ -1831,21 +1998,18 @@ _gimp_image_thumbnail (gint32 image_ID,
*thumbnail_data_count = 0;
*thumbnail_data = NULL;
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
{
- *actual_width = return_vals[1].data.d_int32;
- *actual_height = return_vals[2].data.d_int32;
- *bpp = return_vals[3].data.d_int32;
- *thumbnail_data_count = return_vals[4].data.d_int32;
- *thumbnail_data = g_new (guint8, *thumbnail_data_count);
- memcpy (*thumbnail_data,
- return_vals[5].data.d_int8array,
- *thumbnail_data_count * sizeof (guint8));
+ *actual_width = g_value_get_int (gimp_value_array_index (return_vals, 1));
+ *actual_height = g_value_get_int (gimp_value_array_index (return_vals, 2));
+ *bpp = g_value_get_int (gimp_value_array_index (return_vals, 3));
+ *thumbnail_data_count = g_value_get_int (gimp_value_array_index (return_vals, 4));
+ *thumbnail_data = gimp_value_dup_int8_array (gimp_value_array_index (return_vals, 5));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1865,19 +2029,22 @@ _gimp_image_thumbnail (gint32 image_ID,
gint32
gimp_image_get_active_layer (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 active_layer_ID = -1;
- return_vals = gimp_run_procedure ("gimp-image-get-active-layer",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-active-layer",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- active_layer_ID = return_vals[1].data.d_layer;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ active_layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return active_layer_ID;
}
@@ -1900,19 +2067,23 @@ gboolean
gimp_image_set_active_layer (gint32 image_ID,
gint32 active_layer_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-set-active-layer",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_LAYER, active_layer_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-set-active-layer",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1931,19 +2102,22 @@ gimp_image_set_active_layer (gint32 image_ID,
gint32
gimp_image_get_active_channel (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 active_channel_ID = -1;
- return_vals = gimp_run_procedure ("gimp-image-get-active-channel",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- active_channel_ID = return_vals[1].data.d_channel;
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-active-channel",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ active_channel_ID = gimp_value_get_channel_id (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return active_channel_ID;
}
@@ -1966,19 +2140,23 @@ gboolean
gimp_image_set_active_channel (gint32 image_ID,
gint32 active_channel_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-set-active-channel",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_CHANNEL, active_channel_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-set-active-channel",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1996,19 +2174,22 @@ gimp_image_set_active_channel (gint32 image_ID,
gint32
gimp_image_get_active_vectors (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 active_vectors_ID = -1;
- return_vals = gimp_run_procedure ("gimp-image-get-active-vectors",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- active_vectors_ID = return_vals[1].data.d_vectors;
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-active-vectors",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ active_vectors_ID = gimp_value_get_vectors_id (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return active_vectors_ID;
}
@@ -2028,19 +2209,23 @@ gboolean
gimp_image_set_active_vectors (gint32 image_ID,
gint32 active_vectors_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-set-active-vectors",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_VECTORS, active_vectors_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-set-active-vectors",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -2059,19 +2244,22 @@ gimp_image_set_active_vectors (gint32 image_ID,
gint32
gimp_image_get_selection (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 selection_ID = -1;
- return_vals = gimp_run_procedure ("gimp-image-get-selection",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-selection",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- selection_ID = return_vals[1].data.d_selection;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ selection_ID = gimp_value_get_selection_id (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return selection_ID;
}
@@ -2094,20 +2282,24 @@ gboolean
gimp_image_get_component_active (gint32 image_ID,
GimpChannelType component)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean active = FALSE;
- return_vals = gimp_run_procedure ("gimp-image-get-component-active",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, component,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_ENUM,
+ 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 (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- active = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-component-active",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ active = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return active;
}
@@ -2132,20 +2324,25 @@ gimp_image_set_component_active (gint32 image_ID,
GimpChannelType component,
gboolean active)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-set-component-active",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, component,
- GIMP_PDB_INT32, active,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_ENUM,
+ G_TYPE_BOOLEAN,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-set-component-active",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -2169,20 +2366,24 @@ gboolean
gimp_image_get_component_visible (gint32 image_ID,
GimpChannelType component)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean visible = FALSE;
- return_vals = gimp_run_procedure ("gimp-image-get-component-visible",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, component,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_ENUM,
+ 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 (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- visible = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-component-visible",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ visible = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return visible;
}
@@ -2207,20 +2408,25 @@ gimp_image_set_component_visible (gint32 image_ID,
GimpChannelType component,
gboolean visible)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-set-component-visible",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, component,
- GIMP_PDB_INT32, visible,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_ENUM,
+ G_TYPE_BOOLEAN,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-set-component-visible",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -2243,19 +2449,22 @@ gimp_image_set_component_visible (gint32 image_ID,
gchar *
gimp_image_get_filename (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *filename = NULL;
- return_vals = gimp_run_procedure ("gimp-image-get-filename",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-filename",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- filename = g_strdup (return_vals[1].data.d_string);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ filename = g_value_dup_string (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return filename;
}
@@ -2276,19 +2485,23 @@ gboolean
gimp_image_set_filename (gint32 image_ID,
const gchar *filename)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-set-filename",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_STRING, filename,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_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), filename);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-image-set-filename",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -2314,19 +2527,22 @@ gimp_image_set_filename (gint32 image_ID,
gchar *
gimp_image_get_uri (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *uri = NULL;
- return_vals = gimp_run_procedure ("gimp-image-get-uri",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-uri",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- uri = g_strdup (return_vals[1].data.d_string);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ uri = g_value_dup_string (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return uri;
}
@@ -2348,19 +2564,22 @@ gimp_image_get_uri (gint32 image_ID)
gchar *
gimp_image_get_xcf_uri (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *uri = NULL;
- return_vals = gimp_run_procedure ("gimp-image-get-xcf-uri",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- uri = g_strdup (return_vals[1].data.d_string);
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-xcf-uri",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ uri = g_value_dup_string (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return uri;
}
@@ -2384,19 +2603,22 @@ gimp_image_get_xcf_uri (gint32 image_ID)
gchar *
gimp_image_get_imported_uri (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *uri = NULL;
- return_vals = gimp_run_procedure ("gimp-image-get-imported-uri",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-imported-uri",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- uri = g_strdup (return_vals[1].data.d_string);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ uri = g_value_dup_string (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return uri;
}
@@ -2419,19 +2641,22 @@ gimp_image_get_imported_uri (gint32 image_ID)
gchar *
gimp_image_get_exported_uri (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *uri = NULL;
- return_vals = gimp_run_procedure ("gimp-image-get-exported-uri",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-exported-uri",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- uri = g_strdup (return_vals[1].data.d_string);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ uri = g_value_dup_string (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return uri;
}
@@ -2455,19 +2680,22 @@ gimp_image_get_exported_uri (gint32 image_ID)
gchar *
gimp_image_get_name (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *name = NULL;
- return_vals = gimp_run_procedure ("gimp-image-get-name",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- name = g_strdup (return_vals[1].data.d_string);
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-name",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ name = g_value_dup_string (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return name;
}
@@ -2490,27 +2718,30 @@ gimp_image_get_resolution (gint32 image_ID,
gdouble *xresolution,
gdouble *yresolution)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-get-resolution",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-resolution",
+ args);
+ gimp_value_array_unref (args);
*xresolution = 0.0;
*yresolution = 0.0;
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
{
- *xresolution = return_vals[1].data.d_float;
- *yresolution = return_vals[2].data.d_float;
+ *xresolution = g_value_get_double (gimp_value_array_index (return_vals, 1));
+ *yresolution = g_value_get_double (gimp_value_array_index (return_vals, 2));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -2534,20 +2765,25 @@ gimp_image_set_resolution (gint32 image_ID,
gdouble xresolution,
gdouble yresolution)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-set-resolution",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_FLOAT, xresolution,
- GIMP_PDB_FLOAT, yresolution,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_DOUBLE,
+ G_TYPE_DOUBLE,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-image-set-resolution",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -2568,19 +2804,22 @@ gimp_image_set_resolution (gint32 image_ID,
GimpUnit
gimp_image_get_unit (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
GimpUnit unit = 0;
- return_vals = gimp_run_procedure ("gimp-image-get-unit",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-unit",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- unit = return_vals[1].data.d_unit;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ unit = g_value_get_int (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return unit;
}
@@ -2604,19 +2843,23 @@ gboolean
gimp_image_set_unit (gint32 image_ID,
GimpUnit unit)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-set-unit",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, unit,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-set-unit",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -2636,19 +2879,22 @@ gimp_image_set_unit (gint32 image_ID,
gint
gimp_image_get_tattoo_state (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint tattoo_state = 0;
- return_vals = gimp_run_procedure ("gimp-image-get-tattoo-state",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- tattoo_state = return_vals[1].data.d_tattoo;
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-tattoo-state",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ tattoo_state = g_value_get_uint (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return tattoo_state;
}
@@ -2679,19 +2925,23 @@ gboolean
gimp_image_set_tattoo_state (gint32 image_ID,
gint tattoo_state)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-set-tattoo-state",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, tattoo_state,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-set-tattoo-state",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -2712,20 +2962,24 @@ gint32
gimp_image_get_layer_by_tattoo (gint32 image_ID,
gint tattoo)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 layer_ID = -1;
- return_vals = gimp_run_procedure ("gimp-image-get-layer-by-tattoo",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, tattoo,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_INT32,
+ 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 (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- layer_ID = return_vals[1].data.d_layer;
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-layer-by-tattoo",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return layer_ID;
}
@@ -2746,20 +3000,24 @@ gint32
gimp_image_get_channel_by_tattoo (gint32 image_ID,
gint tattoo)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 channel_ID = -1;
- return_vals = gimp_run_procedure ("gimp-image-get-channel-by-tattoo",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, tattoo,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-channel-by-tattoo",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- channel_ID = return_vals[1].data.d_channel;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ channel_ID = gimp_value_get_channel_id (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return channel_ID;
}
@@ -2782,20 +3040,24 @@ gint32
gimp_image_get_vectors_by_tattoo (gint32 image_ID,
gint tattoo)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 vectors_ID = -1;
- return_vals = gimp_run_procedure ("gimp-image-get-vectors-by-tattoo",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, tattoo,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-vectors-by-tattoo",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- vectors_ID = return_vals[1].data.d_vectors;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ vectors_ID = gimp_value_get_vectors_id (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return vectors_ID;
}
@@ -2818,20 +3080,24 @@ gint32
gimp_image_get_layer_by_name (gint32 image_ID,
const gchar *name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 layer_ID = -1;
- return_vals = gimp_run_procedure ("gimp-image-get-layer-by-name",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_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), name);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- layer_ID = return_vals[1].data.d_layer;
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-layer-by-name",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return layer_ID;
}
@@ -2854,20 +3120,24 @@ gint32
gimp_image_get_channel_by_name (gint32 image_ID,
const gchar *name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 channel_ID = -1;
- return_vals = gimp_run_procedure ("gimp-image-get-channel-by-name",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_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), name);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-channel-by-name",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- channel_ID = return_vals[1].data.d_channel;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ channel_ID = gimp_value_get_channel_id (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return channel_ID;
}
@@ -2890,20 +3160,24 @@ gint32
gimp_image_get_vectors_by_name (gint32 image_ID,
const gchar *name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 vectors_ID = -1;
- return_vals = gimp_run_procedure ("gimp-image-get-vectors-by-name",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_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), name);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- vectors_ID = return_vals[1].data.d_vectors;
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-vectors-by-name",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ vectors_ID = gimp_value_get_vectors_id (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return vectors_ID;
}
@@ -2926,19 +3200,23 @@ gboolean
gimp_image_attach_parasite (gint32 image_ID,
const GimpParasite *parasite)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-attach-parasite",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_PARASITE, parasite,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-attach-parasite",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -2961,19 +3239,23 @@ gboolean
gimp_image_detach_parasite (gint32 image_ID,
const gchar *name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-detach-parasite",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_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), name);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-detach-parasite",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -2996,20 +3278,24 @@ GimpParasite *
gimp_image_get_parasite (gint32 image_ID,
const gchar *name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
GimpParasite *parasite = NULL;
- return_vals = gimp_run_procedure ("gimp-image-get-parasite",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_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), name);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- parasite = gimp_parasite_copy (&return_vals[1].data.d_parasite);
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-parasite",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ parasite = g_value_dup_boxed (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return parasite;
}
@@ -3032,30 +3318,27 @@ gchar **
gimp_image_get_parasite_list (gint32 image_ID,
gint *num_parasites)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar **parasites = NULL;
- gint i;
- return_vals = gimp_run_procedure ("gimp-image-get-parasite-list",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-parasite-list",
+ args);
+ gimp_value_array_unref (args);
*num_parasites = 0;
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
{
- *num_parasites = return_vals[1].data.d_int32;
- if (*num_parasites > 0)
- {
- parasites = g_new0 (gchar *, *num_parasites + 1);
- for (i = 0; i < *num_parasites; i++)
- parasites[i] = g_strdup (return_vals[2].data.d_stringarray[i]);
- }
+ *num_parasites = g_value_get_int (gimp_value_array_index (return_vals, 1));
+ parasites = gimp_value_dup_string_array (gimp_value_array_index (return_vals, 2));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return parasites;
}
diff --git a/libgimp/gimpimagecolorprofile_pdb.c b/libgimp/gimpimagecolorprofile_pdb.c
index 4afa2575b4..9fade49d29 100644
--- a/libgimp/gimpimagecolorprofile_pdb.c
+++ b/libgimp/gimpimagecolorprofile_pdb.c
@@ -22,8 +22,6 @@
#include "config.h"
-#include <string.h>
-
#include "gimp.h"
@@ -55,27 +53,27 @@ guint8 *
_gimp_image_get_color_profile (gint32 image_ID,
gint *num_bytes)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
guint8 *profile_data = NULL;
- return_vals = gimp_run_procedure ("gimp-image-get-color-profile",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-color-profile",
+ args);
+ gimp_value_array_unref (args);
*num_bytes = 0;
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
{
- *num_bytes = return_vals[1].data.d_int32;
- profile_data = g_new (guint8, *num_bytes);
- memcpy (profile_data,
- return_vals[2].data.d_int8array,
- *num_bytes * sizeof (guint8));
+ *num_bytes = g_value_get_int (gimp_value_array_index (return_vals, 1));
+ profile_data = gimp_value_dup_int8_array (gimp_value_array_index (return_vals, 2));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return profile_data;
}
@@ -102,27 +100,27 @@ guint8 *
_gimp_image_get_effective_color_profile (gint32 image_ID,
gint *num_bytes)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
guint8 *profile_data = NULL;
- return_vals = gimp_run_procedure ("gimp-image-get-effective-color-profile",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-effective-color-profile",
+ args);
+ gimp_value_array_unref (args);
*num_bytes = 0;
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
{
- *num_bytes = return_vals[1].data.d_int32;
- profile_data = g_new (guint8, *num_bytes);
- memcpy (profile_data,
- return_vals[2].data.d_int8array,
- *num_bytes * sizeof (guint8));
+ *num_bytes = g_value_get_int (gimp_value_array_index (return_vals, 1));
+ profile_data = gimp_value_dup_int8_array (gimp_value_array_index (return_vals, 2));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return profile_data;
}
@@ -150,20 +148,25 @@ _gimp_image_set_color_profile (gint32 image_ID,
gint num_bytes,
const guint8 *color_profile)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-set-color-profile",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, num_bytes,
- GIMP_PDB_INT8ARRAY, color_profile,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT8_ARRAY,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-set-color-profile",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -190,19 +193,23 @@ gboolean
gimp_image_set_color_profile_from_file (gint32 image_ID,
const gchar *uri)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-set-color-profile-from-file",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_STRING, uri,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_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), uri);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-image-set-color-profile-from-file",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -233,22 +240,29 @@ _gimp_image_convert_color_profile (gint32 image_ID,
GimpColorRenderingIntent intent,
gboolean bpc)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-convert-color-profile",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, num_bytes,
- GIMP_PDB_INT8ARRAY, color_profile,
- GIMP_PDB_INT32, intent,
- GIMP_PDB_INT32, bpc,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT8_ARRAY,
+ G_TYPE_ENUM,
+ G_TYPE_BOOLEAN,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-convert-color-profile",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -277,21 +291,27 @@ gimp_image_convert_color_profile_from_file (gint32 image_ID,
GimpColorRenderingIntent intent,
gboolean bpc)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-convert-color-profile-from-file",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_STRING, uri,
- GIMP_PDB_INT32, intent,
- GIMP_PDB_INT32, bpc,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_STRING,
+ G_TYPE_ENUM,
+ G_TYPE_BOOLEAN,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-convert-color-profile-from-file",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
diff --git a/libgimp/gimpimageconvert_pdb.c b/libgimp/gimpimageconvert_pdb.c
index df72667f56..ddc444a6ce 100644
--- a/libgimp/gimpimageconvert_pdb.c
+++ b/libgimp/gimpimageconvert_pdb.c
@@ -50,18 +50,21 @@
gboolean
gimp_image_convert_rgb (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-convert-rgb",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-image-convert-rgb",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -80,18 +83,21 @@ gimp_image_convert_rgb (gint32 image_ID)
gboolean
gimp_image_convert_grayscale (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-convert-grayscale",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-convert-grayscale",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -133,24 +139,33 @@ gimp_image_convert_indexed (gint32 image_ID,
gboolean remove_unused,
const gchar *palette)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-convert-indexed",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, dither_type,
- GIMP_PDB_INT32, palette_type,
- GIMP_PDB_INT32, num_cols,
- GIMP_PDB_INT32, alpha_dither,
- GIMP_PDB_INT32, remove_unused,
- GIMP_PDB_STRING, palette,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_ENUM,
+ G_TYPE_ENUM,
+ GIMP_TYPE_INT32,
+ G_TYPE_BOOLEAN,
+ G_TYPE_BOOLEAN,
+ G_TYPE_STRING,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-convert-indexed",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -177,21 +192,27 @@ gimp_image_convert_set_dither_matrix (gint width,
gint matrix_length,
const guint8 *matrix)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-convert-set-dither-matrix",
- &nreturn_vals,
- GIMP_PDB_INT32, width,
- GIMP_PDB_INT32, height,
- GIMP_PDB_INT32, matrix_length,
- GIMP_PDB_INT8ARRAY, matrix,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT8_ARRAY,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-image-convert-set-dither-matrix",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -215,19 +236,23 @@ gboolean
gimp_image_convert_precision (gint32 image_ID,
GimpPrecision precision)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-convert-precision",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, precision,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_ENUM,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-convert-precision",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
diff --git a/libgimp/gimpimagegrid_pdb.c b/libgimp/gimpimagegrid_pdb.c
index c207acb4ca..bc06b74006 100644
--- a/libgimp/gimpimagegrid_pdb.c
+++ b/libgimp/gimpimagegrid_pdb.c
@@ -54,27 +54,30 @@ gimp_image_grid_get_spacing (gint32 image_ID,
gdouble *xspacing,
gdouble *yspacing)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-grid-get-spacing",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-grid-get-spacing",
+ args);
+ gimp_value_array_unref (args);
*xspacing = 0.0;
*yspacing = 0.0;
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
{
- *xspacing = return_vals[1].data.d_float;
- *yspacing = return_vals[2].data.d_float;
+ *xspacing = g_value_get_double (gimp_value_array_index (return_vals, 1));
+ *yspacing = g_value_get_double (gimp_value_array_index (return_vals, 2));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -99,20 +102,25 @@ gimp_image_grid_set_spacing (gint32 image_ID,
gdouble xspacing,
gdouble yspacing)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-grid-set-spacing",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_FLOAT, xspacing,
- GIMP_PDB_FLOAT, yspacing,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_DOUBLE,
+ G_TYPE_DOUBLE,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-grid-set-spacing",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -137,27 +145,30 @@ gimp_image_grid_get_offset (gint32 image_ID,
gdouble *xoffset,
gdouble *yoffset)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-grid-get-offset",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-grid-get-offset",
+ args);
+ gimp_value_array_unref (args);
*xoffset = 0.0;
*yoffset = 0.0;
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
{
- *xoffset = return_vals[1].data.d_float;
- *yoffset = return_vals[2].data.d_float;
+ *xoffset = g_value_get_double (gimp_value_array_index (return_vals, 1));
+ *yoffset = g_value_get_double (gimp_value_array_index (return_vals, 2));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -182,20 +193,25 @@ gimp_image_grid_set_offset (gint32 image_ID,
gdouble xoffset,
gdouble yoffset)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-grid-set-offset",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_FLOAT, xoffset,
- GIMP_PDB_FLOAT, yoffset,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_DOUBLE,
+ G_TYPE_DOUBLE,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-image-grid-set-offset",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -217,21 +233,24 @@ gboolean
gimp_image_grid_get_foreground_color (gint32 image_ID,
GimpRGB *fgcolor)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-grid-get-foreground-color",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-grid-get-foreground-color",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
- *fgcolor = return_vals[1].data.d_color;
+ gimp_value_get_rgb (gimp_value_array_index (return_vals, 1), &*fgcolor);
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -253,19 +272,23 @@ gboolean
gimp_image_grid_set_foreground_color (gint32 image_ID,
const GimpRGB *fgcolor)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-grid-set-foreground-color",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_COLOR, fgcolor,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_RGB,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-image-grid-set-foreground-color",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -287,21 +310,24 @@ gboolean
gimp_image_grid_get_background_color (gint32 image_ID,
GimpRGB *bgcolor)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-grid-get-background-color",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-grid-get-background-color",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
- *bgcolor = return_vals[1].data.d_color;
+ gimp_value_get_rgb (gimp_value_array_index (return_vals, 1), &*bgcolor);
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -323,19 +349,23 @@ gboolean
gimp_image_grid_set_background_color (gint32 image_ID,
const GimpRGB *bgcolor)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-grid-set-background-color",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_COLOR, bgcolor,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_RGB,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-grid-set-background-color",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -355,19 +385,22 @@ gimp_image_grid_set_background_color (gint32 image_ID,
GimpGridStyle
gimp_image_grid_get_style (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
GimpGridStyle style = 0;
- return_vals = gimp_run_procedure ("gimp-image-grid-get-style",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- style = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-image-grid-get-style",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ style = g_value_get_enum (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return style;
}
@@ -390,19 +423,23 @@ gboolean
gimp_image_grid_set_style (gint32 image_ID,
GimpGridStyle style)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-grid-set-style",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, style,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_ENUM,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-grid-set-style",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
diff --git a/libgimp/gimpimageguides_pdb.c b/libgimp/gimpimageguides_pdb.c
index 252f970602..54c82e7a8e 100644
--- a/libgimp/gimpimageguides_pdb.c
+++ b/libgimp/gimpimageguides_pdb.c
@@ -51,20 +51,24 @@ gint32
gimp_image_add_hguide (gint32 image_ID,
gint yposition)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 guide_ID = -1;
- return_vals = gimp_run_procedure ("gimp-image-add-hguide",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, yposition,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_INT32,
+ 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 (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- guide_ID = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-image-add-hguide",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ guide_ID = g_value_get_uint (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return guide_ID;
}
@@ -86,20 +90,24 @@ gint32
gimp_image_add_vguide (gint32 image_ID,
gint xposition)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 guide_ID = -1;
- return_vals = gimp_run_procedure ("gimp-image-add-vguide",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, xposition,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-add-vguide",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- guide_ID = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ guide_ID = g_value_get_uint (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return guide_ID;
}
@@ -120,19 +128,23 @@ gboolean
gimp_image_delete_guide (gint32 image_ID,
gint32 guide_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-delete-guide",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, guide_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-delete-guide",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -156,20 +168,24 @@ gint32
gimp_image_find_next_guide (gint32 image_ID,
gint32 guide_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 next_guide_ID = -1;
- return_vals = gimp_run_procedure ("gimp-image-find-next-guide",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, guide_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_INT32,
+ 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 (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- next_guide_ID = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-image-find-next-guide",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ next_guide_ID = g_value_get_uint (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return next_guide_ID;
}
@@ -190,20 +206,24 @@ GimpOrientationType
gimp_image_get_guide_orientation (gint32 image_ID,
gint32 guide_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
GimpOrientationType orientation = GIMP_ORIENTATION_UNKNOWN;
- return_vals = gimp_run_procedure ("gimp-image-get-guide-orientation",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, guide_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-guide-orientation",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- orientation = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ orientation = g_value_get_enum (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return orientation;
}
@@ -224,20 +244,24 @@ gint
gimp_image_get_guide_position (gint32 image_ID,
gint32 guide_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint position = G_MININT /* GIMP_GUIDE_POSITION_UNDEFINED */;
- return_vals = gimp_run_procedure ("gimp-image-get-guide-position",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, guide_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-guide-position",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- position = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ position = g_value_get_int (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return position;
}
diff --git a/libgimp/gimpimagesamplepoints_pdb.c b/libgimp/gimpimagesamplepoints_pdb.c
index 5a8135b85d..ae587159b8 100644
--- a/libgimp/gimpimagesamplepoints_pdb.c
+++ b/libgimp/gimpimagesamplepoints_pdb.c
@@ -55,21 +55,26 @@ gimp_image_add_sample_point (gint32 image_ID,
gint position_x,
gint position_y)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 sample_point_ID = -1;
- return_vals = gimp_run_procedure ("gimp-image-add-sample-point",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, position_x,
- GIMP_PDB_INT32, position_y,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ 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 (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- sample_point_ID = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-image-add-sample-point",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ sample_point_ID = g_value_get_uint (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return sample_point_ID;
}
@@ -92,19 +97,23 @@ gboolean
gimp_image_delete_sample_point (gint32 image_ID,
gint32 sample_point_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-delete-sample-point",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, sample_point_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-delete-sample-point",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -131,20 +140,24 @@ gint32
gimp_image_find_next_sample_point (gint32 image_ID,
gint32 sample_point_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 next_sample_point_ID = -1;
- return_vals = gimp_run_procedure ("gimp-image-find-next-sample-point",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, sample_point_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_INT32,
+ 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 (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- next_sample_point_ID = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-image-find-next-sample-point",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ next_sample_point_ID = g_value_get_uint (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return next_sample_point_ID;
}
@@ -170,23 +183,27 @@ gimp_image_get_sample_point_position (gint32 image_ID,
gint32 sample_point_ID,
gint *position_y)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint position_x = G_MININT;
- return_vals = gimp_run_procedure ("gimp-image-get-sample-point-position",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, sample_point_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-sample-point-position",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
{
- position_x = return_vals[1].data.d_int32;
- *position_y = return_vals[2].data.d_int32;
+ position_x = g_value_get_int (gimp_value_array_index (return_vals, 1));
+ *position_y = g_value_get_int (gimp_value_array_index (return_vals, 2));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return position_x;
}
diff --git a/libgimp/gimpimageselect_pdb.c b/libgimp/gimpimageselect_pdb.c
index cc3d431a0b..9f5f565c17 100644
--- a/libgimp/gimpimageselect_pdb.c
+++ b/libgimp/gimpimageselect_pdb.c
@@ -71,21 +71,27 @@ gimp_image_select_color (gint32 image_ID,
gint32 drawable_ID,
const GimpRGB *color)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-select-color",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, operation,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_COLOR, color,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_ENUM,
+ GIMP_TYPE_DRAWABLE_ID,
+ GIMP_TYPE_RGB,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-image-select-color",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -138,22 +144,29 @@ gimp_image_select_contiguous_color (gint32 image_ID,
gdouble x,
gdouble y)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-select-contiguous-color",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, operation,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_FLOAT, x,
- GIMP_PDB_FLOAT, y,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_ENUM,
+ GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_DOUBLE,
+ G_TYPE_DOUBLE,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-select-contiguous-color",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -188,23 +201,31 @@ gimp_image_select_rectangle (gint32 image_ID,
gdouble width,
gdouble height)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-select-rectangle",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, operation,
- GIMP_PDB_FLOAT, x,
- GIMP_PDB_FLOAT, y,
- GIMP_PDB_FLOAT, width,
- GIMP_PDB_FLOAT, height,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_ENUM,
+ G_TYPE_DOUBLE,
+ G_TYPE_DOUBLE,
+ G_TYPE_DOUBLE,
+ G_TYPE_DOUBLE,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-image-select-rectangle",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -246,25 +267,35 @@ gimp_image_select_round_rectangle (gint32 image_ID,
gdouble corner_radius_x,
gdouble corner_radius_y)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-select-round-rectangle",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, operation,
- GIMP_PDB_FLOAT, x,
- GIMP_PDB_FLOAT, y,
- GIMP_PDB_FLOAT, width,
- GIMP_PDB_FLOAT, height,
- GIMP_PDB_FLOAT, corner_radius_x,
- GIMP_PDB_FLOAT, corner_radius_y,
- GIMP_PDB_END);
-
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
-
- gimp_destroy_params (return_vals, nreturn_vals);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_ENUM,
+ G_TYPE_DOUBLE,
+ G_TYPE_DOUBLE,
+ G_TYPE_DOUBLE,
+ G_TYPE_DOUBLE,
+ G_TYPE_DOUBLE,
+ G_TYPE_DOUBLE,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-select-round-rectangle",
+ args);
+ gimp_value_array_unref (args);
+
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -300,23 +331,31 @@ gimp_image_select_ellipse (gint32 image_ID,
gdouble width,
gdouble height)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-select-ellipse",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, operation,
- GIMP_PDB_FLOAT, x,
- GIMP_PDB_FLOAT, y,
- GIMP_PDB_FLOAT, width,
- GIMP_PDB_FLOAT, height,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_ENUM,
+ G_TYPE_DOUBLE,
+ G_TYPE_DOUBLE,
+ G_TYPE_DOUBLE,
+ G_TYPE_DOUBLE,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-select-ellipse",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -353,21 +392,27 @@ gimp_image_select_polygon (gint32 image_ID,
gint num_segs,
const gdouble *segs)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-select-polygon",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, operation,
- GIMP_PDB_INT32, num_segs,
- GIMP_PDB_FLOATARRAY, segs,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_ENUM,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_FLOAT_ARRAY,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-image-select-polygon",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -398,20 +443,25 @@ gimp_image_select_item (gint32 image_ID,
GimpChannelOps operation,
gint32 item_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-select-item",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, operation,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_ENUM,
+ GIMP_TYPE_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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-select-item",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
diff --git a/libgimp/gimpimagetransform_pdb.c b/libgimp/gimpimagetransform_pdb.c
index f863177c66..2f581e628d 100644
--- a/libgimp/gimpimagetransform_pdb.c
+++ b/libgimp/gimpimagetransform_pdb.c
@@ -61,22 +61,29 @@ gimp_image_resize (gint32 image_ID,
gint offx,
gint offy)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-resize",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, new_width,
- GIMP_PDB_INT32, new_height,
- GIMP_PDB_INT32, offx,
- GIMP_PDB_INT32, offy,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-image-resize",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -99,18 +106,21 @@ gimp_image_resize (gint32 image_ID,
gboolean
gimp_image_resize_to_layers (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-resize-to-layers",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-resize-to-layers",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -136,20 +146,25 @@ gimp_image_scale (gint32 image_ID,
gint new_width,
gint new_height)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-scale",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, new_width,
- GIMP_PDB_INT32, new_height,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-scale",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -180,22 +195,29 @@ gimp_image_crop (gint32 image_ID,
gint offx,
gint offy)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-crop",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, new_width,
- GIMP_PDB_INT32, new_height,
- GIMP_PDB_INT32, offx,
- GIMP_PDB_INT32, offy,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-image-crop",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -215,19 +237,23 @@ gboolean
gimp_image_flip (gint32 image_ID,
GimpOrientationType flip_type)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-flip",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, flip_type,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_ENUM,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-flip",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -247,19 +273,23 @@ gboolean
gimp_image_rotate (gint32 image_ID,
GimpRotationType rotate_type)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-rotate",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, rotate_type,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_ENUM,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-rotate",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
diff --git a/libgimp/gimpimageundo_pdb.c b/libgimp/gimpimageundo_pdb.c
index ec765246b9..342bd65b8d 100644
--- a/libgimp/gimpimageundo_pdb.c
+++ b/libgimp/gimpimageundo_pdb.c
@@ -50,18 +50,21 @@
gboolean
gimp_image_undo_group_start (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-undo-group-start",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-image-undo-group-start",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -80,18 +83,21 @@ gimp_image_undo_group_start (gint32 image_ID)
gboolean
gimp_image_undo_group_end (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-image-undo-group-end",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-undo-group-end",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -112,19 +118,22 @@ gimp_image_undo_group_end (gint32 image_ID)
gboolean
gimp_image_undo_is_enabled (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean enabled = FALSE;
- return_vals = gimp_run_procedure ("gimp-image-undo-is-enabled",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- enabled = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-image-undo-is-enabled",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ enabled = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return enabled;
}
@@ -146,19 +155,22 @@ gimp_image_undo_is_enabled (gint32 image_ID)
gboolean
gimp_image_undo_disable (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean disabled = FALSE;
- return_vals = gimp_run_procedure ("gimp-image-undo-disable",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-undo-disable",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- disabled = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ disabled = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return disabled;
}
@@ -179,19 +191,22 @@ gimp_image_undo_disable (gint32 image_ID)
gboolean
gimp_image_undo_enable (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean enabled = FALSE;
- return_vals = gimp_run_procedure ("gimp-image-undo-enable",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- enabled = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-image-undo-enable",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ enabled = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return enabled;
}
@@ -219,19 +234,22 @@ gimp_image_undo_enable (gint32 image_ID)
gboolean
gimp_image_undo_freeze (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean frozen = FALSE;
- return_vals = gimp_run_procedure ("gimp-image-undo-freeze",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-undo-freeze",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- frozen = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ frozen = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return frozen;
}
@@ -258,19 +276,22 @@ gimp_image_undo_freeze (gint32 image_ID)
gboolean
gimp_image_undo_thaw (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean thawed = FALSE;
- return_vals = gimp_run_procedure ("gimp-image-undo-thaw",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-image-undo-thaw",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- thawed = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ thawed = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return thawed;
}
diff --git a/libgimp/gimpitem_pdb.c b/libgimp/gimpitem_pdb.c
index b5ab9e2192..8527714035 100644
--- a/libgimp/gimpitem_pdb.c
+++ b/libgimp/gimpitem_pdb.c
@@ -22,8 +22,6 @@
#include "config.h"
-#include <string.h>
-
#include "gimp.h"
@@ -52,19 +50,22 @@
gboolean
gimp_item_is_valid (gint32 item_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean valid = FALSE;
- return_vals = gimp_run_procedure ("gimp-item-is-valid",
- &nreturn_vals,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+ G_TYPE_NONE);
+ gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-item-is-valid",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- valid = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ valid = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return valid;
}
@@ -84,19 +85,22 @@ gimp_item_is_valid (gint32 item_ID)
gint32
gimp_item_get_image (gint32 item_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 image_ID = -1;
- return_vals = gimp_run_procedure ("gimp-item-get-image",
- &nreturn_vals,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+ G_TYPE_NONE);
+ gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-item-get-image",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- image_ID = return_vals[1].data.d_image;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ image_ID = gimp_value_get_image_id (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return image_ID;
}
@@ -120,18 +124,21 @@ gimp_item_get_image (gint32 item_ID)
gboolean
gimp_item_delete (gint32 item_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-item-delete",
- &nreturn_vals,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+ G_TYPE_NONE);
+ gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-item-delete",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -151,19 +158,22 @@ gimp_item_delete (gint32 item_ID)
gboolean
gimp_item_is_drawable (gint32 item_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean drawable = FALSE;
- return_vals = gimp_run_procedure ("gimp-item-is-drawable",
- &nreturn_vals,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+ G_TYPE_NONE);
+ gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-item-is-drawable",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- drawable = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ drawable = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return drawable;
}
@@ -183,19 +193,22 @@ gimp_item_is_drawable (gint32 item_ID)
gboolean
gimp_item_is_layer (gint32 item_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean layer = FALSE;
- return_vals = gimp_run_procedure ("gimp-item-is-layer",
- &nreturn_vals,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+ G_TYPE_NONE);
+ gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- layer = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-item-is-layer",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ layer = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return layer;
}
@@ -215,19 +228,22 @@ gimp_item_is_layer (gint32 item_ID)
gboolean
gimp_item_is_text_layer (gint32 item_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean text_layer = FALSE;
- return_vals = gimp_run_procedure ("gimp-item-is-text-layer",
- &nreturn_vals,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+ G_TYPE_NONE);
+ gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-item-is-text-layer",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- text_layer = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ text_layer = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return text_layer;
}
@@ -247,19 +263,22 @@ gimp_item_is_text_layer (gint32 item_ID)
gboolean
gimp_item_is_channel (gint32 item_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean channel = FALSE;
- return_vals = gimp_run_procedure ("gimp-item-is-channel",
- &nreturn_vals,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+ G_TYPE_NONE);
+ gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- channel = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-item-is-channel",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ channel = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return channel;
}
@@ -279,19 +298,22 @@ gimp_item_is_channel (gint32 item_ID)
gboolean
gimp_item_is_layer_mask (gint32 item_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean layer_mask = FALSE;
- return_vals = gimp_run_procedure ("gimp-item-is-layer-mask",
- &nreturn_vals,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+ G_TYPE_NONE);
+ gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-item-is-layer-mask",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- layer_mask = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ layer_mask = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return layer_mask;
}
@@ -311,19 +333,22 @@ gimp_item_is_layer_mask (gint32 item_ID)
gboolean
gimp_item_is_selection (gint32 item_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean selection = FALSE;
- return_vals = gimp_run_procedure ("gimp-item-is-selection",
- &nreturn_vals,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+ G_TYPE_NONE);
+ gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- selection = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-item-is-selection",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ selection = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return selection;
}
@@ -343,19 +368,22 @@ gimp_item_is_selection (gint32 item_ID)
gboolean
gimp_item_is_vectors (gint32 item_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean vectors = FALSE;
- return_vals = gimp_run_procedure ("gimp-item-is-vectors",
- &nreturn_vals,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+ G_TYPE_NONE);
+ gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-item-is-vectors",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- vectors = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ vectors = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return vectors;
}
@@ -376,19 +404,22 @@ gimp_item_is_vectors (gint32 item_ID)
gboolean
gimp_item_is_group (gint32 item_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean group = FALSE;
- return_vals = gimp_run_procedure ("gimp-item-is-group",
- &nreturn_vals,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+ G_TYPE_NONE);
+ gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- group = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-item-is-group",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ group = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return group;
}
@@ -408,19 +439,22 @@ gimp_item_is_group (gint32 item_ID)
gint32
gimp_item_get_parent (gint32 item_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 parent_ID = -1;
- return_vals = gimp_run_procedure ("gimp-item-get-parent",
- &nreturn_vals,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+ G_TYPE_NONE);
+ gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-item-get-parent",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- parent_ID = return_vals[1].data.d_item;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ parent_ID = gimp_value_get_item_id (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return parent_ID;
}
@@ -443,27 +477,27 @@ gint *
gimp_item_get_children (gint32 item_ID,
gint *num_children)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint *child_ids = NULL;
- return_vals = gimp_run_procedure ("gimp-item-get-children",
- &nreturn_vals,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+ G_TYPE_NONE);
+ gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-item-get-children",
+ args);
+ gimp_value_array_unref (args);
*num_children = 0;
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
{
- *num_children = return_vals[1].data.d_int32;
- child_ids = g_new (gint32, *num_children);
- memcpy (child_ids,
- return_vals[2].data.d_int32array,
- *num_children * sizeof (gint32));
+ *num_children = g_value_get_int (gimp_value_array_index (return_vals, 1));
+ child_ids = gimp_value_dup_int32_array (gimp_value_array_index (return_vals, 2));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return child_ids;
}
@@ -483,19 +517,22 @@ gimp_item_get_children (gint32 item_ID,
gboolean
gimp_item_get_expanded (gint32 item_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean expanded = FALSE;
- return_vals = gimp_run_procedure ("gimp-item-get-expanded",
- &nreturn_vals,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+ G_TYPE_NONE);
+ gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-item-get-expanded",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- expanded = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ expanded = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return expanded;
}
@@ -517,19 +554,23 @@ gboolean
gimp_item_set_expanded (gint32 item_ID,
gboolean expanded)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-item-set-expanded",
- &nreturn_vals,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_INT32, expanded,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+ G_TYPE_BOOLEAN,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-item-set-expanded",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -549,19 +590,22 @@ gimp_item_set_expanded (gint32 item_ID,
gchar *
gimp_item_get_name (gint32 item_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *name = NULL;
- return_vals = gimp_run_procedure ("gimp-item-get-name",
- &nreturn_vals,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+ G_TYPE_NONE);
+ gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-item-get-name",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- name = g_strdup (return_vals[1].data.d_string);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ name = g_value_dup_string (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return name;
}
@@ -583,19 +627,23 @@ gboolean
gimp_item_set_name (gint32 item_ID,
const gchar *name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-item-set-name",
- &nreturn_vals,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+ G_TYPE_STRING,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-item-set-name",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -615,19 +663,22 @@ gimp_item_set_name (gint32 item_ID,
gboolean
gimp_item_get_visible (gint32 item_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean visible = FALSE;
- return_vals = gimp_run_procedure ("gimp-item-get-visible",
- &nreturn_vals,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+ G_TYPE_NONE);
+ gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-item-get-visible",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- visible = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ visible = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return visible;
}
@@ -649,19 +700,23 @@ gboolean
gimp_item_set_visible (gint32 item_ID,
gboolean visible)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-item-set-visible",
- &nreturn_vals,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_INT32, visible,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+ G_TYPE_BOOLEAN,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-item-set-visible",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -681,19 +736,22 @@ gimp_item_set_visible (gint32 item_ID,
gboolean
gimp_item_get_linked (gint32 item_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean linked = FALSE;
- return_vals = gimp_run_procedure ("gimp-item-get-linked",
- &nreturn_vals,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+ G_TYPE_NONE);
+ gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- linked = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-item-get-linked",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ linked = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return linked;
}
@@ -715,19 +773,23 @@ gboolean
gimp_item_set_linked (gint32 item_ID,
gboolean linked)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-item-set-linked",
- &nreturn_vals,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_INT32, linked,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+ G_TYPE_BOOLEAN,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-item-set-linked",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -747,19 +809,22 @@ gimp_item_set_linked (gint32 item_ID,
gboolean
gimp_item_get_lock_content (gint32 item_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean lock_content = FALSE;
- return_vals = gimp_run_procedure ("gimp-item-get-lock-content",
- &nreturn_vals,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+ G_TYPE_NONE);
+ gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- lock_content = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-item-get-lock-content",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ lock_content = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return lock_content;
}
@@ -781,19 +846,23 @@ gboolean
gimp_item_set_lock_content (gint32 item_ID,
gboolean lock_content)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-item-set-lock-content",
- &nreturn_vals,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_INT32, lock_content,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+ G_TYPE_BOOLEAN,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-item-set-lock-content",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -813,19 +882,22 @@ gimp_item_set_lock_content (gint32 item_ID,
gboolean
gimp_item_get_lock_position (gint32 item_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean lock_position = FALSE;
- return_vals = gimp_run_procedure ("gimp-item-get-lock-position",
- &nreturn_vals,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+ G_TYPE_NONE);
+ gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- lock_position = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-item-get-lock-position",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ lock_position = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return lock_position;
}
@@ -847,19 +919,23 @@ gboolean
gimp_item_set_lock_position (gint32 item_ID,
gboolean lock_position)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-item-set-lock-position",
- &nreturn_vals,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_INT32, lock_position,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+ G_TYPE_BOOLEAN,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-item-set-lock-position",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -879,19 +955,22 @@ gimp_item_set_lock_position (gint32 item_ID,
GimpColorTag
gimp_item_get_color_tag (gint32 item_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
GimpColorTag color_tag = 0;
- return_vals = gimp_run_procedure ("gimp-item-get-color-tag",
- &nreturn_vals,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+ G_TYPE_NONE);
+ gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- color_tag = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-item-get-color-tag",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ color_tag = g_value_get_enum (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return color_tag;
}
@@ -913,19 +992,23 @@ gboolean
gimp_item_set_color_tag (gint32 item_ID,
GimpColorTag color_tag)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-item-set-color-tag",
- &nreturn_vals,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_INT32, color_tag,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+ G_TYPE_ENUM,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-item-set-color-tag",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -947,19 +1030,22 @@ gimp_item_set_color_tag (gint32 item_ID,
gint
gimp_item_get_tattoo (gint32 item_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint tattoo = 0;
- return_vals = gimp_run_procedure ("gimp-item-get-tattoo",
- &nreturn_vals,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+ G_TYPE_NONE);
+ gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- tattoo = return_vals[1].data.d_tattoo;
+ return_vals = gimp_run_procedure_with_array ("gimp-item-get-tattoo",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ tattoo = g_value_get_uint (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return tattoo;
}
@@ -983,19 +1069,23 @@ gboolean
gimp_item_set_tattoo (gint32 item_ID,
gint tattoo)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-item-set-tattoo",
- &nreturn_vals,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_INT32, tattoo,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-item-set-tattoo",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1018,19 +1108,23 @@ gboolean
gimp_item_attach_parasite (gint32 item_ID,
const GimpParasite *parasite)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-item-attach-parasite",
- &nreturn_vals,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_PARASITE, parasite,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+ GIMP_TYPE_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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-item-attach-parasite",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1053,19 +1147,23 @@ gboolean
gimp_item_detach_parasite (gint32 item_ID,
const gchar *name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-item-detach-parasite",
- &nreturn_vals,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+ G_TYPE_STRING,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-item-detach-parasite",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1087,20 +1185,24 @@ GimpParasite *
gimp_item_get_parasite (gint32 item_ID,
const gchar *name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
GimpParasite *parasite = NULL;
- return_vals = gimp_run_procedure ("gimp-item-get-parasite",
- &nreturn_vals,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+ G_TYPE_STRING,
+ 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 (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- parasite = gimp_parasite_copy (&return_vals[1].data.d_parasite);
+ return_vals = gimp_run_procedure_with_array ("gimp-item-get-parasite",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ parasite = g_value_dup_boxed (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return parasite;
}
@@ -1123,30 +1225,27 @@ gchar **
gimp_item_get_parasite_list (gint32 item_ID,
gint *num_parasites)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar **parasites = NULL;
- gint i;
- return_vals = gimp_run_procedure ("gimp-item-get-parasite-list",
- &nreturn_vals,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+ G_TYPE_NONE);
+ gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-item-get-parasite-list",
+ args);
+ gimp_value_array_unref (args);
*num_parasites = 0;
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
{
- *num_parasites = return_vals[1].data.d_int32;
- if (*num_parasites > 0)
- {
- parasites = g_new0 (gchar *, *num_parasites + 1);
- for (i = 0; i < *num_parasites; i++)
- parasites[i] = g_strdup (return_vals[2].data.d_stringarray[i]);
- }
+ *num_parasites = g_value_get_int (gimp_value_array_index (return_vals, 1));
+ parasites = gimp_value_dup_string_array (gimp_value_array_index (return_vals, 2));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return parasites;
}
diff --git a/libgimp/gimpitemtransform_pdb.c b/libgimp/gimpitemtransform_pdb.c
index c811bef2a1..12c132d593 100644
--- a/libgimp/gimpitemtransform_pdb.c
+++ b/libgimp/gimpitemtransform_pdb.c
@@ -61,21 +61,26 @@ gimp_item_transform_translate (gint32 item_ID,
gdouble off_x,
gdouble off_y)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 ret_item_ID = -1;
- return_vals = gimp_run_procedure ("gimp-item-transform-translate",
- &nreturn_vals,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_FLOAT, off_x,
- GIMP_PDB_FLOAT, off_y,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+ G_TYPE_DOUBLE,
+ G_TYPE_DOUBLE,
+ 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 (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- ret_item_ID = return_vals[1].data.d_item;
+ return_vals = gimp_run_procedure_with_array ("gimp-item-transform-translate",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ ret_item_ID = gimp_value_get_item_id (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return ret_item_ID;
}
@@ -119,22 +124,28 @@ gimp_item_transform_flip_simple (gint32 item_ID,
gboolean auto_center,
gdouble axis)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 ret_item_ID = -1;
- return_vals = gimp_run_procedure ("gimp-item-transform-flip-simple",
- &nreturn_vals,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_INT32, flip_type,
- GIMP_PDB_INT32, auto_center,
- GIMP_PDB_FLOAT, axis,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+ G_TYPE_ENUM,
+ G_TYPE_BOOLEAN,
+ G_TYPE_DOUBLE,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-item-transform-flip-simple",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- ret_item_ID = return_vals[1].data.d_item;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ ret_item_ID = gimp_value_get_item_id (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return ret_item_ID;
}
@@ -180,23 +191,30 @@ gimp_item_transform_flip (gint32 item_ID,
gdouble x1,
gdouble y1)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 ret_item_ID = -1;
- return_vals = gimp_run_procedure ("gimp-item-transform-flip",
- &nreturn_vals,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_FLOAT, x0,
- GIMP_PDB_FLOAT, y0,
- GIMP_PDB_FLOAT, x1,
- GIMP_PDB_FLOAT, y1,
- GIMP_PDB_END);
+ 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_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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-item-transform-flip",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- ret_item_ID = return_vals[1].data.d_item;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ ret_item_ID = gimp_value_get_item_id (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return ret_item_ID;
}
@@ -259,27 +277,38 @@ gimp_item_transform_perspective (gint32 item_ID,
gdouble x3,
gdouble y3)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 ret_item_ID = -1;
- return_vals = gimp_run_procedure ("gimp-item-transform-perspective",
- &nreturn_vals,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_FLOAT, x0,
- GIMP_PDB_FLOAT, y0,
- GIMP_PDB_FLOAT, x1,
- GIMP_PDB_FLOAT, y1,
- GIMP_PDB_FLOAT, x2,
- GIMP_PDB_FLOAT, y2,
- GIMP_PDB_FLOAT, x3,
- GIMP_PDB_FLOAT, y3,
- GIMP_PDB_END);
-
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- ret_item_ID = return_vals[1].data.d_item;
-
- gimp_destroy_params (return_vals, nreturn_vals);
+ 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_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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-item-transform-perspective",
+ args);
+ gimp_value_array_unref (args);
+
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ ret_item_ID = gimp_value_get_item_id (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return ret_item_ID;
}
@@ -328,23 +357,30 @@ gimp_item_transform_rotate_simple (gint32 item_ID,
gdouble center_x,
gdouble center_y)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 ret_item_ID = -1;
- return_vals = gimp_run_procedure ("gimp-item-transform-rotate-simple",
- &nreturn_vals,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_INT32, rotate_type,
- GIMP_PDB_INT32, auto_center,
- GIMP_PDB_FLOAT, center_x,
- GIMP_PDB_FLOAT, center_y,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+ G_TYPE_ENUM,
+ G_TYPE_BOOLEAN,
+ G_TYPE_DOUBLE,
+ G_TYPE_DOUBLE,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-item-transform-rotate-simple",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- ret_item_ID = return_vals[1].data.d_item;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ ret_item_ID = gimp_value_get_item_id (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return ret_item_ID;
}
@@ -395,23 +431,30 @@ gimp_item_transform_rotate (gint32 item_ID,
gdouble center_x,
gdouble center_y)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 ret_item_ID = -1;
- return_vals = gimp_run_procedure ("gimp-item-transform-rotate",
- &nreturn_vals,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_FLOAT, angle,
- GIMP_PDB_INT32, auto_center,
- GIMP_PDB_FLOAT, center_x,
- GIMP_PDB_FLOAT, center_y,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+ G_TYPE_DOUBLE,
+ G_TYPE_BOOLEAN,
+ G_TYPE_DOUBLE,
+ G_TYPE_DOUBLE,
+ 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 (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- ret_item_ID = return_vals[1].data.d_item;
+ return_vals = gimp_run_procedure_with_array ("gimp-item-transform-rotate",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ ret_item_ID = gimp_value_get_item_id (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return ret_item_ID;
}
@@ -459,23 +502,30 @@ gimp_item_transform_scale (gint32 item_ID,
gdouble x1,
gdouble y1)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 ret_item_ID = -1;
- return_vals = gimp_run_procedure ("gimp-item-transform-scale",
- &nreturn_vals,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_FLOAT, x0,
- GIMP_PDB_FLOAT, y0,
- GIMP_PDB_FLOAT, x1,
- GIMP_PDB_FLOAT, y1,
- GIMP_PDB_END);
+ 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_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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-item-transform-scale",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- ret_item_ID = return_vals[1].data.d_item;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ ret_item_ID = gimp_value_get_item_id (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return ret_item_ID;
}
@@ -521,21 +571,26 @@ gimp_item_transform_shear (gint32 item_ID,
GimpOrientationType shear_type,
gdouble magnitude)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 ret_item_ID = -1;
- return_vals = gimp_run_procedure ("gimp-item-transform-shear",
- &nreturn_vals,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_INT32, shear_type,
- GIMP_PDB_FLOAT, magnitude,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_ITEM_ID,
+ G_TYPE_ENUM,
+ G_TYPE_DOUBLE,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-item-transform-shear",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- ret_item_ID = return_vals[1].data.d_item;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ ret_item_ID = gimp_value_get_item_id (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return ret_item_ID;
}
@@ -592,26 +647,36 @@ gimp_item_transform_2d (gint32 item_ID,
gdouble dest_x,
gdouble dest_y)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 ret_item_ID = -1;
- return_vals = gimp_run_procedure ("gimp-item-transform-2d",
- &nreturn_vals,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_FLOAT, source_x,
- GIMP_PDB_FLOAT, source_y,
- GIMP_PDB_FLOAT, scale_x,
- GIMP_PDB_FLOAT, scale_y,
- GIMP_PDB_FLOAT, angle,
- GIMP_PDB_FLOAT, dest_x,
- GIMP_PDB_FLOAT, dest_y,
- GIMP_PDB_END);
-
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- ret_item_ID = return_vals[1].data.d_item;
-
- gimp_destroy_params (return_vals, nreturn_vals);
+ 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_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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-item-transform-2d",
+ args);
+ gimp_value_array_unref (args);
+
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ ret_item_ID = gimp_value_get_item_id (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return ret_item_ID;
}
@@ -670,28 +735,40 @@ gimp_item_transform_matrix (gint32 item_ID,
gdouble coeff_2_1,
gdouble coeff_2_2)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 ret_item_ID = -1;
- return_vals = gimp_run_procedure ("gimp-item-transform-matrix",
- &nreturn_vals,
- GIMP_PDB_ITEM, item_ID,
- GIMP_PDB_FLOAT, coeff_0_0,
- GIMP_PDB_FLOAT, coeff_0_1,
- GIMP_PDB_FLOAT, coeff_0_2,
- GIMP_PDB_FLOAT, coeff_1_0,
- GIMP_PDB_FLOAT, coeff_1_1,
- GIMP_PDB_FLOAT, coeff_1_2,
- GIMP_PDB_FLOAT, coeff_2_0,
- GIMP_PDB_FLOAT, coeff_2_1,
- GIMP_PDB_FLOAT, coeff_2_2,
- GIMP_PDB_END);
-
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- ret_item_ID = return_vals[1].data.d_item;
-
- gimp_destroy_params (return_vals, nreturn_vals);
+ 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,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-item-transform-matrix",
+ args);
+ gimp_value_array_unref (args);
+
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ ret_item_ID = gimp_value_get_item_id (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return ret_item_ID;
}
diff --git a/libgimp/gimplayer_pdb.c b/libgimp/gimplayer_pdb.c
index 73544e4dd1..7f79c2a2d7 100644
--- a/libgimp/gimplayer_pdb.c
+++ b/libgimp/gimplayer_pdb.c
@@ -64,25 +64,34 @@ _gimp_layer_new (gint32 image_ID,
gdouble opacity,
GimpLayerMode mode)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 layer_ID = -1;
- return_vals = gimp_run_procedure ("gimp-layer-new",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, width,
- GIMP_PDB_INT32, height,
- GIMP_PDB_INT32, type,
- GIMP_PDB_STRING, name,
- GIMP_PDB_FLOAT, opacity,
- GIMP_PDB_INT32, mode,
- GIMP_PDB_END);
-
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- layer_ID = return_vals[1].data.d_layer;
-
- gimp_destroy_params (return_vals, nreturn_vals);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ G_TYPE_ENUM,
+ G_TYPE_STRING,
+ G_TYPE_DOUBLE,
+ G_TYPE_ENUM,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-new",
+ args);
+ gimp_value_array_unref (args);
+
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return layer_ID;
}
@@ -110,21 +119,26 @@ gimp_layer_new_from_visible (gint32 image_ID,
gint32 dest_image_ID,
const gchar *name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 layer_ID = -1;
- return_vals = gimp_run_procedure ("gimp-layer-new-from-visible",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_IMAGE, dest_image_ID,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_IMAGE_ID,
+ G_TYPE_STRING,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-new-from-visible",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- layer_ID = return_vals[1].data.d_layer;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return layer_ID;
}
@@ -148,20 +162,24 @@ gint32
gimp_layer_new_from_drawable (gint32 drawable_ID,
gint32 dest_image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 layer_copy_ID = -1;
- return_vals = gimp_run_procedure ("gimp-layer-new-from-drawable",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_IMAGE, dest_image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ GIMP_TYPE_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 (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- layer_copy_ID = return_vals[1].data.d_layer;
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-new-from-drawable",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ layer_copy_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return layer_copy_ID;
}
@@ -187,19 +205,22 @@ gimp_layer_new_from_drawable (gint32 drawable_ID,
gint32
gimp_layer_group_new (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 layer_group_ID = -1;
- return_vals = gimp_run_procedure ("gimp-layer-group-new",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-group-new",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- layer_group_ID = return_vals[1].data.d_layer;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ layer_group_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return layer_group_ID;
}
@@ -224,20 +245,24 @@ gint32
_gimp_layer_copy (gint32 layer_ID,
gboolean add_alpha)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 layer_copy_ID = -1;
- return_vals = gimp_run_procedure ("gimp-layer-copy",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_INT32, add_alpha,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_BOOLEAN,
+ 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 (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- layer_copy_ID = return_vals[1].data.d_layer;
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-copy",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ layer_copy_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return layer_copy_ID;
}
@@ -259,18 +284,21 @@ _gimp_layer_copy (gint32 layer_ID,
gboolean
gimp_layer_add_alpha (gint32 layer_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-layer-add-alpha",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_NONE);
+ gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-add-alpha",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -293,18 +321,21 @@ gimp_layer_add_alpha (gint32 layer_ID)
gboolean
gimp_layer_flatten (gint32 layer_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-layer-flatten",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_NONE);
+ gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-flatten",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -333,21 +364,27 @@ gimp_layer_scale (gint32 layer_ID,
gint new_height,
gboolean local_origin)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-layer-scale",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_INT32, new_width,
- GIMP_PDB_INT32, new_height,
- GIMP_PDB_INT32, local_origin,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ G_TYPE_BOOLEAN,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-scale",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -376,22 +413,29 @@ gimp_layer_resize (gint32 layer_ID,
gint offx,
gint offy)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-layer-resize",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_INT32, new_width,
- GIMP_PDB_INT32, new_height,
- GIMP_PDB_INT32, offx,
- GIMP_PDB_INT32, offy,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-resize",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -410,18 +454,21 @@ gimp_layer_resize (gint32 layer_ID,
gboolean
gimp_layer_resize_to_image_size (gint32 layer_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-layer-resize-to-image-size",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_NONE);
+ gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-resize-to-image-size",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -445,20 +492,25 @@ gimp_layer_set_offsets (gint32 layer_ID,
gint offx,
gint offy)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-layer-set-offsets",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_INT32, offx,
- GIMP_PDB_INT32, offy,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-set-offsets",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -497,20 +549,24 @@ gint32
gimp_layer_create_mask (gint32 layer_ID,
GimpAddMaskType mask_type)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 mask_ID = -1;
- return_vals = gimp_run_procedure ("gimp-layer-create-mask",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_INT32, mask_type,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_ENUM,
+ 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 (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- mask_ID = return_vals[1].data.d_layer_mask;
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-create-mask",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ mask_ID = gimp_value_get_layer_mask_id (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return mask_ID;
}
@@ -529,19 +585,22 @@ gimp_layer_create_mask (gint32 layer_ID,
gint32
gimp_layer_get_mask (gint32 layer_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 mask_ID = -1;
- return_vals = gimp_run_procedure ("gimp-layer-get-mask",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_NONE);
+ gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-get-mask",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- mask_ID = return_vals[1].data.d_layer_mask;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ mask_ID = gimp_value_get_layer_mask_id (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return mask_ID;
}
@@ -562,19 +621,22 @@ gimp_layer_get_mask (gint32 layer_ID)
gint32
gimp_layer_from_mask (gint32 mask_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 layer_ID = -1;
- return_vals = gimp_run_procedure ("gimp-layer-from-mask",
- &nreturn_vals,
- GIMP_PDB_CHANNEL, mask_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_MASK_ID,
+ G_TYPE_NONE);
+ gimp_value_set_layer_mask_id (gimp_value_array_index (args, 0), mask_ID);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- layer_ID = return_vals[1].data.d_layer;
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-from-mask",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return layer_ID;
}
@@ -600,19 +662,23 @@ gboolean
gimp_layer_add_mask (gint32 layer_ID,
gint32 mask_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-layer-add-mask",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_CHANNEL, mask_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ GIMP_TYPE_LAYER_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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-add-mask",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -633,19 +699,23 @@ gboolean
gimp_layer_remove_mask (gint32 layer_ID,
GimpMaskApplyMode mode)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-layer-remove-mask",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_INT32, mode,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_ENUM,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-remove-mask",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -665,19 +735,22 @@ gimp_layer_remove_mask (gint32 layer_ID,
gboolean
gimp_layer_is_floating_sel (gint32 layer_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean is_floating_sel = FALSE;
- return_vals = gimp_run_procedure ("gimp-layer-is-floating-sel",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_NONE);
+ gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-is-floating-sel",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- is_floating_sel = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ is_floating_sel = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return is_floating_sel;
}
@@ -696,19 +769,22 @@ gimp_layer_is_floating_sel (gint32 layer_ID)
gboolean
gimp_layer_get_lock_alpha (gint32 layer_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean lock_alpha = FALSE;
- return_vals = gimp_run_procedure ("gimp-layer-get-lock-alpha",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_NONE);
+ gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- lock_alpha = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-get-lock-alpha",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ lock_alpha = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return lock_alpha;
}
@@ -729,19 +805,23 @@ gboolean
gimp_layer_set_lock_alpha (gint32 layer_ID,
gboolean lock_alpha)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-layer-set-lock-alpha",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_INT32, lock_alpha,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_BOOLEAN,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-set-lock-alpha",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -761,19 +841,22 @@ gimp_layer_set_lock_alpha (gint32 layer_ID,
gboolean
gimp_layer_get_apply_mask (gint32 layer_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean apply_mask = FALSE;
- return_vals = gimp_run_procedure ("gimp-layer-get-apply-mask",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_NONE);
+ gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-get-apply-mask",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- apply_mask = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ apply_mask = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return apply_mask;
}
@@ -796,19 +879,23 @@ gboolean
gimp_layer_set_apply_mask (gint32 layer_ID,
gboolean apply_mask)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-layer-set-apply-mask",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_INT32, apply_mask,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_BOOLEAN,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-set-apply-mask",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -829,19 +916,22 @@ gimp_layer_set_apply_mask (gint32 layer_ID,
gboolean
gimp_layer_get_show_mask (gint32 layer_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean show_mask = FALSE;
- return_vals = gimp_run_procedure ("gimp-layer-get-show-mask",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_NONE);
+ gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-get-show-mask",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- show_mask = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ show_mask = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return show_mask;
}
@@ -864,19 +954,23 @@ gboolean
gimp_layer_set_show_mask (gint32 layer_ID,
gboolean show_mask)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-layer-set-show-mask",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_INT32, show_mask,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_BOOLEAN,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-set-show-mask",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -896,19 +990,22 @@ gimp_layer_set_show_mask (gint32 layer_ID,
gboolean
gimp_layer_get_edit_mask (gint32 layer_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean edit_mask = FALSE;
- return_vals = gimp_run_procedure ("gimp-layer-get-edit-mask",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_NONE);
+ gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-get-edit-mask",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- edit_mask = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ edit_mask = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return edit_mask;
}
@@ -931,19 +1028,23 @@ gboolean
gimp_layer_set_edit_mask (gint32 layer_ID,
gboolean edit_mask)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-layer-set-edit-mask",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_INT32, edit_mask,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_BOOLEAN,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-set-edit-mask",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -961,19 +1062,22 @@ gimp_layer_set_edit_mask (gint32 layer_ID,
gdouble
gimp_layer_get_opacity (gint32 layer_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gdouble opacity = 0.0;
- return_vals = gimp_run_procedure ("gimp-layer-get-opacity",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_NONE);
+ gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-get-opacity",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- opacity = return_vals[1].data.d_float;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ opacity = g_value_get_double (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return opacity;
}
@@ -993,19 +1097,23 @@ gboolean
gimp_layer_set_opacity (gint32 layer_ID,
gdouble opacity)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-layer-set-opacity",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_FLOAT, opacity,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_DOUBLE,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-set-opacity",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1023,19 +1131,22 @@ gimp_layer_set_opacity (gint32 layer_ID,
GimpLayerMode
gimp_layer_get_mode (gint32 layer_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
GimpLayerMode mode = 0;
- return_vals = gimp_run_procedure ("gimp-layer-get-mode",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_NONE);
+ gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-get-mode",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- mode = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ mode = g_value_get_enum (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return mode;
}
@@ -1055,19 +1166,23 @@ gboolean
gimp_layer_set_mode (gint32 layer_ID,
GimpLayerMode mode)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-layer-set-mode",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_INT32, mode,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_ENUM,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-set-mode",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1087,19 +1202,22 @@ gimp_layer_set_mode (gint32 layer_ID,
GimpLayerColorSpace
gimp_layer_get_blend_space (gint32 layer_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
GimpLayerColorSpace blend_space = 0;
- return_vals = gimp_run_procedure ("gimp-layer-get-blend-space",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_NONE);
+ gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- blend_space = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-get-blend-space",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ blend_space = g_value_get_enum (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return blend_space;
}
@@ -1121,19 +1239,23 @@ gboolean
gimp_layer_set_blend_space (gint32 layer_ID,
GimpLayerColorSpace blend_space)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-layer-set-blend-space",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_INT32, blend_space,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_ENUM,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-set-blend-space",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1153,19 +1275,22 @@ gimp_layer_set_blend_space (gint32 layer_ID,
GimpLayerColorSpace
gimp_layer_get_composite_space (gint32 layer_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
GimpLayerColorSpace composite_space = 0;
- return_vals = gimp_run_procedure ("gimp-layer-get-composite-space",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_NONE);
+ gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- composite_space = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-get-composite-space",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ composite_space = g_value_get_enum (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return composite_space;
}
@@ -1187,19 +1312,23 @@ gboolean
gimp_layer_set_composite_space (gint32 layer_ID,
GimpLayerColorSpace composite_space)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-layer-set-composite-space",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_INT32, composite_space,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_ENUM,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-set-composite-space",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1219,19 +1348,22 @@ gimp_layer_set_composite_space (gint32 layer_ID,
GimpLayerCompositeMode
gimp_layer_get_composite_mode (gint32 layer_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
GimpLayerCompositeMode composite_mode = 0;
- return_vals = gimp_run_procedure ("gimp-layer-get-composite-mode",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_NONE);
+ gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- composite_mode = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-get-composite-mode",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ composite_mode = g_value_get_enum (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return composite_mode;
}
@@ -1253,19 +1385,23 @@ gboolean
gimp_layer_set_composite_mode (gint32 layer_ID,
GimpLayerCompositeMode composite_mode)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-layer-set-composite-mode",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_INT32, composite_mode,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_ENUM,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-set-composite-mode",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
diff --git a/libgimp/gimpmessage_pdb.c b/libgimp/gimpmessage_pdb.c
index 3dce5f37b7..408d270c83 100644
--- a/libgimp/gimpmessage_pdb.c
+++ b/libgimp/gimpmessage_pdb.c
@@ -48,18 +48,21 @@
gboolean
gimp_message (const gchar *message)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-message",
- &nreturn_vals,
- GIMP_PDB_STRING, message,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), message);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-message",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -78,18 +81,20 @@ gimp_message (const gchar *message)
GimpMessageHandlerType
gimp_message_get_handler (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
GimpMessageHandlerType handler = 0;
- return_vals = gimp_run_procedure ("gimp-message-get-handler",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-message-get-handler",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- handler = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ handler = g_value_get_enum (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return handler;
}
@@ -109,18 +114,21 @@ gimp_message_get_handler (void)
gboolean
gimp_message_set_handler (GimpMessageHandlerType handler)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-message-set-handler",
- &nreturn_vals,
- GIMP_PDB_INT32, handler,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_ENUM,
+ G_TYPE_NONE);
+ g_value_set_enum (gimp_value_array_index (args, 0), handler);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-message-set-handler",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
diff --git a/libgimp/gimppainttools_pdb.c b/libgimp/gimppainttools_pdb.c
index f03b43ae53..1f3d7f9fea 100644
--- a/libgimp/gimppainttools_pdb.c
+++ b/libgimp/gimppainttools_pdb.c
@@ -57,21 +57,27 @@ gimp_airbrush (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-airbrush",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_FLOAT, pressure,
- GIMP_PDB_INT32, num_strokes,
- GIMP_PDB_FLOATARRAY, strokes,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_DOUBLE,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_FLOAT_ARRAY,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-airbrush",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -97,20 +103,25 @@ gimp_airbrush_default (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-airbrush-default",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_INT32, num_strokes,
- GIMP_PDB_FLOATARRAY, strokes,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_FLOAT_ARRAY,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-airbrush-default",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -151,24 +162,33 @@ gimp_clone (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-clone",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_DRAWABLE, src_drawable_ID,
- GIMP_PDB_INT32, clone_type,
- GIMP_PDB_FLOAT, src_x,
- GIMP_PDB_FLOAT, src_y,
- GIMP_PDB_INT32, num_strokes,
- GIMP_PDB_FLOATARRAY, strokes,
- GIMP_PDB_END);
-
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
-
- gimp_destroy_params (return_vals, nreturn_vals);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_ENUM,
+ G_TYPE_DOUBLE,
+ G_TYPE_DOUBLE,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_FLOAT_ARRAY,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-clone",
+ args);
+ gimp_value_array_unref (args);
+
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -195,20 +215,25 @@ gimp_clone_default (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-clone-default",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_INT32, num_strokes,
- GIMP_PDB_FLOATARRAY, strokes,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_FLOAT_ARRAY,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-clone-default",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -237,22 +262,29 @@ gimp_convolve (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-convolve",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_FLOAT, pressure,
- GIMP_PDB_INT32, convolve_type,
- GIMP_PDB_INT32, num_strokes,
- GIMP_PDB_FLOATARRAY, strokes,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_DOUBLE,
+ G_TYPE_ENUM,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_FLOAT_ARRAY,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-convolve",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -278,20 +310,25 @@ gimp_convolve_default (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-convolve-default",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_INT32, num_strokes,
- GIMP_PDB_FLOATARRAY, strokes,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_FLOAT_ARRAY,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-convolve-default",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -319,23 +356,31 @@ gimp_dodgeburn (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-dodgeburn",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_FLOAT, exposure,
- GIMP_PDB_INT32, dodgeburn_type,
- GIMP_PDB_INT32, dodgeburn_mode,
- GIMP_PDB_INT32, num_strokes,
- GIMP_PDB_FLOATARRAY, strokes,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_DOUBLE,
+ G_TYPE_ENUM,
+ G_TYPE_ENUM,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_FLOAT_ARRAY,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-dodgeburn",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -360,20 +405,25 @@ gimp_dodgeburn_default (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-dodgeburn-default",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_INT32, num_strokes,
- GIMP_PDB_FLOATARRAY, strokes,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_FLOAT_ARRAY,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-dodgeburn-default",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -403,22 +453,29 @@ gimp_eraser (gint32 drawable_ID,
GimpBrushApplicationMode hardness,
GimpPaintApplicationMode method)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-eraser",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_INT32, num_strokes,
- GIMP_PDB_FLOATARRAY, strokes,
- GIMP_PDB_INT32, hardness,
- GIMP_PDB_INT32, method,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_FLOAT_ARRAY,
+ G_TYPE_ENUM,
+ G_TYPE_ENUM,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-eraser",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -444,20 +501,25 @@ gimp_eraser_default (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-eraser-default",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_INT32, num_strokes,
- GIMP_PDB_FLOATARRAY, strokes,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_FLOAT_ARRAY,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-eraser-default",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -492,23 +554,31 @@ gimp_heal (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-heal",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_DRAWABLE, src_drawable_ID,
- GIMP_PDB_FLOAT, src_x,
- GIMP_PDB_FLOAT, src_y,
- GIMP_PDB_INT32, num_strokes,
- GIMP_PDB_FLOATARRAY, strokes,
- GIMP_PDB_END);
+ 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,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-heal",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -537,20 +607,25 @@ gimp_heal_default (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-heal-default",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_INT32, num_strokes,
- GIMP_PDB_FLOATARRAY, strokes,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_FLOAT_ARRAY,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-heal-default",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -587,23 +662,31 @@ gimp_paintbrush (gint32 drawable_ID,
GimpPaintApplicationMode method,
gdouble gradient_length)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-paintbrush",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_FLOAT, fade_out,
- GIMP_PDB_INT32, num_strokes,
- GIMP_PDB_FLOATARRAY, strokes,
- GIMP_PDB_INT32, method,
- GIMP_PDB_FLOAT, gradient_length,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_DOUBLE,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_FLOAT_ARRAY,
+ G_TYPE_ENUM,
+ G_TYPE_DOUBLE,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-paintbrush",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -638,20 +721,25 @@ gimp_paintbrush_default (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-paintbrush-default",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_INT32, num_strokes,
- GIMP_PDB_FLOATARRAY, strokes,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_FLOAT_ARRAY,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-paintbrush-default",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -678,20 +766,25 @@ gimp_pencil (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-pencil",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_INT32, num_strokes,
- GIMP_PDB_FLOATARRAY, strokes,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_FLOAT_ARRAY,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-pencil",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -717,21 +810,27 @@ gimp_smudge (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-smudge",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_FLOAT, pressure,
- GIMP_PDB_INT32, num_strokes,
- GIMP_PDB_FLOATARRAY, strokes,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ G_TYPE_DOUBLE,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_FLOAT_ARRAY,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-smudge",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -756,20 +855,25 @@ gimp_smudge_default (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-smudge-default",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_INT32, num_strokes,
- GIMP_PDB_FLOATARRAY, strokes,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_FLOAT_ARRAY,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-smudge-default",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
diff --git a/libgimp/gimppalette_pdb.c b/libgimp/gimppalette_pdb.c
index b82375482a..2a65737dda 100644
--- a/libgimp/gimppalette_pdb.c
+++ b/libgimp/gimppalette_pdb.c
@@ -22,8 +22,6 @@
#include "config.h"
-#include <string.h>
-
#include "gimp.h"
@@ -51,19 +49,22 @@
gchar *
gimp_palette_new (const gchar *name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *actual_name = NULL;
- return_vals = gimp_run_procedure ("gimp-palette-new",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), name);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-palette-new",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- actual_name = g_strdup (return_vals[1].data.d_string);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ actual_name = g_value_dup_string (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return actual_name;
}
@@ -83,19 +84,22 @@ gimp_palette_new (const gchar *name)
gchar *
gimp_palette_duplicate (const gchar *name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *copy_name = NULL;
- return_vals = gimp_run_procedure ("gimp-palette-duplicate",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), name);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- copy_name = g_strdup (return_vals[1].data.d_string);
+ return_vals = gimp_run_procedure_with_array ("gimp-palette-duplicate",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ copy_name = g_value_dup_string (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return copy_name;
}
@@ -117,20 +121,24 @@ gchar *
gimp_palette_rename (const gchar *name,
const gchar *new_name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *actual_name = NULL;
- return_vals = gimp_run_procedure ("gimp-palette-rename",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_STRING, new_name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_STRING,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-palette-rename",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- actual_name = g_strdup (return_vals[1].data.d_string);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ actual_name = g_value_dup_string (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return actual_name;
}
@@ -150,18 +158,21 @@ gimp_palette_rename (const gchar *name,
gboolean
gimp_palette_delete (const gchar *name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-palette-delete",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), name);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-palette-delete",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -181,19 +192,22 @@ gimp_palette_delete (const gchar *name)
gboolean
gimp_palette_is_editable (const gchar *name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean editable = FALSE;
- return_vals = gimp_run_procedure ("gimp-palette-is-editable",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), name);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-palette-is-editable",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- editable = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ editable = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return editable;
}
@@ -216,23 +230,26 @@ gboolean
gimp_palette_get_info (const gchar *name,
gint *num_colors)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-palette-get-info",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), name);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-palette-get-info",
+ args);
+ gimp_value_array_unref (args);
*num_colors = 0;
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
- *num_colors = return_vals[1].data.d_int32;
+ *num_colors = g_value_get_int (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -254,27 +271,27 @@ GimpRGB *
gimp_palette_get_colors (const gchar *name,
gint *num_colors)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
GimpRGB *colors = NULL;
- return_vals = gimp_run_procedure ("gimp-palette-get-colors",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), name);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-palette-get-colors",
+ args);
+ gimp_value_array_unref (args);
*num_colors = 0;
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
{
- *num_colors = return_vals[1].data.d_int32;
- colors = g_new (GimpRGB, *num_colors);
- memcpy (colors,
- return_vals[2].data.d_colorarray,
- *num_colors * sizeof (GimpRGB));
+ *num_colors = g_value_get_int (gimp_value_array_index (return_vals, 1));
+ colors = gimp_value_dup_rgb_array (gimp_value_array_index (return_vals, 2));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return colors;
}
@@ -295,19 +312,22 @@ gimp_palette_get_colors (const gchar *name,
gint
gimp_palette_get_columns (const gchar *name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint num_columns = 0;
- return_vals = gimp_run_procedure ("gimp-palette-get-columns",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), name);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- num_columns = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-palette-get-columns",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ num_columns = g_value_get_int (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return num_columns;
}
@@ -331,19 +351,23 @@ gboolean
gimp_palette_set_columns (const gchar *name,
gint columns)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-palette-set-columns",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_INT32, columns,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-palette-set-columns",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -370,25 +394,30 @@ gimp_palette_add_entry (const gchar *name,
const GimpRGB *color,
gint *entry_num)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-palette-add-entry",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_STRING, entry_name,
- GIMP_PDB_COLOR, color,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_STRING,
+ GIMP_TYPE_RGB,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-palette-add-entry",
+ args);
+ gimp_value_array_unref (args);
*entry_num = 0;
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
- *entry_num = return_vals[1].data.d_int32;
+ *entry_num = g_value_get_int (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -411,19 +440,23 @@ gboolean
gimp_palette_delete_entry (const gchar *name,
gint entry_num)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-palette-delete-entry",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_INT32, entry_num,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-palette-delete-entry",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -449,22 +482,26 @@ gimp_palette_entry_get_color (const gchar *name,
gint entry_num,
GimpRGB *color)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-palette-entry-get-color",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_INT32, entry_num,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ GIMP_TYPE_INT32,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-palette-entry-get-color",
+ args);
+ gimp_value_array_unref (args);
+
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
- *color = return_vals[1].data.d_color;
+ gimp_value_get_rgb (gimp_value_array_index (return_vals, 1), &*color);
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -490,20 +527,25 @@ gimp_palette_entry_set_color (const gchar *name,
gint entry_num,
const GimpRGB *color)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-palette-entry-set-color",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_INT32, entry_num,
- GIMP_PDB_COLOR, color,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_RGB,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-palette-entry-set-color",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -529,24 +571,28 @@ gimp_palette_entry_get_name (const gchar *name,
gint entry_num,
gchar **entry_name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-palette-entry-get-name",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_INT32, entry_num,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-palette-entry-get-name",
+ args);
+ gimp_value_array_unref (args);
*entry_name = NULL;
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
- *entry_name = g_strdup (return_vals[1].data.d_string);
+ *entry_name = g_value_dup_string (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -572,20 +618,25 @@ gimp_palette_entry_set_name (const gchar *name,
gint entry_num,
const gchar *entry_name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-palette-entry-set-name",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_INT32, entry_num,
- GIMP_PDB_STRING, entry_name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ GIMP_TYPE_INT32,
+ G_TYPE_STRING,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-palette-entry-set-name",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
diff --git a/libgimp/gimppalettes_pdb.c b/libgimp/gimppalettes_pdb.c
index 5ef79d630b..adf1873aad 100644
--- a/libgimp/gimppalettes_pdb.c
+++ b/libgimp/gimppalettes_pdb.c
@@ -47,17 +47,19 @@
gboolean
gimp_palettes_refresh (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-palettes-refresh",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-palettes-refresh",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -80,30 +82,27 @@ gchar **
gimp_palettes_get_list (const gchar *filter,
gint *num_palettes)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar **palette_list = NULL;
- gint i;
- return_vals = gimp_run_procedure ("gimp-palettes-get-list",
- &nreturn_vals,
- GIMP_PDB_STRING, filter,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), filter);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-palettes-get-list",
+ args);
+ gimp_value_array_unref (args);
*num_palettes = 0;
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
{
- *num_palettes = return_vals[1].data.d_int32;
- if (*num_palettes > 0)
- {
- palette_list = g_new0 (gchar *, *num_palettes + 1);
- for (i = 0; i < *num_palettes; i++)
- palette_list[i] = g_strdup (return_vals[2].data.d_stringarray[i]);
- }
+ *num_palettes = g_value_get_int (gimp_value_array_index (return_vals, 1));
+ palette_list = gimp_value_dup_string_array (gimp_value_array_index (return_vals, 2));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return palette_list;
}
diff --git a/libgimp/gimppaletteselect_pdb.c b/libgimp/gimppaletteselect_pdb.c
index 0e64e1bc67..e1f208cbad 100644
--- a/libgimp/gimppaletteselect_pdb.c
+++ b/libgimp/gimppaletteselect_pdb.c
@@ -51,20 +51,25 @@ gimp_palettes_popup (const gchar *palette_callback,
const gchar *popup_title,
const gchar *initial_palette)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-palettes-popup",
- &nreturn_vals,
- GIMP_PDB_STRING, palette_callback,
- GIMP_PDB_STRING, popup_title,
- GIMP_PDB_STRING, initial_palette,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_STRING,
+ G_TYPE_STRING,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-palettes-popup",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -82,18 +87,21 @@ gimp_palettes_popup (const gchar *palette_callback,
gboolean
gimp_palettes_close_popup (const gchar *palette_callback)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-palettes-close-popup",
- &nreturn_vals,
- GIMP_PDB_STRING, palette_callback,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), palette_callback);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-palettes-close-popup",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -113,19 +121,23 @@ gboolean
gimp_palettes_set_popup (const gchar *palette_callback,
const gchar *palette_name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-palettes-set-popup",
- &nreturn_vals,
- GIMP_PDB_STRING, palette_callback,
- GIMP_PDB_STRING, palette_name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_STRING,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-palettes-set-popup",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
diff --git a/libgimp/gimppattern_pdb.c b/libgimp/gimppattern_pdb.c
index 827b70fc39..10454a2b5c 100644
--- a/libgimp/gimppattern_pdb.c
+++ b/libgimp/gimppattern_pdb.c
@@ -22,8 +22,6 @@
#include "config.h"
-#include <string.h>
-
#include "gimp.h"
@@ -58,29 +56,32 @@ gimp_pattern_get_info (const gchar *name,
gint *height,
gint *bpp)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-pattern-get-info",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), name);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-pattern-get-info",
+ args);
+ gimp_value_array_unref (args);
*width = 0;
*height = 0;
*bpp = 0;
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
{
- *width = return_vals[1].data.d_int32;
- *height = return_vals[2].data.d_int32;
- *bpp = return_vals[3].data.d_int32;
+ *width = g_value_get_int (gimp_value_array_index (return_vals, 1));
+ *height = g_value_get_int (gimp_value_array_index (return_vals, 2));
+ *bpp = g_value_get_int (gimp_value_array_index (return_vals, 3));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -112,14 +113,17 @@ gimp_pattern_get_pixels (const gchar *name,
gint *num_color_bytes,
guint8 **color_bytes)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-pattern-get-pixels",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), name);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-pattern-get-pixels",
+ args);
+ gimp_value_array_unref (args);
*width = 0;
*height = 0;
@@ -127,21 +131,18 @@ gimp_pattern_get_pixels (const gchar *name,
*num_color_bytes = 0;
*color_bytes = NULL;
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
{
- *width = return_vals[1].data.d_int32;
- *height = return_vals[2].data.d_int32;
- *bpp = return_vals[3].data.d_int32;
- *num_color_bytes = return_vals[4].data.d_int32;
- *color_bytes = g_new (guint8, *num_color_bytes);
- memcpy (*color_bytes,
- return_vals[5].data.d_int8array,
- *num_color_bytes * sizeof (guint8));
+ *width = g_value_get_int (gimp_value_array_index (return_vals, 1));
+ *height = g_value_get_int (gimp_value_array_index (return_vals, 2));
+ *bpp = g_value_get_int (gimp_value_array_index (return_vals, 3));
+ *num_color_bytes = g_value_get_int (gimp_value_array_index (return_vals, 4));
+ *color_bytes = gimp_value_dup_int8_array (gimp_value_array_index (return_vals, 5));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
diff --git a/libgimp/gimppatterns_pdb.c b/libgimp/gimppatterns_pdb.c
index 6273837b42..27d3389ac3 100644
--- a/libgimp/gimppatterns_pdb.c
+++ b/libgimp/gimppatterns_pdb.c
@@ -47,17 +47,19 @@
gboolean
gimp_patterns_refresh (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-patterns-refresh",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-patterns-refresh",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -80,30 +82,27 @@ gchar **
gimp_patterns_get_list (const gchar *filter,
gint *num_patterns)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar **pattern_list = NULL;
- gint i;
- return_vals = gimp_run_procedure ("gimp-patterns-get-list",
- &nreturn_vals,
- GIMP_PDB_STRING, filter,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), filter);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-patterns-get-list",
+ args);
+ gimp_value_array_unref (args);
*num_patterns = 0;
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
{
- *num_patterns = return_vals[1].data.d_int32;
- if (*num_patterns > 0)
- {
- pattern_list = g_new0 (gchar *, *num_patterns + 1);
- for (i = 0; i < *num_patterns; i++)
- pattern_list[i] = g_strdup (return_vals[2].data.d_stringarray[i]);
- }
+ *num_patterns = g_value_get_int (gimp_value_array_index (return_vals, 1));
+ pattern_list = gimp_value_dup_string_array (gimp_value_array_index (return_vals, 2));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return pattern_list;
}
diff --git a/libgimp/gimppatternselect_pdb.c b/libgimp/gimppatternselect_pdb.c
index 12ea47f050..fc5855612b 100644
--- a/libgimp/gimppatternselect_pdb.c
+++ b/libgimp/gimppatternselect_pdb.c
@@ -51,20 +51,25 @@ gimp_patterns_popup (const gchar *pattern_callback,
const gchar *popup_title,
const gchar *initial_pattern)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-patterns-popup",
- &nreturn_vals,
- GIMP_PDB_STRING, pattern_callback,
- GIMP_PDB_STRING, popup_title,
- GIMP_PDB_STRING, initial_pattern,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_STRING,
+ G_TYPE_STRING,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-patterns-popup",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -82,18 +87,21 @@ gimp_patterns_popup (const gchar *pattern_callback,
gboolean
gimp_patterns_close_popup (const gchar *pattern_callback)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-patterns-close-popup",
- &nreturn_vals,
- GIMP_PDB_STRING, pattern_callback,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), pattern_callback);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-patterns-close-popup",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -113,19 +121,23 @@ gboolean
gimp_patterns_set_popup (const gchar *pattern_callback,
const gchar *pattern_name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-patterns-set-popup",
- &nreturn_vals,
- GIMP_PDB_STRING, pattern_callback,
- GIMP_PDB_STRING, pattern_name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_STRING,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-patterns-set-popup",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
diff --git a/libgimp/gimpplugin_pdb.c b/libgimp/gimpplugin_pdb.c
index 6998a55679..1f931107c1 100644
--- a/libgimp/gimpplugin_pdb.c
+++ b/libgimp/gimpplugin_pdb.c
@@ -57,19 +57,23 @@ gboolean
gimp_plugin_domain_register (const gchar *domain_name,
const gchar *domain_path)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-plugin-domain-register",
- &nreturn_vals,
- GIMP_PDB_STRING, domain_name,
- GIMP_PDB_STRING, domain_path,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_STRING,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-plugin-domain-register",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -93,19 +97,23 @@ gboolean
gimp_plugin_help_register (const gchar *domain_name,
const gchar *domain_uri)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-plugin-help-register",
- &nreturn_vals,
- GIMP_PDB_STRING, domain_name,
- GIMP_PDB_STRING, domain_uri,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_STRING,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-plugin-help-register",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -128,19 +136,23 @@ gboolean
gimp_plugin_menu_register (const gchar *procedure_name,
const gchar *menu_path)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-plugin-menu-register",
- &nreturn_vals,
- GIMP_PDB_STRING, procedure_name,
- GIMP_PDB_STRING, menu_path,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_STRING,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-plugin-menu-register",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -165,19 +177,23 @@ gboolean
gimp_plugin_menu_branch_register (const gchar *menu_path,
const gchar *menu_name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-plugin-menu-branch-register",
- &nreturn_vals,
- GIMP_PDB_STRING, menu_path,
- GIMP_PDB_STRING, menu_name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_STRING,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-plugin-menu-branch-register",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -203,21 +219,27 @@ _gimp_plugin_icon_register (const gchar *procedure_name,
gint icon_data_length,
const guint8 *icon_data)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-plugin-icon-register",
- &nreturn_vals,
- GIMP_PDB_STRING, procedure_name,
- GIMP_PDB_INT32, icon_type,
- GIMP_PDB_INT32, icon_data_length,
- GIMP_PDB_INT8ARRAY, icon_data,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_ENUM,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT8_ARRAY,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-plugin-icon-register",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -244,18 +266,21 @@ _gimp_plugin_icon_register (const gchar *procedure_name,
gboolean
gimp_plugin_set_pdb_error_handler (GimpPDBErrorHandler handler)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-plugin-set-pdb-error-handler",
- &nreturn_vals,
- GIMP_PDB_INT32, handler,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_ENUM,
+ G_TYPE_NONE);
+ g_value_set_enum (gimp_value_array_index (args, 0), handler);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-plugin-set-pdb-error-handler",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -276,18 +301,20 @@ gimp_plugin_set_pdb_error_handler (GimpPDBErrorHandler handler)
GimpPDBErrorHandler
gimp_plugin_get_pdb_error_handler (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
GimpPDBErrorHandler handler = 0;
- return_vals = gimp_run_procedure ("gimp-plugin-get-pdb-error-handler",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-plugin-get-pdb-error-handler",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- handler = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ handler = g_value_get_enum (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return handler;
}
diff --git a/libgimp/gimpproceduraldb_pdb.c b/libgimp/gimpproceduraldb_pdb.c
index 32f47cff00..7d5f97f69e 100644
--- a/libgimp/gimpproceduraldb_pdb.c
+++ b/libgimp/gimpproceduraldb_pdb.c
@@ -22,8 +22,6 @@
#include "config.h"
-#include <string.h>
-
#include "gimp.h"
@@ -50,18 +48,20 @@
gchar *
gimp_procedural_db_temp_name (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *temp_name = NULL;
- return_vals = gimp_run_procedure ("gimp-procedural-db-temp-name",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-procedural-db-temp-name",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- temp_name = g_strdup (return_vals[1].data.d_string);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ temp_name = g_value_dup_string (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return temp_name;
}
@@ -81,18 +81,21 @@ gimp_procedural_db_temp_name (void)
gboolean
gimp_procedural_db_dump (const gchar *filename)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-procedural-db-dump",
- &nreturn_vals,
- GIMP_PDB_STRING, filename,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), filename);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-procedural-db-dump",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -138,39 +141,42 @@ gimp_procedural_db_query (const gchar *name,
gint *num_matches,
gchar ***procedure_names)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- gint i;
-
- return_vals = gimp_run_procedure ("gimp-procedural-db-query",
- &nreturn_vals,
- GIMP_PDB_STRING, name,
- GIMP_PDB_STRING, blurb,
- GIMP_PDB_STRING, help,
- GIMP_PDB_STRING, author,
- GIMP_PDB_STRING, copyright,
- GIMP_PDB_STRING, date,
- GIMP_PDB_STRING, proc_type,
- GIMP_PDB_END);
+
+ 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,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-procedural-db-query",
+ args);
+ gimp_value_array_unref (args);
*num_matches = 0;
*procedure_names = NULL;
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
{
- *num_matches = return_vals[1].data.d_int32;
- if (*num_matches > 0)
- {
- *procedure_names = g_new0 (gchar *, *num_matches + 1);
- for (i = 0; i < *num_matches; i++)
- (*procedure_names)[i] = g_strdup (return_vals[2].data.d_stringarray[i]);
- }
+ *num_matches = g_value_get_int (gimp_value_array_index (return_vals, 1));
+ *procedure_names = gimp_value_dup_string_array (gimp_value_array_index (return_vals, 2));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -191,19 +197,22 @@ gimp_procedural_db_query (const gchar *name,
gboolean
gimp_procedural_db_proc_exists (const gchar *procedure_name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean exists = FALSE;
- return_vals = gimp_run_procedure ("gimp-procedural-db-proc-exists",
- &nreturn_vals,
- GIMP_PDB_STRING, procedure_name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), procedure_name);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-procedural-db-proc-exists",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- exists = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ exists = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return exists;
}
@@ -243,14 +252,17 @@ _gimp_procedural_db_proc_info (const gchar *procedure_name,
gint *num_args,
gint *num_values)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-procedural-db-proc-info",
- &nreturn_vals,
- GIMP_PDB_STRING, procedure_name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), procedure_name);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-procedural-db-proc-info",
+ args);
+ gimp_value_array_unref (args);
*blurb = NULL;
*help = NULL;
@@ -261,21 +273,21 @@ _gimp_procedural_db_proc_info (const gchar *procedure_name,
*num_args = 0;
*num_values = 0;
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
{
- *blurb = g_strdup (return_vals[1].data.d_string);
- *help = g_strdup (return_vals[2].data.d_string);
- *author = g_strdup (return_vals[3].data.d_string);
- *copyright = g_strdup (return_vals[4].data.d_string);
- *date = g_strdup (return_vals[5].data.d_string);
- *proc_type = return_vals[6].data.d_int32;
- *num_args = return_vals[7].data.d_int32;
- *num_values = return_vals[8].data.d_int32;
+ *blurb = g_value_dup_string (gimp_value_array_index (return_vals, 1));
+ *help = g_value_dup_string (gimp_value_array_index (return_vals, 2));
+ *author = g_value_dup_string (gimp_value_array_index (return_vals, 3));
+ *copyright = g_value_dup_string (gimp_value_array_index (return_vals, 4));
+ *date = g_value_dup_string (gimp_value_array_index (return_vals, 5));
+ *proc_type = g_value_get_enum (gimp_value_array_index (return_vals, 6));
+ *num_args = g_value_get_int (gimp_value_array_index (return_vals, 7));
+ *num_values = g_value_get_int (gimp_value_array_index (return_vals, 8));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -303,30 +315,34 @@ gimp_procedural_db_proc_arg (const gchar *procedure_name,
gchar **arg_name,
gchar **arg_desc)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-procedural-db-proc-arg",
- &nreturn_vals,
- GIMP_PDB_STRING, procedure_name,
- GIMP_PDB_INT32, arg_num,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-procedural-db-proc-arg",
+ args);
+ gimp_value_array_unref (args);
*arg_type = 0;
*arg_name = NULL;
*arg_desc = NULL;
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
{
- *arg_type = return_vals[1].data.d_int32;
- *arg_name = g_strdup (return_vals[2].data.d_string);
- *arg_desc = g_strdup (return_vals[3].data.d_string);
+ *arg_type = g_value_get_enum (gimp_value_array_index (return_vals, 1));
+ *arg_name = g_value_dup_string (gimp_value_array_index (return_vals, 2));
+ *arg_desc = g_value_dup_string (gimp_value_array_index (return_vals, 3));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -355,30 +371,34 @@ gimp_procedural_db_proc_val (const gchar *procedure_name,
gchar **val_name,
gchar **val_desc)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-procedural-db-proc-val",
- &nreturn_vals,
- GIMP_PDB_STRING, procedure_name,
- GIMP_PDB_INT32, val_num,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-procedural-db-proc-val",
+ args);
+ gimp_value_array_unref (args);
*val_type = 0;
*val_name = NULL;
*val_desc = NULL;
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
{
- *val_type = return_vals[1].data.d_int32;
- *val_name = g_strdup (return_vals[2].data.d_string);
- *val_desc = g_strdup (return_vals[3].data.d_string);
+ *val_type = g_value_get_enum (gimp_value_array_index (return_vals, 1));
+ *val_name = g_value_dup_string (gimp_value_array_index (return_vals, 2));
+ *val_desc = g_value_dup_string (gimp_value_array_index (return_vals, 3));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -403,30 +423,30 @@ _gimp_procedural_db_get_data (const gchar *identifier,
gint *bytes,
guint8 **data)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-procedural-db-get-data",
- &nreturn_vals,
- GIMP_PDB_STRING, identifier,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), identifier);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-procedural-db-get-data",
+ args);
+ gimp_value_array_unref (args);
*bytes = 0;
*data = NULL;
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
{
- *bytes = return_vals[1].data.d_int32;
- *data = g_new (guint8, *bytes);
- memcpy (*data,
- return_vals[2].data.d_int8array,
- *bytes * sizeof (guint8));
+ *bytes = g_value_get_int (gimp_value_array_index (return_vals, 1));
+ *data = gimp_value_dup_int8_array (gimp_value_array_index (return_vals, 2));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -446,19 +466,22 @@ _gimp_procedural_db_get_data (const gchar *identifier,
gint
gimp_procedural_db_get_data_size (const gchar *identifier)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint bytes = 0;
- return_vals = gimp_run_procedure ("gimp-procedural-db-get-data-size",
- &nreturn_vals,
- GIMP_PDB_STRING, identifier,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), identifier);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- bytes = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-procedural-db-get-data-size",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ bytes = g_value_get_int (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return bytes;
}
@@ -482,20 +505,25 @@ _gimp_procedural_db_set_data (const gchar *identifier,
gint bytes,
const guint8 *data)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-procedural-db-set-data",
- &nreturn_vals,
- GIMP_PDB_STRING, identifier,
- GIMP_PDB_INT32, bytes,
- GIMP_PDB_INT8ARRAY, data,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT8_ARRAY,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-procedural-db-set-data",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
diff --git a/libgimp/gimpprogress_pdb.c b/libgimp/gimpprogress_pdb.c
index a35df17322..2ce99a19a2 100644
--- a/libgimp/gimpprogress_pdb.c
+++ b/libgimp/gimpprogress_pdb.c
@@ -50,19 +50,23 @@ gboolean
_gimp_progress_init (const gchar *message,
gint32 gdisplay_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-progress-init",
- &nreturn_vals,
- GIMP_PDB_STRING, message,
- GIMP_PDB_DISPLAY, gdisplay_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ GIMP_TYPE_DISPLAY_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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-progress-init",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -81,18 +85,21 @@ _gimp_progress_init (const gchar *message,
gboolean
_gimp_progress_update (gdouble percentage)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-progress-update",
- &nreturn_vals,
- GIMP_PDB_FLOAT, percentage,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_DOUBLE,
+ G_TYPE_NONE);
+ g_value_set_double (gimp_value_array_index (args, 0), percentage);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-progress-update",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -115,17 +122,19 @@ _gimp_progress_update (gdouble percentage)
gboolean
gimp_progress_pulse (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-progress-pulse",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-progress-pulse",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -147,18 +156,21 @@ gimp_progress_pulse (void)
gboolean
gimp_progress_set_text (const gchar *message)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-progress-set-text",
- &nreturn_vals,
- GIMP_PDB_STRING, message,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), message);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-progress-set-text",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -179,17 +191,19 @@ gimp_progress_set_text (const gchar *message)
gboolean
gimp_progress_end (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-progress-end",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-progress-end",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -210,18 +224,20 @@ gimp_progress_end (void)
gint
gimp_progress_get_window_handle (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint window = 0;
- return_vals = gimp_run_procedure ("gimp-progress-get-window-handle",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- window = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-progress-get-window-handle",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ window = g_value_get_int (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return window;
}
@@ -244,18 +260,21 @@ gimp_progress_get_window_handle (void)
gboolean
_gimp_progress_install (const gchar *progress_callback)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-progress-install",
- &nreturn_vals,
- GIMP_PDB_STRING, progress_callback,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), progress_callback);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-progress-install",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -276,18 +295,21 @@ _gimp_progress_install (const gchar *progress_callback)
gboolean
_gimp_progress_uninstall (const gchar *progress_callback)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-progress-uninstall",
- &nreturn_vals,
- GIMP_PDB_STRING, progress_callback,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), progress_callback);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-progress-uninstall",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -307,18 +329,21 @@ _gimp_progress_uninstall (const gchar *progress_callback)
gboolean
gimp_progress_cancel (const gchar *progress_callback)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-progress-cancel",
- &nreturn_vals,
- GIMP_PDB_STRING, progress_callback,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_NONE);
+ g_value_set_string (gimp_value_array_index (args, 0), progress_callback);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-progress-cancel",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
diff --git a/libgimp/gimpselection_pdb.c b/libgimp/gimpselection_pdb.c
index d82678fd5a..b44862a6d2 100644
--- a/libgimp/gimpselection_pdb.c
+++ b/libgimp/gimpselection_pdb.c
@@ -64,14 +64,17 @@ gimp_selection_bounds (gint32 image_ID,
gint *x2,
gint *y2)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-selection-bounds",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-selection-bounds",
+ args);
+ gimp_value_array_unref (args);
*non_empty = FALSE;
*x1 = 0;
@@ -79,18 +82,18 @@ gimp_selection_bounds (gint32 image_ID,
*x2 = 0;
*y2 = 0;
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
{
- *non_empty = return_vals[1].data.d_int32;
- *x1 = return_vals[2].data.d_int32;
- *y1 = return_vals[3].data.d_int32;
- *x2 = return_vals[4].data.d_int32;
- *y2 = return_vals[5].data.d_int32;
+ *non_empty = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+ *x1 = g_value_get_int (gimp_value_array_index (return_vals, 2));
+ *y1 = g_value_get_int (gimp_value_array_index (return_vals, 3));
+ *x2 = g_value_get_int (gimp_value_array_index (return_vals, 4));
+ *y2 = g_value_get_int (gimp_value_array_index (return_vals, 5));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -113,21 +116,26 @@ gimp_selection_value (gint32 image_ID,
gint x,
gint y)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint value = 0;
- return_vals = gimp_run_procedure ("gimp-selection-value",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, x,
- GIMP_PDB_INT32, y,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-selection-value",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- value = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ value = g_value_get_int (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return value;
}
@@ -146,19 +154,22 @@ gimp_selection_value (gint32 image_ID,
gboolean
gimp_selection_is_empty (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean is_empty = FALSE;
- return_vals = gimp_run_procedure ("gimp-selection-is-empty",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- is_empty = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-selection-is-empty",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ is_empty = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return is_empty;
}
@@ -184,20 +195,25 @@ gimp_selection_translate (gint32 image_ID,
gint offx,
gint offy)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-selection-translate",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, offx,
- GIMP_PDB_INT32, offy,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-selection-translate",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -224,21 +240,26 @@ _gimp_selection_float (gint32 drawable_ID,
gint offx,
gint offy)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 layer_ID = -1;
- return_vals = gimp_run_procedure ("gimp-selection-float",
- &nreturn_vals,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_INT32, offx,
- GIMP_PDB_INT32, offy,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_DRAWABLE_ID,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ 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 (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- layer_ID = return_vals[1].data.d_layer;
+ return_vals = gimp_run_procedure_with_array ("gimp-selection-float",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return layer_ID;
}
@@ -257,18 +278,21 @@ _gimp_selection_float (gint32 drawable_ID,
gboolean
gimp_selection_invert (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-selection-invert",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-selection-invert",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -289,18 +313,21 @@ gimp_selection_invert (gint32 image_ID)
gboolean
gimp_selection_sharpen (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-selection-sharpen",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-selection-sharpen",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -319,18 +346,21 @@ gimp_selection_sharpen (gint32 image_ID)
gboolean
gimp_selection_all (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-selection-all",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-selection-all",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -349,18 +379,21 @@ gimp_selection_all (gint32 image_ID)
gboolean
gimp_selection_none (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-selection-none",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-selection-none",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -381,19 +414,23 @@ gboolean
gimp_selection_feather (gint32 image_ID,
gdouble radius)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-selection-feather",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_FLOAT, radius,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_DOUBLE,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-selection-feather",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -415,19 +452,23 @@ gboolean
gimp_selection_border (gint32 image_ID,
gint radius)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-selection-border",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, radius,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_INT32,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-selection-border",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -448,19 +489,23 @@ gboolean
gimp_selection_grow (gint32 image_ID,
gint steps)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-selection-grow",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, steps,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-selection-grow",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -482,19 +527,23 @@ gboolean
gimp_selection_shrink (gint32 image_ID,
gint steps)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-selection-shrink",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_INT32, steps,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_INT32,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-selection-shrink",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -517,18 +566,21 @@ gimp_selection_shrink (gint32 image_ID,
gboolean
gimp_selection_flood (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-selection-flood",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-selection-flood",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -548,19 +600,22 @@ gimp_selection_flood (gint32 image_ID)
gint32
gimp_selection_save (gint32 image_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 channel_ID = -1;
- return_vals = gimp_run_procedure ("gimp-selection-save",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_NONE);
+ gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-selection-save",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- channel_ID = return_vals[1].data.d_channel;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ channel_ID = gimp_value_get_channel_id (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return channel_ID;
}
diff --git a/libgimp/gimptextlayer_pdb.c b/libgimp/gimptextlayer_pdb.c
index 2a606fa67f..d68d07cd6b 100644
--- a/libgimp/gimptextlayer_pdb.c
+++ b/libgimp/gimptextlayer_pdb.c
@@ -62,23 +62,30 @@ gimp_text_layer_new (gint32 image_ID,
gdouble size,
GimpUnit unit)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 layer_ID = -1;
- return_vals = gimp_run_procedure ("gimp-text-layer-new",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_STRING, text,
- GIMP_PDB_STRING, fontname,
- GIMP_PDB_FLOAT, size,
- GIMP_PDB_INT32, unit,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_STRING,
+ G_TYPE_STRING,
+ G_TYPE_DOUBLE,
+ GIMP_TYPE_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 (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- layer_ID = return_vals[1].data.d_layer;
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-new",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return layer_ID;
}
@@ -98,19 +105,22 @@ gimp_text_layer_new (gint32 image_ID,
gchar *
gimp_text_layer_get_text (gint32 layer_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *text = NULL;
- return_vals = gimp_run_procedure ("gimp-text-layer-get-text",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_NONE);
+ gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-get-text",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- text = g_strdup (return_vals[1].data.d_string);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ text = g_value_dup_string (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return text;
}
@@ -132,19 +142,23 @@ gboolean
gimp_text_layer_set_text (gint32 layer_ID,
const gchar *text)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-text-layer-set-text",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_STRING, text,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_STRING,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-set-text",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -169,19 +183,22 @@ gimp_text_layer_set_text (gint32 layer_ID,
gchar *
gimp_text_layer_get_markup (gint32 layer_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *markup = NULL;
- return_vals = gimp_run_procedure ("gimp-text-layer-get-markup",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_NONE);
+ gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-get-markup",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- markup = g_strdup (return_vals[1].data.d_string);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ markup = g_value_dup_string (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return markup;
}
@@ -201,19 +218,22 @@ gimp_text_layer_get_markup (gint32 layer_ID)
gchar *
gimp_text_layer_get_font (gint32 layer_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *font = NULL;
- return_vals = gimp_run_procedure ("gimp-text-layer-get-font",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_NONE);
+ gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- font = g_strdup (return_vals[1].data.d_string);
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-get-font",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ font = g_value_dup_string (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return font;
}
@@ -235,19 +255,23 @@ gboolean
gimp_text_layer_set_font (gint32 layer_ID,
const gchar *font)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-text-layer-set-font",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_STRING, font,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_STRING,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-set-font",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -271,22 +295,25 @@ gdouble
gimp_text_layer_get_font_size (gint32 layer_ID,
GimpUnit *unit)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gdouble font_size = 0.0;
- return_vals = gimp_run_procedure ("gimp-text-layer-get-font-size",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_NONE);
+ gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-get-font-size",
+ args);
+ gimp_value_array_unref (args);
+
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
{
- font_size = return_vals[1].data.d_float;
- *unit = return_vals[2].data.d_unit;
+ font_size = g_value_get_double (gimp_value_array_index (return_vals, 1));
+ *unit = g_value_get_int (gimp_value_array_index (return_vals, 2));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return font_size;
}
@@ -311,20 +338,25 @@ gimp_text_layer_set_font_size (gint32 layer_ID,
gdouble font_size,
GimpUnit unit)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-text-layer-set-font-size",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_FLOAT, font_size,
- GIMP_PDB_INT32, unit,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_DOUBLE,
+ GIMP_TYPE_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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-set-font-size",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -346,19 +378,22 @@ gimp_text_layer_set_font_size (gint32 layer_ID,
gboolean
gimp_text_layer_get_antialias (gint32 layer_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean antialias = FALSE;
- return_vals = gimp_run_procedure ("gimp-text-layer-get-antialias",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_NONE);
+ gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- antialias = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-get-antialias",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ antialias = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return antialias;
}
@@ -381,19 +416,23 @@ gboolean
gimp_text_layer_set_antialias (gint32 layer_ID,
gboolean antialias)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-text-layer-set-antialias",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_INT32, antialias,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_BOOLEAN,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-set-antialias",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -415,19 +454,22 @@ gimp_text_layer_set_antialias (gint32 layer_ID,
GimpTextHintStyle
gimp_text_layer_get_hint_style (gint32 layer_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
GimpTextHintStyle style = 0;
- return_vals = gimp_run_procedure ("gimp-text-layer-get-hint-style",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_NONE);
+ gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- style = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-get-hint-style",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ style = g_value_get_enum (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return style;
}
@@ -451,19 +493,23 @@ gboolean
gimp_text_layer_set_hint_style (gint32 layer_ID,
GimpTextHintStyle style)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-text-layer-set-hint-style",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_INT32, style,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_ENUM,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-set-hint-style",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -484,19 +530,22 @@ gimp_text_layer_set_hint_style (gint32 layer_ID,
gboolean
gimp_text_layer_get_kerning (gint32 layer_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean kerning = FALSE;
- return_vals = gimp_run_procedure ("gimp-text-layer-get-kerning",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_NONE);
+ gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- kerning = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-get-kerning",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ kerning = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return kerning;
}
@@ -518,19 +567,23 @@ gboolean
gimp_text_layer_set_kerning (gint32 layer_ID,
gboolean kerning)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-text-layer-set-kerning",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_INT32, kerning,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_BOOLEAN,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-set-kerning",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -551,19 +604,22 @@ gimp_text_layer_set_kerning (gint32 layer_ID,
gchar *
gimp_text_layer_get_language (gint32 layer_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *language = NULL;
- return_vals = gimp_run_procedure ("gimp-text-layer-get-language",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_NONE);
+ gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-get-language",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- language = g_strdup (return_vals[1].data.d_string);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ language = g_value_dup_string (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return language;
}
@@ -586,19 +642,23 @@ gboolean
gimp_text_layer_set_language (gint32 layer_ID,
const gchar *language)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-text-layer-set-language",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_STRING, language,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_STRING,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-set-language",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -619,19 +679,22 @@ gimp_text_layer_set_language (gint32 layer_ID,
GimpTextDirection
gimp_text_layer_get_base_direction (gint32 layer_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
GimpTextDirection direction = 0;
- return_vals = gimp_run_procedure ("gimp-text-layer-get-base-direction",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_NONE);
+ gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-get-base-direction",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- direction = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ direction = g_value_get_enum (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return direction;
}
@@ -654,19 +717,23 @@ gboolean
gimp_text_layer_set_base_direction (gint32 layer_ID,
GimpTextDirection direction)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-text-layer-set-base-direction",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_INT32, direction,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_ENUM,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-set-base-direction",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -687,19 +754,22 @@ gimp_text_layer_set_base_direction (gint32 layer_ID,
GimpTextJustification
gimp_text_layer_get_justification (gint32 layer_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
GimpTextJustification justify = 0;
- return_vals = gimp_run_procedure ("gimp-text-layer-get-justification",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_NONE);
+ gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-get-justification",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- justify = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ justify = g_value_get_enum (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return justify;
}
@@ -722,19 +792,23 @@ gboolean
gimp_text_layer_set_justification (gint32 layer_ID,
GimpTextJustification justify)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-text-layer-set-justification",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_INT32, justify,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_ENUM,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-set-justification",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -756,21 +830,24 @@ gboolean
gimp_text_layer_get_color (gint32 layer_ID,
GimpRGB *color)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-text-layer-get-color",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_NONE);
+ gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-get-color",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
- *color = return_vals[1].data.d_color;
+ gimp_value_get_rgb (gimp_value_array_index (return_vals, 1), &*color);
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -792,19 +869,23 @@ gboolean
gimp_text_layer_set_color (gint32 layer_ID,
const GimpRGB *color)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-text-layer-set-color",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_COLOR, color,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ GIMP_TYPE_RGB,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-set-color",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -825,19 +906,22 @@ gimp_text_layer_set_color (gint32 layer_ID,
gdouble
gimp_text_layer_get_indent (gint32 layer_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gdouble indent = 0.0;
- return_vals = gimp_run_procedure ("gimp-text-layer-get-indent",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_NONE);
+ gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- indent = return_vals[1].data.d_float;
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-get-indent",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ indent = g_value_get_double (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return indent;
}
@@ -860,19 +944,23 @@ gboolean
gimp_text_layer_set_indent (gint32 layer_ID,
gdouble indent)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-text-layer-set-indent",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_FLOAT, indent,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_DOUBLE,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-set-indent",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -893,19 +981,22 @@ gimp_text_layer_set_indent (gint32 layer_ID,
gdouble
gimp_text_layer_get_line_spacing (gint32 layer_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gdouble line_spacing = 0.0;
- return_vals = gimp_run_procedure ("gimp-text-layer-get-line-spacing",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_NONE);
+ gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- line_spacing = return_vals[1].data.d_float;
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-get-line-spacing",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ line_spacing = g_value_get_double (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return line_spacing;
}
@@ -928,19 +1019,23 @@ gboolean
gimp_text_layer_set_line_spacing (gint32 layer_ID,
gdouble line_spacing)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-text-layer-set-line-spacing",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_FLOAT, line_spacing,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_DOUBLE,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-set-line-spacing",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -961,19 +1056,22 @@ gimp_text_layer_set_line_spacing (gint32 layer_ID,
gdouble
gimp_text_layer_get_letter_spacing (gint32 layer_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gdouble letter_spacing = 0.0;
- return_vals = gimp_run_procedure ("gimp-text-layer-get-letter-spacing",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_NONE);
+ gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- letter_spacing = return_vals[1].data.d_float;
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-get-letter-spacing",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ letter_spacing = g_value_get_double (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return letter_spacing;
}
@@ -996,19 +1094,23 @@ gboolean
gimp_text_layer_set_letter_spacing (gint32 layer_ID,
gdouble letter_spacing)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-text-layer-set-letter-spacing",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_FLOAT, letter_spacing,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_DOUBLE,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-set-letter-spacing",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1034,20 +1136,25 @@ gimp_text_layer_resize (gint32 layer_ID,
gdouble width,
gdouble height)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-text-layer-resize",
- &nreturn_vals,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_FLOAT, width,
- GIMP_PDB_FLOAT, height,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_LAYER_ID,
+ G_TYPE_DOUBLE,
+ G_TYPE_DOUBLE,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-resize",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
diff --git a/libgimp/gimptexttool_pdb.c b/libgimp/gimptexttool_pdb.c
index 9f4f3c8a18..4feb314d40 100644
--- a/libgimp/gimptexttool_pdb.c
+++ b/libgimp/gimptexttool_pdb.c
@@ -78,28 +78,40 @@ gimp_text_fontname (gint32 image_ID,
GimpSizeType size_type,
const gchar *fontname)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 text_layer_ID = -1;
- return_vals = gimp_run_procedure ("gimp-text-fontname",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_DRAWABLE, drawable_ID,
- GIMP_PDB_FLOAT, x,
- GIMP_PDB_FLOAT, y,
- GIMP_PDB_STRING, text,
- GIMP_PDB_INT32, border,
- GIMP_PDB_INT32, antialias,
- GIMP_PDB_FLOAT, size,
- GIMP_PDB_INT32, size_type,
- GIMP_PDB_STRING, fontname,
- GIMP_PDB_END);
-
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- text_layer_ID = return_vals[1].data.d_layer;
-
- gimp_destroy_params (return_vals, nreturn_vals);
+ 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,
+ G_TYPE_ENUM,
+ G_TYPE_STRING,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-text-fontname",
+ args);
+ gimp_value_array_unref (args);
+
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ text_layer_ID = gimp_value_get_layer_id (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return text_layer_ID;
}
@@ -137,34 +149,40 @@ gimp_text_get_extents_fontname (const gchar *text,
gint *ascent,
gint *descent)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-text-get-extents-fontname",
- &nreturn_vals,
- GIMP_PDB_STRING, text,
- GIMP_PDB_FLOAT, size,
- GIMP_PDB_INT32, size_type,
- GIMP_PDB_STRING, fontname,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_STRING,
+ G_TYPE_DOUBLE,
+ G_TYPE_ENUM,
+ G_TYPE_STRING,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-text-get-extents-fontname",
+ args);
+ gimp_value_array_unref (args);
*width = 0;
*height = 0;
*ascent = 0;
*descent = 0;
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
{
- *width = return_vals[1].data.d_int32;
- *height = return_vals[2].data.d_int32;
- *ascent = return_vals[3].data.d_int32;
- *descent = return_vals[4].data.d_int32;
+ *width = g_value_get_int (gimp_value_array_index (return_vals, 1));
+ *height = g_value_get_int (gimp_value_array_index (return_vals, 2));
+ *ascent = g_value_get_int (gimp_value_array_index (return_vals, 3));
+ *descent = g_value_get_int (gimp_value_array_index (return_vals, 4));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
diff --git a/libgimp/gimpunit_pdb.c b/libgimp/gimpunit_pdb.c
index fff9e127b0..d93a982872 100644
--- a/libgimp/gimpunit_pdb.c
+++ b/libgimp/gimpunit_pdb.c
@@ -47,18 +47,20 @@
gint
_gimp_unit_get_number_of_units (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint num_units = GIMP_UNIT_END;
- return_vals = gimp_run_procedure ("gimp-unit-get-number-of-units",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- num_units = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-unit-get-number-of-units",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ num_units = g_value_get_int (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return num_units;
}
@@ -75,18 +77,20 @@ _gimp_unit_get_number_of_units (void)
gint
_gimp_unit_get_number_of_built_in_units (void)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint num_units = GIMP_UNIT_END;
- return_vals = gimp_run_procedure ("gimp-unit-get-number-of-built-in-units",
- &nreturn_vals,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (G_TYPE_NONE);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-unit-get-number-of-built-in-units",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- num_units = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ num_units = g_value_get_int (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return num_units;
}
@@ -119,25 +123,34 @@ _gimp_unit_new (const gchar *identifier,
const gchar *singular,
const gchar *plural)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
GimpUnit unit_id = GIMP_UNIT_INCH;
- return_vals = gimp_run_procedure ("gimp-unit-new",
- &nreturn_vals,
- GIMP_PDB_STRING, identifier,
- GIMP_PDB_FLOAT, factor,
- GIMP_PDB_INT32, digits,
- GIMP_PDB_STRING, symbol,
- GIMP_PDB_STRING, abbreviation,
- GIMP_PDB_STRING, singular,
- GIMP_PDB_STRING, plural,
- GIMP_PDB_END);
-
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- unit_id = return_vals[1].data.d_unit;
-
- gimp_destroy_params (return_vals, nreturn_vals);
+ 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,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-unit-new",
+ args);
+ gimp_value_array_unref (args);
+
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ unit_id = g_value_get_int (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return unit_id;
}
@@ -157,19 +170,22 @@ _gimp_unit_new (const gchar *identifier,
gboolean
_gimp_unit_get_deletion_flag (GimpUnit unit_id)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean deletion_flag = FALSE;
- return_vals = gimp_run_procedure ("gimp-unit-get-deletion-flag",
- &nreturn_vals,
- GIMP_PDB_INT32, unit_id,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_UNIT,
+ G_TYPE_NONE);
+ g_value_set_int (gimp_value_array_index (args, 0), unit_id);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- deletion_flag = return_vals[1].data.d_int32;
+ return_vals = gimp_run_procedure_with_array ("gimp-unit-get-deletion-flag",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ deletion_flag = g_value_get_boolean (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return deletion_flag;
}
@@ -191,19 +207,23 @@ gboolean
_gimp_unit_set_deletion_flag (GimpUnit unit_id,
gboolean deletion_flag)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-unit-set-deletion-flag",
- &nreturn_vals,
- GIMP_PDB_INT32, unit_id,
- GIMP_PDB_INT32, deletion_flag,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_UNIT,
+ G_TYPE_BOOLEAN,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-unit-set-deletion-flag",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -223,19 +243,22 @@ _gimp_unit_set_deletion_flag (GimpUnit unit_id,
gchar *
_gimp_unit_get_identifier (GimpUnit unit_id)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *identifier = NULL;
- return_vals = gimp_run_procedure ("gimp-unit-get-identifier",
- &nreturn_vals,
- GIMP_PDB_INT32, unit_id,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_UNIT,
+ G_TYPE_NONE);
+ g_value_set_int (gimp_value_array_index (args, 0), unit_id);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-unit-get-identifier",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- identifier = g_strdup (return_vals[1].data.d_string);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ identifier = g_value_dup_string (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return identifier;
}
@@ -255,19 +278,22 @@ _gimp_unit_get_identifier (GimpUnit unit_id)
gdouble
_gimp_unit_get_factor (GimpUnit unit_id)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gdouble factor = 0.0;
- return_vals = gimp_run_procedure ("gimp-unit-get-factor",
- &nreturn_vals,
- GIMP_PDB_INT32, unit_id,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_UNIT,
+ G_TYPE_NONE);
+ g_value_set_int (gimp_value_array_index (args, 0), unit_id);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- factor = return_vals[1].data.d_float;
+ return_vals = gimp_run_procedure_with_array ("gimp-unit-get-factor",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ factor = g_value_get_double (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return factor;
}
@@ -288,19 +314,22 @@ _gimp_unit_get_factor (GimpUnit unit_id)
gint
_gimp_unit_get_digits (GimpUnit unit_id)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint digits = 0;
- return_vals = gimp_run_procedure ("gimp-unit-get-digits",
- &nreturn_vals,
- GIMP_PDB_INT32, unit_id,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_UNIT,
+ G_TYPE_NONE);
+ g_value_set_int (gimp_value_array_index (args, 0), unit_id);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-unit-get-digits",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- digits = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ digits = g_value_get_int (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return digits;
}
@@ -318,19 +347,22 @@ _gimp_unit_get_digits (GimpUnit unit_id)
gchar *
_gimp_unit_get_symbol (GimpUnit unit_id)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *symbol = NULL;
- return_vals = gimp_run_procedure ("gimp-unit-get-symbol",
- &nreturn_vals,
- GIMP_PDB_INT32, unit_id,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_UNIT,
+ G_TYPE_NONE);
+ g_value_set_int (gimp_value_array_index (args, 0), unit_id);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-unit-get-symbol",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- symbol = g_strdup (return_vals[1].data.d_string);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ symbol = g_value_dup_string (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return symbol;
}
@@ -349,19 +381,22 @@ _gimp_unit_get_symbol (GimpUnit unit_id)
gchar *
_gimp_unit_get_abbreviation (GimpUnit unit_id)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *abbreviation = NULL;
- return_vals = gimp_run_procedure ("gimp-unit-get-abbreviation",
- &nreturn_vals,
- GIMP_PDB_INT32, unit_id,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_UNIT,
+ G_TYPE_NONE);
+ g_value_set_int (gimp_value_array_index (args, 0), unit_id);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- abbreviation = g_strdup (return_vals[1].data.d_string);
+ return_vals = gimp_run_procedure_with_array ("gimp-unit-get-abbreviation",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ abbreviation = g_value_dup_string (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return abbreviation;
}
@@ -379,19 +414,22 @@ _gimp_unit_get_abbreviation (GimpUnit unit_id)
gchar *
_gimp_unit_get_singular (GimpUnit unit_id)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *singular = NULL;
- return_vals = gimp_run_procedure ("gimp-unit-get-singular",
- &nreturn_vals,
- GIMP_PDB_INT32, unit_id,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_UNIT,
+ G_TYPE_NONE);
+ g_value_set_int (gimp_value_array_index (args, 0), unit_id);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-unit-get-singular",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- singular = g_strdup (return_vals[1].data.d_string);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ singular = g_value_dup_string (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return singular;
}
@@ -409,19 +447,22 @@ _gimp_unit_get_singular (GimpUnit unit_id)
gchar *
_gimp_unit_get_plural (GimpUnit unit_id)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *plural = NULL;
- return_vals = gimp_run_procedure ("gimp-unit-get-plural",
- &nreturn_vals,
- GIMP_PDB_INT32, unit_id,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_UNIT,
+ G_TYPE_NONE);
+ g_value_set_int (gimp_value_array_index (args, 0), unit_id);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-unit-get-plural",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- plural = g_strdup (return_vals[1].data.d_string);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ plural = g_value_dup_string (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return plural;
}
diff --git a/libgimp/gimpvectors_pdb.c b/libgimp/gimpvectors_pdb.c
index 78926b7b0d..c2563a96f1 100644
--- a/libgimp/gimpvectors_pdb.c
+++ b/libgimp/gimpvectors_pdb.c
@@ -22,8 +22,6 @@
#include "config.h"
-#include <string.h>
-
#include "gimp.h"
@@ -55,20 +53,24 @@ gint32
gimp_vectors_new (gint32 image_ID,
const gchar *name)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 vectors_ID = -1;
- return_vals = gimp_run_procedure ("gimp-vectors-new",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_STRING, name,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_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), name);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-new",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- vectors_ID = return_vals[1].data.d_vectors;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ vectors_ID = gimp_value_get_vectors_id (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return vectors_ID;
}
@@ -91,20 +93,24 @@ gint32
gimp_vectors_new_from_text_layer (gint32 image_ID,
gint32 layer_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 vectors_ID = -1;
- return_vals = gimp_run_procedure ("gimp-vectors-new-from-text-layer",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_LAYER, layer_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_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 (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- vectors_ID = return_vals[1].data.d_vectors;
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-new-from-text-layer",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ vectors_ID = gimp_value_get_vectors_id (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return vectors_ID;
}
@@ -125,19 +131,22 @@ gimp_vectors_new_from_text_layer (gint32 image_ID,
gint32
gimp_vectors_copy (gint32 vectors_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint32 vectors_copy_ID = -1;
- return_vals = gimp_run_procedure ("gimp-vectors-copy",
- &nreturn_vals,
- GIMP_PDB_VECTORS, vectors_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_VECTORS_ID,
+ G_TYPE_NONE);
+ gimp_value_set_vectors_id (gimp_value_array_index (args, 0), vectors_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-copy",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- vectors_copy_ID = return_vals[1].data.d_vectors;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ vectors_copy_ID = gimp_value_get_vectors_id (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return vectors_copy_ID;
}
@@ -160,27 +169,27 @@ gint *
gimp_vectors_get_strokes (gint32 vectors_ID,
gint *num_strokes)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint *stroke_ids = NULL;
- return_vals = gimp_run_procedure ("gimp-vectors-get-strokes",
- &nreturn_vals,
- GIMP_PDB_VECTORS, vectors_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_VECTORS_ID,
+ G_TYPE_NONE);
+ gimp_value_set_vectors_id (gimp_value_array_index (args, 0), vectors_ID);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-get-strokes",
+ args);
+ gimp_value_array_unref (args);
*num_strokes = 0;
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
{
- *num_strokes = return_vals[1].data.d_int32;
- stroke_ids = g_new (gint32, *num_strokes);
- memcpy (stroke_ids,
- return_vals[2].data.d_int32array,
- *num_strokes * sizeof (gint32));
+ *num_strokes = g_value_get_int (gimp_value_array_index (return_vals, 1));
+ stroke_ids = gimp_value_dup_int32_array (gimp_value_array_index (return_vals, 2));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return stroke_ids;
}
@@ -204,21 +213,26 @@ gimp_vectors_stroke_get_length (gint32 vectors_ID,
gint stroke_id,
gdouble precision)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gdouble length = 0.0;
- return_vals = gimp_run_procedure ("gimp-vectors-stroke-get-length",
- &nreturn_vals,
- GIMP_PDB_VECTORS, vectors_ID,
- GIMP_PDB_INT32, stroke_id,
- GIMP_PDB_FLOAT, precision,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_VECTORS_ID,
+ GIMP_TYPE_INT32,
+ G_TYPE_DOUBLE,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-stroke-get-length",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- length = return_vals[1].data.d_float;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ length = g_value_get_double (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return length;
}
@@ -257,34 +271,40 @@ gimp_vectors_stroke_get_point_at_dist (gint32 vectors_ID,
gdouble *slope,
gboolean *valid)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-vectors-stroke-get-point-at-dist",
- &nreturn_vals,
- GIMP_PDB_VECTORS, vectors_ID,
- GIMP_PDB_INT32, stroke_id,
- GIMP_PDB_FLOAT, dist,
- GIMP_PDB_FLOAT, precision,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_VECTORS_ID,
+ GIMP_TYPE_INT32,
+ G_TYPE_DOUBLE,
+ G_TYPE_DOUBLE,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-stroke-get-point-at-dist",
+ args);
+ gimp_value_array_unref (args);
*x_point = 0.0;
*y_point = 0.0;
*slope = 0.0;
*valid = FALSE;
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
{
- *x_point = return_vals[1].data.d_float;
- *y_point = return_vals[2].data.d_float;
- *slope = return_vals[3].data.d_float;
- *valid = return_vals[4].data.d_int32;
+ *x_point = g_value_get_double (gimp_value_array_index (return_vals, 1));
+ *y_point = g_value_get_double (gimp_value_array_index (return_vals, 2));
+ *slope = g_value_get_double (gimp_value_array_index (return_vals, 3));
+ *valid = g_value_get_boolean (gimp_value_array_index (return_vals, 4));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -306,19 +326,23 @@ gboolean
gimp_vectors_remove_stroke (gint32 vectors_ID,
gint stroke_id)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-vectors-remove-stroke",
- &nreturn_vals,
- GIMP_PDB_VECTORS, vectors_ID,
- GIMP_PDB_INT32, stroke_id,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_VECTORS_ID,
+ GIMP_TYPE_INT32,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-remove-stroke",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -340,19 +364,23 @@ gboolean
gimp_vectors_stroke_close (gint32 vectors_ID,
gint stroke_id)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-vectors-stroke-close",
- &nreturn_vals,
- GIMP_PDB_VECTORS, vectors_ID,
- GIMP_PDB_INT32, stroke_id,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_VECTORS_ID,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-stroke-close",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -378,21 +406,27 @@ gimp_vectors_stroke_translate (gint32 vectors_ID,
gint off_x,
gint off_y)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-vectors-stroke-translate",
- &nreturn_vals,
- GIMP_PDB_VECTORS, vectors_ID,
- GIMP_PDB_INT32, stroke_id,
- GIMP_PDB_INT32, off_x,
- GIMP_PDB_INT32, off_y,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_VECTORS_ID,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_INT32,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-stroke-translate",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -418,21 +452,27 @@ gimp_vectors_stroke_scale (gint32 vectors_ID,
gdouble scale_x,
gdouble scale_y)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-vectors-stroke-scale",
- &nreturn_vals,
- GIMP_PDB_VECTORS, vectors_ID,
- GIMP_PDB_INT32, stroke_id,
- GIMP_PDB_FLOAT, scale_x,
- GIMP_PDB_FLOAT, scale_y,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_VECTORS_ID,
+ GIMP_TYPE_INT32,
+ G_TYPE_DOUBLE,
+ G_TYPE_DOUBLE,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-stroke-scale",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -460,22 +500,29 @@ gimp_vectors_stroke_rotate (gint32 vectors_ID,
gdouble center_y,
gdouble angle)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-vectors-stroke-rotate",
- &nreturn_vals,
- GIMP_PDB_VECTORS, vectors_ID,
- GIMP_PDB_INT32, stroke_id,
- GIMP_PDB_FLOAT, center_x,
- GIMP_PDB_FLOAT, center_y,
- GIMP_PDB_FLOAT, angle,
- GIMP_PDB_END);
+ 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_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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-stroke-rotate",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -501,21 +548,27 @@ gimp_vectors_stroke_flip (gint32 vectors_ID,
GimpOrientationType flip_type,
gdouble axis)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-vectors-stroke-flip",
- &nreturn_vals,
- GIMP_PDB_VECTORS, vectors_ID,
- GIMP_PDB_INT32, stroke_id,
- GIMP_PDB_INT32, flip_type,
- GIMP_PDB_FLOAT, axis,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_VECTORS_ID,
+ GIMP_TYPE_INT32,
+ G_TYPE_ENUM,
+ G_TYPE_DOUBLE,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-stroke-flip",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -547,23 +600,31 @@ gimp_vectors_stroke_flip_free (gint32 vectors_ID,
gdouble x2,
gdouble y2)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-vectors-stroke-flip-free",
- &nreturn_vals,
- GIMP_PDB_VECTORS, vectors_ID,
- GIMP_PDB_INT32, stroke_id,
- GIMP_PDB_FLOAT, x1,
- GIMP_PDB_FLOAT, y1,
- GIMP_PDB_FLOAT, x2,
- GIMP_PDB_FLOAT, y2,
- GIMP_PDB_END);
+ 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_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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-stroke-flip-free",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -595,30 +656,31 @@ gimp_vectors_stroke_get_points (gint32 vectors_ID,
gdouble **controlpoints,
gboolean *closed)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
GimpVectorsStrokeType type = 0;
- return_vals = gimp_run_procedure ("gimp-vectors-stroke-get-points",
- &nreturn_vals,
- GIMP_PDB_VECTORS, vectors_ID,
- GIMP_PDB_INT32, stroke_id,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_VECTORS_ID,
+ GIMP_TYPE_INT32,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-stroke-get-points",
+ args);
+ gimp_value_array_unref (args);
*num_points = 0;
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
{
- type = return_vals[1].data.d_int32;
- *num_points = return_vals[2].data.d_int32;
- *controlpoints = g_new (gdouble, *num_points);
- memcpy (*controlpoints,
- return_vals[3].data.d_floatarray,
- *num_points * sizeof (gdouble));
- *closed = return_vals[4].data.d_int32;
+ type = g_value_get_enum (gimp_value_array_index (return_vals, 1));
+ *num_points = g_value_get_int (gimp_value_array_index (return_vals, 2));
+ *controlpoints = gimp_value_dup_float_array (gimp_value_array_index (return_vals, 3));
+ *closed = g_value_get_boolean (gimp_value_array_index (return_vals, 4));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return type;
}
@@ -653,23 +715,30 @@ gimp_vectors_stroke_new_from_points (gint32 vectors_ID,
const gdouble *controlpoints,
gboolean closed)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint stroke_id = 0;
- return_vals = gimp_run_procedure ("gimp-vectors-stroke-new-from-points",
- &nreturn_vals,
- GIMP_PDB_VECTORS, vectors_ID,
- GIMP_PDB_INT32, type,
- GIMP_PDB_INT32, num_points,
- GIMP_PDB_FLOATARRAY, controlpoints,
- GIMP_PDB_INT32, closed,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_VECTORS_ID,
+ G_TYPE_ENUM,
+ GIMP_TYPE_INT32,
+ GIMP_TYPE_FLOAT_ARRAY,
+ G_TYPE_BOOLEAN,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-stroke-new-from-points",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- stroke_id = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ stroke_id = g_value_get_int (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return stroke_id;
}
@@ -697,30 +766,32 @@ gimp_vectors_stroke_interpolate (gint32 vectors_ID,
gint *num_coords,
gboolean *closed)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gdouble *coords = NULL;
- return_vals = gimp_run_procedure ("gimp-vectors-stroke-interpolate",
- &nreturn_vals,
- GIMP_PDB_VECTORS, vectors_ID,
- GIMP_PDB_INT32, stroke_id,
- GIMP_PDB_FLOAT, precision,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_VECTORS_ID,
+ GIMP_TYPE_INT32,
+ G_TYPE_DOUBLE,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-stroke-interpolate",
+ args);
+ gimp_value_array_unref (args);
*num_coords = 0;
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
{
- *num_coords = return_vals[1].data.d_int32;
- coords = g_new (gdouble, *num_coords);
- memcpy (coords,
- return_vals[2].data.d_floatarray,
- *num_coords * sizeof (gdouble));
- *closed = return_vals[3].data.d_int32;
+ *num_coords = g_value_get_int (gimp_value_array_index (return_vals, 1));
+ coords = gimp_value_dup_float_array (gimp_value_array_index (return_vals, 2));
+ *closed = g_value_get_boolean (gimp_value_array_index (return_vals, 3));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return coords;
}
@@ -744,21 +815,26 @@ gimp_vectors_bezier_stroke_new_moveto (gint32 vectors_ID,
gdouble x0,
gdouble y0)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint stroke_id = 0;
- return_vals = gimp_run_procedure ("gimp-vectors-bezier-stroke-new-moveto",
- &nreturn_vals,
- GIMP_PDB_VECTORS, vectors_ID,
- GIMP_PDB_FLOAT, x0,
- GIMP_PDB_FLOAT, y0,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_VECTORS_ID,
+ G_TYPE_DOUBLE,
+ G_TYPE_DOUBLE,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-bezier-stroke-new-moveto",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- stroke_id = return_vals[1].data.d_int32;
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ stroke_id = g_value_get_int (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return stroke_id;
}
@@ -784,21 +860,27 @@ gimp_vectors_bezier_stroke_lineto (gint32 vectors_ID,
gdouble x0,
gdouble y0)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-vectors-bezier-stroke-lineto",
- &nreturn_vals,
- GIMP_PDB_VECTORS, vectors_ID,
- GIMP_PDB_INT32, stroke_id,
- GIMP_PDB_FLOAT, x0,
- GIMP_PDB_FLOAT, y0,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_VECTORS_ID,
+ GIMP_TYPE_INT32,
+ G_TYPE_DOUBLE,
+ G_TYPE_DOUBLE,
+ 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);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-bezier-stroke-lineto",
+ args);
+ gimp_value_array_unref (args);
- gimp_destroy_params (return_vals, nreturn_vals);
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -830,23 +912,31 @@ gimp_vectors_bezier_stroke_conicto (gint32 vectors_ID,
gdouble x1,
gdouble y1)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-vectors-bezier-stroke-conicto",
- &nreturn_vals,
- GIMP_PDB_VECTORS, vectors_ID,
- GIMP_PDB_INT32, stroke_id,
- GIMP_PDB_FLOAT, x0,
- GIMP_PDB_FLOAT, y0,
- GIMP_PDB_FLOAT, x1,
- GIMP_PDB_FLOAT, y1,
- GIMP_PDB_END);
+ 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_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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-bezier-stroke-conicto",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -880,25 +970,35 @@ gimp_vectors_bezier_stroke_cubicto (gint32 vectors_ID,
gdouble x2,
gdouble y2)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-vectors-bezier-stroke-cubicto",
- &nreturn_vals,
- GIMP_PDB_VECTORS, vectors_ID,
- GIMP_PDB_INT32, stroke_id,
- GIMP_PDB_FLOAT, x0,
- GIMP_PDB_FLOAT, y0,
- GIMP_PDB_FLOAT, x1,
- GIMP_PDB_FLOAT, y1,
- GIMP_PDB_FLOAT, x2,
- GIMP_PDB_FLOAT, y2,
- GIMP_PDB_END);
-
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
-
- gimp_destroy_params (return_vals, nreturn_vals);
+ 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,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-bezier-stroke-cubicto",
+ args);
+ gimp_value_array_unref (args);
+
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -928,24 +1028,32 @@ gimp_vectors_bezier_stroke_new_ellipse (gint32 vectors_ID,
gdouble radius_y,
gdouble angle)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gint stroke_id = 0;
- return_vals = gimp_run_procedure ("gimp-vectors-bezier-stroke-new-ellipse",
- &nreturn_vals,
- GIMP_PDB_VECTORS, vectors_ID,
- GIMP_PDB_FLOAT, x0,
- GIMP_PDB_FLOAT, y0,
- GIMP_PDB_FLOAT, radius_x,
- GIMP_PDB_FLOAT, radius_y,
- GIMP_PDB_FLOAT, angle,
- GIMP_PDB_END);
-
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- stroke_id = return_vals[1].data.d_int32;
-
- gimp_destroy_params (return_vals, nreturn_vals);
+ 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,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-bezier-stroke-new-ellipse",
+ args);
+ gimp_value_array_unref (args);
+
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ stroke_id = g_value_get_int (gimp_value_array_index (return_vals, 1));
+
+ gimp_value_array_unref (return_vals);
return stroke_id;
}
@@ -974,35 +1082,38 @@ gimp_vectors_import_from_file (gint32 image_ID,
gboolean merge,
gboolean scale,
gint *num_vectors,
- gint32 **vectors_ids)
+ gint **vectors_ids)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-vectors-import-from-file",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_STRING, filename,
- GIMP_PDB_INT32, merge,
- GIMP_PDB_INT32, scale,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_STRING,
+ G_TYPE_BOOLEAN,
+ G_TYPE_BOOLEAN,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-import-from-file",
+ args);
+ gimp_value_array_unref (args);
*num_vectors = 0;
*vectors_ids = NULL;
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
{
- *num_vectors = return_vals[1].data.d_int32;
- *vectors_ids = g_new (gint32, *num_vectors);
- memcpy (*vectors_ids,
- return_vals[2].data.d_int32array,
- *num_vectors * sizeof (gint32));
+ *num_vectors = g_value_get_int (gimp_value_array_index (return_vals, 1));
+ *vectors_ids = gimp_value_dup_int32_array (gimp_value_array_index (return_vals, 2));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1034,36 +1145,40 @@ gimp_vectors_import_from_string (gint32 image_ID,
gboolean merge,
gboolean scale,
gint *num_vectors,
- gint32 **vectors_ids)
+ gint **vectors_ids)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-vectors-import-from-string",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_STRING, string,
- GIMP_PDB_INT32, length,
- GIMP_PDB_INT32, merge,
- GIMP_PDB_INT32, scale,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_STRING,
+ GIMP_TYPE_INT32,
+ G_TYPE_BOOLEAN,
+ G_TYPE_BOOLEAN,
+ 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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-import-from-string",
+ args);
+ gimp_value_array_unref (args);
*num_vectors = 0;
*vectors_ids = NULL;
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
{
- *num_vectors = return_vals[1].data.d_int32;
- *vectors_ids = g_new (gint32, *num_vectors);
- memcpy (*vectors_ids,
- return_vals[2].data.d_int32array,
- *num_vectors * sizeof (gint32));
+ *num_vectors = g_value_get_int (gimp_value_array_index (return_vals, 1));
+ *vectors_ids = gimp_value_dup_int32_array (gimp_value_array_index (return_vals, 2));
}
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1090,20 +1205,25 @@ gimp_vectors_export_to_file (gint32 image_ID,
const gchar *filename,
gint32 vectors_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gboolean success = TRUE;
- return_vals = gimp_run_procedure ("gimp-vectors-export-to-file",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_STRING, filename,
- GIMP_PDB_VECTORS, vectors_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ G_TYPE_STRING,
+ GIMP_TYPE_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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-export-to-file",
+ args);
+ gimp_value_array_unref (args);
- success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+ success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return success;
}
@@ -1128,20 +1248,24 @@ gchar *
gimp_vectors_export_to_string (gint32 image_ID,
gint32 vectors_ID)
{
- GimpParam *return_vals;
- gint nreturn_vals;
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
gchar *string = NULL;
- return_vals = gimp_run_procedure ("gimp-vectors-export-to-string",
- &nreturn_vals,
- GIMP_PDB_IMAGE, image_ID,
- GIMP_PDB_VECTORS, vectors_ID,
- GIMP_PDB_END);
+ args = gimp_value_array_new_from_types (GIMP_TYPE_IMAGE_ID,
+ GIMP_TYPE_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);
+
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-export-to-string",
+ args);
+ gimp_value_array_unref (args);
- if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
- string = g_strdup (return_vals[1].data.d_string);
+ if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
+ string = g_value_dup_string (gimp_value_array_index (return_vals, 1));
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
return string;
}
diff --git a/libgimp/gimpvectors_pdb.h b/libgimp/gimpvectors_pdb.h
index 41314baf8d..9679f511ed 100644
--- a/libgimp/gimpvectors_pdb.h
+++ b/libgimp/gimpvectors_pdb.h
@@ -124,14 +124,14 @@ gboolean gimp_vectors_import_from_file (gint32
gboolean merge,
gboolean scale,
gint *num_vectors,
- gint32 **vectors_ids);
+ gint **vectors_ids);
gboolean gimp_vectors_import_from_string (gint32 image_ID,
const gchar *string,
gint length,
gboolean merge,
gboolean scale,
gint *num_vectors,
- gint32 **vectors_ids);
+ gint **vectors_ids);
gboolean gimp_vectors_export_to_file (gint32 image_ID,
const gchar *filename,
gint32 vectors_ID);
diff --git a/pdb/lib.pl b/pdb/lib.pl
index 61b0506e59..58d7422836 100644
--- a/pdb/lib.pl
+++ b/pdb/lib.pl
@@ -136,12 +136,42 @@ sub generate {
}
# The parameters to the function
- my $arglist = ""; my $argpass = "";
- my $argdesc = ""; my $sincedesc = "";
+ my $arglist = "";
+ my $argdesc = "";
+ my $sincedesc = "";
+ my $value_array = "";
+ my $arg_array = "";
+ my $argc = 0;
foreach (@inargs) {
my ($type) = &arg_parse($_->{type});
- my $desc = exists $_->{desc} ? $_->{desc} : "";
my $arg = $arg_types{$type};
+ my $var = $_->{name};
+ my $desc = exists $_->{desc} ? $_->{desc} : "";
+ my $var_len;
+ my $value;
+
+ $var .= '_ID' if $arg->{id};
+
+ # This gets passed to gimp_value_array_new_with_types()
+ $value_array .= "$arg->{gtype},\n" . " " x 42;
+
+ $value = "gimp_value_array_index (args, $argc)";
+
+ if (exists $_->{array}) {
+ my $arrayarg = $_->{array};
+
+ 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"/;
+
+ $argc++;
$wrapped = "_" if exists $_->{wrap};
@@ -156,22 +186,13 @@ sub generate {
$argdesc .= '_ID' if $arg->{id};
$argdesc .= ": $desc";
- # This is what's passed into gimp_run_procedure
- $argpass .= "\n" . ' ' x 36;
- $argpass .= "GIMP_PDB_$arg->{name}, ";
-
- $argpass .= "$_->{name}";
- $argpass .= '_ID' if $arg->{id};
-
- $argpass .= ',';
-
unless ($argdesc =~ /[\.\!\?]$/) { $argdesc .= '.' }
$argdesc .= "\n";
}
# This marshals the return value(s)
my $return_args = "";
- my $return_marshal = "gimp_destroy_params (return_vals, nreturn_vals);";
+ my $return_marshal = "gimp_value_array_unref (return_vals);";
# return success/failure boolean if we don't have anything else
if ($rettype eq 'void') {
@@ -253,14 +274,14 @@ sub generate {
if ($rettype eq 'void') {
$return_marshal .= <<CODE;
-success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
if (success)
CODE
}
else {
$return_marshal .= <<CODE;
-if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
CODE
}
@@ -273,107 +294,34 @@ CODE
my $arg = $arg_types{$type};
my $var;
- my $ch = "";
- my $cf = "";
-
- if ($type =~ /^string(array)?/) {
- $ch = 'g_strdup (';
- $cf = ')';
- }
- elsif ($type =~ /parasite/) {
- $ch = 'gimp_parasite_copy (&';
- $cf = ')';
- }
- elsif ($type =~ /boolean|enum|guide|sample_point/) {
+ if ($type =~ /boolean|enum|guide|sample_point/) {
$type = 'int32';
}
- if (exists $_->{num}) {
- $numpos = $argc;
- $numtype = $type;
- if (!exists $_->{no_lib}) {
- $arglist .= "gint \*$_->{libname}, ";
- $argdesc .= " * \@$_->{libname}: $desc";
- }
- }
- elsif (exists $_->{array}) {
- my $datatype = $arg->{type};
- chop $datatype;
- $datatype =~ s/ *$//;
-
- my $var = $_->{libname}; my $dh = ""; my $df = "";
- unless (exists $_->{retval}) {
- $var = "*$var"; $dh = "(*"; $df = ")";
- if ($type eq 'stringarray') {
- $arglist .= "$datatype**$_->{libname}, ";
- }
- else {
- $arglist .= "$datatype **$_->{libname}, ";
- }
- $argdesc .= " * \@$_->{libname}: $desc";
- }
+ # The return value variable
+ $var = "";
- if ($ch || $cf) {
- $return_args .= "\n" . ' ' x 2 . "gint i;";
- }
+ unless (exists $_->{retval}) {
+ $var .= '*';
+ $arglist .= &libtype($_, 1);
+ $arglist .= '*' unless exists $arg->{struct};
+ $arglist .= "$_->{libname}";
+ $arglist .= '_ID' if $arg->{id};
+ $arglist .= ', ';
- my $numvar = '*' . $_->{array}->{name};
- $numvar = "num_$_->{name}" if exists $_->{array}->{no_lib};
+ $argdesc .= " * \@$_->{libname}";
+ $argdesc .= '_ID' if $arg->{id};
+ $argdesc .= ": $desc";
+ }
- $return_marshal .= <<NUMVAR;
- $numvar = return_vals[$numpos].data.d_$numtype;
-NUMVAR
+ $var = exists $_->{retval} ? "" : '*';
+ $var .= $_->{libname};
+ $var .= '_ID' if $arg->{id};
- if ($type =~ /stringarray/) {
- $return_marshal .= <<CP;
- if ($numvar > 0)
- {
- $var = g_new0 ($datatype, $numvar + 1);
- for (i = 0; i < $numvar; i++)
- $dh$_->{name}$df\[i] = ${ch}return_vals[$argc].data.d_$type\[i]${cf};
- }
-CP
- }
- else {
- $return_marshal .= <<NEW . (($ch || $cf) ? <<CP1 : <<CP2);
- $var = g_new ($datatype, $numvar);
-NEW
- for (i = 0; i < $numvar; i++)
- $dh$_->{name}$df\[i] = ${ch}return_vals[$argc].data.d_$type\[i]${cf};
-CP1
- memcpy ($var,
- return_vals[$argc].data.d_$type,
- $numvar * sizeof ($datatype));
-CP2
- }
- $out->{headers} = "#include <string.h>\n" unless ($ch || $cf);
- }
- else {
- # The return value variable
- $var = "";
-
- unless (exists $_->{retval}) {
- $var .= '*';
- $arglist .= &libtype($_, 1);
- $arglist .= '*' unless exists $arg->{struct};
- $arglist .= "$_->{libname}";
- $arglist .= '_ID' if $arg->{id};
- $arglist .= ', ';
-
- $argdesc .= " * \@$_->{libname}";
- $argdesc .= '_ID' if $arg->{id};
- $argdesc .= ": $desc";
- }
-
- $var = exists $_->{retval} ? "" : '*';
- $var .= $_->{libname};
- $var .= '_ID' if $arg->{id};
+ $value = "gimp_value_array_index (return_vals, $argc)";
- $return_marshal .= ' ' x 2 if $#outargs;
- $return_marshal .= <<CODE
- $var = ${ch}return_vals[$argc].data.d_$type${cf};
-CODE
- }
+ $return_marshal .= ' ' x 2 if $#outargs;
+ $return_marshal .= eval qq/" $arg->{dup_value_func};\n"/;
if ($argdesc) {
unless ($argdesc =~ /[\.\!\?]$/) { $argdesc .= '.' }
@@ -386,7 +334,7 @@ CODE
$return_marshal .= <<'CODE';
- gimp_destroy_params (return_vals, nreturn_vals);
+ gimp_value_array_unref (return_vals);
CODE
unless ($retvoid) {
@@ -398,7 +346,7 @@ CODE
}
else {
$return_marshal = <<CODE;
-success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
+success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
$return_marshal
@@ -505,12 +453,14 @@ $retdesc$sincedesc
$rettype
$wrapped$funcname ($clist)
{
- GimpParam *return_vals;
- gint nreturn_vals;$return_args
-
- return_vals = gimp_run_procedure ("gimp-$proc->{canonical_name}",
- \&nreturn_vals,$argpass
- GIMP_PDB_END);
+ GimpValueArray *args;
+ GimpValueArray *return_vals;$return_args
+
+ args = gimp_value_array_new_from_types (${value_array}G_TYPE_NONE);
+$arg_array
+ return_vals = gimp_run_procedure_with_array ("gimp-$proc->{canonical_name}",
+ args);
+ gimp_value_array_unref (args);
$return_marshal
}
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
