[gimp] pdb, libgimp: make all PDB wrappers use GimpPDB to run procedures
- From: Michael Natterer <mitch src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gimp] pdb, libgimp: make all PDB wrappers use GimpPDB to run procedures
- Date: Tue, 6 Aug 2019 19:34:47 +0000 (UTC)
commit c2e537484540f94d9df4157d28274ddad2da5b74
Author: Michael Natterer <mitch gimp org>
Date: Tue Aug 6 21:34:00 2019 +0200
pdb, libgimp: make all PDB wrappers use GimpPDB to run procedures
libgimp/gimp_pdb.c | 70 ++-
libgimp/gimpbrush_pdb.c | 220 +++++--
libgimp/gimpbrushes_pdb.c | 20 +-
libgimp/gimpbrushselect_pdb.c | 30 +-
libgimp/gimpbuffer_pdb.c | 70 ++-
libgimp/gimpchannel_pdb.c | 100 +++-
libgimp/gimpcontext_pdb.c | 1130 ++++++++++++++++++++++++++++-------
libgimp/gimpdebug_pdb.c | 20 +-
libgimp/gimpdisplay_pdb.c | 60 +-
libgimp/gimpdrawable_pdb.c | 240 ++++++--
libgimp/gimpdrawablecolor_pdb.c | 140 ++++-
libgimp/gimpdrawableedit_pdb.c | 60 +-
libgimp/gimpdynamics_pdb.c | 20 +-
libgimp/gimpedit_pdb.c | 100 +++-
libgimp/gimpfileops_pdb.c | 130 +++-
libgimp/gimpfloatingsel_pdb.c | 40 +-
libgimp/gimpfonts_pdb.c | 20 +-
libgimp/gimpfontselect_pdb.c | 30 +-
libgimp/gimpgimprc_pdb.c | 70 ++-
libgimp/gimpgradient_pdb.c | 310 ++++++++--
libgimp/gimpgradients_pdb.c | 20 +-
libgimp/gimpgradientselect_pdb.c | 30 +-
libgimp/gimphelp_pdb.c | 10 +-
libgimp/gimpimage_pdb.c | 820 ++++++++++++++++++++-----
libgimp/gimpimagecolorprofile_pdb.c | 60 +-
libgimp/gimpimageconvert_pdb.c | 50 +-
libgimp/gimpimagegrid_pdb.c | 100 +++-
libgimp/gimpimageguides_pdb.c | 60 +-
libgimp/gimpimagesamplepoints_pdb.c | 40 +-
libgimp/gimpimageselect_pdb.c | 70 ++-
libgimp/gimpimagetransform_pdb.c | 60 +-
libgimp/gimpimageundo_pdb.c | 70 ++-
libgimp/gimpitem_pdb.c | 330 ++++++++--
libgimp/gimpitemtransform_pdb.c | 100 +++-
libgimp/gimplayer_pdb.c | 350 ++++++++---
libgimp/gimpmessage_pdb.c | 30 +-
libgimp/gimppainttools_pdb.c | 170 ++++--
libgimp/gimppalette_pdb.c | 150 ++++-
libgimp/gimppalettes_pdb.c | 20 +-
libgimp/gimppaletteselect_pdb.c | 30 +-
libgimp/gimppattern_pdb.c | 20 +-
libgimp/gimppatterns_pdb.c | 20 +-
libgimp/gimppatternselect_pdb.c | 30 +-
libgimp/gimppdb_pdb.c | 120 +++-
libgimp/gimpplugin_pdb.c | 70 ++-
libgimp/gimpprogress_pdb.c | 90 ++-
libgimp/gimpselection_pdb.c | 150 ++++-
libgimp/gimptextlayer_pdb.c | 290 +++++++--
libgimp/gimptexttool_pdb.c | 20 +-
libgimp/gimpunit_pdb.c | 120 +++-
libgimp/gimpvectors_pdb.c | 250 ++++++--
pdb/lib.pl | 10 +-
52 files changed, 5312 insertions(+), 1328 deletions(-)
---
diff --git a/libgimp/gimp_pdb.c b/libgimp/gimp_pdb.c
index d76da322b8..111ecd1b53 100644
--- a/libgimp/gimp_pdb.c
+++ b/libgimp/gimp_pdb.c
@@ -52,14 +52,20 @@
gchar *
gimp_version (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *version = NULL;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-version",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-version",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-version",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -84,14 +90,20 @@ gimp_version (void)
gint
gimp_getpid (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint pid = 0;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-getpid",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-getpid",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-getpid",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -117,6 +129,7 @@ gimp_getpid (void)
gboolean
gimp_attach_parasite (const GimpParasite *parasite)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -125,8 +138,13 @@ gimp_attach_parasite (const GimpParasite *parasite)
G_TYPE_NONE);
g_value_set_boxed (gimp_value_array_index (args, 0), parasite);
- return_vals = gimp_run_procedure_with_array ("gimp-attach-parasite",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-attach-parasite",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-attach-parasite",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -152,6 +170,7 @@ gimp_attach_parasite (const GimpParasite *parasite)
gboolean
gimp_detach_parasite (const gchar *name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -160,8 +179,13 @@ gimp_detach_parasite (const gchar *name)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-detach-parasite",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-detach-parasite",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -186,6 +210,7 @@ gimp_detach_parasite (const gchar *name)
GimpParasite *
gimp_get_parasite (const gchar *name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpParasite *parasite = NULL;
@@ -194,8 +219,13 @@ gimp_get_parasite (const gchar *name)
G_TYPE_NONE);
g_value_set_string (gimp_value_array_index (args, 0), name);
- return_vals = gimp_run_procedure_with_array ("gimp-get-parasite",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-get-parasite",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-get-parasite",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -223,14 +253,20 @@ gimp_get_parasite (const gchar *name)
gchar **
gimp_get_parasite_list (gint *num_parasites)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar **parasites = NULL;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-get-parasite-list",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-get-parasite-list",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-get-parasite-list",
+ args);
gimp_value_array_unref (args);
*num_parasites = 0;
@@ -261,6 +297,7 @@ gimp_get_parasite_list (gint *num_parasites)
gchar *
gimp_temp_name (const gchar *extension)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *name = NULL;
@@ -269,8 +306,13 @@ gimp_temp_name (const gchar *extension)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-temp-name",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-temp-name",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
diff --git a/libgimp/gimpbrush_pdb.c b/libgimp/gimpbrush_pdb.c
index 0e909716ba..2e56332167 100644
--- a/libgimp/gimpbrush_pdb.c
+++ b/libgimp/gimpbrush_pdb.c
@@ -50,6 +50,7 @@
gchar *
gimp_brush_new (const gchar *name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *actual_name = NULL;
@@ -58,8 +59,13 @@ gimp_brush_new (const gchar *name)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-brush-new",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-brush-new",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -86,6 +92,7 @@ gimp_brush_new (const gchar *name)
gchar *
gimp_brush_duplicate (const gchar *name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *copy_name = NULL;
@@ -94,8 +101,13 @@ gimp_brush_duplicate (const gchar *name)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-brush-duplicate",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-brush-duplicate",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -121,6 +133,7 @@ gimp_brush_duplicate (const gchar *name)
gboolean
gimp_brush_is_generated (const gchar *name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean generated = FALSE;
@@ -129,8 +142,13 @@ gimp_brush_is_generated (const gchar *name)
G_TYPE_NONE);
g_value_set_string (gimp_value_array_index (args, 0), name);
- return_vals = gimp_run_procedure_with_array ("gimp-brush-is-generated",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-brush-is-generated",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-brush-is-generated",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -159,6 +177,7 @@ gchar *
gimp_brush_rename (const gchar *name,
const gchar *new_name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *actual_name = NULL;
@@ -169,8 +188,13 @@ gimp_brush_rename (const gchar *name,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-brush-rename",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-brush-rename",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -196,6 +220,7 @@ gimp_brush_rename (const gchar *name,
gboolean
gimp_brush_delete (const gchar *name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -204,8 +229,13 @@ gimp_brush_delete (const gchar *name)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-brush-delete",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-brush-delete",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -230,6 +260,7 @@ gimp_brush_delete (const gchar *name)
gboolean
gimp_brush_is_editable (const gchar *name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean editable = FALSE;
@@ -238,8 +269,13 @@ gimp_brush_is_editable (const gchar *name)
G_TYPE_NONE);
g_value_set_string (gimp_value_array_index (args, 0), name);
- return_vals = gimp_run_procedure_with_array ("gimp-brush-is-editable",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-brush-is-editable",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-brush-is-editable",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -274,6 +310,7 @@ gimp_brush_get_info (const gchar *name,
gint *mask_bpp,
gint *color_bpp)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -282,8 +319,13 @@ gimp_brush_get_info (const gchar *name,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-brush-get-info",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-brush-get-info",
+ args);
gimp_value_array_unref (args);
*width = 0;
@@ -338,6 +380,7 @@ gimp_brush_get_pixels (const gchar *name,
gint *num_color_bytes,
guint8 **color_bytes)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -346,8 +389,13 @@ gimp_brush_get_pixels (const gchar *name,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-brush-get-pixels",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-brush-get-pixels",
+ args);
gimp_value_array_unref (args);
*width = 0;
@@ -397,6 +445,7 @@ gboolean
gimp_brush_get_spacing (const gchar *name,
gint *spacing)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -405,8 +454,13 @@ gimp_brush_get_spacing (const gchar *name,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-brush-get-spacing",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-brush-get-spacing",
+ args);
gimp_value_array_unref (args);
*spacing = 0;
@@ -439,6 +493,7 @@ gboolean
gimp_brush_set_spacing (const gchar *name,
gint spacing)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -449,8 +504,13 @@ gimp_brush_set_spacing (const gchar *name,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-brush-set-spacing",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-brush-set-spacing",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -480,6 +540,7 @@ gimp_brush_set_spacing (const gchar *name,
GimpBrushGeneratedShape
gimp_brush_get_shape (const gchar *name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpBrushGeneratedShape shape = 0;
@@ -488,8 +549,13 @@ gimp_brush_get_shape (const gchar *name)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-brush-get-shape",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-brush-get-shape",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -522,6 +588,7 @@ GimpBrushGeneratedShape
gimp_brush_set_shape (const gchar *name,
GimpBrushGeneratedShape shape_in)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpBrushGeneratedShape shape_out = 0;
@@ -532,8 +599,13 @@ gimp_brush_set_shape (const gchar *name,
g_value_set_string (gimp_value_array_index (args, 0), name);
g_value_set_enum (gimp_value_array_index (args, 1), shape_in);
- return_vals = gimp_run_procedure_with_array ("gimp-brush-set-shape",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-brush-set-shape",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-brush-set-shape",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -560,6 +632,7 @@ gimp_brush_set_shape (const gchar *name,
gdouble
gimp_brush_get_radius (const gchar *name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble radius = 0.0;
@@ -568,8 +641,13 @@ gimp_brush_get_radius (const gchar *name)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-brush-get-radius",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-brush-get-radius",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -598,6 +676,7 @@ gdouble
gimp_brush_set_radius (const gchar *name,
gdouble radius_in)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble radius_out = 0.0;
@@ -608,8 +687,13 @@ gimp_brush_set_radius (const gchar *name,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-brush-set-radius",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-brush-set-radius",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -636,6 +720,7 @@ gimp_brush_set_radius (const gchar *name,
gint
gimp_brush_get_spikes (const gchar *name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint spikes = 0;
@@ -644,8 +729,13 @@ gimp_brush_get_spikes (const gchar *name)
G_TYPE_NONE);
g_value_set_string (gimp_value_array_index (args, 0), name);
- return_vals = gimp_run_procedure_with_array ("gimp-brush-get-spikes",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-brush-get-spikes",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-brush-get-spikes",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -674,6 +764,7 @@ gint
gimp_brush_set_spikes (const gchar *name,
gint spikes_in)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint spikes_out = 0;
@@ -684,8 +775,13 @@ gimp_brush_set_spikes (const gchar *name,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-brush-set-spikes",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-brush-set-spikes",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -714,6 +810,7 @@ gimp_brush_set_spikes (const gchar *name,
gdouble
gimp_brush_get_hardness (const gchar *name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble hardness = 0.0;
@@ -722,8 +819,13 @@ gimp_brush_get_hardness (const gchar *name)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-brush-get-hardness",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-brush-get-hardness",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -753,6 +855,7 @@ gdouble
gimp_brush_set_hardness (const gchar *name,
gdouble hardness_in)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble hardness_out = 0.0;
@@ -763,8 +866,13 @@ gimp_brush_set_hardness (const gchar *name,
g_value_set_string (gimp_value_array_index (args, 0), name);
g_value_set_double (gimp_value_array_index (args, 1), hardness_in);
- return_vals = gimp_run_procedure_with_array ("gimp-brush-set-hardness",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-brush-set-hardness",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-brush-set-hardness",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -792,6 +900,7 @@ gimp_brush_set_hardness (const gchar *name,
gdouble
gimp_brush_get_aspect_ratio (const gchar *name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble aspect_ratio = 0.0;
@@ -800,8 +909,13 @@ gimp_brush_get_aspect_ratio (const gchar *name)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-brush-get-aspect-ratio",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-brush-get-aspect-ratio",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -831,6 +945,7 @@ gdouble
gimp_brush_set_aspect_ratio (const gchar *name,
gdouble aspect_ratio_in)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble aspect_ratio_out = 0.0;
@@ -841,8 +956,13 @@ gimp_brush_set_aspect_ratio (const gchar *name,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-brush-set-aspect-ratio",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-brush-set-aspect-ratio",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -869,6 +989,7 @@ gimp_brush_set_aspect_ratio (const gchar *name,
gdouble
gimp_brush_get_angle (const gchar *name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble angle = 0.0;
@@ -877,8 +998,13 @@ gimp_brush_get_angle (const gchar *name)
G_TYPE_NONE);
g_value_set_string (gimp_value_array_index (args, 0), name);
- return_vals = gimp_run_procedure_with_array ("gimp-brush-get-angle",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-brush-get-angle",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-brush-get-angle",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -907,6 +1033,7 @@ gdouble
gimp_brush_set_angle (const gchar *name,
gdouble angle_in)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble angle_out = 0.0;
@@ -917,8 +1044,13 @@ gimp_brush_set_angle (const gchar *name,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-brush-set-angle",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-brush-set-angle",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
diff --git a/libgimp/gimpbrushes_pdb.c b/libgimp/gimpbrushes_pdb.c
index 34238a465d..55467c8e1c 100644
--- a/libgimp/gimpbrushes_pdb.c
+++ b/libgimp/gimpbrushes_pdb.c
@@ -47,14 +47,20 @@
gboolean
gimp_brushes_refresh (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-brushes-refresh",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-brushes-refresh",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-brushes-refresh",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -83,6 +89,7 @@ gchar **
gimp_brushes_get_list (const gchar *filter,
gint *num_brushes)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar **brush_list = NULL;
@@ -91,8 +98,13 @@ gimp_brushes_get_list (const gchar *filter,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-brushes-get-list",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-brushes-get-list",
+ args);
gimp_value_array_unref (args);
*num_brushes = 0;
diff --git a/libgimp/gimpbrushselect_pdb.c b/libgimp/gimpbrushselect_pdb.c
index de40e2e537..6cfa764fa9 100644
--- a/libgimp/gimpbrushselect_pdb.c
+++ b/libgimp/gimpbrushselect_pdb.c
@@ -57,6 +57,7 @@ gimp_brushes_popup (const gchar *brush_callback,
gint spacing,
GimpLayerMode paint_mode)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -75,8 +76,13 @@ gimp_brushes_popup (const gchar *brush_callback,
g_value_set_int (gimp_value_array_index (args, 4), spacing);
g_value_set_enum (gimp_value_array_index (args, 5), paint_mode);
- return_vals = gimp_run_procedure_with_array ("gimp-brushes-popup",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-brushes-popup",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-brushes-popup",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -99,6 +105,7 @@ gimp_brushes_popup (const gchar *brush_callback,
gboolean
gimp_brushes_close_popup (const gchar *brush_callback)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -107,8 +114,13 @@ gimp_brushes_close_popup (const gchar *brush_callback)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-brushes-close-popup",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-brushes-close-popup",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -139,6 +151,7 @@ gimp_brushes_set_popup (const gchar *brush_callback,
gint spacing,
GimpLayerMode paint_mode)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -155,8 +168,13 @@ gimp_brushes_set_popup (const gchar *brush_callback,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-brushes-set-popup",
+ args);
+ else
+ 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;
diff --git a/libgimp/gimpbuffer_pdb.c b/libgimp/gimpbuffer_pdb.c
index e55829dddc..7c3065bfd9 100644
--- a/libgimp/gimpbuffer_pdb.c
+++ b/libgimp/gimpbuffer_pdb.c
@@ -54,6 +54,7 @@ gchar **
gimp_buffers_get_list (const gchar *filter,
gint *num_buffers)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar **buffer_list = NULL;
@@ -62,8 +63,13 @@ gimp_buffers_get_list (const gchar *filter,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-buffers-get-list",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-buffers-get-list",
+ args);
gimp_value_array_unref (args);
*num_buffers = 0;
@@ -97,6 +103,7 @@ gchar *
gimp_buffer_rename (const gchar *buffer_name,
const gchar *new_name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *real_name = NULL;
@@ -107,8 +114,13 @@ gimp_buffer_rename (const gchar *buffer_name,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-buffer-rename",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-buffer-rename",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -134,6 +146,7 @@ gimp_buffer_rename (const gchar *buffer_name,
gboolean
gimp_buffer_delete (const gchar *buffer_name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -142,8 +155,13 @@ gimp_buffer_delete (const gchar *buffer_name)
G_TYPE_NONE);
g_value_set_string (gimp_value_array_index (args, 0), buffer_name);
- return_vals = gimp_run_procedure_with_array ("gimp-buffer-delete",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-buffer-delete",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-buffer-delete",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -168,6 +186,7 @@ gimp_buffer_delete (const gchar *buffer_name)
gint
gimp_buffer_get_width (const gchar *buffer_name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint width = 0;
@@ -176,8 +195,13 @@ gimp_buffer_get_width (const gchar *buffer_name)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-buffer-get-width",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-buffer-get-width",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -203,6 +227,7 @@ gimp_buffer_get_width (const gchar *buffer_name)
gint
gimp_buffer_get_height (const gchar *buffer_name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint height = 0;
@@ -211,8 +236,13 @@ gimp_buffer_get_height (const gchar *buffer_name)
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-height",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-buffer-get-height",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-buffer-get-height",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -238,6 +268,7 @@ gimp_buffer_get_height (const gchar *buffer_name)
gint
gimp_buffer_get_bytes (const gchar *buffer_name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint bytes = 0;
@@ -246,8 +277,13 @@ gimp_buffer_get_bytes (const gchar *buffer_name)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-buffer-get-bytes",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-buffer-get-bytes",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -273,6 +309,7 @@ gimp_buffer_get_bytes (const gchar *buffer_name)
GimpImageBaseType
gimp_buffer_get_image_type (const gchar *buffer_name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpImageBaseType image_type = 0;
@@ -281,8 +318,13 @@ gimp_buffer_get_image_type (const gchar *buffer_name)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-buffer-get-image-type",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-buffer-get-image-type",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
diff --git a/libgimp/gimpchannel_pdb.c b/libgimp/gimpchannel_pdb.c
index 1a4e8abb91..8fe3c34f9d 100644
--- a/libgimp/gimpchannel_pdb.c
+++ b/libgimp/gimpchannel_pdb.c
@@ -63,6 +63,7 @@ _gimp_channel_new (gint32 image_ID,
gdouble opacity,
const GimpRGB *color)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 channel_ID = -1;
@@ -81,8 +82,13 @@ _gimp_channel_new (gint32 image_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-channel-new",
+ args);
+ else
+ 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)
@@ -116,6 +122,7 @@ gimp_channel_new_from_component (gint32 image_ID,
GimpChannelType component,
const gchar *name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 channel_ID = -1;
@@ -128,8 +135,13 @@ gimp_channel_new_from_component (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-channel-new-from-component",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-channel-new-from-component",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -155,6 +167,7 @@ gimp_channel_new_from_component (gint32 image_ID,
gint32
gimp_channel_copy (gint32 channel_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 channel_copy_ID = -1;
@@ -163,8 +176,13 @@ gimp_channel_copy (gint32 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-copy",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-channel-copy",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-channel-copy",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -197,6 +215,7 @@ gimp_channel_combine_masks (gint32 channel1_ID,
gint offx,
gint offy)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -213,8 +232,13 @@ gimp_channel_combine_masks (gint32 channel1_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-channel-combine-masks",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-channel-combine-masks",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -239,6 +263,7 @@ gimp_channel_combine_masks (gint32 channel1_ID,
gboolean
gimp_channel_get_show_masked (gint32 channel_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean show_masked = FALSE;
@@ -247,8 +272,13 @@ gimp_channel_get_show_masked (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-channel-get-show-masked",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-channel-get-show-masked",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -276,6 +306,7 @@ gboolean
gimp_channel_set_show_masked (gint32 channel_ID,
gboolean show_masked)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -286,8 +317,13 @@ gimp_channel_set_show_masked (gint32 channel_ID,
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);
- return_vals = gimp_run_procedure_with_array ("gimp-channel-set-show-masked",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-channel-set-show-masked",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-channel-set-show-masked",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -310,6 +346,7 @@ gimp_channel_set_show_masked (gint32 channel_ID,
gdouble
gimp_channel_get_opacity (gint32 channel_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble opacity = 0.0;
@@ -318,8 +355,13 @@ gimp_channel_get_opacity (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-channel-get-opacity",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-channel-get-opacity",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -345,6 +387,7 @@ gboolean
gimp_channel_set_opacity (gint32 channel_ID,
gdouble opacity)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -355,8 +398,13 @@ gimp_channel_set_opacity (gint32 channel_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-channel-set-opacity",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-channel-set-opacity",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -381,6 +429,7 @@ gboolean
gimp_channel_get_color (gint32 channel_ID,
GimpRGB *color)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -389,8 +438,13 @@ gimp_channel_get_color (gint32 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-color",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-channel-get-color",
+ args);
+ else
+ 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;
@@ -418,6 +472,7 @@ gboolean
gimp_channel_set_color (gint32 channel_ID,
const GimpRGB *color)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -428,8 +483,13 @@ gimp_channel_set_color (gint32 channel_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-channel-set-color",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-channel-set-color",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
diff --git a/libgimp/gimpcontext_pdb.c b/libgimp/gimpcontext_pdb.c
index 0c39b156aa..85511edcf0 100644
--- a/libgimp/gimpcontext_pdb.c
+++ b/libgimp/gimpcontext_pdb.c
@@ -50,14 +50,20 @@
gboolean
gimp_context_push (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-push",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-push",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-push",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -84,14 +90,20 @@ gimp_context_push (void)
gboolean
gimp_context_pop (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-pop",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-pop",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-pop",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -119,14 +131,20 @@ gimp_context_pop (void)
gboolean
gimp_context_set_defaults (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-defaults",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-defaults",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-defaults",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -154,14 +172,20 @@ gboolean
gimp_context_list_paint_methods (gint *num_paint_methods,
gchar ***paint_methods)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-list-paint-methods",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-list-paint-methods",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-list-paint-methods",
+ args);
gimp_value_array_unref (args);
*num_paint_methods = 0;
@@ -196,14 +220,20 @@ gimp_context_list_paint_methods (gint *num_paint_methods,
gchar *
gimp_context_get_paint_method (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *name = NULL;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-paint-method",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-paint-method",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-paint-method",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -234,6 +264,7 @@ gimp_context_get_paint_method (void)
gboolean
gimp_context_set_paint_method (const gchar *name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -242,8 +273,13 @@ gimp_context_set_paint_method (const gchar *name)
G_TYPE_NONE);
g_value_set_string (gimp_value_array_index (args, 0), name);
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-paint-method",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-paint-method",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-paint-method",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -267,14 +303,20 @@ gimp_context_set_paint_method (const gchar *name)
GimpStrokeMethod
gimp_context_get_stroke_method (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpStrokeMethod stroke_method = 0;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-stroke-method",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-stroke-method",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-stroke-method",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -302,6 +344,7 @@ gimp_context_get_stroke_method (void)
gboolean
gimp_context_set_stroke_method (GimpStrokeMethod stroke_method)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -310,8 +353,13 @@ gimp_context_set_stroke_method (GimpStrokeMethod stroke_method)
G_TYPE_NONE);
g_value_set_enum (gimp_value_array_index (args, 0), stroke_method);
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-stroke-method",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-stroke-method",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-stroke-method",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -338,14 +386,20 @@ gimp_context_set_stroke_method (GimpStrokeMethod stroke_method)
gboolean
gimp_context_get_foreground (GimpRGB *foreground)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-foreground",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-foreground",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-foreground",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -375,6 +429,7 @@ gimp_context_get_foreground (GimpRGB *foreground)
gboolean
gimp_context_set_foreground (const GimpRGB *foreground)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -383,8 +438,13 @@ gimp_context_set_foreground (const GimpRGB *foreground)
G_TYPE_NONE);
gimp_value_set_rgb (gimp_value_array_index (args, 0), foreground);
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-foreground",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-foreground",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-foreground",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -411,14 +471,20 @@ gimp_context_set_foreground (const GimpRGB *foreground)
gboolean
gimp_context_get_background (GimpRGB *background)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-background",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-background",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-background",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -449,6 +515,7 @@ gimp_context_get_background (GimpRGB *background)
gboolean
gimp_context_set_background (const GimpRGB *background)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -457,8 +524,13 @@ gimp_context_set_background (const GimpRGB *background)
G_TYPE_NONE);
gimp_value_set_rgb (gimp_value_array_index (args, 0), background);
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-background",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-background",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-background",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -484,14 +556,20 @@ gimp_context_set_background (const GimpRGB *background)
gboolean
gimp_context_set_default_colors (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-default-colors",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-default-colors",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-default-colors",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -517,14 +595,20 @@ gimp_context_set_default_colors (void)
gboolean
gimp_context_swap_colors (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-swap-colors",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-swap-colors",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-swap-colors",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -549,14 +633,20 @@ gimp_context_swap_colors (void)
gdouble
gimp_context_get_opacity (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble opacity = 0.0;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-opacity",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-opacity",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-opacity",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -583,6 +673,7 @@ gimp_context_get_opacity (void)
gboolean
gimp_context_set_opacity (gdouble opacity)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -591,8 +682,13 @@ gimp_context_set_opacity (gdouble opacity)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-opacity",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-opacity",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -618,14 +714,20 @@ gimp_context_set_opacity (gdouble opacity)
GimpLayerMode
gimp_context_get_paint_mode (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpLayerMode paint_mode = 0;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-paint-mode",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-paint-mode",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-paint-mode",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -651,6 +753,7 @@ gimp_context_get_paint_mode (void)
gboolean
gimp_context_set_paint_mode (GimpLayerMode paint_mode)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -659,8 +762,13 @@ gimp_context_set_paint_mode (GimpLayerMode paint_mode)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-paint-mode",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-paint-mode",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -684,14 +792,20 @@ gimp_context_set_paint_mode (GimpLayerMode paint_mode)
gdouble
gimp_context_get_line_width (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble line_width = 0.0;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-line-width",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-line-width",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-line-width",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -721,6 +835,7 @@ gimp_context_get_line_width (void)
gboolean
gimp_context_set_line_width (gdouble line_width)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -729,8 +844,13 @@ gimp_context_set_line_width (gdouble line_width)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-line-width",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-line-width",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -754,14 +874,20 @@ gimp_context_set_line_width (gdouble line_width)
GimpUnit
gimp_context_get_line_width_unit (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpUnit line_width_unit = 0;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-line-width-unit",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-line-width-unit",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-line-width-unit",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -792,6 +918,7 @@ gimp_context_get_line_width_unit (void)
gboolean
gimp_context_set_line_width_unit (GimpUnit line_width_unit)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -800,8 +927,13 @@ gimp_context_set_line_width_unit (GimpUnit line_width_unit)
G_TYPE_NONE);
g_value_set_int (gimp_value_array_index (args, 0), line_width_unit);
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-line-width-unit",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-line-width-unit",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-line-width-unit",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -825,14 +957,20 @@ gimp_context_set_line_width_unit (GimpUnit line_width_unit)
GimpCapStyle
gimp_context_get_line_cap_style (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpCapStyle cap_style = 0;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-line-cap-style",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-line-cap-style",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-line-cap-style",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -863,6 +1001,7 @@ gimp_context_get_line_cap_style (void)
gboolean
gimp_context_set_line_cap_style (GimpCapStyle cap_style)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -871,8 +1010,13 @@ gimp_context_set_line_cap_style (GimpCapStyle cap_style)
G_TYPE_NONE);
g_value_set_enum (gimp_value_array_index (args, 0), cap_style);
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-line-cap-style",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-line-cap-style",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-line-cap-style",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -896,14 +1040,20 @@ gimp_context_set_line_cap_style (GimpCapStyle cap_style)
GimpJoinStyle
gimp_context_get_line_join_style (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpJoinStyle join_style = 0;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-line-join-style",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-line-join-style",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-line-join-style",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -934,6 +1084,7 @@ gimp_context_get_line_join_style (void)
gboolean
gimp_context_set_line_join_style (GimpJoinStyle join_style)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -942,8 +1093,13 @@ gimp_context_set_line_join_style (GimpJoinStyle join_style)
G_TYPE_NONE);
g_value_set_enum (gimp_value_array_index (args, 0), join_style);
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-line-join-style",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-line-join-style",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-line-join-style",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -967,14 +1123,20 @@ gimp_context_set_line_join_style (GimpJoinStyle join_style)
gdouble
gimp_context_get_line_miter_limit (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble miter_limit = 0.0;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-line-miter-limit",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-line-miter-limit",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-line-miter-limit",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -1008,6 +1170,7 @@ gimp_context_get_line_miter_limit (void)
gboolean
gimp_context_set_line_miter_limit (gdouble miter_limit)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1016,8 +1179,13 @@ gimp_context_set_line_miter_limit (gdouble miter_limit)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-line-miter-limit",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-line-miter-limit",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1041,14 +1209,20 @@ gimp_context_set_line_miter_limit (gdouble miter_limit)
gdouble
gimp_context_get_line_dash_offset (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble dash_offset = 0.0;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-line-dash-offset",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-line-dash-offset",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-line-dash-offset",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -1079,6 +1253,7 @@ gimp_context_get_line_dash_offset (void)
gboolean
gimp_context_set_line_dash_offset (gdouble dash_offset)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1087,8 +1262,13 @@ gimp_context_set_line_dash_offset (gdouble dash_offset)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-line-dash-offset",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-line-dash-offset",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1115,14 +1295,20 @@ gboolean
gimp_context_get_line_dash_pattern (gint *num_dashes,
gdouble **dashes)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-line-dash-pattern",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-line-dash-pattern",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-line-dash-pattern",
+ args);
gimp_value_array_unref (args);
*num_dashes = 0;
@@ -1167,6 +1353,7 @@ gboolean
gimp_context_set_line_dash_pattern (gint num_dashes,
const gdouble *dashes)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1177,8 +1364,13 @@ gimp_context_set_line_dash_pattern (gint num_dashes,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-line-dash-pattern",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-line-dash-pattern",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1205,14 +1397,20 @@ gimp_context_set_line_dash_pattern (gint num_dashes,
gchar *
gimp_context_get_brush (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *name = NULL;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-brush",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-brush",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-brush",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -1242,6 +1440,7 @@ gimp_context_get_brush (void)
gboolean
gimp_context_set_brush (const gchar *name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1250,8 +1449,13 @@ gimp_context_set_brush (const gchar *name)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-brush",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-brush",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1275,14 +1479,20 @@ gimp_context_set_brush (const gchar *name)
gdouble
gimp_context_get_brush_size (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble size = 0.0;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-brush-size",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-brush-size",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-brush-size",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -1308,6 +1518,7 @@ gimp_context_get_brush_size (void)
gboolean
gimp_context_set_brush_size (gdouble size)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1316,8 +1527,13 @@ gimp_context_set_brush_size (gdouble size)
G_TYPE_NONE);
g_value_set_double (gimp_value_array_index (args, 0), size);
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-brush-size",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-brush-size",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-brush-size",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1342,14 +1558,20 @@ gimp_context_set_brush_size (gdouble size)
gboolean
gimp_context_set_brush_default_size (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-brush-default-size",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-brush-default-size",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-brush-default-size",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1373,14 +1595,20 @@ gimp_context_set_brush_default_size (void)
gdouble
gimp_context_get_brush_aspect_ratio (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble aspect = 0.0;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-brush-aspect-ratio",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-brush-aspect-ratio",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-brush-aspect-ratio",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -1406,6 +1634,7 @@ gimp_context_get_brush_aspect_ratio (void)
gboolean
gimp_context_set_brush_aspect_ratio (gdouble aspect)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1414,8 +1643,13 @@ gimp_context_set_brush_aspect_ratio (gdouble aspect)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-brush-aspect-ratio",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-brush-aspect-ratio",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1439,14 +1673,20 @@ gimp_context_set_brush_aspect_ratio (gdouble aspect)
gdouble
gimp_context_get_brush_angle (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble angle = 0.0;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-brush-angle",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-brush-angle",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-brush-angle",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -1472,6 +1712,7 @@ gimp_context_get_brush_angle (void)
gboolean
gimp_context_set_brush_angle (gdouble angle)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1480,8 +1721,13 @@ gimp_context_set_brush_angle (gdouble angle)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-brush-angle",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-brush-angle",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1506,14 +1752,20 @@ gimp_context_set_brush_angle (gdouble angle)
gdouble
gimp_context_get_brush_spacing (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble spacing = 0.0;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-brush-spacing",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-brush-spacing",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-brush-spacing",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -1540,6 +1792,7 @@ gimp_context_get_brush_spacing (void)
gboolean
gimp_context_set_brush_spacing (gdouble spacing)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1548,8 +1801,13 @@ gimp_context_set_brush_spacing (gdouble spacing)
G_TYPE_NONE);
g_value_set_double (gimp_value_array_index (args, 0), spacing);
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-brush-spacing",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-brush-spacing",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-brush-spacing",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1574,14 +1832,20 @@ gimp_context_set_brush_spacing (gdouble spacing)
gboolean
gimp_context_set_brush_default_spacing (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-brush-default-spacing",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-brush-default-spacing",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-brush-default-spacing",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1605,14 +1869,20 @@ gimp_context_set_brush_default_spacing (void)
gdouble
gimp_context_get_brush_hardness (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble hardness = 0.0;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-brush-hardness",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-brush-hardness",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-brush-hardness",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -1638,6 +1908,7 @@ gimp_context_get_brush_hardness (void)
gboolean
gimp_context_set_brush_hardness (gdouble hardness)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1646,8 +1917,13 @@ gimp_context_set_brush_hardness (gdouble hardness)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-brush-hardness",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-brush-hardness",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1672,14 +1948,20 @@ gimp_context_set_brush_hardness (gdouble hardness)
gboolean
gimp_context_set_brush_default_hardness (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-brush-default-hardness",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-brush-default-hardness",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-brush-default-hardness",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1703,14 +1985,20 @@ gimp_context_set_brush_default_hardness (void)
gdouble
gimp_context_get_brush_force (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble force = 0.0;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-brush-force",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-brush-force",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-brush-force",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -1736,6 +2024,7 @@ gimp_context_get_brush_force (void)
gboolean
gimp_context_set_brush_force (gdouble force)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1744,8 +2033,13 @@ gimp_context_set_brush_force (gdouble force)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-brush-force",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-brush-force",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1772,14 +2066,20 @@ gimp_context_set_brush_force (gdouble force)
gchar *
gimp_context_get_dynamics (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *name = NULL;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-dynamics",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-dynamics",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-dynamics",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -1810,6 +2110,7 @@ gimp_context_get_dynamics (void)
gboolean
gimp_context_set_dynamics (const gchar *name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1818,8 +2119,13 @@ gimp_context_set_dynamics (const gchar *name)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-dynamics",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-dynamics",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1845,14 +2151,20 @@ gimp_context_set_dynamics (const gchar *name)
gchar *
gimp_context_get_mypaint_brush (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *name = NULL;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-mypaint-brush",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-mypaint-brush",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-mypaint-brush",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -1883,6 +2195,7 @@ gimp_context_get_mypaint_brush (void)
gboolean
gimp_context_set_mypaint_brush (const gchar *name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1891,8 +2204,13 @@ gimp_context_set_mypaint_brush (const gchar *name)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-mypaint-brush",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-mypaint-brush",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1919,14 +2237,20 @@ gimp_context_set_mypaint_brush (const gchar *name)
gchar *
gimp_context_get_pattern (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *name = NULL;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-pattern",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-pattern",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-pattern",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -1957,6 +2281,7 @@ gimp_context_get_pattern (void)
gboolean
gimp_context_set_pattern (const gchar *name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1965,8 +2290,13 @@ gimp_context_set_pattern (const gchar *name)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-pattern",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-pattern",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1991,14 +2321,20 @@ gimp_context_set_pattern (const gchar *name)
gchar *
gimp_context_get_gradient (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *name = NULL;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-gradient",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-gradient",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-gradient",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -2029,6 +2365,7 @@ gimp_context_get_gradient (void)
gboolean
gimp_context_set_gradient (const gchar *name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -2037,8 +2374,13 @@ gimp_context_set_gradient (const gchar *name)
G_TYPE_NONE);
g_value_set_string (gimp_value_array_index (args, 0), name);
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-gradient",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-gradient",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-gradient",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -2064,14 +2406,20 @@ gimp_context_set_gradient (const gchar *name)
gboolean
gimp_context_set_gradient_fg_bg_rgb (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-gradient-fg-bg-rgb",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-gradient-fg-bg-rgb",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -2097,14 +2445,20 @@ gimp_context_set_gradient_fg_bg_rgb (void)
gboolean
gimp_context_set_gradient_fg_bg_hsv_cw (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-gradient-fg-bg-hsv-cw",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-gradient-fg-bg-hsv-cw",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-gradient-fg-bg-hsv-cw",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -2130,14 +2484,20 @@ gimp_context_set_gradient_fg_bg_hsv_cw (void)
gboolean
gimp_context_set_gradient_fg_bg_hsv_ccw (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-gradient-fg-bg-hsv-ccw",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-gradient-fg-bg-hsv-ccw",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -2163,14 +2523,20 @@ gimp_context_set_gradient_fg_bg_hsv_ccw (void)
gboolean
gimp_context_set_gradient_fg_transparent (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-gradient-fg-transparent",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-gradient-fg-transparent",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-gradient-fg-transparent",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -2195,14 +2561,20 @@ gimp_context_set_gradient_fg_transparent (void)
GimpGradientBlendColorSpace
gimp_context_get_gradient_blend_color_space (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpGradientBlendColorSpace blend_color_space = 0;
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-gradient-blend-color-space",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-gradient-blend-color-space",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -2229,6 +2601,7 @@ gimp_context_get_gradient_blend_color_space (void)
gboolean
gimp_context_set_gradient_blend_color_space (GimpGradientBlendColorSpace blend_color_space)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -2237,8 +2610,13 @@ gimp_context_set_gradient_blend_color_space (GimpGradientBlendColorSpace blend_c
G_TYPE_NONE);
g_value_set_enum (gimp_value_array_index (args, 0), blend_color_space);
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-gradient-blend-color-space",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-gradient-blend-color-space",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-gradient-blend-color-space",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -2262,14 +2640,20 @@ gimp_context_set_gradient_blend_color_space (GimpGradientBlendColorSpace blend_c
GimpRepeatMode
gimp_context_get_gradient_repeat_mode (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpRepeatMode repeat_mode = 0;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-gradient-repeat-mode",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-gradient-repeat-mode",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-gradient-repeat-mode",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -2295,6 +2679,7 @@ gimp_context_get_gradient_repeat_mode (void)
gboolean
gimp_context_set_gradient_repeat_mode (GimpRepeatMode repeat_mode)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -2303,8 +2688,13 @@ gimp_context_set_gradient_repeat_mode (GimpRepeatMode repeat_mode)
G_TYPE_NONE);
g_value_set_enum (gimp_value_array_index (args, 0), repeat_mode);
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-gradient-repeat-mode",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-gradient-repeat-mode",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-gradient-repeat-mode",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -2329,14 +2719,20 @@ gimp_context_set_gradient_repeat_mode (GimpRepeatMode repeat_mode)
gboolean
gimp_context_get_gradient_reverse (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean reverse = FALSE;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-gradient-reverse",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-gradient-reverse",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-gradient-reverse",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -2363,6 +2759,7 @@ gimp_context_get_gradient_reverse (void)
gboolean
gimp_context_set_gradient_reverse (gboolean reverse)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -2371,8 +2768,13 @@ gimp_context_set_gradient_reverse (gboolean reverse)
G_TYPE_NONE);
g_value_set_boolean (gimp_value_array_index (args, 0), reverse);
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-gradient-reverse",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-gradient-reverse",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-gradient-reverse",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -2397,14 +2799,20 @@ gimp_context_set_gradient_reverse (gboolean reverse)
gchar *
gimp_context_get_palette (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *name = NULL;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-palette",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-palette",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-palette",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -2435,6 +2843,7 @@ gimp_context_get_palette (void)
gboolean
gimp_context_set_palette (const gchar *name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -2443,8 +2852,13 @@ gimp_context_set_palette (const gchar *name)
G_TYPE_NONE);
g_value_set_string (gimp_value_array_index (args, 0), name);
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-palette",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-palette",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-palette",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -2469,14 +2883,20 @@ gimp_context_set_palette (const gchar *name)
gchar *
gimp_context_get_font (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *name = NULL;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-font",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-font",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-font",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -2506,6 +2926,7 @@ gimp_context_get_font (void)
gboolean
gimp_context_set_font (const gchar *name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -2514,8 +2935,13 @@ gimp_context_set_font (const gchar *name)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-font",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-font",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -2539,14 +2965,20 @@ gimp_context_set_font (const gchar *name)
gboolean
gimp_context_get_antialias (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean antialias = FALSE;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-antialias",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-antialias",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-antialias",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -2583,6 +3015,7 @@ gimp_context_get_antialias (void)
gboolean
gimp_context_set_antialias (gboolean antialias)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -2591,8 +3024,13 @@ gimp_context_set_antialias (gboolean antialias)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-antialias",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-antialias",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -2616,14 +3054,20 @@ gimp_context_set_antialias (gboolean antialias)
gboolean
gimp_context_get_feather (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean feather = FALSE;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-feather",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-feather",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-feather",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -2658,6 +3102,7 @@ gimp_context_get_feather (void)
gboolean
gimp_context_set_feather (gboolean feather)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -2666,8 +3111,13 @@ gimp_context_set_feather (gboolean feather)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-feather",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-feather",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -2694,14 +3144,20 @@ gboolean
gimp_context_get_feather_radius (gdouble *feather_radius_x,
gdouble *feather_radius_y)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-feather-radius",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-feather-radius",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-feather-radius",
+ args);
gimp_value_array_unref (args);
*feather_radius_x = 0.0;
@@ -2740,6 +3196,7 @@ gboolean
gimp_context_set_feather_radius (gdouble feather_radius_x,
gdouble feather_radius_y)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -2750,8 +3207,13 @@ gimp_context_set_feather_radius (gdouble feather_radius_x,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-feather-radius",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-feather-radius",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -2775,14 +3237,20 @@ gimp_context_set_feather_radius (gdouble feather_radius_x,
gboolean
gimp_context_get_sample_merged (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean sample_merged = FALSE;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-sample-merged",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-sample-merged",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-sample-merged",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -2818,6 +3286,7 @@ gimp_context_get_sample_merged (void)
gboolean
gimp_context_set_sample_merged (gboolean sample_merged)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -2826,8 +3295,13 @@ gimp_context_set_sample_merged (gboolean sample_merged)
G_TYPE_NONE);
g_value_set_boolean (gimp_value_array_index (args, 0), sample_merged);
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-sample-merged",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-sample-merged",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-sample-merged",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -2851,14 +3325,20 @@ gimp_context_set_sample_merged (gboolean sample_merged)
GimpSelectCriterion
gimp_context_get_sample_criterion (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpSelectCriterion sample_criterion = 0;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-sample-criterion",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-sample-criterion",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-sample-criterion",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -2892,6 +3372,7 @@ gimp_context_get_sample_criterion (void)
gboolean
gimp_context_set_sample_criterion (GimpSelectCriterion sample_criterion)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -2900,8 +3381,13 @@ gimp_context_set_sample_criterion (GimpSelectCriterion sample_criterion)
G_TYPE_NONE);
g_value_set_enum (gimp_value_array_index (args, 0), sample_criterion);
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-sample-criterion",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-sample-criterion",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-sample-criterion",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -2925,14 +3411,20 @@ gimp_context_set_sample_criterion (GimpSelectCriterion sample_criterion)
gdouble
gimp_context_get_sample_threshold (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble sample_threshold = 0.0;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-sample-threshold",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-sample-threshold",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-sample-threshold",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -2967,6 +3459,7 @@ gimp_context_get_sample_threshold (void)
gboolean
gimp_context_set_sample_threshold (gdouble sample_threshold)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -2975,8 +3468,13 @@ gimp_context_set_sample_threshold (gdouble sample_threshold)
G_TYPE_NONE);
g_value_set_double (gimp_value_array_index (args, 0), sample_threshold);
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-sample-threshold",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-sample-threshold",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-sample-threshold",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -3001,14 +3499,20 @@ gimp_context_set_sample_threshold (gdouble sample_threshold)
gint
gimp_context_get_sample_threshold_int (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint sample_threshold = 0;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-sample-threshold-int",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-sample-threshold-int",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-sample-threshold-int",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -3035,6 +3539,7 @@ gimp_context_get_sample_threshold_int (void)
gboolean
gimp_context_set_sample_threshold_int (gint sample_threshold)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -3043,8 +3548,13 @@ gimp_context_set_sample_threshold_int (gint sample_threshold)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-sample-threshold-int",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-sample-threshold-int",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -3068,14 +3578,20 @@ gimp_context_set_sample_threshold_int (gint sample_threshold)
gboolean
gimp_context_get_sample_transparent (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean sample_transparent = FALSE;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-sample-transparent",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-sample-transparent",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-sample-transparent",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -3109,6 +3625,7 @@ gimp_context_get_sample_transparent (void)
gboolean
gimp_context_set_sample_transparent (gboolean sample_transparent)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -3117,8 +3634,13 @@ gimp_context_set_sample_transparent (gboolean sample_transparent)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-sample-transparent",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-sample-transparent",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -3142,14 +3664,20 @@ gimp_context_set_sample_transparent (gboolean sample_transparent)
gboolean
gimp_context_get_diagonal_neighbors (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean diagonal_neighbors = FALSE;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-diagonal-neighbors",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-diagonal-neighbors",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-diagonal-neighbors",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -3184,6 +3712,7 @@ gimp_context_get_diagonal_neighbors (void)
gboolean
gimp_context_set_diagonal_neighbors (gboolean diagonal_neighbors)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -3192,8 +3721,13 @@ gimp_context_set_diagonal_neighbors (gboolean diagonal_neighbors)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-diagonal-neighbors",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-diagonal-neighbors",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -3218,14 +3752,20 @@ gimp_context_set_diagonal_neighbors (gboolean diagonal_neighbors)
GeglDistanceMetric
gimp_context_get_distance_metric (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GeglDistanceMetric metric = 0;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-distance-metric",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-distance-metric",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-distance-metric",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -3257,6 +3797,7 @@ gimp_context_get_distance_metric (void)
gboolean
gimp_context_set_distance_metric (GeglDistanceMetric metric)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -3265,8 +3806,13 @@ gimp_context_set_distance_metric (GeglDistanceMetric metric)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-distance-metric",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-distance-metric",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -3294,14 +3840,20 @@ gimp_context_set_distance_metric (GeglDistanceMetric metric)
GimpInterpolationType
gimp_context_get_interpolation (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpInterpolationType interpolation = 0;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-interpolation",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-interpolation",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-interpolation",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -3334,6 +3886,7 @@ gimp_context_get_interpolation (void)
gboolean
gimp_context_set_interpolation (GimpInterpolationType interpolation)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -3342,8 +3895,13 @@ gimp_context_set_interpolation (GimpInterpolationType interpolation)
G_TYPE_NONE);
g_value_set_enum (gimp_value_array_index (args, 0), interpolation);
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-interpolation",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-interpolation",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-interpolation",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -3369,14 +3927,20 @@ gimp_context_set_interpolation (GimpInterpolationType interpolation)
GimpTransformDirection
gimp_context_get_transform_direction (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpTransformDirection transform_direction = 0;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-transform-direction",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-transform-direction",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-transform-direction",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -3408,6 +3972,7 @@ gimp_context_get_transform_direction (void)
gboolean
gimp_context_set_transform_direction (GimpTransformDirection transform_direction)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -3416,8 +3981,13 @@ gimp_context_set_transform_direction (GimpTransformDirection transform_direction
G_TYPE_NONE);
g_value_set_enum (gimp_value_array_index (args, 0), transform_direction);
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-transform-direction",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-transform-direction",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-transform-direction",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -3443,14 +4013,20 @@ gimp_context_set_transform_direction (GimpTransformDirection transform_direction
GimpTransformResize
gimp_context_get_transform_resize (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpTransformResize transform_resize = 0;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-transform-resize",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-transform-resize",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-transform-resize",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -3486,6 +4062,7 @@ gimp_context_get_transform_resize (void)
gboolean
gimp_context_set_transform_resize (GimpTransformResize transform_resize)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -3494,8 +4071,13 @@ gimp_context_set_transform_resize (GimpTransformResize transform_resize)
G_TYPE_NONE);
g_value_set_enum (gimp_value_array_index (args, 0), transform_resize);
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-transform-resize",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-transform-resize",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-transform-resize",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -3519,14 +4101,20 @@ gimp_context_set_transform_resize (GimpTransformResize transform_resize)
gdouble
gimp_context_get_ink_size (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble size = 0.0;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-ink-size",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-ink-size",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-ink-size",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -3552,6 +4140,7 @@ gimp_context_get_ink_size (void)
gboolean
gimp_context_set_ink_size (gdouble size)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -3560,8 +4149,13 @@ gimp_context_set_ink_size (gdouble size)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-ink-size",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-ink-size",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -3585,14 +4179,20 @@ gimp_context_set_ink_size (gdouble size)
gdouble
gimp_context_get_ink_angle (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble angle = 0.0;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-ink-angle",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-ink-angle",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-ink-angle",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -3618,6 +4218,7 @@ gimp_context_get_ink_angle (void)
gboolean
gimp_context_set_ink_angle (gdouble angle)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -3626,8 +4227,13 @@ gimp_context_set_ink_angle (gdouble angle)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-ink-angle",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-ink-angle",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -3651,14 +4257,20 @@ gimp_context_set_ink_angle (gdouble angle)
gdouble
gimp_context_get_ink_size_sensitivity (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble size = 0.0;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-ink-size-sensitivity",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-ink-size-sensitivity",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-ink-size-sensitivity",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -3684,6 +4296,7 @@ gimp_context_get_ink_size_sensitivity (void)
gboolean
gimp_context_set_ink_size_sensitivity (gdouble size)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -3692,8 +4305,13 @@ gimp_context_set_ink_size_sensitivity (gdouble size)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-ink-size-sensitivity",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-ink-size-sensitivity",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -3717,14 +4335,20 @@ gimp_context_set_ink_size_sensitivity (gdouble size)
gdouble
gimp_context_get_ink_tilt_sensitivity (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble tilt = 0.0;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-ink-tilt-sensitivity",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-ink-tilt-sensitivity",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-ink-tilt-sensitivity",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -3750,6 +4374,7 @@ gimp_context_get_ink_tilt_sensitivity (void)
gboolean
gimp_context_set_ink_tilt_sensitivity (gdouble tilt)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -3758,8 +4383,13 @@ gimp_context_set_ink_tilt_sensitivity (gdouble tilt)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-ink-tilt-sensitivity",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-ink-tilt-sensitivity",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -3783,14 +4413,20 @@ gimp_context_set_ink_tilt_sensitivity (gdouble tilt)
gdouble
gimp_context_get_ink_speed_sensitivity (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble speed = 0.0;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-ink-speed-sensitivity",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-ink-speed-sensitivity",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-ink-speed-sensitivity",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -3816,6 +4452,7 @@ gimp_context_get_ink_speed_sensitivity (void)
gboolean
gimp_context_set_ink_speed_sensitivity (gdouble speed)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -3824,8 +4461,13 @@ gimp_context_set_ink_speed_sensitivity (gdouble speed)
G_TYPE_NONE);
g_value_set_double (gimp_value_array_index (args, 0), speed);
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-ink-speed-sensitivity",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-ink-speed-sensitivity",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-ink-speed-sensitivity",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -3849,14 +4491,20 @@ gimp_context_set_ink_speed_sensitivity (gdouble speed)
GimpInkBlobType
gimp_context_get_ink_blob_type (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpInkBlobType type = 0;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-ink-blob-type",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-ink-blob-type",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-ink-blob-type",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -3882,6 +4530,7 @@ gimp_context_get_ink_blob_type (void)
gboolean
gimp_context_set_ink_blob_type (GimpInkBlobType type)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -3890,8 +4539,13 @@ gimp_context_set_ink_blob_type (GimpInkBlobType type)
G_TYPE_NONE);
g_value_set_enum (gimp_value_array_index (args, 0), type);
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-ink-blob-type",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-ink-blob-type",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-ink-blob-type",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -3915,14 +4569,20 @@ gimp_context_set_ink_blob_type (GimpInkBlobType type)
gdouble
gimp_context_get_ink_blob_aspect_ratio (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble aspect = 0.0;
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-ink-blob-aspect-ratio",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-ink-blob-aspect-ratio",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -3948,6 +4608,7 @@ gimp_context_get_ink_blob_aspect_ratio (void)
gboolean
gimp_context_set_ink_blob_aspect_ratio (gdouble aspect)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -3956,8 +4617,13 @@ gimp_context_set_ink_blob_aspect_ratio (gdouble aspect)
G_TYPE_NONE);
g_value_set_double (gimp_value_array_index (args, 0), aspect);
- return_vals = gimp_run_procedure_with_array ("gimp-context-set-ink-blob-aspect-ratio",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-ink-blob-aspect-ratio",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-ink-blob-aspect-ratio",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -3981,14 +4647,20 @@ gimp_context_set_ink_blob_aspect_ratio (gdouble aspect)
gdouble
gimp_context_get_ink_blob_angle (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble angle = 0.0;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-context-get-ink-blob-angle",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-get-ink-blob-angle",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-get-ink-blob-angle",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -4014,6 +4686,7 @@ gimp_context_get_ink_blob_angle (void)
gboolean
gimp_context_set_ink_blob_angle (gdouble angle)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -4022,8 +4695,13 @@ gimp_context_set_ink_blob_angle (gdouble angle)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-context-set-ink-blob-angle",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-context-set-ink-blob-angle",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
diff --git a/libgimp/gimpdebug_pdb.c b/libgimp/gimpdebug_pdb.c
index 621f5a11c4..124d439ee1 100644
--- a/libgimp/gimpdebug_pdb.c
+++ b/libgimp/gimpdebug_pdb.c
@@ -54,14 +54,20 @@
gboolean
gimp_debug_timer_start (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-debug-timer-start",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-debug-timer-start",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-debug-timer-start",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -90,14 +96,20 @@ gimp_debug_timer_start (void)
gdouble
gimp_debug_timer_end (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble elapsed = 0.0;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-debug-timer-end",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-debug-timer-end",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-debug-timer-end",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
diff --git a/libgimp/gimpdisplay_pdb.c b/libgimp/gimpdisplay_pdb.c
index b5fd724b9c..53fedc895f 100644
--- a/libgimp/gimpdisplay_pdb.c
+++ b/libgimp/gimpdisplay_pdb.c
@@ -50,6 +50,7 @@
gboolean
gimp_display_is_valid (gint32 display_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean valid = FALSE;
@@ -58,8 +59,13 @@ gimp_display_is_valid (gint32 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-is-valid",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-display-is-valid",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-display-is-valid",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -88,6 +94,7 @@ gimp_display_is_valid (gint32 display_ID)
gint32
gimp_display_new (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 display_ID = -1;
@@ -96,8 +103,13 @@ gimp_display_new (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-display-new",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-display-new",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -125,6 +137,7 @@ gimp_display_new (gint32 image_ID)
gboolean
gimp_display_delete (gint32 display_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -133,8 +146,13 @@ gimp_display_delete (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-display-delete",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-display-delete",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -163,6 +181,7 @@ gimp_display_delete (gint32 display_ID)
gint
gimp_display_get_window_handle (gint32 display_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint window = 0;
@@ -171,8 +190,13 @@ gimp_display_get_window_handle (gint32 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-get-window-handle",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-display-get-window-handle",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-display-get-window-handle",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -198,14 +222,20 @@ gimp_display_get_window_handle (gint32 display_ID)
gboolean
gimp_displays_flush (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-displays-flush",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-displays-flush",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-displays-flush",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -233,6 +263,7 @@ gboolean
gimp_displays_reconnect (gint32 old_image_ID,
gint32 new_image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -243,8 +274,13 @@ gimp_displays_reconnect (gint32 old_image_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-displays-reconnect",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-displays-reconnect",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
diff --git a/libgimp/gimpdrawable_pdb.c b/libgimp/gimpdrawable_pdb.c
index 399f5693d8..caa070bb85 100644
--- a/libgimp/gimpdrawable_pdb.c
+++ b/libgimp/gimpdrawable_pdb.c
@@ -53,6 +53,7 @@
gchar *
_gimp_drawable_get_format (gint32 drawable_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *format = NULL;
@@ -61,8 +62,13 @@ _gimp_drawable_get_format (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-drawable-get-format",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-get-format",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -91,6 +97,7 @@ _gimp_drawable_get_format (gint32 drawable_ID)
gchar *
_gimp_drawable_get_thumbnail_format (gint32 drawable_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *format = NULL;
@@ -99,8 +106,13 @@ _gimp_drawable_get_thumbnail_format (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-drawable-get-thumbnail-format",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-get-thumbnail-format",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -124,6 +136,7 @@ _gimp_drawable_get_thumbnail_format (gint32 drawable_ID)
GimpImageType
gimp_drawable_type (gint32 drawable_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpImageType type = 0;
@@ -132,8 +145,13 @@ gimp_drawable_type (gint32 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",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-drawable-type",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-type",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -160,6 +178,7 @@ gimp_drawable_type (gint32 drawable_ID)
GimpImageType
gimp_drawable_type_with_alpha (gint32 drawable_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpImageType type_with_alpha = 0;
@@ -168,8 +187,13 @@ gimp_drawable_type_with_alpha (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-drawable-type-with-alpha",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-type-with-alpha",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -195,6 +219,7 @@ gimp_drawable_type_with_alpha (gint32 drawable_ID)
gboolean
gimp_drawable_has_alpha (gint32 drawable_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean has_alpha = FALSE;
@@ -203,8 +228,13 @@ gimp_drawable_has_alpha (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-drawable-has-alpha",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-has-alpha",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -229,6 +259,7 @@ gimp_drawable_has_alpha (gint32 drawable_ID)
gboolean
gimp_drawable_is_rgb (gint32 drawable_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean is_rgb = FALSE;
@@ -237,8 +268,13 @@ gimp_drawable_is_rgb (gint32 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-rgb",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-drawable-is-rgb",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-is-rgb",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -263,6 +299,7 @@ gimp_drawable_is_rgb (gint32 drawable_ID)
gboolean
gimp_drawable_is_gray (gint32 drawable_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean is_gray = FALSE;
@@ -271,8 +308,13 @@ gimp_drawable_is_gray (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-drawable-is-gray",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-is-gray",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -297,6 +339,7 @@ gimp_drawable_is_gray (gint32 drawable_ID)
gboolean
gimp_drawable_is_indexed (gint32 drawable_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean is_indexed = FALSE;
@@ -305,8 +348,13 @@ gimp_drawable_is_indexed (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-drawable-is-indexed",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-is-indexed",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -330,6 +378,7 @@ gimp_drawable_is_indexed (gint32 drawable_ID)
gint
gimp_drawable_bpp (gint32 drawable_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint bpp = 0;
@@ -338,8 +387,13 @@ gimp_drawable_bpp (gint32 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-bpp",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-drawable-bpp",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-bpp",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -363,6 +417,7 @@ gimp_drawable_bpp (gint32 drawable_ID)
gint
gimp_drawable_width (gint32 drawable_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint width = 0;
@@ -371,8 +426,13 @@ gimp_drawable_width (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-drawable-width",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-width",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -396,6 +456,7 @@ gimp_drawable_width (gint32 drawable_ID)
gint
gimp_drawable_height (gint32 drawable_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint height = 0;
@@ -404,8 +465,13 @@ gimp_drawable_height (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-drawable-height",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-height",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -435,6 +501,7 @@ gimp_drawable_offsets (gint32 drawable_ID,
gint *offset_x,
gint *offset_y)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -443,8 +510,13 @@ gimp_drawable_offsets (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-drawable-offsets",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-offsets",
+ args);
gimp_value_array_unref (args);
*offset_x = 0;
@@ -496,6 +568,7 @@ gimp_drawable_mask_bounds (gint32 drawable_ID,
gint *x2,
gint *y2)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean non_empty = FALSE;
@@ -504,8 +577,13 @@ gimp_drawable_mask_bounds (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-drawable-mask-bounds",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-mask-bounds",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -550,6 +628,7 @@ gimp_drawable_mask_intersect (gint32 drawable_ID,
gint *width,
gint *height)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean non_empty = FALSE;
@@ -558,8 +637,13 @@ gimp_drawable_mask_intersect (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-drawable-mask-intersect",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-mask-intersect",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -594,6 +678,7 @@ gboolean
gimp_drawable_merge_shadow (gint32 drawable_ID,
gboolean undo)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -604,8 +689,13 @@ gimp_drawable_merge_shadow (gint32 drawable_ID,
gimp_value_set_drawable_id (gimp_value_array_index (args, 0), drawable_ID);
g_value_set_boolean (gimp_value_array_index (args, 1), undo);
- return_vals = gimp_run_procedure_with_array ("gimp-drawable-merge-shadow",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-drawable-merge-shadow",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-merge-shadow",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -633,6 +723,7 @@ gimp_drawable_merge_shadow (gint32 drawable_ID,
gboolean
gimp_drawable_free_shadow (gint32 drawable_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -641,8 +732,13 @@ gimp_drawable_free_shadow (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-drawable-free-shadow",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-free-shadow",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -676,6 +772,7 @@ gimp_drawable_update (gint32 drawable_ID,
gint width,
gint height)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -692,8 +789,13 @@ gimp_drawable_update (gint32 drawable_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-drawable-update",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-update",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -726,6 +828,7 @@ gimp_drawable_get_pixel (gint32 drawable_ID,
gint y_coord,
gint *num_channels)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
guint8 *pixel = NULL;
@@ -738,8 +841,13 @@ gimp_drawable_get_pixel (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-drawable-get-pixel",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-get-pixel",
+ args);
gimp_value_array_unref (args);
*num_channels = 0;
@@ -780,6 +888,7 @@ gimp_drawable_set_pixel (gint32 drawable_ID,
gint num_channels,
const guint8 *pixel)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -796,8 +905,13 @@ gimp_drawable_set_pixel (gint32 drawable_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-drawable-set-pixel",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-set-pixel",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -832,6 +946,7 @@ gboolean
gimp_drawable_fill (gint32 drawable_ID,
GimpFillType fill_type)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -842,8 +957,13 @@ gimp_drawable_fill (gint32 drawable_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-drawable-fill",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-fill",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -880,6 +1000,7 @@ gimp_drawable_offset (gint32 drawable_ID,
gint offset_x,
gint offset_y)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -896,8 +1017,13 @@ gimp_drawable_offset (gint32 drawable_ID,
g_value_set_int (gimp_value_array_index (args, 3), offset_x);
g_value_set_int (gimp_value_array_index (args, 4), offset_y);
- return_vals = gimp_run_procedure_with_array ("gimp-drawable-offset",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-drawable-offset",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-offset",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -937,6 +1063,7 @@ _gimp_drawable_thumbnail (gint32 drawable_ID,
gint *thumbnail_data_count,
guint8 **thumbnail_data)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -949,8 +1076,13 @@ _gimp_drawable_thumbnail (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-drawable-thumbnail",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-thumbnail",
+ args);
gimp_value_array_unref (args);
*actual_width = 0;
@@ -1015,6 +1147,7 @@ _gimp_drawable_sub_thumbnail (gint32 drawable_ID,
gint *thumbnail_data_count,
guint8 **thumbnail_data)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1035,8 +1168,13 @@ _gimp_drawable_sub_thumbnail (gint32 drawable_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-drawable-sub-thumbnail",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-sub-thumbnail",
+ args);
gimp_value_array_unref (args);
*width = 0;
@@ -1081,6 +1219,7 @@ gimp_drawable_foreground_extract (gint32 drawable_ID,
GimpForegroundExtractMode mode,
gint32 mask_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1093,8 +1232,13 @@ gimp_drawable_foreground_extract (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-drawable-foreground-extract",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-foreground-extract",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
diff --git a/libgimp/gimpdrawablecolor_pdb.c b/libgimp/gimpdrawablecolor_pdb.c
index f9604682e6..60b4867b0d 100644
--- a/libgimp/gimpdrawablecolor_pdb.c
+++ b/libgimp/gimpdrawablecolor_pdb.c
@@ -56,6 +56,7 @@ gimp_drawable_brightness_contrast (gint32 drawable_ID,
gdouble brightness,
gdouble contrast)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -68,8 +69,13 @@ gimp_drawable_brightness_contrast (gint32 drawable_ID,
g_value_set_double (gimp_value_array_index (args, 1), brightness);
g_value_set_double (gimp_value_array_index (args, 2), contrast);
- return_vals = gimp_run_procedure_with_array ("gimp-drawable-brightness-contrast",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-drawable-brightness-contrast",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-brightness-contrast",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -111,6 +117,7 @@ gimp_drawable_color_balance (gint32 drawable_ID,
gdouble magenta_green,
gdouble yellow_blue)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -129,8 +136,13 @@ gimp_drawable_color_balance (gint32 drawable_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-drawable-color-balance",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-color-balance",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -164,6 +176,7 @@ gimp_drawable_colorize_hsl (gint32 drawable_ID,
gdouble saturation,
gdouble lightness)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -178,8 +191,13 @@ gimp_drawable_colorize_hsl (gint32 drawable_ID,
g_value_set_double (gimp_value_array_index (args, 2), saturation);
g_value_set_double (gimp_value_array_index (args, 3), lightness);
- return_vals = gimp_run_procedure_with_array ("gimp-drawable-colorize-hsl",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-drawable-colorize-hsl",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-colorize-hsl",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -215,6 +233,7 @@ gimp_drawable_curves_explicit (gint32 drawable_ID,
gint num_values,
const gdouble *values)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -229,8 +248,13 @@ gimp_drawable_curves_explicit (gint32 drawable_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-drawable-curves-explicit",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-curves-explicit",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -266,6 +290,7 @@ gimp_drawable_curves_spline (gint32 drawable_ID,
gint num_points,
const gdouble *points)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -280,8 +305,13 @@ gimp_drawable_curves_spline (gint32 drawable_ID,
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);
- return_vals = gimp_run_procedure_with_array ("gimp-drawable-curves-spline",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-drawable-curves-spline",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-curves-spline",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -311,6 +341,7 @@ gboolean
gimp_drawable_desaturate (gint32 drawable_ID,
GimpDesaturateMode desaturate_mode)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -321,8 +352,13 @@ gimp_drawable_desaturate (gint32 drawable_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-drawable-desaturate",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-desaturate",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -355,6 +391,7 @@ gboolean
gimp_drawable_equalize (gint32 drawable_ID,
gboolean mask_only)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -365,8 +402,13 @@ gimp_drawable_equalize (gint32 drawable_ID,
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);
- return_vals = gimp_run_procedure_with_array ("gimp-drawable-equalize",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-drawable-equalize",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-equalize",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -424,6 +466,7 @@ gimp_drawable_histogram (gint32 drawable_ID,
gdouble *count,
gdouble *percentile)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -438,8 +481,13 @@ gimp_drawable_histogram (gint32 drawable_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-drawable-histogram",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-histogram",
+ args);
gimp_value_array_unref (args);
*mean = 0.0;
@@ -495,6 +543,7 @@ gimp_drawable_hue_saturation (gint32 drawable_ID,
gdouble saturation,
gdouble overlap)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -513,8 +562,13 @@ gimp_drawable_hue_saturation (gint32 drawable_ID,
g_value_set_double (gimp_value_array_index (args, 4), saturation);
g_value_set_double (gimp_value_array_index (args, 5), overlap);
- return_vals = gimp_run_procedure_with_array ("gimp-drawable-hue-saturation",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-drawable-hue-saturation",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-hue-saturation",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -544,6 +598,7 @@ gboolean
gimp_drawable_invert (gint32 drawable_ID,
gboolean linear)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -554,8 +609,13 @@ gimp_drawable_invert (gint32 drawable_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-drawable-invert",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-invert",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -607,6 +667,7 @@ gimp_drawable_levels (gint32 drawable_ID,
gdouble high_output,
gboolean clamp_output)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -631,8 +692,13 @@ gimp_drawable_levels (gint32 drawable_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-drawable-levels",
+ args);
+ else
+ 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;
@@ -659,6 +725,7 @@ gimp_drawable_levels (gint32 drawable_ID,
gboolean
gimp_drawable_levels_stretch (gint32 drawable_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -667,8 +734,13 @@ gimp_drawable_levels_stretch (gint32 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-levels-stretch",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-drawable-levels-stretch",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-levels-stretch",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -696,6 +768,7 @@ gboolean
gimp_drawable_posterize (gint32 drawable_ID,
gint levels)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -706,8 +779,13 @@ gimp_drawable_posterize (gint32 drawable_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-drawable-posterize",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-posterize",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -741,6 +819,7 @@ gimp_drawable_threshold (gint32 drawable_ID,
gdouble low_threshold,
gdouble high_threshold)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -755,8 +834,13 @@ gimp_drawable_threshold (gint32 drawable_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-drawable-threshold",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-threshold",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
diff --git a/libgimp/gimpdrawableedit_pdb.c b/libgimp/gimpdrawableedit_pdb.c
index e60f369360..a568a88a95 100644
--- a/libgimp/gimpdrawableedit_pdb.c
+++ b/libgimp/gimpdrawableedit_pdb.c
@@ -54,6 +54,7 @@
gboolean
gimp_drawable_edit_clear (gint32 drawable_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -62,8 +63,13 @@ gimp_drawable_edit_clear (gint32 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-edit-clear",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-drawable-edit-clear",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-edit-clear",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -96,6 +102,7 @@ gboolean
gimp_drawable_edit_fill (gint32 drawable_ID,
GimpFillType fill_type)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -106,8 +113,13 @@ gimp_drawable_edit_fill (gint32 drawable_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-drawable-edit-fill",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-edit-fill",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -150,6 +162,7 @@ gimp_drawable_edit_bucket_fill (gint32 drawable_ID,
gdouble x,
gdouble y)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -164,8 +177,13 @@ gimp_drawable_edit_bucket_fill (gint32 drawable_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-drawable-edit-bucket-fill",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-edit-bucket-fill",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -221,6 +239,7 @@ gimp_drawable_edit_gradient_fill (gint32 drawable_ID,
gdouble x2,
gdouble y2)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -249,8 +268,13 @@ gimp_drawable_edit_gradient_fill (gint32 drawable_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-drawable-edit-gradient-fill",
+ args);
+ else
+ 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;
@@ -284,6 +308,7 @@ gimp_drawable_edit_gradient_fill (gint32 drawable_ID,
gboolean
gimp_drawable_edit_stroke_selection (gint32 drawable_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -292,8 +317,13 @@ gimp_drawable_edit_stroke_selection (gint32 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-edit-stroke-selection",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-drawable-edit-stroke-selection",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-edit-stroke-selection",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -331,6 +361,7 @@ gboolean
gimp_drawable_edit_stroke_item (gint32 drawable_ID,
gint32 item_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -341,8 +372,13 @@ gimp_drawable_edit_stroke_item (gint32 drawable_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-drawable-edit-stroke-item",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-drawable-edit-stroke-item",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
diff --git a/libgimp/gimpdynamics_pdb.c b/libgimp/gimpdynamics_pdb.c
index 82682ec563..2e480db408 100644
--- a/libgimp/gimpdynamics_pdb.c
+++ b/libgimp/gimpdynamics_pdb.c
@@ -50,14 +50,20 @@
gboolean
gimp_dynamics_refresh (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-dynamics-refresh",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-dynamics-refresh",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-dynamics-refresh",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -87,6 +93,7 @@ gchar **
gimp_dynamics_get_list (const gchar *filter,
gint *num_dynamics)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar **dynamics_list = NULL;
@@ -95,8 +102,13 @@ gimp_dynamics_get_list (const gchar *filter,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-dynamics-get-list",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-dynamics-get-list",
+ args);
gimp_value_array_unref (args);
*num_dynamics = 0;
diff --git a/libgimp/gimpedit_pdb.c b/libgimp/gimpedit_pdb.c
index f9bc807060..914a040b1f 100644
--- a/libgimp/gimpedit_pdb.c
+++ b/libgimp/gimpedit_pdb.c
@@ -54,6 +54,7 @@
gboolean
gimp_edit_cut (gint32 drawable_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean non_empty = FALSE;
@@ -62,8 +63,13 @@ gimp_edit_cut (gint32 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-cut",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-edit-cut",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-edit-cut",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -94,6 +100,7 @@ gimp_edit_cut (gint32 drawable_ID)
gboolean
gimp_edit_copy (gint32 drawable_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean non_empty = FALSE;
@@ -102,8 +109,13 @@ gimp_edit_copy (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-edit-copy",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-edit-copy",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -134,6 +146,7 @@ gimp_edit_copy (gint32 drawable_ID)
gboolean
gimp_edit_copy_visible (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean non_empty = FALSE;
@@ -142,8 +155,13 @@ gimp_edit_copy_visible (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-edit-copy-visible",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-edit-copy-visible",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -183,6 +201,7 @@ gint32
gimp_edit_paste (gint32 drawable_ID,
gboolean paste_into)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 floating_sel_ID = -1;
@@ -193,8 +212,13 @@ gimp_edit_paste (gint32 drawable_ID,
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);
- return_vals = gimp_run_procedure_with_array ("gimp-edit-paste",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-edit-paste",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-edit-paste",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -222,14 +246,20 @@ gimp_edit_paste (gint32 drawable_ID,
gint32
gimp_edit_paste_as_new_image (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 image_ID = -1;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-edit-paste-as-new-image",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-edit-paste-as-new-image",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-edit-paste-as-new-image",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -262,6 +292,7 @@ gchar *
gimp_edit_named_cut (gint32 drawable_ID,
const gchar *buffer_name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *real_name = NULL;
@@ -272,8 +303,13 @@ gimp_edit_named_cut (gint32 drawable_ID,
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-cut",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-edit-named-cut",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-edit-named-cut",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -306,6 +342,7 @@ gchar *
gimp_edit_named_copy (gint32 drawable_ID,
const gchar *buffer_name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *real_name = NULL;
@@ -316,8 +353,13 @@ gimp_edit_named_copy (gint32 drawable_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-edit-named-copy",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-edit-named-copy",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -350,6 +392,7 @@ gchar *
gimp_edit_named_copy_visible (gint32 image_ID,
const gchar *buffer_name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *real_name = NULL;
@@ -360,8 +403,13 @@ gimp_edit_named_copy_visible (gint32 image_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-edit-named-copy-visible",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-edit-named-copy-visible",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -392,6 +440,7 @@ gimp_edit_named_paste (gint32 drawable_ID,
const gchar *buffer_name,
gboolean paste_into)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 floating_sel_ID = -1;
@@ -404,8 +453,13 @@ gimp_edit_named_paste (gint32 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);
- return_vals = gimp_run_procedure_with_array ("gimp-edit-named-paste",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-edit-named-paste",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-edit-named-paste",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -432,6 +486,7 @@ gimp_edit_named_paste (gint32 drawable_ID,
gint32
gimp_edit_named_paste_as_new_image (const gchar *buffer_name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 image_ID = -1;
@@ -440,8 +495,13 @@ gimp_edit_named_paste_as_new_image (const gchar *buffer_name)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-edit-named-paste-as-new-image",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-edit-named-paste-as-new-image",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
diff --git a/libgimp/gimpfileops_pdb.c b/libgimp/gimpfileops_pdb.c
index a111389329..c16cbd2657 100644
--- a/libgimp/gimpfileops_pdb.c
+++ b/libgimp/gimpfileops_pdb.c
@@ -57,6 +57,7 @@ gimp_file_load (GimpRunMode run_mode,
const gchar *filename,
const gchar *raw_filename)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 image_ID = -1;
@@ -69,8 +70,13 @@ gimp_file_load (GimpRunMode 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-file-load",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-file-load",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -103,6 +109,7 @@ gimp_file_load_layer (GimpRunMode run_mode,
gint32 image_ID,
const gchar *filename)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 layer_ID = -1;
@@ -115,8 +122,13 @@ gimp_file_load_layer (GimpRunMode 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-layer",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-file-load-layer",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-file-load-layer",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -153,6 +165,7 @@ gimp_file_load_layers (GimpRunMode run_mode,
const gchar *filename,
gint *num_layers)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint *layer_ids = NULL;
@@ -165,8 +178,13 @@ gimp_file_load_layers (GimpRunMode 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-file-load-layers",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-file-load-layers",
+ args);
gimp_value_array_unref (args);
*num_layers = 0;
@@ -209,6 +227,7 @@ gimp_file_save (GimpRunMode run_mode,
const gchar *filename,
const gchar *raw_filename)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -225,8 +244,13 @@ gimp_file_save (GimpRunMode run_mode,
g_value_set_string (gimp_value_array_index (args, 3), filename);
g_value_set_string (gimp_value_array_index (args, 4), raw_filename);
- return_vals = gimp_run_procedure_with_array ("gimp-file-save",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-file-save",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-file-save",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -256,6 +280,7 @@ gboolean
gimp_file_save_thumbnail (gint32 image_ID,
const gchar *filename)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -266,8 +291,13 @@ gimp_file_save_thumbnail (gint32 image_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-file-save-thumbnail",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-file-save-thumbnail",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -297,6 +327,7 @@ gimp_register_magic_load_handler (const gchar *procedure_name,
const gchar *prefixes,
const gchar *magics)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -311,8 +342,13 @@ gimp_register_magic_load_handler (const gchar *procedure_name,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-register-magic-load-handler",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-register-magic-load-handler",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -340,6 +376,7 @@ gimp_register_load_handler (const gchar *procedure_name,
const gchar *extensions,
const gchar *prefixes)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -352,8 +389,13 @@ gimp_register_load_handler (const gchar *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-load-handler",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-register-load-handler",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-register-load-handler",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -381,6 +423,7 @@ gimp_register_save_handler (const gchar *procedure_name,
const gchar *extensions,
const gchar *prefixes)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -393,8 +436,13 @@ gimp_register_save_handler (const gchar *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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-register-save-handler",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-register-save-handler",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -425,6 +473,7 @@ gboolean
gimp_register_file_handler_priority (const gchar *procedure_name,
gint priority)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -435,8 +484,13 @@ gimp_register_file_handler_priority (const gchar *procedure_name,
g_value_set_string (gimp_value_array_index (args, 0), procedure_name);
g_value_set_int (gimp_value_array_index (args, 1), priority);
- return_vals = gimp_run_procedure_with_array ("gimp-register-file-handler-priority",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-register-file-handler-priority",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-register-file-handler-priority",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -468,6 +522,7 @@ gboolean
gimp_register_file_handler_mime (const gchar *procedure_name,
const gchar *mime_types)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -478,8 +533,13 @@ gimp_register_file_handler_mime (const gchar *procedure_name,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-register-file-handler-mime",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-register-file-handler-mime",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -507,6 +567,7 @@ gimp_register_file_handler_mime (const gchar *procedure_name,
gboolean
gimp_register_file_handler_uri (const gchar *procedure_name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -515,8 +576,13 @@ gimp_register_file_handler_uri (const gchar *procedure_name)
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-uri",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-register-file-handler-uri",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-register-file-handler-uri",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -544,6 +610,7 @@ gimp_register_file_handler_uri (const gchar *procedure_name)
gboolean
gimp_register_file_handler_raw (const gchar *procedure_name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -552,8 +619,13 @@ gimp_register_file_handler_raw (const gchar *procedure_name)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-register-file-handler-raw",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-register-file-handler-raw",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -585,6 +657,7 @@ gboolean
gimp_register_thumbnail_loader (const gchar *load_proc,
const gchar *thumb_proc)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -595,8 +668,13 @@ gimp_register_thumbnail_loader (const gchar *load_proc,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-register-thumbnail-loader",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-register-thumbnail-loader",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
diff --git a/libgimp/gimpfloatingsel_pdb.c b/libgimp/gimpfloatingsel_pdb.c
index 6d0382eb0e..b8f043e592 100644
--- a/libgimp/gimpfloatingsel_pdb.c
+++ b/libgimp/gimpfloatingsel_pdb.c
@@ -49,6 +49,7 @@
gboolean
gimp_floating_sel_remove (gint32 floating_sel_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -57,8 +58,13 @@ gimp_floating_sel_remove (gint32 floating_sel_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-remove",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-floating-sel-remove",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-floating-sel-remove",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -84,6 +90,7 @@ gimp_floating_sel_remove (gint32 floating_sel_ID)
gboolean
gimp_floating_sel_anchor (gint32 floating_sel_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -92,8 +99,13 @@ gimp_floating_sel_anchor (gint32 floating_sel_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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-floating-sel-anchor",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-floating-sel-anchor",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -123,6 +135,7 @@ gimp_floating_sel_anchor (gint32 floating_sel_ID)
gboolean
gimp_floating_sel_to_layer (gint32 floating_sel_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -131,8 +144,13 @@ gimp_floating_sel_to_layer (gint32 floating_sel_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-to-layer",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-floating-sel-to-layer",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-floating-sel-to-layer",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -158,6 +176,7 @@ gboolean
gimp_floating_sel_attach (gint32 layer_ID,
gint32 drawable_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -168,8 +187,13 @@ gimp_floating_sel_attach (gint32 layer_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-floating-sel-attach",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-floating-sel-attach",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
diff --git a/libgimp/gimpfonts_pdb.c b/libgimp/gimpfonts_pdb.c
index 18f9c93253..aaf83c9fba 100644
--- a/libgimp/gimpfonts_pdb.c
+++ b/libgimp/gimpfonts_pdb.c
@@ -48,14 +48,20 @@
gboolean
gimp_fonts_refresh (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-fonts-refresh",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-fonts-refresh",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-fonts-refresh",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -83,6 +89,7 @@ gchar **
gimp_fonts_get_list (const gchar *filter,
gint *num_fonts)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar **font_list = NULL;
@@ -91,8 +98,13 @@ gimp_fonts_get_list (const gchar *filter,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-fonts-get-list",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-fonts-get-list",
+ args);
gimp_value_array_unref (args);
*num_fonts = 0;
diff --git a/libgimp/gimpfontselect_pdb.c b/libgimp/gimpfontselect_pdb.c
index b1dee3b839..f86db99f79 100644
--- a/libgimp/gimpfontselect_pdb.c
+++ b/libgimp/gimpfontselect_pdb.c
@@ -51,6 +51,7 @@ gimp_fonts_popup (const gchar *font_callback,
const gchar *popup_title,
const gchar *initial_font)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -63,8 +64,13 @@ gimp_fonts_popup (const gchar *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);
- return_vals = gimp_run_procedure_with_array ("gimp-fonts-popup",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-fonts-popup",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-fonts-popup",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -87,6 +93,7 @@ gimp_fonts_popup (const gchar *font_callback,
gboolean
gimp_fonts_close_popup (const gchar *font_callback)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -95,8 +102,13 @@ gimp_fonts_close_popup (const gchar *font_callback)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-fonts-close-popup",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-fonts-close-popup",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -121,6 +133,7 @@ gboolean
gimp_fonts_set_popup (const gchar *font_callback,
const gchar *font_name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -131,8 +144,13 @@ gimp_fonts_set_popup (const gchar *font_callback,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-fonts-set-popup",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-fonts-set-popup",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
diff --git a/libgimp/gimpgimprc_pdb.c b/libgimp/gimpgimprc_pdb.c
index de5d27540c..cf4684aef3 100644
--- a/libgimp/gimpgimprc_pdb.c
+++ b/libgimp/gimpgimprc_pdb.c
@@ -56,6 +56,7 @@
gchar *
gimp_gimprc_query (const gchar *token)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *value = NULL;
@@ -64,8 +65,13 @@ gimp_gimprc_query (const gchar *token)
G_TYPE_NONE);
g_value_set_string (gimp_value_array_index (args, 0), token);
- return_vals = gimp_run_procedure_with_array ("gimp-gimprc-query",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-gimprc-query",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-gimprc-query",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -95,6 +101,7 @@ gboolean
gimp_gimprc_set (const gchar *token,
const gchar *value)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -105,8 +112,13 @@ gimp_gimprc_set (const gchar *token,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-gimprc-set",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-gimprc-set",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -129,14 +141,20 @@ gimp_gimprc_set (const gchar *token,
gchar *
gimp_get_default_comment (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *comment = NULL;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-get-default-comment",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-get-default-comment",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-get-default-comment",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -161,14 +179,20 @@ gimp_get_default_comment (void)
GimpUnit
gimp_get_default_unit (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpUnit unit_id = 0;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-get-default-unit",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-get-default-unit",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-get-default-unit",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -197,14 +221,20 @@ gboolean
gimp_get_monitor_resolution (gdouble *xres,
gdouble *yres)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-get-monitor-resolution",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-get-monitor-resolution",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-get-monitor-resolution",
+ args);
gimp_value_array_unref (args);
*xres = 0.0;
@@ -239,14 +269,20 @@ gimp_get_monitor_resolution (gdouble *xres,
gchar *
_gimp_get_color_configuration (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *config = NULL;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-get-color-configuration",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-get-color-configuration",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-get-color-configuration",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -270,14 +306,20 @@ _gimp_get_color_configuration (void)
gchar *
gimp_get_module_load_inhibit (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *load_inhibit = NULL;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-get-module-load-inhibit",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-get-module-load-inhibit",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-get-module-load-inhibit",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
diff --git a/libgimp/gimpgradient_pdb.c b/libgimp/gimpgradient_pdb.c
index f9ecb76c2c..7ee72efa07 100644
--- a/libgimp/gimpgradient_pdb.c
+++ b/libgimp/gimpgradient_pdb.c
@@ -50,6 +50,7 @@
gchar *
gimp_gradient_new (const gchar *name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *actual_name = NULL;
@@ -58,8 +59,13 @@ gimp_gradient_new (const gchar *name)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-gradient-new",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-new",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -86,6 +92,7 @@ gimp_gradient_new (const gchar *name)
gchar *
gimp_gradient_duplicate (const gchar *name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *copy_name = NULL;
@@ -94,8 +101,13 @@ gimp_gradient_duplicate (const gchar *name)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-gradient-duplicate",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-duplicate",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -121,6 +133,7 @@ gimp_gradient_duplicate (const gchar *name)
gboolean
gimp_gradient_is_editable (const gchar *name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean editable = FALSE;
@@ -129,8 +142,13 @@ gimp_gradient_is_editable (const gchar *name)
G_TYPE_NONE);
g_value_set_string (gimp_value_array_index (args, 0), name);
- return_vals = gimp_run_procedure_with_array ("gimp-gradient-is-editable",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-gradient-is-editable",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-is-editable",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -159,6 +177,7 @@ gchar *
gimp_gradient_rename (const gchar *name,
const gchar *new_name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *actual_name = NULL;
@@ -169,8 +188,13 @@ gimp_gradient_rename (const gchar *name,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-gradient-rename",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-rename",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -196,6 +220,7 @@ gimp_gradient_rename (const gchar *name,
gboolean
gimp_gradient_delete (const gchar *name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -204,8 +229,13 @@ gimp_gradient_delete (const gchar *name)
G_TYPE_NONE);
g_value_set_string (gimp_value_array_index (args, 0), name);
- return_vals = gimp_run_procedure_with_array ("gimp-gradient-delete",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-gradient-delete",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-delete",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -231,6 +261,7 @@ gimp_gradient_delete (const gchar *name)
gint
gimp_gradient_get_number_of_segments (const gchar *name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint num_segments = 0;
@@ -239,8 +270,13 @@ gimp_gradient_get_number_of_segments (const gchar *name)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-gradient-get-number-of-segments",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-get-number-of-segments",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -280,6 +316,7 @@ gimp_gradient_get_uniform_samples (const gchar *name,
gint *num_color_samples,
gdouble **color_samples)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -292,8 +329,13 @@ gimp_gradient_get_uniform_samples (const gchar *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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-gradient-get-uniform-samples",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-get-uniform-samples",
+ args);
gimp_value_array_unref (args);
*num_color_samples = 0;
@@ -342,6 +384,7 @@ gimp_gradient_get_custom_samples (const gchar *name,
gint *num_color_samples,
gdouble **color_samples)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -356,8 +399,13 @@ gimp_gradient_get_custom_samples (const gchar *name,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-gradient-get-custom-samples",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-get-custom-samples",
+ args);
gimp_value_array_unref (args);
*num_color_samples = 0;
@@ -398,6 +446,7 @@ gimp_gradient_segment_get_left_color (const gchar *name,
GimpRGB *color,
gdouble *opacity)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -408,8 +457,13 @@ gimp_gradient_segment_get_left_color (const gchar *name,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-gradient-segment-get-left-color",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-get-left-color",
+ args);
gimp_value_array_unref (args);
*opacity = 0.0;
@@ -449,6 +503,7 @@ gimp_gradient_segment_set_left_color (const gchar *name,
const GimpRGB *color,
gdouble opacity)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -463,8 +518,13 @@ gimp_gradient_segment_set_left_color (const gchar *name,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-gradient-segment-set-left-color",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-set-left-color",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -496,6 +556,7 @@ gimp_gradient_segment_get_right_color (const gchar *name,
GimpRGB *color,
gdouble *opacity)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -506,8 +567,13 @@ gimp_gradient_segment_get_right_color (const gchar *name,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-gradient-segment-get-right-color",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-get-right-color",
+ args);
gimp_value_array_unref (args);
*opacity = 0.0;
@@ -547,6 +613,7 @@ gimp_gradient_segment_set_right_color (const gchar *name,
const GimpRGB *color,
gdouble opacity)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -561,8 +628,13 @@ gimp_gradient_segment_set_right_color (const gchar *name,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-gradient-segment-set-right-color",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-set-right-color",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -592,6 +664,7 @@ gimp_gradient_segment_get_left_pos (const gchar *name,
gint segment,
gdouble *pos)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -602,8 +675,13 @@ gimp_gradient_segment_get_left_pos (const gchar *name,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-gradient-segment-get-left-pos",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-get-left-pos",
+ args);
gimp_value_array_unref (args);
*pos = 0.0;
@@ -643,6 +721,7 @@ gimp_gradient_segment_set_left_pos (const gchar *name,
gdouble pos,
gdouble *final_pos)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -655,8 +734,13 @@ gimp_gradient_segment_set_left_pos (const gchar *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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-gradient-segment-set-left-pos",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-set-left-pos",
+ args);
gimp_value_array_unref (args);
*final_pos = 0.0;
@@ -691,6 +775,7 @@ gimp_gradient_segment_get_middle_pos (const gchar *name,
gint segment,
gdouble *pos)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -701,8 +786,13 @@ gimp_gradient_segment_get_middle_pos (const gchar *name,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-gradient-segment-get-middle-pos",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-get-middle-pos",
+ args);
gimp_value_array_unref (args);
*pos = 0.0;
@@ -741,6 +831,7 @@ gimp_gradient_segment_set_middle_pos (const gchar *name,
gdouble pos,
gdouble *final_pos)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -753,8 +844,13 @@ gimp_gradient_segment_set_middle_pos (const gchar *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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-gradient-segment-set-middle-pos",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-set-middle-pos",
+ args);
gimp_value_array_unref (args);
*final_pos = 0.0;
@@ -789,6 +885,7 @@ gimp_gradient_segment_get_right_pos (const gchar *name,
gint segment,
gdouble *pos)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -799,8 +896,13 @@ gimp_gradient_segment_get_right_pos (const gchar *name,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-gradient-segment-get-right-pos",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-get-right-pos",
+ args);
gimp_value_array_unref (args);
*pos = 0.0;
@@ -840,6 +942,7 @@ gimp_gradient_segment_set_right_pos (const gchar *name,
gdouble pos,
gdouble *final_pos)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -852,8 +955,13 @@ gimp_gradient_segment_set_right_pos (const gchar *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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-gradient-segment-set-right-pos",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-set-right-pos",
+ args);
gimp_value_array_unref (args);
*final_pos = 0.0;
@@ -888,6 +996,7 @@ gimp_gradient_segment_get_blending_function (const gchar *name,
gint segment,
GimpGradientSegmentType *blend_func)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -898,8 +1007,13 @@ gimp_gradient_segment_get_blending_function (const gchar *name,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-gradient-segment-get-blending-function",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-get-blending-function",
+ args);
gimp_value_array_unref (args);
*blend_func = 0;
@@ -934,6 +1048,7 @@ gimp_gradient_segment_get_coloring_type (const gchar *name,
gint segment,
GimpGradientSegmentColor *coloring_type)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -944,8 +1059,13 @@ gimp_gradient_segment_get_coloring_type (const gchar *name,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-gradient-segment-get-coloring-type",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-get-coloring-type",
+ args);
gimp_value_array_unref (args);
*coloring_type = 0;
@@ -982,6 +1102,7 @@ gimp_gradient_segment_range_set_blending_function (const gchar *name
gint end_segment,
GimpGradientSegmentType blending_function)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -996,8 +1117,13 @@ gimp_gradient_segment_range_set_blending_function (const gchar *name
g_value_set_int (gimp_value_array_index (args, 2), end_segment);
g_value_set_enum (gimp_value_array_index (args, 3), blending_function);
- return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-range-set-blending-function",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-gradient-segment-range-set-blending-function",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-range-set-blending-function",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1029,6 +1155,7 @@ gimp_gradient_segment_range_set_coloring_type (const gchar *name,
gint end_segment,
GimpGradientSegmentColor coloring_type)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1043,8 +1170,13 @@ gimp_gradient_segment_range_set_coloring_type (const gchar *name,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-gradient-segment-range-set-coloring-type",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-range-set-coloring-type",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1073,6 +1205,7 @@ gimp_gradient_segment_range_flip (const gchar *name,
gint start_segment,
gint end_segment)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1085,8 +1218,13 @@ gimp_gradient_segment_range_flip (const gchar *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-flip",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-gradient-segment-range-flip",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-range-flip",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1119,6 +1257,7 @@ gimp_gradient_segment_range_replicate (const gchar *name,
gint end_segment,
gint replicate_times)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1133,8 +1272,13 @@ gimp_gradient_segment_range_replicate (const gchar *name,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-gradient-segment-range-replicate",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-range-replicate",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1164,6 +1308,7 @@ gimp_gradient_segment_range_split_midpoint (const gchar *name,
gint start_segment,
gint end_segment)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1176,8 +1321,13 @@ gimp_gradient_segment_range_split_midpoint (const gchar *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-split-midpoint",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-gradient-segment-range-split-midpoint",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-range-split-midpoint",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1209,6 +1359,7 @@ gimp_gradient_segment_range_split_uniform (const gchar *name,
gint end_segment,
gint split_parts)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1223,8 +1374,13 @@ gimp_gradient_segment_range_split_uniform (const gchar *name,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-gradient-segment-range-split-uniform",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-range-split-uniform",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1253,6 +1409,7 @@ gimp_gradient_segment_range_delete (const gchar *name,
gint start_segment,
gint end_segment)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1265,8 +1422,13 @@ gimp_gradient_segment_range_delete (const gchar *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-delete",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-gradient-segment-range-delete",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-range-delete",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1296,6 +1458,7 @@ gimp_gradient_segment_range_redistribute_handles (const gchar *name,
gint start_segment,
gint end_segment)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1308,8 +1471,13 @@ gimp_gradient_segment_range_redistribute_handles (const gchar *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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-gradient-segment-range-redistribute-handles",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-range-redistribute-handles",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1340,6 +1508,7 @@ gimp_gradient_segment_range_blend_colors (const gchar *name,
gint start_segment,
gint end_segment)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1352,8 +1521,13 @@ gimp_gradient_segment_range_blend_colors (const gchar *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-colors",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-gradient-segment-range-blend-colors",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-range-blend-colors",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1384,6 +1558,7 @@ gimp_gradient_segment_range_blend_opacity (const gchar *name,
gint start_segment,
gint end_segment)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1396,8 +1571,13 @@ gimp_gradient_segment_range_blend_opacity (const gchar *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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-gradient-segment-range-blend-opacity",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-gradient-segment-range-blend-opacity",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1432,6 +1612,7 @@ gimp_gradient_segment_range_move (const gchar *name,
gdouble delta,
gboolean control_compress)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble final_delta = 0.0;
@@ -1448,8 +1629,13 @@ gimp_gradient_segment_range_move (const gchar *name,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-gradient-segment-range-move",
+ args);
+ else
+ 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)
diff --git a/libgimp/gimpgradients_pdb.c b/libgimp/gimpgradients_pdb.c
index 8cee4832be..02f8d0b89e 100644
--- a/libgimp/gimpgradients_pdb.c
+++ b/libgimp/gimpgradients_pdb.c
@@ -47,14 +47,20 @@
gboolean
gimp_gradients_refresh (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-gradients-refresh",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-gradients-refresh",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-gradients-refresh",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -83,6 +89,7 @@ gchar **
gimp_gradients_get_list (const gchar *filter,
gint *num_gradients)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar **gradient_list = NULL;
@@ -91,8 +98,13 @@ gimp_gradients_get_list (const gchar *filter,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-gradients-get-list",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-gradients-get-list",
+ args);
gimp_value_array_unref (args);
*num_gradients = 0;
diff --git a/libgimp/gimpgradientselect_pdb.c b/libgimp/gimpgradientselect_pdb.c
index d054091dfa..11b47dfff6 100644
--- a/libgimp/gimpgradientselect_pdb.c
+++ b/libgimp/gimpgradientselect_pdb.c
@@ -53,6 +53,7 @@ gimp_gradients_popup (const gchar *gradient_callback,
const gchar *initial_gradient,
gint sample_size)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -67,8 +68,13 @@ gimp_gradients_popup (const gchar *gradient_callback,
g_value_set_string (gimp_value_array_index (args, 2), initial_gradient);
g_value_set_int (gimp_value_array_index (args, 3), sample_size);
- return_vals = gimp_run_procedure_with_array ("gimp-gradients-popup",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-gradients-popup",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-gradients-popup",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -91,6 +97,7 @@ gimp_gradients_popup (const gchar *gradient_callback,
gboolean
gimp_gradients_close_popup (const gchar *gradient_callback)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -99,8 +106,13 @@ gimp_gradients_close_popup (const gchar *gradient_callback)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-gradients-close-popup",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-gradients-close-popup",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -125,6 +137,7 @@ gboolean
gimp_gradients_set_popup (const gchar *gradient_callback,
const gchar *gradient_name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -135,8 +148,13 @@ gimp_gradients_set_popup (const gchar *gradient_callback,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-gradients-set-popup",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-gradients-set-popup",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
diff --git a/libgimp/gimphelp_pdb.c b/libgimp/gimphelp_pdb.c
index 4c7088d1e4..1f633c474f 100644
--- a/libgimp/gimphelp_pdb.c
+++ b/libgimp/gimphelp_pdb.c
@@ -54,6 +54,7 @@ gboolean
gimp_help (const gchar *help_domain,
const gchar *help_id)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -64,8 +65,13 @@ gimp_help (const gchar *help_domain,
g_value_set_string (gimp_value_array_index (args, 0), help_domain);
g_value_set_string (gimp_value_array_index (args, 1), help_id);
- return_vals = gimp_run_procedure_with_array ("gimp-help",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-help",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-help",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
diff --git a/libgimp/gimpimage_pdb.c b/libgimp/gimpimage_pdb.c
index 35c32d5b7e..737011857a 100644
--- a/libgimp/gimpimage_pdb.c
+++ b/libgimp/gimpimage_pdb.c
@@ -51,6 +51,7 @@
gboolean
gimp_image_is_valid (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean valid = FALSE;
@@ -59,8 +60,13 @@ gimp_image_is_valid (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-is-valid",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-is-valid",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -86,14 +92,20 @@ gimp_image_is_valid (gint32 image_ID)
gint *
gimp_image_list (gint *num_images)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint *image_ids = NULL;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-image-list",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-list",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-list",
+ args);
gimp_value_array_unref (args);
*num_images = 0;
@@ -135,6 +147,7 @@ gimp_image_new (gint width,
gint height,
GimpImageBaseType type)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 image_ID = -1;
@@ -147,8 +160,13 @@ gimp_image_new (gint width,
g_value_set_int (gimp_value_array_index (args, 1), height);
g_value_set_enum (gimp_value_array_index (args, 2), type);
- return_vals = gimp_run_procedure_with_array ("gimp-image-new",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-new",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-new",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -184,6 +202,7 @@ gimp_image_new_with_precision (gint width,
GimpImageBaseType type,
GimpPrecision precision)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 image_ID = -1;
@@ -198,8 +217,13 @@ gimp_image_new_with_precision (gint width,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-new-with-precision",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-new-with-precision",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -224,6 +248,7 @@ gimp_image_new_with_precision (gint width,
gint32
gimp_image_duplicate (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 new_image_ID = -1;
@@ -232,8 +257,13 @@ gimp_image_duplicate (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-duplicate",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-duplicate",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -262,6 +292,7 @@ gimp_image_duplicate (gint32 image_ID)
gboolean
gimp_image_delete (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -270,8 +301,13 @@ gimp_image_delete (gint32 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-delete",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-delete",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-delete",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -295,6 +331,7 @@ gimp_image_delete (gint32 image_ID)
GimpImageBaseType
gimp_image_base_type (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpImageBaseType base_type = 0;
@@ -303,8 +340,13 @@ gimp_image_base_type (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-base-type",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-base-type",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -330,6 +372,7 @@ gimp_image_base_type (gint32 image_ID)
GimpPrecision
gimp_image_get_precision (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpPrecision precision = 0;
@@ -338,8 +381,13 @@ gimp_image_get_precision (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-get-precision",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-precision",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -365,6 +413,7 @@ gimp_image_get_precision (gint32 image_ID)
GimpLayerMode
gimp_image_get_default_new_layer_mode (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpLayerMode mode = 0;
@@ -373,8 +422,13 @@ gimp_image_get_default_new_layer_mode (gint32 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-default-new-layer-mode",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-get-default-new-layer-mode",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-default-new-layer-mode",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -399,6 +453,7 @@ gimp_image_get_default_new_layer_mode (gint32 image_ID)
gint
gimp_image_width (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint width = 0;
@@ -407,8 +462,13 @@ gimp_image_width (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-width",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-width",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -433,6 +493,7 @@ gimp_image_width (gint32 image_ID)
gint
gimp_image_height (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint height = 0;
@@ -441,8 +502,13 @@ gimp_image_height (gint32 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-height",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-height",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-height",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -471,6 +537,7 @@ gint *
gimp_image_get_layers (gint32 image_ID,
gint *num_layers)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint *layer_ids = NULL;
@@ -479,8 +546,13 @@ gimp_image_get_layers (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-get-layers",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-layers",
+ args);
gimp_value_array_unref (args);
*num_layers = 0;
@@ -517,6 +589,7 @@ gint *
gimp_image_get_channels (gint32 image_ID,
gint *num_channels)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint *channel_ids = NULL;
@@ -525,8 +598,13 @@ gimp_image_get_channels (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-get-channels",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-channels",
+ args);
gimp_value_array_unref (args);
*num_channels = 0;
@@ -562,6 +640,7 @@ gint *
gimp_image_get_vectors (gint32 image_ID,
gint *num_vectors)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint *vector_ids = NULL;
@@ -570,8 +649,13 @@ gimp_image_get_vectors (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-get-vectors",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-vectors",
+ args);
gimp_value_array_unref (args);
*num_vectors = 0;
@@ -605,6 +689,7 @@ gimp_image_get_vectors (gint32 image_ID,
gint32
gimp_image_get_active_drawable (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 drawable_ID = -1;
@@ -613,8 +698,13 @@ gimp_image_get_active_drawable (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-get-active-drawable",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-active-drawable",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -641,6 +731,7 @@ gimp_image_get_active_drawable (gint32 image_ID)
gboolean
gimp_image_unset_active_channel (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -649,8 +740,13 @@ gimp_image_unset_active_channel (gint32 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-unset-active-channel",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-unset-active-channel",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-unset-active-channel",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -674,6 +770,7 @@ gimp_image_unset_active_channel (gint32 image_ID)
gint32
gimp_image_get_floating_sel (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 floating_sel_ID = -1;
@@ -682,8 +779,13 @@ gimp_image_get_floating_sel (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-get-floating-sel",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-floating-sel",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -709,6 +811,7 @@ gimp_image_get_floating_sel (gint32 image_ID)
gint32
gimp_image_floating_sel_attached_to (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 drawable_ID = -1;
@@ -717,8 +820,13 @@ gimp_image_floating_sel_attached_to (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-floating-sel-attached-to",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-floating-sel-attached-to",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -766,6 +874,7 @@ gimp_image_pick_color (gint32 image_ID,
gdouble average_radius,
GimpRGB *color)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -786,8 +895,13 @@ gimp_image_pick_color (gint32 image_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-pick-color",
+ args);
+ else
+ 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;
@@ -821,6 +935,7 @@ gimp_image_pick_correlate_layer (gint32 image_ID,
gint x,
gint y)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 layer_ID = -1;
@@ -833,8 +948,13 @@ gimp_image_pick_correlate_layer (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-pick-correlate-layer",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-pick-correlate-layer",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -874,6 +994,7 @@ gimp_image_insert_layer (gint32 image_ID,
gint32 parent_ID,
gint position)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -888,8 +1009,13 @@ gimp_image_insert_layer (gint32 image_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);
- return_vals = gimp_run_procedure_with_array ("gimp-image-insert-layer",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-insert-layer",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-insert-layer",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -918,6 +1044,7 @@ gboolean
gimp_image_remove_layer (gint32 image_ID,
gint32 layer_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -928,8 +1055,13 @@ gimp_image_remove_layer (gint32 image_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-remove-layer",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-remove-layer",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -960,6 +1092,7 @@ gimp_image_remove_layer (gint32 image_ID,
gboolean
gimp_image_freeze_layers (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -968,8 +1101,13 @@ gimp_image_freeze_layers (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-freeze-layers",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-freeze-layers",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -998,6 +1136,7 @@ gimp_image_freeze_layers (gint32 image_ID)
gboolean
gimp_image_thaw_layers (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1006,8 +1145,13 @@ gimp_image_thaw_layers (gint32 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-layers",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-thaw-layers",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-thaw-layers",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1041,6 +1185,7 @@ gimp_image_insert_channel (gint32 image_ID,
gint32 parent_ID,
gint position)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1055,8 +1200,13 @@ gimp_image_insert_channel (gint32 image_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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-insert-channel",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-insert-channel",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1082,6 +1232,7 @@ gboolean
gimp_image_remove_channel (gint32 image_ID,
gint32 channel_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1092,8 +1243,13 @@ gimp_image_remove_channel (gint32 image_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-remove-channel",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-remove-channel",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1125,6 +1281,7 @@ gimp_image_remove_channel (gint32 image_ID,
gboolean
gimp_image_freeze_channels (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1133,8 +1290,13 @@ gimp_image_freeze_channels (gint32 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-channels",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-freeze-channels",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-freeze-channels",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1163,6 +1325,7 @@ gimp_image_freeze_channels (gint32 image_ID)
gboolean
gimp_image_thaw_channels (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1171,8 +1334,13 @@ gimp_image_thaw_channels (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-thaw-channels",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-thaw-channels",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1206,6 +1374,7 @@ gimp_image_insert_vectors (gint32 image_ID,
gint32 parent_ID,
gint position)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1220,8 +1389,13 @@ gimp_image_insert_vectors (gint32 image_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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-insert-vectors",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-insert-vectors",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1249,6 +1423,7 @@ gboolean
gimp_image_remove_vectors (gint32 image_ID,
gint32 vectors_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1259,8 +1434,13 @@ gimp_image_remove_vectors (gint32 image_ID,
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-image-remove-vectors",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-remove-vectors",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-remove-vectors",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1292,6 +1472,7 @@ gimp_image_remove_vectors (gint32 image_ID,
gboolean
gimp_image_freeze_vectors (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1300,8 +1481,13 @@ gimp_image_freeze_vectors (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-freeze-vectors",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-freeze-vectors",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1330,6 +1516,7 @@ gimp_image_freeze_vectors (gint32 image_ID)
gboolean
gimp_image_thaw_vectors (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1338,8 +1525,13 @@ gimp_image_thaw_vectors (gint32 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-vectors",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-thaw-vectors",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-thaw-vectors",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1369,6 +1561,7 @@ gint
gimp_image_get_item_position (gint32 image_ID,
gint32 item_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint position = 0;
@@ -1379,8 +1572,13 @@ gimp_image_get_item_position (gint32 image_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-get-item-position",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-item-position",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -1409,6 +1607,7 @@ gboolean
gimp_image_raise_item (gint32 image_ID,
gint32 item_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1419,8 +1618,13 @@ gimp_image_raise_item (gint32 image_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-raise-item",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-raise-item",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1448,6 +1652,7 @@ gboolean
gimp_image_lower_item (gint32 image_ID,
gint32 item_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1458,8 +1663,13 @@ gimp_image_lower_item (gint32 image_ID,
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-lower-item",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-lower-item",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-lower-item",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1487,6 +1697,7 @@ gboolean
gimp_image_raise_item_to_top (gint32 image_ID,
gint32 item_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1497,8 +1708,13 @@ gimp_image_raise_item_to_top (gint32 image_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-raise-item-to-top",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-raise-item-to-top",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1527,6 +1743,7 @@ gboolean
gimp_image_lower_item_to_bottom (gint32 image_ID,
gint32 item_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1537,8 +1754,13 @@ gimp_image_lower_item_to_bottom (gint32 image_ID,
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-lower-item-to-bottom",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-lower-item-to-bottom",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-lower-item-to-bottom",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1569,6 +1791,7 @@ gimp_image_reorder_item (gint32 image_ID,
gint32 parent_ID,
gint position)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1583,8 +1806,13 @@ gimp_image_reorder_item (gint32 image_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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-reorder-item",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-reorder-item",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1610,6 +1838,7 @@ gimp_image_reorder_item (gint32 image_ID,
gint32
gimp_image_flatten (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 layer_ID = -1;
@@ -1618,8 +1847,13 @@ gimp_image_flatten (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-flatten",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-flatten",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -1650,6 +1884,7 @@ gint32
gimp_image_merge_visible_layers (gint32 image_ID,
GimpMergeType merge_type)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 layer_ID = -1;
@@ -1660,8 +1895,13 @@ gimp_image_merge_visible_layers (gint32 image_ID,
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);
- return_vals = gimp_run_procedure_with_array ("gimp-image-merge-visible-layers",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-merge-visible-layers",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-merge-visible-layers",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -1695,6 +1935,7 @@ gimp_image_merge_down (gint32 image_ID,
gint32 merge_layer_ID,
GimpMergeType merge_type)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 layer_ID = -1;
@@ -1707,8 +1948,13 @@ gimp_image_merge_down (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-merge-down",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-merge-down",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -1740,6 +1986,7 @@ guint8 *
_gimp_image_get_colormap (gint32 image_ID,
gint *num_bytes)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
guint8 *colormap = NULL;
@@ -1748,8 +1995,13 @@ _gimp_image_get_colormap (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-get-colormap",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-colormap",
+ args);
gimp_value_array_unref (args);
*num_bytes = 0;
@@ -1786,6 +2038,7 @@ _gimp_image_set_colormap (gint32 image_ID,
gint num_bytes,
const guint8 *colormap)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1798,8 +2051,13 @@ _gimp_image_set_colormap (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-set-colormap",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-set-colormap",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1823,6 +2081,7 @@ _gimp_image_set_colormap (gint32 image_ID,
gchar *
_gimp_image_get_metadata (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *metadata_string = NULL;
@@ -1831,8 +2090,13 @@ _gimp_image_get_metadata (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-get-metadata",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-metadata",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -1858,6 +2122,7 @@ gboolean
_gimp_image_set_metadata (gint32 image_ID,
const gchar *metadata_string)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1868,8 +2133,13 @@ _gimp_image_set_metadata (gint32 image_ID,
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);
- return_vals = gimp_run_procedure_with_array ("gimp-image-set-metadata",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-set-metadata",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-set-metadata",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1897,6 +2167,7 @@ _gimp_image_set_metadata (gint32 image_ID,
gboolean
gimp_image_clean_all (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1905,8 +2176,13 @@ gimp_image_clean_all (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-clean-all",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-clean-all",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1932,6 +2208,7 @@ gimp_image_clean_all (gint32 image_ID)
gboolean
gimp_image_is_dirty (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean dirty = FALSE;
@@ -1940,8 +2217,13 @@ gimp_image_is_dirty (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-is-dirty",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-is-dirty",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -1982,6 +2264,7 @@ _gimp_image_thumbnail (gint32 image_ID,
gint *thumbnail_data_count,
guint8 **thumbnail_data)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1994,8 +2277,13 @@ _gimp_image_thumbnail (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-thumbnail",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-thumbnail",
+ args);
gimp_value_array_unref (args);
*actual_width = 0;
@@ -2035,6 +2323,7 @@ _gimp_image_thumbnail (gint32 image_ID,
gint32
gimp_image_get_active_layer (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 active_layer_ID = -1;
@@ -2043,8 +2332,13 @@ gimp_image_get_active_layer (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-get-active-layer",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-active-layer",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -2073,6 +2367,7 @@ gboolean
gimp_image_set_active_layer (gint32 image_ID,
gint32 active_layer_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -2083,8 +2378,13 @@ gimp_image_set_active_layer (gint32 image_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-set-active-layer",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-set-active-layer",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -2108,6 +2408,7 @@ gimp_image_set_active_layer (gint32 image_ID,
gint32
gimp_image_get_active_channel (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 active_channel_ID = -1;
@@ -2116,8 +2417,13 @@ gimp_image_get_active_channel (gint32 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-channel",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-get-active-channel",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-active-channel",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -2146,6 +2452,7 @@ gboolean
gimp_image_set_active_channel (gint32 image_ID,
gint32 active_channel_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -2156,8 +2463,13 @@ gimp_image_set_active_channel (gint32 image_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-set-active-channel",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-set-active-channel",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -2180,6 +2492,7 @@ gimp_image_set_active_channel (gint32 image_ID,
gint32
gimp_image_get_active_vectors (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 active_vectors_ID = -1;
@@ -2188,8 +2501,13 @@ gimp_image_get_active_vectors (gint32 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-vectors",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-get-active-vectors",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-active-vectors",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -2215,6 +2533,7 @@ gboolean
gimp_image_set_active_vectors (gint32 image_ID,
gint32 active_vectors_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -2225,8 +2544,13 @@ gimp_image_set_active_vectors (gint32 image_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-set-active-vectors",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-set-active-vectors",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -2250,6 +2574,7 @@ gimp_image_set_active_vectors (gint32 image_ID,
gint32
gimp_image_get_selection (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 selection_ID = -1;
@@ -2258,8 +2583,13 @@ gimp_image_get_selection (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-get-selection",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-selection",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -2288,6 +2618,7 @@ gboolean
gimp_image_get_component_active (gint32 image_ID,
GimpChannelType component)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean active = FALSE;
@@ -2298,8 +2629,13 @@ gimp_image_get_component_active (gint32 image_ID,
gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
g_value_set_enum (gimp_value_array_index (args, 1), component);
- return_vals = gimp_run_procedure_with_array ("gimp-image-get-component-active",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-get-component-active",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-component-active",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -2330,6 +2666,7 @@ gimp_image_set_component_active (gint32 image_ID,
GimpChannelType component,
gboolean active)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -2342,8 +2679,13 @@ gimp_image_set_component_active (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-set-component-active",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-set-component-active",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -2372,6 +2714,7 @@ gboolean
gimp_image_get_component_visible (gint32 image_ID,
GimpChannelType component)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean visible = FALSE;
@@ -2382,8 +2725,13 @@ gimp_image_get_component_visible (gint32 image_ID,
gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
g_value_set_enum (gimp_value_array_index (args, 1), component);
- return_vals = gimp_run_procedure_with_array ("gimp-image-get-component-visible",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-get-component-visible",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-component-visible",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -2414,6 +2762,7 @@ gimp_image_set_component_visible (gint32 image_ID,
GimpChannelType component,
gboolean visible)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -2426,8 +2775,13 @@ gimp_image_set_component_visible (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-set-component-visible",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-set-component-visible",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -2455,6 +2809,7 @@ gimp_image_set_component_visible (gint32 image_ID,
gchar *
gimp_image_get_filename (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *filename = NULL;
@@ -2463,8 +2818,13 @@ gimp_image_get_filename (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-get-filename",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-filename",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -2491,6 +2851,7 @@ gboolean
gimp_image_set_filename (gint32 image_ID,
const gchar *filename)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -2501,8 +2862,13 @@ gimp_image_set_filename (gint32 image_ID,
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-image-set-filename",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-set-filename",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-set-filename",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -2534,6 +2900,7 @@ gimp_image_set_filename (gint32 image_ID,
gchar *
gimp_image_get_uri (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *uri = NULL;
@@ -2542,8 +2909,13 @@ gimp_image_get_uri (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-get-uri",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-uri",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -2571,6 +2943,7 @@ gimp_image_get_uri (gint32 image_ID)
gchar *
gimp_image_get_xcf_uri (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *uri = NULL;
@@ -2579,8 +2952,13 @@ gimp_image_get_xcf_uri (gint32 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-xcf-uri",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-get-xcf-uri",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-xcf-uri",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -2610,6 +2988,7 @@ gimp_image_get_xcf_uri (gint32 image_ID)
gchar *
gimp_image_get_imported_uri (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *uri = NULL;
@@ -2618,8 +2997,13 @@ gimp_image_get_imported_uri (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-get-imported-uri",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-imported-uri",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -2648,6 +3032,7 @@ gimp_image_get_imported_uri (gint32 image_ID)
gchar *
gimp_image_get_exported_uri (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *uri = NULL;
@@ -2656,8 +3041,13 @@ gimp_image_get_exported_uri (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-get-exported-uri",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-exported-uri",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -2688,6 +3078,7 @@ gimp_image_get_exported_uri (gint32 image_ID)
gchar *
gimp_image_get_name (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *name = NULL;
@@ -2696,8 +3087,13 @@ gimp_image_get_name (gint32 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-name",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-get-name",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-name",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -2726,6 +3122,7 @@ gimp_image_get_resolution (gint32 image_ID,
gdouble *xresolution,
gdouble *yresolution)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -2734,8 +3131,13 @@ gimp_image_get_resolution (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-get-resolution",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-resolution",
+ args);
gimp_value_array_unref (args);
*xresolution = 0.0;
@@ -2773,6 +3175,7 @@ gimp_image_set_resolution (gint32 image_ID,
gdouble xresolution,
gdouble yresolution)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -2785,8 +3188,13 @@ gimp_image_set_resolution (gint32 image_ID,
g_value_set_double (gimp_value_array_index (args, 1), xresolution);
g_value_set_double (gimp_value_array_index (args, 2), yresolution);
- return_vals = gimp_run_procedure_with_array ("gimp-image-set-resolution",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-set-resolution",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-set-resolution",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -2812,6 +3220,7 @@ gimp_image_set_resolution (gint32 image_ID,
GimpUnit
gimp_image_get_unit (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpUnit unit = 0;
@@ -2820,8 +3229,13 @@ gimp_image_get_unit (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-get-unit",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-unit",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -2851,6 +3265,7 @@ gboolean
gimp_image_set_unit (gint32 image_ID,
GimpUnit unit)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -2861,8 +3276,13 @@ gimp_image_set_unit (gint32 image_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-set-unit",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-set-unit",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -2887,6 +3307,7 @@ gimp_image_set_unit (gint32 image_ID,
gint
gimp_image_get_tattoo_state (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint tattoo_state = 0;
@@ -2895,8 +3316,13 @@ gimp_image_get_tattoo_state (gint32 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-tattoo-state",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-get-tattoo-state",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-tattoo-state",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -2933,6 +3359,7 @@ gboolean
gimp_image_set_tattoo_state (gint32 image_ID,
gint tattoo_state)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -2943,8 +3370,13 @@ gimp_image_set_tattoo_state (gint32 image_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-set-tattoo-state",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-set-tattoo-state",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -2970,6 +3402,7 @@ gint32
gimp_image_get_layer_by_tattoo (gint32 image_ID,
gint tattoo)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 layer_ID = -1;
@@ -2980,8 +3413,13 @@ gimp_image_get_layer_by_tattoo (gint32 image_ID,
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-layer-by-tattoo",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-get-layer-by-tattoo",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-layer-by-tattoo",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -3008,6 +3446,7 @@ gint32
gimp_image_get_channel_by_tattoo (gint32 image_ID,
gint tattoo)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 channel_ID = -1;
@@ -3018,8 +3457,13 @@ gimp_image_get_channel_by_tattoo (gint32 image_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-get-channel-by-tattoo",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-channel-by-tattoo",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -3048,6 +3492,7 @@ gint32
gimp_image_get_vectors_by_tattoo (gint32 image_ID,
gint tattoo)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 vectors_ID = -1;
@@ -3058,8 +3503,13 @@ gimp_image_get_vectors_by_tattoo (gint32 image_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-get-vectors-by-tattoo",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-vectors-by-tattoo",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -3088,6 +3538,7 @@ gint32
gimp_image_get_layer_by_name (gint32 image_ID,
const gchar *name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 layer_ID = -1;
@@ -3098,8 +3549,13 @@ gimp_image_get_layer_by_name (gint32 image_ID,
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-layer-by-name",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-get-layer-by-name",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-layer-by-name",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -3128,6 +3584,7 @@ gint32
gimp_image_get_channel_by_name (gint32 image_ID,
const gchar *name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 channel_ID = -1;
@@ -3138,8 +3595,13 @@ gimp_image_get_channel_by_name (gint32 image_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-get-channel-by-name",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-channel-by-name",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -3168,6 +3630,7 @@ gint32
gimp_image_get_vectors_by_name (gint32 image_ID,
const gchar *name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 vectors_ID = -1;
@@ -3178,8 +3641,13 @@ gimp_image_get_vectors_by_name (gint32 image_ID,
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-vectors-by-name",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-get-vectors-by-name",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-vectors-by-name",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -3208,6 +3676,7 @@ gboolean
gimp_image_attach_parasite (gint32 image_ID,
const GimpParasite *parasite)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -3218,8 +3687,13 @@ gimp_image_attach_parasite (gint32 image_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-attach-parasite",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-attach-parasite",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -3247,6 +3721,7 @@ gboolean
gimp_image_detach_parasite (gint32 image_ID,
const gchar *name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -3257,8 +3732,13 @@ gimp_image_detach_parasite (gint32 image_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-detach-parasite",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-detach-parasite",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -3286,6 +3766,7 @@ GimpParasite *
gimp_image_get_parasite (gint32 image_ID,
const gchar *name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpParasite *parasite = NULL;
@@ -3296,8 +3777,13 @@ gimp_image_get_parasite (gint32 image_ID,
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-parasite",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-get-parasite",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-parasite",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -3327,6 +3813,7 @@ gchar **
gimp_image_get_parasite_list (gint32 image_ID,
gint *num_parasites)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar **parasites = NULL;
@@ -3335,8 +3822,13 @@ gimp_image_get_parasite_list (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-get-parasite-list",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-parasite-list",
+ args);
gimp_value_array_unref (args);
*num_parasites = 0;
diff --git a/libgimp/gimpimagecolorprofile_pdb.c b/libgimp/gimpimagecolorprofile_pdb.c
index 8077af8e5b..8ebcdd910a 100644
--- a/libgimp/gimpimagecolorprofile_pdb.c
+++ b/libgimp/gimpimagecolorprofile_pdb.c
@@ -54,6 +54,7 @@ guint8 *
_gimp_image_get_color_profile (gint32 image_ID,
gint *num_bytes)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
guint8 *profile_data = NULL;
@@ -62,8 +63,13 @@ _gimp_image_get_color_profile (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-get-color-profile",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-color-profile",
+ args);
gimp_value_array_unref (args);
*num_bytes = 0;
@@ -102,6 +108,7 @@ guint8 *
_gimp_image_get_effective_color_profile (gint32 image_ID,
gint *num_bytes)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
guint8 *profile_data = NULL;
@@ -110,8 +117,13 @@ _gimp_image_get_effective_color_profile (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-get-effective-color-profile",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-effective-color-profile",
+ args);
gimp_value_array_unref (args);
*num_bytes = 0;
@@ -150,6 +162,7 @@ _gimp_image_set_color_profile (gint32 image_ID,
gint num_bytes,
const guint8 *color_profile)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -162,8 +175,13 @@ _gimp_image_set_color_profile (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-set-color-profile",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-set-color-profile",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -195,6 +213,7 @@ gboolean
gimp_image_set_color_profile_from_file (gint32 image_ID,
const gchar *uri)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -205,8 +224,13 @@ gimp_image_set_color_profile_from_file (gint32 image_ID,
gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
g_value_set_string (gimp_value_array_index (args, 1), uri);
- return_vals = gimp_run_procedure_with_array ("gimp-image-set-color-profile-from-file",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-set-color-profile-from-file",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-set-color-profile-from-file",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -242,6 +266,7 @@ _gimp_image_convert_color_profile (gint32 image_ID,
GimpColorRenderingIntent intent,
gboolean bpc)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -258,8 +283,13 @@ _gimp_image_convert_color_profile (gint32 image_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-convert-color-profile",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-convert-color-profile",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -293,6 +323,7 @@ gimp_image_convert_color_profile_from_file (gint32 image_ID,
GimpColorRenderingIntent intent,
gboolean bpc)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -307,8 +338,13 @@ gimp_image_convert_color_profile_from_file (gint32 image_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-convert-color-profile-from-file",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-convert-color-profile-from-file",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
diff --git a/libgimp/gimpimageconvert_pdb.c b/libgimp/gimpimageconvert_pdb.c
index 7e27889c03..4539d2b87b 100644
--- a/libgimp/gimpimageconvert_pdb.c
+++ b/libgimp/gimpimageconvert_pdb.c
@@ -50,6 +50,7 @@
gboolean
gimp_image_convert_rgb (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -58,8 +59,13 @@ gimp_image_convert_rgb (gint32 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-rgb",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-convert-rgb",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-convert-rgb",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -83,6 +89,7 @@ gimp_image_convert_rgb (gint32 image_ID)
gboolean
gimp_image_convert_grayscale (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -91,8 +98,13 @@ gimp_image_convert_grayscale (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-convert-grayscale",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-convert-grayscale",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -139,6 +151,7 @@ gimp_image_convert_indexed (gint32 image_ID,
gboolean remove_unused,
const gchar *palette)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -159,8 +172,13 @@ gimp_image_convert_indexed (gint32 image_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-convert-indexed",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-convert-indexed",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -192,6 +210,7 @@ gimp_image_convert_set_dither_matrix (gint width,
gint matrix_length,
const guint8 *matrix)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -206,8 +225,13 @@ gimp_image_convert_set_dither_matrix (gint width,
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);
- return_vals = gimp_run_procedure_with_array ("gimp-image-convert-set-dither-matrix",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-convert-set-dither-matrix",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-convert-set-dither-matrix",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -236,6 +260,7 @@ gboolean
gimp_image_convert_precision (gint32 image_ID,
GimpPrecision precision)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -246,8 +271,13 @@ gimp_image_convert_precision (gint32 image_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-convert-precision",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-convert-precision",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
diff --git a/libgimp/gimpimagegrid_pdb.c b/libgimp/gimpimagegrid_pdb.c
index ff0322edde..1650af812d 100644
--- a/libgimp/gimpimagegrid_pdb.c
+++ b/libgimp/gimpimagegrid_pdb.c
@@ -54,6 +54,7 @@ gimp_image_grid_get_spacing (gint32 image_ID,
gdouble *xspacing,
gdouble *yspacing)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -62,8 +63,13 @@ gimp_image_grid_get_spacing (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-grid-get-spacing",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-grid-get-spacing",
+ args);
gimp_value_array_unref (args);
*xspacing = 0.0;
@@ -102,6 +108,7 @@ gimp_image_grid_set_spacing (gint32 image_ID,
gdouble xspacing,
gdouble yspacing)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -114,8 +121,13 @@ gimp_image_grid_set_spacing (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-grid-set-spacing",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-grid-set-spacing",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -145,6 +157,7 @@ gimp_image_grid_get_offset (gint32 image_ID,
gdouble *xoffset,
gdouble *yoffset)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -153,8 +166,13 @@ gimp_image_grid_get_offset (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-grid-get-offset",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-grid-get-offset",
+ args);
gimp_value_array_unref (args);
*xoffset = 0.0;
@@ -193,6 +211,7 @@ gimp_image_grid_set_offset (gint32 image_ID,
gdouble xoffset,
gdouble yoffset)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -205,8 +224,13 @@ gimp_image_grid_set_offset (gint32 image_ID,
g_value_set_double (gimp_value_array_index (args, 1), xoffset);
g_value_set_double (gimp_value_array_index (args, 2), yoffset);
- return_vals = gimp_run_procedure_with_array ("gimp-image-grid-set-offset",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-grid-set-offset",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-grid-set-offset",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -233,6 +257,7 @@ gboolean
gimp_image_grid_get_foreground_color (gint32 image_ID,
GimpRGB *fgcolor)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -241,8 +266,13 @@ gimp_image_grid_get_foreground_color (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-grid-get-foreground-color",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-grid-get-foreground-color",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -272,6 +302,7 @@ gboolean
gimp_image_grid_set_foreground_color (gint32 image_ID,
const GimpRGB *fgcolor)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -282,8 +313,13 @@ gimp_image_grid_set_foreground_color (gint32 image_ID,
gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
gimp_value_set_rgb (gimp_value_array_index (args, 1), fgcolor);
- return_vals = gimp_run_procedure_with_array ("gimp-image-grid-set-foreground-color",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-grid-set-foreground-color",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-grid-set-foreground-color",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -310,6 +346,7 @@ gboolean
gimp_image_grid_get_background_color (gint32 image_ID,
GimpRGB *bgcolor)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -318,8 +355,13 @@ gimp_image_grid_get_background_color (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-grid-get-background-color",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-grid-get-background-color",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -349,6 +391,7 @@ gboolean
gimp_image_grid_set_background_color (gint32 image_ID,
const GimpRGB *bgcolor)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -359,8 +402,13 @@ gimp_image_grid_set_background_color (gint32 image_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-grid-set-background-color",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-grid-set-background-color",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -385,6 +433,7 @@ gimp_image_grid_set_background_color (gint32 image_ID,
GimpGridStyle
gimp_image_grid_get_style (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpGridStyle style = 0;
@@ -393,8 +442,13 @@ gimp_image_grid_get_style (gint32 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-style",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-grid-get-style",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-grid-get-style",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -423,6 +477,7 @@ gboolean
gimp_image_grid_set_style (gint32 image_ID,
GimpGridStyle style)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -433,8 +488,13 @@ gimp_image_grid_set_style (gint32 image_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-grid-set-style",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-grid-set-style",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
diff --git a/libgimp/gimpimageguides_pdb.c b/libgimp/gimpimageguides_pdb.c
index 54c82e7a8e..8394fed6f1 100644
--- a/libgimp/gimpimageguides_pdb.c
+++ b/libgimp/gimpimageguides_pdb.c
@@ -51,6 +51,7 @@ gint32
gimp_image_add_hguide (gint32 image_ID,
gint yposition)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 guide_ID = -1;
@@ -61,8 +62,13 @@ gimp_image_add_hguide (gint32 image_ID,
gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
g_value_set_int (gimp_value_array_index (args, 1), yposition);
- return_vals = gimp_run_procedure_with_array ("gimp-image-add-hguide",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-add-hguide",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-add-hguide",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -90,6 +96,7 @@ gint32
gimp_image_add_vguide (gint32 image_ID,
gint xposition)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 guide_ID = -1;
@@ -100,8 +107,13 @@ gimp_image_add_vguide (gint32 image_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-add-vguide",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-add-vguide",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -128,6 +140,7 @@ gboolean
gimp_image_delete_guide (gint32 image_ID,
gint32 guide_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -138,8 +151,13 @@ gimp_image_delete_guide (gint32 image_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-delete-guide",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-delete-guide",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -168,6 +186,7 @@ gint32
gimp_image_find_next_guide (gint32 image_ID,
gint32 guide_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 next_guide_ID = -1;
@@ -178,8 +197,13 @@ gimp_image_find_next_guide (gint32 image_ID,
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-find-next-guide",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-find-next-guide",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-find-next-guide",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -206,6 +230,7 @@ GimpOrientationType
gimp_image_get_guide_orientation (gint32 image_ID,
gint32 guide_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpOrientationType orientation = GIMP_ORIENTATION_UNKNOWN;
@@ -216,8 +241,13 @@ gimp_image_get_guide_orientation (gint32 image_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-get-guide-orientation",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-guide-orientation",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -244,6 +274,7 @@ gint
gimp_image_get_guide_position (gint32 image_ID,
gint32 guide_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint position = G_MININT /* GIMP_GUIDE_POSITION_UNDEFINED */;
@@ -254,8 +285,13 @@ gimp_image_get_guide_position (gint32 image_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-get-guide-position",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-guide-position",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
diff --git a/libgimp/gimpimagesamplepoints_pdb.c b/libgimp/gimpimagesamplepoints_pdb.c
index 132dc93a5b..5855224e78 100644
--- a/libgimp/gimpimagesamplepoints_pdb.c
+++ b/libgimp/gimpimagesamplepoints_pdb.c
@@ -55,6 +55,7 @@ gimp_image_add_sample_point (gint32 image_ID,
gint position_x,
gint position_y)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 sample_point_ID = -1;
@@ -67,8 +68,13 @@ gimp_image_add_sample_point (gint32 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);
- return_vals = gimp_run_procedure_with_array ("gimp-image-add-sample-point",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-add-sample-point",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-add-sample-point",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -97,6 +103,7 @@ gboolean
gimp_image_delete_sample_point (gint32 image_ID,
gint32 sample_point_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -107,8 +114,13 @@ gimp_image_delete_sample_point (gint32 image_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-delete-sample-point",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-delete-sample-point",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -140,6 +152,7 @@ gint32
gimp_image_find_next_sample_point (gint32 image_ID,
gint32 sample_point_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 next_sample_point_ID = -1;
@@ -150,8 +163,13 @@ gimp_image_find_next_sample_point (gint32 image_ID,
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-find-next-sample-point",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-find-next-sample-point",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-find-next-sample-point",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -183,6 +201,7 @@ gimp_image_get_sample_point_position (gint32 image_ID,
gint32 sample_point_ID,
gint *position_y)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint position_x = G_MININT;
@@ -193,8 +212,13 @@ gimp_image_get_sample_point_position (gint32 image_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-get-sample-point-position",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-get-sample-point-position",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
diff --git a/libgimp/gimpimageselect_pdb.c b/libgimp/gimpimageselect_pdb.c
index 0ae9966ee4..5e5f90024c 100644
--- a/libgimp/gimpimageselect_pdb.c
+++ b/libgimp/gimpimageselect_pdb.c
@@ -71,6 +71,7 @@ gimp_image_select_color (gint32 image_ID,
gint32 drawable_ID,
const GimpRGB *color)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -85,8 +86,13 @@ gimp_image_select_color (gint32 image_ID,
gimp_value_set_drawable_id (gimp_value_array_index (args, 2), drawable_ID);
gimp_value_set_rgb (gimp_value_array_index (args, 3), color);
- return_vals = gimp_run_procedure_with_array ("gimp-image-select-color",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-select-color",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-select-color",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -144,6 +150,7 @@ gimp_image_select_contiguous_color (gint32 image_ID,
gdouble x,
gdouble y)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -160,8 +167,13 @@ gimp_image_select_contiguous_color (gint32 image_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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-select-contiguous-color",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-select-contiguous-color",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -201,6 +213,7 @@ gimp_image_select_rectangle (gint32 image_ID,
gdouble width,
gdouble height)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -219,8 +232,13 @@ gimp_image_select_rectangle (gint32 image_ID,
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-rectangle",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-select-rectangle",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-select-rectangle",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -267,6 +285,7 @@ gimp_image_select_round_rectangle (gint32 image_ID,
gdouble corner_radius_x,
gdouble corner_radius_y)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -289,8 +308,13 @@ gimp_image_select_round_rectangle (gint32 image_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-select-round-rectangle",
+ args);
+ else
+ 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;
@@ -331,6 +355,7 @@ gimp_image_select_ellipse (gint32 image_ID,
gdouble width,
gdouble height)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -349,8 +374,13 @@ gimp_image_select_ellipse (gint32 image_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-select-ellipse",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-select-ellipse",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -392,6 +422,7 @@ gimp_image_select_polygon (gint32 image_ID,
gint num_segs,
const gdouble *segs)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -406,8 +437,13 @@ gimp_image_select_polygon (gint32 image_ID,
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);
- return_vals = gimp_run_procedure_with_array ("gimp-image-select-polygon",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-select-polygon",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-select-polygon",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -443,6 +479,7 @@ gimp_image_select_item (gint32 image_ID,
GimpChannelOps operation,
gint32 item_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -455,8 +492,13 @@ gimp_image_select_item (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-select-item",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-select-item",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
diff --git a/libgimp/gimpimagetransform_pdb.c b/libgimp/gimpimagetransform_pdb.c
index 2847f1cfc0..7efbe2ab2b 100644
--- a/libgimp/gimpimagetransform_pdb.c
+++ b/libgimp/gimpimagetransform_pdb.c
@@ -61,6 +61,7 @@ gimp_image_resize (gint32 image_ID,
gint offx,
gint offy)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -77,8 +78,13 @@ gimp_image_resize (gint32 image_ID,
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-image-resize",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-resize",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-resize",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -106,6 +112,7 @@ gimp_image_resize (gint32 image_ID,
gboolean
gimp_image_resize_to_layers (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -114,8 +121,13 @@ gimp_image_resize_to_layers (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-resize-to-layers",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-resize-to-layers",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -146,6 +158,7 @@ gimp_image_scale (gint32 image_ID,
gint new_width,
gint new_height)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -158,8 +171,13 @@ gimp_image_scale (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-scale",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-scale",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -195,6 +213,7 @@ gimp_image_crop (gint32 image_ID,
gint offx,
gint offy)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -211,8 +230,13 @@ gimp_image_crop (gint32 image_ID,
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-image-crop",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-crop",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-crop",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -237,6 +261,7 @@ gboolean
gimp_image_flip (gint32 image_ID,
GimpOrientationType flip_type)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -247,8 +272,13 @@ gimp_image_flip (gint32 image_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-flip",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-flip",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -273,6 +303,7 @@ gboolean
gimp_image_rotate (gint32 image_ID,
GimpRotationType rotate_type)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -283,8 +314,13 @@ gimp_image_rotate (gint32 image_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-rotate",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-rotate",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
diff --git a/libgimp/gimpimageundo_pdb.c b/libgimp/gimpimageundo_pdb.c
index 342bd65b8d..20202f25e3 100644
--- a/libgimp/gimpimageundo_pdb.c
+++ b/libgimp/gimpimageundo_pdb.c
@@ -50,6 +50,7 @@
gboolean
gimp_image_undo_group_start (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -58,8 +59,13 @@ gimp_image_undo_group_start (gint32 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-start",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-undo-group-start",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-undo-group-start",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -83,6 +89,7 @@ gimp_image_undo_group_start (gint32 image_ID)
gboolean
gimp_image_undo_group_end (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -91,8 +98,13 @@ gimp_image_undo_group_end (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-undo-group-end",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-undo-group-end",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -118,6 +130,7 @@ gimp_image_undo_group_end (gint32 image_ID)
gboolean
gimp_image_undo_is_enabled (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean enabled = FALSE;
@@ -126,8 +139,13 @@ gimp_image_undo_is_enabled (gint32 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-is-enabled",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-undo-is-enabled",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-undo-is-enabled",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -155,6 +173,7 @@ gimp_image_undo_is_enabled (gint32 image_ID)
gboolean
gimp_image_undo_disable (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean disabled = FALSE;
@@ -163,8 +182,13 @@ gimp_image_undo_disable (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-undo-disable",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-undo-disable",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -191,6 +215,7 @@ gimp_image_undo_disable (gint32 image_ID)
gboolean
gimp_image_undo_enable (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean enabled = FALSE;
@@ -199,8 +224,13 @@ gimp_image_undo_enable (gint32 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-enable",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-undo-enable",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-undo-enable",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -234,6 +264,7 @@ gimp_image_undo_enable (gint32 image_ID)
gboolean
gimp_image_undo_freeze (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean frozen = FALSE;
@@ -242,8 +273,13 @@ gimp_image_undo_freeze (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-undo-freeze",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-undo-freeze",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -276,6 +312,7 @@ gimp_image_undo_freeze (gint32 image_ID)
gboolean
gimp_image_undo_thaw (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean thawed = FALSE;
@@ -284,8 +321,13 @@ gimp_image_undo_thaw (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-image-undo-thaw",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-image-undo-thaw",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
diff --git a/libgimp/gimpitem_pdb.c b/libgimp/gimpitem_pdb.c
index e1d53ab201..e270fd181c 100644
--- a/libgimp/gimpitem_pdb.c
+++ b/libgimp/gimpitem_pdb.c
@@ -50,6 +50,7 @@
gboolean
gimp_item_is_valid (gint32 item_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean valid = FALSE;
@@ -58,8 +59,13 @@ gimp_item_is_valid (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-item-is-valid",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-item-is-valid",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -85,6 +91,7 @@ gimp_item_is_valid (gint32 item_ID)
gint32
gimp_item_get_image (gint32 item_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 image_ID = -1;
@@ -93,8 +100,13 @@ gimp_item_get_image (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-item-get-image",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-item-get-image",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -124,6 +136,7 @@ gimp_item_get_image (gint32 item_ID)
gboolean
gimp_item_delete (gint32 item_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -132,8 +145,13 @@ gimp_item_delete (gint32 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-delete",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-item-delete",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-item-delete",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -158,6 +176,7 @@ gimp_item_delete (gint32 item_ID)
gboolean
gimp_item_is_drawable (gint32 item_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean drawable = FALSE;
@@ -166,8 +185,13 @@ gimp_item_is_drawable (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-item-is-drawable",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-item-is-drawable",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -193,6 +217,7 @@ gimp_item_is_drawable (gint32 item_ID)
gboolean
gimp_item_is_layer (gint32 item_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean layer = FALSE;
@@ -201,8 +226,13 @@ gimp_item_is_layer (gint32 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",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-item-is-layer",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-item-is-layer",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -228,6 +258,7 @@ gimp_item_is_layer (gint32 item_ID)
gboolean
gimp_item_is_text_layer (gint32 item_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean text_layer = FALSE;
@@ -236,8 +267,13 @@ gimp_item_is_text_layer (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-item-is-text-layer",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-item-is-text-layer",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -263,6 +299,7 @@ gimp_item_is_text_layer (gint32 item_ID)
gboolean
gimp_item_is_channel (gint32 item_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean channel = FALSE;
@@ -271,8 +308,13 @@ gimp_item_is_channel (gint32 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-channel",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-item-is-channel",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-item-is-channel",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -298,6 +340,7 @@ gimp_item_is_channel (gint32 item_ID)
gboolean
gimp_item_is_layer_mask (gint32 item_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean layer_mask = FALSE;
@@ -306,8 +349,13 @@ gimp_item_is_layer_mask (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-item-is-layer-mask",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-item-is-layer-mask",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -333,6 +381,7 @@ gimp_item_is_layer_mask (gint32 item_ID)
gboolean
gimp_item_is_selection (gint32 item_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean selection = FALSE;
@@ -341,8 +390,13 @@ gimp_item_is_selection (gint32 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-selection",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-item-is-selection",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-item-is-selection",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -368,6 +422,7 @@ gimp_item_is_selection (gint32 item_ID)
gboolean
gimp_item_is_vectors (gint32 item_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean vectors = FALSE;
@@ -376,8 +431,13 @@ gimp_item_is_vectors (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-item-is-vectors",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-item-is-vectors",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -404,6 +464,7 @@ gimp_item_is_vectors (gint32 item_ID)
gboolean
gimp_item_is_group (gint32 item_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean group = FALSE;
@@ -412,8 +473,13 @@ gimp_item_is_group (gint32 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-group",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-item-is-group",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-item-is-group",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -439,6 +505,7 @@ gimp_item_is_group (gint32 item_ID)
gint32
gimp_item_get_parent (gint32 item_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 parent_ID = -1;
@@ -447,8 +514,13 @@ gimp_item_get_parent (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-item-get-parent",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-item-get-parent",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -479,6 +551,7 @@ gint *
gimp_item_get_children (gint32 item_ID,
gint *num_children)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint *child_ids = NULL;
@@ -487,8 +560,13 @@ gimp_item_get_children (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-item-get-children",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-item-get-children",
+ args);
gimp_value_array_unref (args);
*num_children = 0;
@@ -519,6 +597,7 @@ gimp_item_get_children (gint32 item_ID,
gboolean
gimp_item_get_expanded (gint32 item_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean expanded = FALSE;
@@ -527,8 +606,13 @@ gimp_item_get_expanded (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-item-get-expanded",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-item-get-expanded",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -556,6 +640,7 @@ gboolean
gimp_item_set_expanded (gint32 item_ID,
gboolean expanded)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -566,8 +651,13 @@ gimp_item_set_expanded (gint32 item_ID,
gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
g_value_set_boolean (gimp_value_array_index (args, 1), expanded);
- return_vals = gimp_run_procedure_with_array ("gimp-item-set-expanded",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-item-set-expanded",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-item-set-expanded",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -593,6 +683,7 @@ gimp_item_set_expanded (gint32 item_ID,
gchar *
gimp_item_get_name (gint32 item_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *name = NULL;
@@ -601,8 +692,13 @@ gimp_item_get_name (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-item-get-name",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-item-get-name",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -630,6 +726,7 @@ gboolean
gimp_item_set_name (gint32 item_ID,
const gchar *name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -640,8 +737,13 @@ gimp_item_set_name (gint32 item_ID,
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-set-name",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-item-set-name",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-item-set-name",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -666,6 +768,7 @@ gimp_item_set_name (gint32 item_ID,
gboolean
gimp_item_get_visible (gint32 item_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean visible = FALSE;
@@ -674,8 +777,13 @@ gimp_item_get_visible (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-item-get-visible",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-item-get-visible",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -703,6 +811,7 @@ gboolean
gimp_item_set_visible (gint32 item_ID,
gboolean visible)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -713,8 +822,13 @@ gimp_item_set_visible (gint32 item_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-item-set-visible",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-item-set-visible",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -739,6 +853,7 @@ gimp_item_set_visible (gint32 item_ID,
gboolean
gimp_item_get_linked (gint32 item_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean linked = FALSE;
@@ -747,8 +862,13 @@ gimp_item_get_linked (gint32 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-linked",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-item-get-linked",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-item-get-linked",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -776,6 +896,7 @@ gboolean
gimp_item_set_linked (gint32 item_ID,
gboolean linked)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -786,8 +907,13 @@ gimp_item_set_linked (gint32 item_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-item-set-linked",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-item-set-linked",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -812,6 +938,7 @@ gimp_item_set_linked (gint32 item_ID,
gboolean
gimp_item_get_lock_content (gint32 item_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean lock_content = FALSE;
@@ -820,8 +947,13 @@ gimp_item_get_lock_content (gint32 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-lock-content",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-item-get-lock-content",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-item-get-lock-content",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -849,6 +981,7 @@ gboolean
gimp_item_set_lock_content (gint32 item_ID,
gboolean lock_content)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -859,8 +992,13 @@ gimp_item_set_lock_content (gint32 item_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-item-set-lock-content",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-item-set-lock-content",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -885,6 +1023,7 @@ gimp_item_set_lock_content (gint32 item_ID,
gboolean
gimp_item_get_lock_position (gint32 item_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean lock_position = FALSE;
@@ -893,8 +1032,13 @@ gimp_item_get_lock_position (gint32 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-lock-position",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-item-get-lock-position",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-item-get-lock-position",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -922,6 +1066,7 @@ gboolean
gimp_item_set_lock_position (gint32 item_ID,
gboolean lock_position)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -932,8 +1077,13 @@ gimp_item_set_lock_position (gint32 item_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-item-set-lock-position",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-item-set-lock-position",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -958,6 +1108,7 @@ gimp_item_set_lock_position (gint32 item_ID,
GimpColorTag
gimp_item_get_color_tag (gint32 item_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpColorTag color_tag = 0;
@@ -966,8 +1117,13 @@ gimp_item_get_color_tag (gint32 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-color-tag",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-item-get-color-tag",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-item-get-color-tag",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -995,6 +1151,7 @@ gboolean
gimp_item_set_color_tag (gint32 item_ID,
GimpColorTag color_tag)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1005,8 +1162,13 @@ gimp_item_set_color_tag (gint32 item_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-item-set-color-tag",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-item-set-color-tag",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1033,6 +1195,7 @@ gimp_item_set_color_tag (gint32 item_ID,
gint
gimp_item_get_tattoo (gint32 item_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint tattoo = 0;
@@ -1041,8 +1204,13 @@ gimp_item_get_tattoo (gint32 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-tattoo",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-item-get-tattoo",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-item-get-tattoo",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -1072,6 +1240,7 @@ gboolean
gimp_item_set_tattoo (gint32 item_ID,
gint tattoo)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1082,8 +1251,13 @@ gimp_item_set_tattoo (gint32 item_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-item-set-tattoo",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-item-set-tattoo",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1111,6 +1285,7 @@ gboolean
gimp_item_attach_parasite (gint32 item_ID,
const GimpParasite *parasite)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1121,8 +1296,13 @@ gimp_item_attach_parasite (gint32 item_ID,
gimp_value_set_item_id (gimp_value_array_index (args, 0), item_ID);
g_value_set_boxed (gimp_value_array_index (args, 1), parasite);
- return_vals = gimp_run_procedure_with_array ("gimp-item-attach-parasite",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-item-attach-parasite",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-item-attach-parasite",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1150,6 +1330,7 @@ gboolean
gimp_item_detach_parasite (gint32 item_ID,
const gchar *name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1160,8 +1341,13 @@ gimp_item_detach_parasite (gint32 item_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-item-detach-parasite",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-item-detach-parasite",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1188,6 +1374,7 @@ GimpParasite *
gimp_item_get_parasite (gint32 item_ID,
const gchar *name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpParasite *parasite = NULL;
@@ -1198,8 +1385,13 @@ gimp_item_get_parasite (gint32 item_ID,
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-get-parasite",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-item-get-parasite",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-item-get-parasite",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -1229,6 +1421,7 @@ gchar **
gimp_item_get_parasite_list (gint32 item_ID,
gint *num_parasites)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar **parasites = NULL;
@@ -1237,8 +1430,13 @@ gimp_item_get_parasite_list (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-item-get-parasite-list",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-item-get-parasite-list",
+ args);
gimp_value_array_unref (args);
*num_parasites = 0;
diff --git a/libgimp/gimpitemtransform_pdb.c b/libgimp/gimpitemtransform_pdb.c
index 3a0f8aaebd..34e49f9959 100644
--- a/libgimp/gimpitemtransform_pdb.c
+++ b/libgimp/gimpitemtransform_pdb.c
@@ -61,6 +61,7 @@ gimp_item_transform_translate (gint32 item_ID,
gdouble off_x,
gdouble off_y)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 ret_item_ID = -1;
@@ -73,8 +74,13 @@ gimp_item_transform_translate (gint32 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);
- return_vals = gimp_run_procedure_with_array ("gimp-item-transform-translate",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-item-transform-translate",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-item-transform-translate",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -124,6 +130,7 @@ gimp_item_transform_flip_simple (gint32 item_ID,
gboolean auto_center,
gdouble axis)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 ret_item_ID = -1;
@@ -138,8 +145,13 @@ gimp_item_transform_flip_simple (gint32 item_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-item-transform-flip-simple",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-item-transform-flip-simple",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -191,6 +203,7 @@ gimp_item_transform_flip (gint32 item_ID,
gdouble x1,
gdouble y1)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 ret_item_ID = -1;
@@ -207,8 +220,13 @@ gimp_item_transform_flip (gint32 item_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-item-transform-flip",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-item-transform-flip",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -277,6 +295,7 @@ gimp_item_transform_perspective (gint32 item_ID,
gdouble x3,
gdouble y3)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 ret_item_ID = -1;
@@ -301,8 +320,13 @@ gimp_item_transform_perspective (gint32 item_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-item-transform-perspective",
+ args);
+ else
+ 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)
@@ -357,6 +381,7 @@ gimp_item_transform_rotate_simple (gint32 item_ID,
gdouble center_x,
gdouble center_y)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 ret_item_ID = -1;
@@ -373,8 +398,13 @@ gimp_item_transform_rotate_simple (gint32 item_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-item-transform-rotate-simple",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-item-transform-rotate-simple",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -431,6 +461,7 @@ gimp_item_transform_rotate (gint32 item_ID,
gdouble center_x,
gdouble center_y)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 ret_item_ID = -1;
@@ -447,8 +478,13 @@ gimp_item_transform_rotate (gint32 item_ID,
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",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-item-transform-rotate",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-item-transform-rotate",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -502,6 +538,7 @@ gimp_item_transform_scale (gint32 item_ID,
gdouble x1,
gdouble y1)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 ret_item_ID = -1;
@@ -518,8 +555,13 @@ gimp_item_transform_scale (gint32 item_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-item-transform-scale",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-item-transform-scale",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -571,6 +613,7 @@ gimp_item_transform_shear (gint32 item_ID,
GimpOrientationType shear_type,
gdouble magnitude)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 ret_item_ID = -1;
@@ -583,8 +626,13 @@ gimp_item_transform_shear (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-item-transform-shear",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-item-transform-shear",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -647,6 +695,7 @@ gimp_item_transform_2d (gint32 item_ID,
gdouble dest_x,
gdouble dest_y)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 ret_item_ID = -1;
@@ -669,8 +718,13 @@ gimp_item_transform_2d (gint32 item_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-item-transform-2d",
+ args);
+ else
+ 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)
@@ -735,6 +789,7 @@ gimp_item_transform_matrix (gint32 item_ID,
gdouble coeff_2_1,
gdouble coeff_2_2)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 ret_item_ID = -1;
@@ -761,8 +816,13 @@ gimp_item_transform_matrix (gint32 item_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-item-transform-matrix",
+ args);
+ else
+ 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)
diff --git a/libgimp/gimplayer_pdb.c b/libgimp/gimplayer_pdb.c
index f6c7482635..412fa82327 100644
--- a/libgimp/gimplayer_pdb.c
+++ b/libgimp/gimplayer_pdb.c
@@ -64,6 +64,7 @@ _gimp_layer_new (gint32 image_ID,
gdouble opacity,
GimpLayerMode mode)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 layer_ID = -1;
@@ -84,8 +85,13 @@ _gimp_layer_new (gint32 image_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-layer-new",
+ args);
+ else
+ 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)
@@ -119,6 +125,7 @@ gimp_layer_new_from_visible (gint32 image_ID,
gint32 dest_image_ID,
const gchar *name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 layer_ID = -1;
@@ -131,8 +138,13 @@ gimp_layer_new_from_visible (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-layer-new-from-visible",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-new-from-visible",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -162,6 +174,7 @@ gint32
gimp_layer_new_from_drawable (gint32 drawable_ID,
gint32 dest_image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 layer_copy_ID = -1;
@@ -172,8 +185,13 @@ gimp_layer_new_from_drawable (gint32 drawable_ID,
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);
- return_vals = gimp_run_procedure_with_array ("gimp-layer-new-from-drawable",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-layer-new-from-drawable",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-new-from-drawable",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -205,6 +223,7 @@ gimp_layer_new_from_drawable (gint32 drawable_ID,
gint32
gimp_layer_group_new (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 layer_group_ID = -1;
@@ -213,8 +232,13 @@ gimp_layer_group_new (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-layer-group-new",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-group-new",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -245,6 +269,7 @@ gint32
_gimp_layer_copy (gint32 layer_ID,
gboolean add_alpha)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 layer_copy_ID = -1;
@@ -255,8 +280,13 @@ _gimp_layer_copy (gint32 layer_ID,
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);
- return_vals = gimp_run_procedure_with_array ("gimp-layer-copy",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-layer-copy",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-copy",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -284,6 +314,7 @@ _gimp_layer_copy (gint32 layer_ID,
gboolean
gimp_layer_add_alpha (gint32 layer_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -292,8 +323,13 @@ gimp_layer_add_alpha (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-layer-add-alpha",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-add-alpha",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -321,6 +357,7 @@ gimp_layer_add_alpha (gint32 layer_ID)
gboolean
gimp_layer_flatten (gint32 layer_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -329,8 +366,13 @@ gimp_layer_flatten (gint32 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-flatten",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-layer-flatten",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-flatten",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -364,6 +406,7 @@ gimp_layer_scale (gint32 layer_ID,
gint new_height,
gboolean local_origin)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -378,8 +421,13 @@ gimp_layer_scale (gint32 layer_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-layer-scale",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-scale",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -413,6 +461,7 @@ gimp_layer_resize (gint32 layer_ID,
gint offx,
gint offy)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -429,8 +478,13 @@ gimp_layer_resize (gint32 layer_ID,
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-layer-resize",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-layer-resize",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-resize",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -454,6 +508,7 @@ gimp_layer_resize (gint32 layer_ID,
gboolean
gimp_layer_resize_to_image_size (gint32 layer_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -462,8 +517,13 @@ gimp_layer_resize_to_image_size (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-layer-resize-to-image-size",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-resize-to-image-size",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -492,6 +552,7 @@ gimp_layer_set_offsets (gint32 layer_ID,
gint offx,
gint offy)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -504,8 +565,13 @@ gimp_layer_set_offsets (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-layer-set-offsets",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-set-offsets",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -549,6 +615,7 @@ gint32
gimp_layer_create_mask (gint32 layer_ID,
GimpAddMaskType mask_type)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 mask_ID = -1;
@@ -559,8 +626,13 @@ gimp_layer_create_mask (gint32 layer_ID,
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);
- return_vals = gimp_run_procedure_with_array ("gimp-layer-create-mask",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-layer-create-mask",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-create-mask",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -585,6 +657,7 @@ gimp_layer_create_mask (gint32 layer_ID,
gint32
gimp_layer_get_mask (gint32 layer_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 mask_ID = -1;
@@ -593,8 +666,13 @@ gimp_layer_get_mask (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-layer-get-mask",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-get-mask",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -621,6 +699,7 @@ gimp_layer_get_mask (gint32 layer_ID)
gint32
gimp_layer_from_mask (gint32 mask_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 layer_ID = -1;
@@ -629,8 +708,13 @@ gimp_layer_from_mask (gint32 mask_ID)
G_TYPE_NONE);
gimp_value_set_layer_mask_id (gimp_value_array_index (args, 0), mask_ID);
- return_vals = gimp_run_procedure_with_array ("gimp-layer-from-mask",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-layer-from-mask",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-from-mask",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -662,6 +746,7 @@ gboolean
gimp_layer_add_mask (gint32 layer_ID,
gint32 mask_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -672,8 +757,13 @@ gimp_layer_add_mask (gint32 layer_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-layer-add-mask",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-add-mask",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -699,6 +789,7 @@ gboolean
gimp_layer_remove_mask (gint32 layer_ID,
GimpMaskApplyMode mode)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -709,8 +800,13 @@ gimp_layer_remove_mask (gint32 layer_ID,
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-remove-mask",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-layer-remove-mask",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-remove-mask",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -735,6 +831,7 @@ gimp_layer_remove_mask (gint32 layer_ID,
gboolean
gimp_layer_is_floating_sel (gint32 layer_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean is_floating_sel = FALSE;
@@ -743,8 +840,13 @@ gimp_layer_is_floating_sel (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-layer-is-floating-sel",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-is-floating-sel",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -769,6 +871,7 @@ gimp_layer_is_floating_sel (gint32 layer_ID)
gboolean
gimp_layer_get_lock_alpha (gint32 layer_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean lock_alpha = FALSE;
@@ -777,8 +880,13 @@ gimp_layer_get_lock_alpha (gint32 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-lock-alpha",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-layer-get-lock-alpha",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-get-lock-alpha",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -805,6 +913,7 @@ gboolean
gimp_layer_set_lock_alpha (gint32 layer_ID,
gboolean lock_alpha)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -815,8 +924,13 @@ gimp_layer_set_lock_alpha (gint32 layer_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-layer-set-lock-alpha",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-set-lock-alpha",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -841,6 +955,7 @@ gimp_layer_set_lock_alpha (gint32 layer_ID,
gboolean
gimp_layer_get_apply_mask (gint32 layer_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean apply_mask = FALSE;
@@ -849,8 +964,13 @@ gimp_layer_get_apply_mask (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-layer-get-apply-mask",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-get-apply-mask",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -879,6 +999,7 @@ gboolean
gimp_layer_set_apply_mask (gint32 layer_ID,
gboolean apply_mask)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -889,8 +1010,13 @@ gimp_layer_set_apply_mask (gint32 layer_ID,
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);
- return_vals = gimp_run_procedure_with_array ("gimp-layer-set-apply-mask",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-layer-set-apply-mask",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-set-apply-mask",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -916,6 +1042,7 @@ gimp_layer_set_apply_mask (gint32 layer_ID,
gboolean
gimp_layer_get_show_mask (gint32 layer_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean show_mask = FALSE;
@@ -924,8 +1051,13 @@ gimp_layer_get_show_mask (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-layer-get-show-mask",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-get-show-mask",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -954,6 +1086,7 @@ gboolean
gimp_layer_set_show_mask (gint32 layer_ID,
gboolean show_mask)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -964,8 +1097,13 @@ gimp_layer_set_show_mask (gint32 layer_ID,
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);
- return_vals = gimp_run_procedure_with_array ("gimp-layer-set-show-mask",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-layer-set-show-mask",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-set-show-mask",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -990,6 +1128,7 @@ gimp_layer_set_show_mask (gint32 layer_ID,
gboolean
gimp_layer_get_edit_mask (gint32 layer_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean edit_mask = FALSE;
@@ -998,8 +1137,13 @@ gimp_layer_get_edit_mask (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-layer-get-edit-mask",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-get-edit-mask",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -1028,6 +1172,7 @@ gboolean
gimp_layer_set_edit_mask (gint32 layer_ID,
gboolean edit_mask)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1038,8 +1183,13 @@ gimp_layer_set_edit_mask (gint32 layer_ID,
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);
- return_vals = gimp_run_procedure_with_array ("gimp-layer-set-edit-mask",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-layer-set-edit-mask",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-set-edit-mask",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1062,6 +1212,7 @@ gimp_layer_set_edit_mask (gint32 layer_ID,
gdouble
gimp_layer_get_opacity (gint32 layer_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble opacity = 0.0;
@@ -1070,8 +1221,13 @@ gimp_layer_get_opacity (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-layer-get-opacity",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-get-opacity",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -1097,6 +1253,7 @@ gboolean
gimp_layer_set_opacity (gint32 layer_ID,
gdouble opacity)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1107,8 +1264,13 @@ gimp_layer_set_opacity (gint32 layer_ID,
gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
g_value_set_double (gimp_value_array_index (args, 1), opacity);
- return_vals = gimp_run_procedure_with_array ("gimp-layer-set-opacity",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-layer-set-opacity",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-set-opacity",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1131,6 +1293,7 @@ gimp_layer_set_opacity (gint32 layer_ID,
GimpLayerMode
gimp_layer_get_mode (gint32 layer_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpLayerMode mode = 0;
@@ -1139,8 +1302,13 @@ gimp_layer_get_mode (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-layer-get-mode",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-get-mode",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -1166,6 +1334,7 @@ gboolean
gimp_layer_set_mode (gint32 layer_ID,
GimpLayerMode mode)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1176,8 +1345,13 @@ gimp_layer_set_mode (gint32 layer_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-layer-set-mode",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-set-mode",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1202,6 +1376,7 @@ gimp_layer_set_mode (gint32 layer_ID,
GimpLayerColorSpace
gimp_layer_get_blend_space (gint32 layer_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpLayerColorSpace blend_space = 0;
@@ -1210,8 +1385,13 @@ gimp_layer_get_blend_space (gint32 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-blend-space",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-layer-get-blend-space",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-get-blend-space",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -1239,6 +1419,7 @@ gboolean
gimp_layer_set_blend_space (gint32 layer_ID,
GimpLayerColorSpace blend_space)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1249,8 +1430,13 @@ gimp_layer_set_blend_space (gint32 layer_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-layer-set-blend-space",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-set-blend-space",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1275,6 +1461,7 @@ gimp_layer_set_blend_space (gint32 layer_ID,
GimpLayerColorSpace
gimp_layer_get_composite_space (gint32 layer_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpLayerColorSpace composite_space = 0;
@@ -1283,8 +1470,13 @@ gimp_layer_get_composite_space (gint32 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-composite-space",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-layer-get-composite-space",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-get-composite-space",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -1312,6 +1504,7 @@ gboolean
gimp_layer_set_composite_space (gint32 layer_ID,
GimpLayerColorSpace composite_space)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1322,8 +1515,13 @@ gimp_layer_set_composite_space (gint32 layer_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-layer-set-composite-space",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-set-composite-space",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1348,6 +1546,7 @@ gimp_layer_set_composite_space (gint32 layer_ID,
GimpLayerCompositeMode
gimp_layer_get_composite_mode (gint32 layer_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpLayerCompositeMode composite_mode = 0;
@@ -1356,8 +1555,13 @@ gimp_layer_get_composite_mode (gint32 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-composite-mode",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-layer-get-composite-mode",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-get-composite-mode",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -1385,6 +1589,7 @@ gboolean
gimp_layer_set_composite_mode (gint32 layer_ID,
GimpLayerCompositeMode composite_mode)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1395,8 +1600,13 @@ gimp_layer_set_composite_mode (gint32 layer_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-layer-set-composite-mode",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-layer-set-composite-mode",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
diff --git a/libgimp/gimpmessage_pdb.c b/libgimp/gimpmessage_pdb.c
index ec7f2136a4..6810c8d40b 100644
--- a/libgimp/gimpmessage_pdb.c
+++ b/libgimp/gimpmessage_pdb.c
@@ -48,6 +48,7 @@
gboolean
gimp_message (const gchar *message)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -56,8 +57,13 @@ gimp_message (const gchar *message)
G_TYPE_NONE);
g_value_set_string (gimp_value_array_index (args, 0), message);
- return_vals = gimp_run_procedure_with_array ("gimp-message",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-message",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-message",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -81,14 +87,20 @@ gimp_message (const gchar *message)
GimpMessageHandlerType
gimp_message_get_handler (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpMessageHandlerType handler = 0;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-message-get-handler",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-message-get-handler",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-message-get-handler",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -114,6 +126,7 @@ gimp_message_get_handler (void)
gboolean
gimp_message_set_handler (GimpMessageHandlerType handler)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -122,8 +135,13 @@ gimp_message_set_handler (GimpMessageHandlerType handler)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-message-set-handler",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-message-set-handler",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
diff --git a/libgimp/gimppainttools_pdb.c b/libgimp/gimppainttools_pdb.c
index 82cc77f667..0e4c1d4483 100644
--- a/libgimp/gimppainttools_pdb.c
+++ b/libgimp/gimppainttools_pdb.c
@@ -57,6 +57,7 @@ gimp_airbrush (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -71,8 +72,13 @@ gimp_airbrush (gint32 drawable_ID,
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);
- return_vals = gimp_run_procedure_with_array ("gimp-airbrush",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-airbrush",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-airbrush",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -103,6 +109,7 @@ gimp_airbrush_default (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -115,8 +122,13 @@ gimp_airbrush_default (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-airbrush-default",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-airbrush-default",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -162,6 +174,7 @@ gimp_clone (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -182,8 +195,13 @@ gimp_clone (gint32 drawable_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-clone",
+ args);
+ else
+ 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;
@@ -215,6 +233,7 @@ gimp_clone_default (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -227,8 +246,13 @@ gimp_clone_default (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-clone-default",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-clone-default",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -262,6 +286,7 @@ gimp_convolve (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -278,8 +303,13 @@ gimp_convolve (gint32 drawable_ID,
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);
- return_vals = gimp_run_procedure_with_array ("gimp-convolve",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-convolve",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-convolve",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -310,6 +340,7 @@ gimp_convolve_default (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -322,8 +353,13 @@ gimp_convolve_default (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-convolve-default",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-convolve-default",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -356,6 +392,7 @@ gimp_dodgeburn (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -374,8 +411,13 @@ gimp_dodgeburn (gint32 drawable_ID,
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-dodgeburn",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-dodgeburn",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-dodgeburn",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -405,6 +447,7 @@ gimp_dodgeburn_default (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -417,8 +460,13 @@ gimp_dodgeburn_default (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-dodgeburn-default",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-dodgeburn-default",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -453,6 +501,7 @@ gimp_eraser (gint32 drawable_ID,
GimpBrushApplicationMode hardness,
GimpPaintApplicationMode method)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -469,8 +518,13 @@ gimp_eraser (gint32 drawable_ID,
g_value_set_enum (gimp_value_array_index (args, 3), hardness);
g_value_set_enum (gimp_value_array_index (args, 4), method);
- return_vals = gimp_run_procedure_with_array ("gimp-eraser",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-eraser",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-eraser",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -501,6 +555,7 @@ gimp_eraser_default (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -513,8 +568,13 @@ gimp_eraser_default (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-eraser-default",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-eraser-default",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -554,6 +614,7 @@ gimp_heal (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -572,8 +633,13 @@ gimp_heal (gint32 drawable_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-heal",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-heal",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -607,6 +673,7 @@ gimp_heal_default (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -619,8 +686,13 @@ gimp_heal_default (gint32 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-heal-default",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-heal-default",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-heal-default",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -662,6 +734,7 @@ gimp_paintbrush (gint32 drawable_ID,
GimpPaintApplicationMode method,
gdouble gradient_length)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -680,8 +753,13 @@ gimp_paintbrush (gint32 drawable_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-paintbrush",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-paintbrush",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -721,6 +799,7 @@ gimp_paintbrush_default (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -733,8 +812,13 @@ gimp_paintbrush_default (gint32 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-paintbrush-default",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-paintbrush-default",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-paintbrush-default",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -766,6 +850,7 @@ gimp_pencil (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -778,8 +863,13 @@ gimp_pencil (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-pencil",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-pencil",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -810,6 +900,7 @@ gimp_smudge (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -824,8 +915,13 @@ gimp_smudge (gint32 drawable_ID,
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);
- return_vals = gimp_run_procedure_with_array ("gimp-smudge",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-smudge",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-smudge",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -855,6 +951,7 @@ gimp_smudge_default (gint32 drawable_ID,
gint num_strokes,
const gdouble *strokes)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -867,8 +964,13 @@ gimp_smudge_default (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-smudge-default",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-smudge-default",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
diff --git a/libgimp/gimppalette_pdb.c b/libgimp/gimppalette_pdb.c
index 9709301cd0..529ac327b9 100644
--- a/libgimp/gimppalette_pdb.c
+++ b/libgimp/gimppalette_pdb.c
@@ -50,6 +50,7 @@
gchar *
gimp_palette_new (const gchar *name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *actual_name = NULL;
@@ -58,8 +59,13 @@ gimp_palette_new (const gchar *name)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-palette-new",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-palette-new",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -86,6 +92,7 @@ gimp_palette_new (const gchar *name)
gchar *
gimp_palette_duplicate (const gchar *name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *copy_name = NULL;
@@ -94,8 +101,13 @@ gimp_palette_duplicate (const gchar *name)
G_TYPE_NONE);
g_value_set_string (gimp_value_array_index (args, 0), name);
- return_vals = gimp_run_procedure_with_array ("gimp-palette-duplicate",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-palette-duplicate",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-palette-duplicate",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -124,6 +136,7 @@ gchar *
gimp_palette_rename (const gchar *name,
const gchar *new_name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *actual_name = NULL;
@@ -134,8 +147,13 @@ gimp_palette_rename (const gchar *name,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-palette-rename",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-palette-rename",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -161,6 +179,7 @@ gimp_palette_rename (const gchar *name,
gboolean
gimp_palette_delete (const gchar *name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -169,8 +188,13 @@ gimp_palette_delete (const gchar *name)
G_TYPE_NONE);
g_value_set_string (gimp_value_array_index (args, 0), name);
- return_vals = gimp_run_procedure_with_array ("gimp-palette-delete",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-palette-delete",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-palette-delete",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -195,6 +219,7 @@ gimp_palette_delete (const gchar *name)
gboolean
gimp_palette_is_editable (const gchar *name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean editable = FALSE;
@@ -203,8 +228,13 @@ gimp_palette_is_editable (const gchar *name)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-palette-is-editable",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-palette-is-editable",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -233,6 +263,7 @@ gboolean
gimp_palette_get_info (const gchar *name,
gint *num_colors)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -241,8 +272,13 @@ gimp_palette_get_info (const gchar *name,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-palette-get-info",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-palette-get-info",
+ args);
gimp_value_array_unref (args);
*num_colors = 0;
@@ -276,6 +312,7 @@ GimpRGB *
gimp_palette_get_colors (const gchar *name,
gint *num_colors)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpRGB *colors = NULL;
@@ -284,8 +321,13 @@ gimp_palette_get_colors (const gchar *name,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-palette-get-colors",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-palette-get-colors",
+ args);
gimp_value_array_unref (args);
*num_colors = 0;
@@ -317,6 +359,7 @@ gimp_palette_get_colors (const gchar *name,
gint
gimp_palette_get_columns (const gchar *name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint num_columns = 0;
@@ -325,8 +368,13 @@ gimp_palette_get_columns (const gchar *name)
G_TYPE_NONE);
g_value_set_string (gimp_value_array_index (args, 0), name);
- return_vals = gimp_run_procedure_with_array ("gimp-palette-get-columns",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-palette-get-columns",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-palette-get-columns",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -356,6 +404,7 @@ gboolean
gimp_palette_set_columns (const gchar *name,
gint columns)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -366,8 +415,13 @@ gimp_palette_set_columns (const gchar *name,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-palette-set-columns",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-palette-set-columns",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -399,6 +453,7 @@ gimp_palette_add_entry (const gchar *name,
const GimpRGB *color,
gint *entry_num)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -411,8 +466,13 @@ gimp_palette_add_entry (const gchar *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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-palette-add-entry",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-palette-add-entry",
+ args);
gimp_value_array_unref (args);
*entry_num = 0;
@@ -445,6 +505,7 @@ gboolean
gimp_palette_delete_entry (const gchar *name,
gint entry_num)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -455,8 +516,13 @@ gimp_palette_delete_entry (const gchar *name,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-palette-delete-entry",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-palette-delete-entry",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -487,6 +553,7 @@ gimp_palette_entry_get_color (const gchar *name,
gint entry_num,
GimpRGB *color)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -497,8 +564,13 @@ gimp_palette_entry_get_color (const gchar *name,
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-color",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-palette-entry-get-color",
+ args);
+ else
+ 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;
@@ -532,6 +604,7 @@ gimp_palette_entry_set_color (const gchar *name,
gint entry_num,
const GimpRGB *color)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -544,8 +617,13 @@ gimp_palette_entry_set_color (const gchar *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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-palette-entry-set-color",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-palette-entry-set-color",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -576,6 +654,7 @@ gimp_palette_entry_get_name (const gchar *name,
gint entry_num,
gchar **entry_name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -586,8 +665,13 @@ gimp_palette_entry_get_name (const gchar *name,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-palette-entry-get-name",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-palette-entry-get-name",
+ args);
gimp_value_array_unref (args);
*entry_name = NULL;
@@ -623,6 +707,7 @@ gimp_palette_entry_set_name (const gchar *name,
gint entry_num,
const gchar *entry_name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -635,8 +720,13 @@ gimp_palette_entry_set_name (const gchar *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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-palette-entry-set-name",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-palette-entry-set-name",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
diff --git a/libgimp/gimppalettes_pdb.c b/libgimp/gimppalettes_pdb.c
index 13897910ef..1aa2a652a6 100644
--- a/libgimp/gimppalettes_pdb.c
+++ b/libgimp/gimppalettes_pdb.c
@@ -47,14 +47,20 @@
gboolean
gimp_palettes_refresh (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-palettes-refresh",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-palettes-refresh",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-palettes-refresh",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -83,6 +89,7 @@ gchar **
gimp_palettes_get_list (const gchar *filter,
gint *num_palettes)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar **palette_list = NULL;
@@ -91,8 +98,13 @@ gimp_palettes_get_list (const gchar *filter,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-palettes-get-list",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-palettes-get-list",
+ args);
gimp_value_array_unref (args);
*num_palettes = 0;
diff --git a/libgimp/gimppaletteselect_pdb.c b/libgimp/gimppaletteselect_pdb.c
index e1f208cbad..f26c52398d 100644
--- a/libgimp/gimppaletteselect_pdb.c
+++ b/libgimp/gimppaletteselect_pdb.c
@@ -51,6 +51,7 @@ gimp_palettes_popup (const gchar *palette_callback,
const gchar *popup_title,
const gchar *initial_palette)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -63,8 +64,13 @@ gimp_palettes_popup (const gchar *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);
- return_vals = gimp_run_procedure_with_array ("gimp-palettes-popup",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-palettes-popup",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-palettes-popup",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -87,6 +93,7 @@ gimp_palettes_popup (const gchar *palette_callback,
gboolean
gimp_palettes_close_popup (const gchar *palette_callback)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -95,8 +102,13 @@ gimp_palettes_close_popup (const gchar *palette_callback)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-palettes-close-popup",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-palettes-close-popup",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -121,6 +133,7 @@ gboolean
gimp_palettes_set_popup (const gchar *palette_callback,
const gchar *palette_name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -131,8 +144,13 @@ gimp_palettes_set_popup (const gchar *palette_callback,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-palettes-set-popup",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-palettes-set-popup",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
diff --git a/libgimp/gimppattern_pdb.c b/libgimp/gimppattern_pdb.c
index a59f7e4156..f27e92c865 100644
--- a/libgimp/gimppattern_pdb.c
+++ b/libgimp/gimppattern_pdb.c
@@ -56,6 +56,7 @@ gimp_pattern_get_info (const gchar *name,
gint *height,
gint *bpp)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -64,8 +65,13 @@ gimp_pattern_get_info (const gchar *name,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-pattern-get-info",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-pattern-get-info",
+ args);
gimp_value_array_unref (args);
*width = 0;
@@ -113,6 +119,7 @@ gimp_pattern_get_pixels (const gchar *name,
gint *num_color_bytes,
guint8 **color_bytes)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -121,8 +128,13 @@ gimp_pattern_get_pixels (const gchar *name,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-pattern-get-pixels",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-pattern-get-pixels",
+ args);
gimp_value_array_unref (args);
*width = 0;
diff --git a/libgimp/gimppatterns_pdb.c b/libgimp/gimppatterns_pdb.c
index 56a5779973..6aa5aa6f30 100644
--- a/libgimp/gimppatterns_pdb.c
+++ b/libgimp/gimppatterns_pdb.c
@@ -47,14 +47,20 @@
gboolean
gimp_patterns_refresh (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-patterns-refresh",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-patterns-refresh",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-patterns-refresh",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -83,6 +89,7 @@ gchar **
gimp_patterns_get_list (const gchar *filter,
gint *num_patterns)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar **pattern_list = NULL;
@@ -91,8 +98,13 @@ gimp_patterns_get_list (const gchar *filter,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-patterns-get-list",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-patterns-get-list",
+ args);
gimp_value_array_unref (args);
*num_patterns = 0;
diff --git a/libgimp/gimppatternselect_pdb.c b/libgimp/gimppatternselect_pdb.c
index fc5855612b..2289720975 100644
--- a/libgimp/gimppatternselect_pdb.c
+++ b/libgimp/gimppatternselect_pdb.c
@@ -51,6 +51,7 @@ gimp_patterns_popup (const gchar *pattern_callback,
const gchar *popup_title,
const gchar *initial_pattern)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -63,8 +64,13 @@ gimp_patterns_popup (const gchar *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);
- return_vals = gimp_run_procedure_with_array ("gimp-patterns-popup",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-patterns-popup",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-patterns-popup",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -87,6 +93,7 @@ gimp_patterns_popup (const gchar *pattern_callback,
gboolean
gimp_patterns_close_popup (const gchar *pattern_callback)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -95,8 +102,13 @@ gimp_patterns_close_popup (const gchar *pattern_callback)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-patterns-close-popup",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-patterns-close-popup",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -121,6 +133,7 @@ gboolean
gimp_patterns_set_popup (const gchar *pattern_callback,
const gchar *pattern_name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -131,8 +144,13 @@ gimp_patterns_set_popup (const gchar *pattern_callback,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-patterns-set-popup",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-patterns-set-popup",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
diff --git a/libgimp/gimppdb_pdb.c b/libgimp/gimppdb_pdb.c
index 882b7ecf7b..f8c1ea6c97 100644
--- a/libgimp/gimppdb_pdb.c
+++ b/libgimp/gimppdb_pdb.c
@@ -38,14 +38,20 @@
gchar *
gimp_pdb_temp_name (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *temp_name = NULL;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-pdb-temp-name",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-pdb-temp-name",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-pdb-temp-name",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -71,6 +77,7 @@ gimp_pdb_temp_name (void)
gboolean
gimp_pdb_dump (const gchar *filename)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -79,8 +86,13 @@ gimp_pdb_dump (const gchar *filename)
G_TYPE_NONE);
g_value_set_string (gimp_value_array_index (args, 0), filename);
- return_vals = gimp_run_procedure_with_array ("gimp-pdb-dump",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-pdb-dump",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-pdb-dump",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -131,6 +143,7 @@ gimp_pdb_query (const gchar *name,
gint *num_matches,
gchar ***procedure_names)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -151,8 +164,13 @@ gimp_pdb_query (const gchar *name,
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-pdb-query",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-pdb-query",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-pdb-query",
+ args);
gimp_value_array_unref (args);
*num_matches = 0;
@@ -187,6 +205,7 @@ gimp_pdb_query (const gchar *name,
gboolean
_gimp_pdb_proc_exists (const gchar *procedure_name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean exists = FALSE;
@@ -195,8 +214,13 @@ _gimp_pdb_proc_exists (const gchar *procedure_name)
G_TYPE_NONE);
g_value_set_string (gimp_value_array_index (args, 0), procedure_name);
- return_vals = gimp_run_procedure_with_array ("gimp-pdb-proc-exists",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-pdb-proc-exists",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-pdb-proc-exists",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -242,6 +266,7 @@ _gimp_pdb_proc_info (const gchar *procedure_name,
gint *num_args,
gint *num_values)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -250,8 +275,13 @@ _gimp_pdb_proc_info (const gchar *procedure_name,
G_TYPE_NONE);
g_value_set_string (gimp_value_array_index (args, 0), procedure_name);
- return_vals = gimp_run_procedure_with_array ("gimp-pdb-proc-info",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-pdb-proc-info",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-pdb-proc-info",
+ args);
gimp_value_array_unref (args);
*blurb = NULL;
@@ -305,6 +335,7 @@ _gimp_pdb_proc_arg (const gchar *procedure_name,
gchar **arg_name,
gchar **arg_desc)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -315,8 +346,13 @@ _gimp_pdb_proc_arg (const gchar *procedure_name,
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-pdb-proc-arg",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-pdb-proc-arg",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-pdb-proc-arg",
+ args);
gimp_value_array_unref (args);
*arg_type = 0;
@@ -361,6 +397,7 @@ _gimp_pdb_proc_val (const gchar *procedure_name,
gchar **val_name,
gchar **val_desc)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -371,8 +408,13 @@ _gimp_pdb_proc_val (const gchar *procedure_name,
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-pdb-proc-val",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-pdb-proc-val",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-pdb-proc-val",
+ args);
gimp_value_array_unref (args);
*val_type = 0;
@@ -412,6 +454,7 @@ GParamSpec *
gimp_pdb_proc_argument (const gchar *procedure_name,
gint arg_num)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GParamSpec *param_spec = NULL;
@@ -422,8 +465,13 @@ gimp_pdb_proc_argument (const gchar *procedure_name,
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-pdb-proc-argument",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-pdb-proc-argument",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-pdb-proc-argument",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -454,6 +502,7 @@ GParamSpec *
gimp_pdb_proc_return_value (const gchar *procedure_name,
gint val_num)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GParamSpec *param_spec = NULL;
@@ -464,8 +513,13 @@ gimp_pdb_proc_return_value (const gchar *procedure_name,
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-pdb-proc-return-value",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-pdb-proc-return-value",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-pdb-proc-return-value",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -496,6 +550,7 @@ _gimp_pdb_get_data (const gchar *identifier,
gint *bytes,
guint8 **data)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -504,8 +559,13 @@ _gimp_pdb_get_data (const gchar *identifier,
G_TYPE_NONE);
g_value_set_string (gimp_value_array_index (args, 0), identifier);
- return_vals = gimp_run_procedure_with_array ("gimp-pdb-get-data",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-pdb-get-data",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-pdb-get-data",
+ args);
gimp_value_array_unref (args);
*bytes = 0;
@@ -539,6 +599,7 @@ _gimp_pdb_get_data (const gchar *identifier,
gint
_gimp_pdb_get_data_size (const gchar *identifier)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint bytes = 0;
@@ -547,8 +608,13 @@ _gimp_pdb_get_data_size (const gchar *identifier)
G_TYPE_NONE);
g_value_set_string (gimp_value_array_index (args, 0), identifier);
- return_vals = gimp_run_procedure_with_array ("gimp-pdb-get-data-size",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-pdb-get-data-size",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-pdb-get-data-size",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -578,6 +644,7 @@ _gimp_pdb_set_data (const gchar *identifier,
gint bytes,
const guint8 *data)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -590,8 +657,13 @@ _gimp_pdb_set_data (const gchar *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-pdb-set-data",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-pdb-set-data",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-pdb-set-data",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
diff --git a/libgimp/gimpplugin_pdb.c b/libgimp/gimpplugin_pdb.c
index a3d475b84c..c49e219161 100644
--- a/libgimp/gimpplugin_pdb.c
+++ b/libgimp/gimpplugin_pdb.c
@@ -46,6 +46,7 @@ gboolean
_gimp_plugin_domain_register (const gchar *domain_name,
const gchar *domain_path)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -56,8 +57,13 @@ _gimp_plugin_domain_register (const gchar *domain_name,
g_value_set_string (gimp_value_array_index (args, 0), domain_name);
g_value_set_string (gimp_value_array_index (args, 1), domain_path);
- return_vals = gimp_run_procedure_with_array ("gimp-plugin-domain-register",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-plugin-domain-register",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-plugin-domain-register",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -86,6 +92,7 @@ gboolean
_gimp_plugin_help_register (const gchar *domain_name,
const gchar *domain_uri)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -96,8 +103,13 @@ _gimp_plugin_help_register (const gchar *domain_name,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-plugin-help-register",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-plugin-help-register",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -127,6 +139,7 @@ gboolean
_gimp_plugin_menu_branch_register (const gchar *menu_path,
const gchar *menu_name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -137,8 +150,13 @@ _gimp_plugin_menu_branch_register (const gchar *menu_path,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-plugin-menu-branch-register",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-plugin-menu-branch-register",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -166,6 +184,7 @@ gboolean
_gimp_plugin_menu_register (const gchar *procedure_name,
const gchar *menu_path)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -176,8 +195,13 @@ _gimp_plugin_menu_register (const gchar *procedure_name,
g_value_set_string (gimp_value_array_index (args, 0), procedure_name);
g_value_set_string (gimp_value_array_index (args, 1), menu_path);
- return_vals = gimp_run_procedure_with_array ("gimp-plugin-menu-register",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-plugin-menu-register",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-plugin-menu-register",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -208,6 +232,7 @@ _gimp_plugin_icon_register (const gchar *procedure_name,
gint icon_data_length,
const guint8 *icon_data)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -222,8 +247,13 @@ _gimp_plugin_icon_register (const gchar *procedure_name,
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);
- return_vals = gimp_run_procedure_with_array ("gimp-plugin-icon-register",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-plugin-icon-register",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-plugin-icon-register",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -255,6 +285,7 @@ _gimp_plugin_icon_register (const gchar *procedure_name,
gboolean
gimp_plugin_set_pdb_error_handler (GimpPDBErrorHandler handler)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -263,8 +294,13 @@ gimp_plugin_set_pdb_error_handler (GimpPDBErrorHandler handler)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-plugin-set-pdb-error-handler",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-plugin-set-pdb-error-handler",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -290,14 +326,20 @@ gimp_plugin_set_pdb_error_handler (GimpPDBErrorHandler handler)
GimpPDBErrorHandler
gimp_plugin_get_pdb_error_handler (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpPDBErrorHandler handler = 0;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-plugin-get-pdb-error-handler",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-plugin-get-pdb-error-handler",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-plugin-get-pdb-error-handler",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
diff --git a/libgimp/gimpprogress_pdb.c b/libgimp/gimpprogress_pdb.c
index 2ce99a19a2..ae7552b6ac 100644
--- a/libgimp/gimpprogress_pdb.c
+++ b/libgimp/gimpprogress_pdb.c
@@ -50,6 +50,7 @@ gboolean
_gimp_progress_init (const gchar *message,
gint32 gdisplay_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -60,8 +61,13 @@ _gimp_progress_init (const gchar *message,
g_value_set_string (gimp_value_array_index (args, 0), message);
gimp_value_set_display_id (gimp_value_array_index (args, 1), gdisplay_ID);
- return_vals = gimp_run_procedure_with_array ("gimp-progress-init",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-progress-init",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-progress-init",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -85,6 +91,7 @@ _gimp_progress_init (const gchar *message,
gboolean
_gimp_progress_update (gdouble percentage)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -93,8 +100,13 @@ _gimp_progress_update (gdouble percentage)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-progress-update",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-progress-update",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -122,14 +134,20 @@ _gimp_progress_update (gdouble percentage)
gboolean
gimp_progress_pulse (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-progress-pulse",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-progress-pulse",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-progress-pulse",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -156,6 +174,7 @@ gimp_progress_pulse (void)
gboolean
gimp_progress_set_text (const gchar *message)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -164,8 +183,13 @@ gimp_progress_set_text (const gchar *message)
G_TYPE_NONE);
g_value_set_string (gimp_value_array_index (args, 0), message);
- return_vals = gimp_run_procedure_with_array ("gimp-progress-set-text",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-progress-set-text",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-progress-set-text",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -191,14 +215,20 @@ gimp_progress_set_text (const gchar *message)
gboolean
gimp_progress_end (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-progress-end",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-progress-end",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-progress-end",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -224,14 +254,20 @@ gimp_progress_end (void)
gint
gimp_progress_get_window_handle (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint window = 0;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-progress-get-window-handle",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-progress-get-window-handle",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-progress-get-window-handle",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -260,6 +296,7 @@ gimp_progress_get_window_handle (void)
gboolean
_gimp_progress_install (const gchar *progress_callback)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -268,8 +305,13 @@ _gimp_progress_install (const gchar *progress_callback)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-progress-install",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-progress-install",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -295,6 +337,7 @@ _gimp_progress_install (const gchar *progress_callback)
gboolean
_gimp_progress_uninstall (const gchar *progress_callback)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -303,8 +346,13 @@ _gimp_progress_uninstall (const gchar *progress_callback)
G_TYPE_NONE);
g_value_set_string (gimp_value_array_index (args, 0), progress_callback);
- return_vals = gimp_run_procedure_with_array ("gimp-progress-uninstall",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-progress-uninstall",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-progress-uninstall",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -329,6 +377,7 @@ _gimp_progress_uninstall (const gchar *progress_callback)
gboolean
gimp_progress_cancel (const gchar *progress_callback)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -337,8 +386,13 @@ gimp_progress_cancel (const gchar *progress_callback)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-progress-cancel",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-progress-cancel",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
diff --git a/libgimp/gimpselection_pdb.c b/libgimp/gimpselection_pdb.c
index f3e48775dc..f10869f815 100644
--- a/libgimp/gimpselection_pdb.c
+++ b/libgimp/gimpselection_pdb.c
@@ -64,6 +64,7 @@ gimp_selection_bounds (gint32 image_ID,
gint *x2,
gint *y2)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -72,8 +73,13 @@ gimp_selection_bounds (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-selection-bounds",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-selection-bounds",
+ args);
gimp_value_array_unref (args);
*non_empty = FALSE;
@@ -116,6 +122,7 @@ gimp_selection_value (gint32 image_ID,
gint x,
gint y)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint value = 0;
@@ -128,8 +135,13 @@ gimp_selection_value (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-selection-value",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-selection-value",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -154,6 +166,7 @@ gimp_selection_value (gint32 image_ID,
gboolean
gimp_selection_is_empty (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean is_empty = FALSE;
@@ -162,8 +175,13 @@ gimp_selection_is_empty (gint32 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-is-empty",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-selection-is-empty",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-selection-is-empty",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -195,6 +213,7 @@ gimp_selection_translate (gint32 image_ID,
gint offx,
gint offy)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -207,8 +226,13 @@ gimp_selection_translate (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-selection-translate",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-selection-translate",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -240,6 +264,7 @@ _gimp_selection_float (gint32 drawable_ID,
gint offx,
gint offy)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 layer_ID = -1;
@@ -252,8 +277,13 @@ _gimp_selection_float (gint32 drawable_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-float",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-selection-float",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-selection-float",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -278,6 +308,7 @@ _gimp_selection_float (gint32 drawable_ID,
gboolean
gimp_selection_invert (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -286,8 +317,13 @@ gimp_selection_invert (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-selection-invert",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-selection-invert",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -313,6 +349,7 @@ gimp_selection_invert (gint32 image_ID)
gboolean
gimp_selection_sharpen (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -321,8 +358,13 @@ gimp_selection_sharpen (gint32 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-sharpen",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-selection-sharpen",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-selection-sharpen",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -346,6 +388,7 @@ gimp_selection_sharpen (gint32 image_ID)
gboolean
gimp_selection_all (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -354,8 +397,13 @@ gimp_selection_all (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-selection-all",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-selection-all",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -379,6 +427,7 @@ gimp_selection_all (gint32 image_ID)
gboolean
gimp_selection_none (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -387,8 +436,13 @@ gimp_selection_none (gint32 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-none",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-selection-none",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-selection-none",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -414,6 +468,7 @@ gboolean
gimp_selection_feather (gint32 image_ID,
gdouble radius)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -424,8 +479,13 @@ gimp_selection_feather (gint32 image_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-selection-feather",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-selection-feather",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -452,6 +512,7 @@ gboolean
gimp_selection_border (gint32 image_ID,
gint radius)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -462,8 +523,13 @@ gimp_selection_border (gint32 image_ID,
gimp_value_set_image_id (gimp_value_array_index (args, 0), image_ID);
g_value_set_int (gimp_value_array_index (args, 1), radius);
- return_vals = gimp_run_procedure_with_array ("gimp-selection-border",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-selection-border",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-selection-border",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -489,6 +555,7 @@ gboolean
gimp_selection_grow (gint32 image_ID,
gint steps)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -499,8 +566,13 @@ gimp_selection_grow (gint32 image_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-selection-grow",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-selection-grow",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -527,6 +599,7 @@ gboolean
gimp_selection_shrink (gint32 image_ID,
gint steps)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -537,8 +610,13 @@ gimp_selection_shrink (gint32 image_ID,
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-shrink",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-selection-shrink",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-selection-shrink",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -566,6 +644,7 @@ gimp_selection_shrink (gint32 image_ID,
gboolean
gimp_selection_flood (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -574,8 +653,13 @@ gimp_selection_flood (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-selection-flood",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-selection-flood",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -600,6 +684,7 @@ gimp_selection_flood (gint32 image_ID)
gint32
gimp_selection_save (gint32 image_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 channel_ID = -1;
@@ -608,8 +693,13 @@ gimp_selection_save (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-selection-save",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-selection-save",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
diff --git a/libgimp/gimptextlayer_pdb.c b/libgimp/gimptextlayer_pdb.c
index badbc33362..e71562c3d8 100644
--- a/libgimp/gimptextlayer_pdb.c
+++ b/libgimp/gimptextlayer_pdb.c
@@ -62,6 +62,7 @@ gimp_text_layer_new (gint32 image_ID,
gdouble size,
GimpUnit unit)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 layer_ID = -1;
@@ -78,8 +79,13 @@ gimp_text_layer_new (gint32 image_ID,
g_value_set_double (gimp_value_array_index (args, 3), size);
g_value_set_int (gimp_value_array_index (args, 4), unit);
- return_vals = gimp_run_procedure_with_array ("gimp-text-layer-new",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-text-layer-new",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-new",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -106,6 +112,7 @@ gimp_text_layer_new (gint32 image_ID,
gchar *
gimp_text_layer_get_text (gint32 layer_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *text = NULL;
@@ -114,8 +121,13 @@ gimp_text_layer_get_text (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-text-layer-get-text",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-get-text",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -143,6 +155,7 @@ gboolean
gimp_text_layer_set_text (gint32 layer_ID,
const gchar *text)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -153,8 +166,13 @@ gimp_text_layer_set_text (gint32 layer_ID,
gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
g_value_set_string (gimp_value_array_index (args, 1), text);
- return_vals = gimp_run_procedure_with_array ("gimp-text-layer-set-text",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-text-layer-set-text",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-set-text",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -185,6 +203,7 @@ gimp_text_layer_set_text (gint32 layer_ID,
gchar *
gimp_text_layer_get_markup (gint32 layer_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *markup = NULL;
@@ -193,8 +212,13 @@ gimp_text_layer_get_markup (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-text-layer-get-markup",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-get-markup",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -222,6 +246,7 @@ gimp_text_layer_get_markup (gint32 layer_ID)
gchar *
gimp_text_layer_get_font (gint32 layer_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *font = NULL;
@@ -230,8 +255,13 @@ gimp_text_layer_get_font (gint32 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-font",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-text-layer-get-font",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-get-font",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -259,6 +289,7 @@ gboolean
gimp_text_layer_set_font (gint32 layer_ID,
const gchar *font)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -269,8 +300,13 @@ gimp_text_layer_set_font (gint32 layer_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-text-layer-set-font",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-set-font",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -299,6 +335,7 @@ gdouble
gimp_text_layer_get_font_size (gint32 layer_ID,
GimpUnit *unit)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble font_size = 0.0;
@@ -307,8 +344,13 @@ gimp_text_layer_get_font_size (gint32 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-font-size",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-text-layer-get-font-size",
+ args);
+ else
+ 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)
@@ -342,6 +384,7 @@ gimp_text_layer_set_font_size (gint32 layer_ID,
gdouble font_size,
GimpUnit unit)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -354,8 +397,13 @@ gimp_text_layer_set_font_size (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-text-layer-set-font-size",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-set-font-size",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -381,6 +429,7 @@ gimp_text_layer_set_font_size (gint32 layer_ID,
gboolean
gimp_text_layer_get_antialias (gint32 layer_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean antialias = FALSE;
@@ -389,8 +438,13 @@ gimp_text_layer_get_antialias (gint32 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-antialias",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-text-layer-get-antialias",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-get-antialias",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -419,6 +473,7 @@ gboolean
gimp_text_layer_set_antialias (gint32 layer_ID,
gboolean antialias)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -429,8 +484,13 @@ gimp_text_layer_set_antialias (gint32 layer_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-text-layer-set-antialias",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-set-antialias",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -457,6 +517,7 @@ gimp_text_layer_set_antialias (gint32 layer_ID,
GimpTextHintStyle
gimp_text_layer_get_hint_style (gint32 layer_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpTextHintStyle style = 0;
@@ -465,8 +526,13 @@ gimp_text_layer_get_hint_style (gint32 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-hint-style",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-text-layer-get-hint-style",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-get-hint-style",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -496,6 +562,7 @@ gboolean
gimp_text_layer_set_hint_style (gint32 layer_ID,
GimpTextHintStyle style)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -506,8 +573,13 @@ gimp_text_layer_set_hint_style (gint32 layer_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-text-layer-set-hint-style",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-set-hint-style",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -533,6 +605,7 @@ gimp_text_layer_set_hint_style (gint32 layer_ID,
gboolean
gimp_text_layer_get_kerning (gint32 layer_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean kerning = FALSE;
@@ -541,8 +614,13 @@ gimp_text_layer_get_kerning (gint32 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-kerning",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-text-layer-get-kerning",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-get-kerning",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -570,6 +648,7 @@ gboolean
gimp_text_layer_set_kerning (gint32 layer_ID,
gboolean kerning)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -580,8 +659,13 @@ gimp_text_layer_set_kerning (gint32 layer_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-text-layer-set-kerning",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-set-kerning",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -608,6 +692,7 @@ gimp_text_layer_set_kerning (gint32 layer_ID,
gchar *
gimp_text_layer_get_language (gint32 layer_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *language = NULL;
@@ -616,8 +701,13 @@ gimp_text_layer_get_language (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-text-layer-get-language",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-get-language",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -646,6 +736,7 @@ gboolean
gimp_text_layer_set_language (gint32 layer_ID,
const gchar *language)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -656,8 +747,13 @@ gimp_text_layer_set_language (gint32 layer_ID,
gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
g_value_set_string (gimp_value_array_index (args, 1), language);
- return_vals = gimp_run_procedure_with_array ("gimp-text-layer-set-language",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-text-layer-set-language",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-set-language",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -683,6 +779,7 @@ gimp_text_layer_set_language (gint32 layer_ID,
GimpTextDirection
gimp_text_layer_get_base_direction (gint32 layer_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpTextDirection direction = 0;
@@ -691,8 +788,13 @@ gimp_text_layer_get_base_direction (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-text-layer-get-base-direction",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-get-base-direction",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -721,6 +823,7 @@ gboolean
gimp_text_layer_set_base_direction (gint32 layer_ID,
GimpTextDirection direction)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -731,8 +834,13 @@ gimp_text_layer_set_base_direction (gint32 layer_ID,
gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
g_value_set_enum (gimp_value_array_index (args, 1), direction);
- return_vals = gimp_run_procedure_with_array ("gimp-text-layer-set-base-direction",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-text-layer-set-base-direction",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-set-base-direction",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -758,6 +866,7 @@ gimp_text_layer_set_base_direction (gint32 layer_ID,
GimpTextJustification
gimp_text_layer_get_justification (gint32 layer_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpTextJustification justify = 0;
@@ -766,8 +875,13 @@ gimp_text_layer_get_justification (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-text-layer-get-justification",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-get-justification",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -796,6 +910,7 @@ gboolean
gimp_text_layer_set_justification (gint32 layer_ID,
GimpTextJustification justify)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -806,8 +921,13 @@ gimp_text_layer_set_justification (gint32 layer_ID,
gimp_value_set_layer_id (gimp_value_array_index (args, 0), layer_ID);
g_value_set_enum (gimp_value_array_index (args, 1), justify);
- return_vals = gimp_run_procedure_with_array ("gimp-text-layer-set-justification",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-text-layer-set-justification",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-set-justification",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -834,6 +954,7 @@ gboolean
gimp_text_layer_get_color (gint32 layer_ID,
GimpRGB *color)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -842,8 +963,13 @@ gimp_text_layer_get_color (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-text-layer-get-color",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-get-color",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -873,6 +999,7 @@ gboolean
gimp_text_layer_set_color (gint32 layer_ID,
const GimpRGB *color)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -883,8 +1010,13 @@ gimp_text_layer_set_color (gint32 layer_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-text-layer-set-color",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-set-color",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -910,6 +1042,7 @@ gimp_text_layer_set_color (gint32 layer_ID,
gdouble
gimp_text_layer_get_indent (gint32 layer_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble indent = 0.0;
@@ -918,8 +1051,13 @@ gimp_text_layer_get_indent (gint32 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-indent",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-text-layer-get-indent",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-get-indent",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -948,6 +1086,7 @@ gboolean
gimp_text_layer_set_indent (gint32 layer_ID,
gdouble indent)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -958,8 +1097,13 @@ gimp_text_layer_set_indent (gint32 layer_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-text-layer-set-indent",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-set-indent",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -985,6 +1129,7 @@ gimp_text_layer_set_indent (gint32 layer_ID,
gdouble
gimp_text_layer_get_line_spacing (gint32 layer_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble line_spacing = 0.0;
@@ -993,8 +1138,13 @@ gimp_text_layer_get_line_spacing (gint32 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-line-spacing",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-text-layer-get-line-spacing",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-get-line-spacing",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -1023,6 +1173,7 @@ gboolean
gimp_text_layer_set_line_spacing (gint32 layer_ID,
gdouble line_spacing)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1033,8 +1184,13 @@ gimp_text_layer_set_line_spacing (gint32 layer_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-text-layer-set-line-spacing",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-set-line-spacing",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1060,6 +1216,7 @@ gimp_text_layer_set_line_spacing (gint32 layer_ID,
gdouble
gimp_text_layer_get_letter_spacing (gint32 layer_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble letter_spacing = 0.0;
@@ -1068,8 +1225,13 @@ gimp_text_layer_get_letter_spacing (gint32 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-letter-spacing",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-text-layer-get-letter-spacing",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-get-letter-spacing",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -1098,6 +1260,7 @@ gboolean
gimp_text_layer_set_letter_spacing (gint32 layer_ID,
gdouble letter_spacing)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1108,8 +1271,13 @@ gimp_text_layer_set_letter_spacing (gint32 layer_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-text-layer-set-letter-spacing",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-set-letter-spacing",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1140,6 +1308,7 @@ gimp_text_layer_resize (gint32 layer_ID,
gdouble width,
gdouble height)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1152,8 +1321,13 @@ gimp_text_layer_resize (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-text-layer-resize",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-text-layer-resize",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
diff --git a/libgimp/gimptexttool_pdb.c b/libgimp/gimptexttool_pdb.c
index 812b000fa3..3121c647f0 100644
--- a/libgimp/gimptexttool_pdb.c
+++ b/libgimp/gimptexttool_pdb.c
@@ -78,6 +78,7 @@ gimp_text_fontname (gint32 image_ID,
GimpSizeType size_type,
const gchar *fontname)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 text_layer_ID = -1;
@@ -104,8 +105,13 @@ gimp_text_fontname (gint32 image_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-text-fontname",
+ args);
+ else
+ 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)
@@ -149,6 +155,7 @@ gimp_text_get_extents_fontname (const gchar *text,
gint *ascent,
gint *descent)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -163,8 +170,13 @@ gimp_text_get_extents_fontname (const gchar *text,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-text-get-extents-fontname",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-text-get-extents-fontname",
+ args);
gimp_value_array_unref (args);
*width = 0;
diff --git a/libgimp/gimpunit_pdb.c b/libgimp/gimpunit_pdb.c
index e31a8b301d..1f2abc549a 100644
--- a/libgimp/gimpunit_pdb.c
+++ b/libgimp/gimpunit_pdb.c
@@ -36,14 +36,20 @@
gint
_gimp_unit_get_number_of_units (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint num_units = GIMP_UNIT_END;
args = gimp_value_array_new_from_types (G_TYPE_NONE);
- return_vals = gimp_run_procedure_with_array ("gimp-unit-get-number-of-units",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-unit-get-number-of-units",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-unit-get-number-of-units",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -66,14 +72,20 @@ _gimp_unit_get_number_of_units (void)
gint
_gimp_unit_get_number_of_built_in_units (void)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint num_units = GIMP_UNIT_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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-unit-get-number-of-built-in-units",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-unit-get-number-of-built-in-units",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -112,6 +124,7 @@ _gimp_unit_new (const gchar *identifier,
const gchar *singular,
const gchar *plural)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpUnit unit_id = GIMP_UNIT_INCH;
@@ -132,8 +145,13 @@ _gimp_unit_new (const gchar *identifier,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-unit-new",
+ args);
+ else
+ 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)
@@ -159,6 +177,7 @@ _gimp_unit_new (const gchar *identifier,
gboolean
_gimp_unit_get_deletion_flag (GimpUnit unit_id)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean deletion_flag = FALSE;
@@ -167,8 +186,13 @@ _gimp_unit_get_deletion_flag (GimpUnit unit_id)
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-deletion-flag",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-unit-get-deletion-flag",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-unit-get-deletion-flag",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -196,6 +220,7 @@ gboolean
_gimp_unit_set_deletion_flag (GimpUnit unit_id,
gboolean deletion_flag)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -206,8 +231,13 @@ _gimp_unit_set_deletion_flag (GimpUnit unit_id,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-unit-set-deletion-flag",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-unit-set-deletion-flag",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -233,6 +263,7 @@ _gimp_unit_set_deletion_flag (GimpUnit unit_id,
gchar *
_gimp_unit_get_identifier (GimpUnit unit_id)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *identifier = NULL;
@@ -241,8 +272,13 @@ _gimp_unit_get_identifier (GimpUnit unit_id)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-unit-get-identifier",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-unit-get-identifier",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -268,6 +304,7 @@ _gimp_unit_get_identifier (GimpUnit unit_id)
gdouble
_gimp_unit_get_factor (GimpUnit unit_id)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble factor = 0.0;
@@ -276,8 +313,13 @@ _gimp_unit_get_factor (GimpUnit unit_id)
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-factor",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-unit-get-factor",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-unit-get-factor",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -304,6 +346,7 @@ _gimp_unit_get_factor (GimpUnit unit_id)
gint
_gimp_unit_get_digits (GimpUnit unit_id)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint digits = 0;
@@ -312,8 +355,13 @@ _gimp_unit_get_digits (GimpUnit unit_id)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-unit-get-digits",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-unit-get-digits",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -338,6 +386,7 @@ _gimp_unit_get_digits (GimpUnit unit_id)
gchar *
_gimp_unit_get_symbol (GimpUnit unit_id)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *symbol = NULL;
@@ -346,8 +395,13 @@ _gimp_unit_get_symbol (GimpUnit unit_id)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-unit-get-symbol",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-unit-get-symbol",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -373,6 +427,7 @@ _gimp_unit_get_symbol (GimpUnit unit_id)
gchar *
_gimp_unit_get_abbreviation (GimpUnit unit_id)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *abbreviation = NULL;
@@ -381,8 +436,13 @@ _gimp_unit_get_abbreviation (GimpUnit unit_id)
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-abbreviation",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-unit-get-abbreviation",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-unit-get-abbreviation",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -407,6 +467,7 @@ _gimp_unit_get_abbreviation (GimpUnit unit_id)
gchar *
_gimp_unit_get_singular (GimpUnit unit_id)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *singular = NULL;
@@ -415,8 +476,13 @@ _gimp_unit_get_singular (GimpUnit unit_id)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-unit-get-singular",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-unit-get-singular",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -441,6 +507,7 @@ _gimp_unit_get_singular (GimpUnit unit_id)
gchar *
_gimp_unit_get_plural (GimpUnit unit_id)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *plural = NULL;
@@ -449,8 +516,13 @@ _gimp_unit_get_plural (GimpUnit unit_id)
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-unit-get-plural",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-unit-get-plural",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
diff --git a/libgimp/gimpvectors_pdb.c b/libgimp/gimpvectors_pdb.c
index a569ac2697..aa41b59fd5 100644
--- a/libgimp/gimpvectors_pdb.c
+++ b/libgimp/gimpvectors_pdb.c
@@ -52,6 +52,7 @@ gint32
gimp_vectors_new (gint32 image_ID,
const gchar *name)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 vectors_ID = -1;
@@ -62,8 +63,13 @@ gimp_vectors_new (gint32 image_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-vectors-new",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-new",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -92,6 +98,7 @@ gint32
gimp_vectors_new_from_text_layer (gint32 image_ID,
gint32 layer_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 vectors_ID = -1;
@@ -102,8 +109,13 @@ gimp_vectors_new_from_text_layer (gint32 image_ID,
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-vectors-new-from-text-layer",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-vectors-new-from-text-layer",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-new-from-text-layer",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -130,6 +142,7 @@ gimp_vectors_new_from_text_layer (gint32 image_ID,
gint32
gimp_vectors_copy (gint32 vectors_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint32 vectors_copy_ID = -1;
@@ -138,8 +151,13 @@ gimp_vectors_copy (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-vectors-copy",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-copy",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -170,6 +188,7 @@ gint *
gimp_vectors_get_strokes (gint32 vectors_ID,
gint *num_strokes)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint *stroke_ids = NULL;
@@ -178,8 +197,13 @@ gimp_vectors_get_strokes (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-vectors-get-strokes",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-get-strokes",
+ args);
gimp_value_array_unref (args);
*num_strokes = 0;
@@ -214,6 +238,7 @@ gimp_vectors_stroke_get_length (gint32 vectors_ID,
gint stroke_id,
gdouble precision)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble length = 0.0;
@@ -226,8 +251,13 @@ gimp_vectors_stroke_get_length (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-vectors-stroke-get-length",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-stroke-get-length",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -272,6 +302,7 @@ gimp_vectors_stroke_get_point_at_dist (gint32 vectors_ID,
gdouble *slope,
gboolean *valid)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -286,8 +317,13 @@ gimp_vectors_stroke_get_point_at_dist (gint32 vectors_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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-vectors-stroke-get-point-at-dist",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-stroke-get-point-at-dist",
+ args);
gimp_value_array_unref (args);
*x_point = 0.0;
@@ -327,6 +363,7 @@ gboolean
gimp_vectors_remove_stroke (gint32 vectors_ID,
gint stroke_id)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -337,8 +374,13 @@ gimp_vectors_remove_stroke (gint32 vectors_ID,
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-remove-stroke",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-vectors-remove-stroke",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-remove-stroke",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -365,6 +407,7 @@ gboolean
gimp_vectors_stroke_close (gint32 vectors_ID,
gint stroke_id)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -375,8 +418,13 @@ gimp_vectors_stroke_close (gint32 vectors_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-vectors-stroke-close",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-stroke-close",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -407,6 +455,7 @@ gimp_vectors_stroke_translate (gint32 vectors_ID,
gint off_x,
gint off_y)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -421,8 +470,13 @@ gimp_vectors_stroke_translate (gint32 vectors_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);
- return_vals = gimp_run_procedure_with_array ("gimp-vectors-stroke-translate",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-vectors-stroke-translate",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-stroke-translate",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -453,6 +507,7 @@ gimp_vectors_stroke_scale (gint32 vectors_ID,
gdouble scale_x,
gdouble scale_y)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -467,8 +522,13 @@ gimp_vectors_stroke_scale (gint32 vectors_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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-vectors-stroke-scale",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-stroke-scale",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -501,6 +561,7 @@ gimp_vectors_stroke_rotate (gint32 vectors_ID,
gdouble center_y,
gdouble angle)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -517,8 +578,13 @@ gimp_vectors_stroke_rotate (gint32 vectors_ID,
g_value_set_double (gimp_value_array_index (args, 3), center_y);
g_value_set_double (gimp_value_array_index (args, 4), angle);
- return_vals = gimp_run_procedure_with_array ("gimp-vectors-stroke-rotate",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-vectors-stroke-rotate",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-stroke-rotate",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -549,6 +615,7 @@ gimp_vectors_stroke_flip (gint32 vectors_ID,
GimpOrientationType flip_type,
gdouble axis)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -563,8 +630,13 @@ gimp_vectors_stroke_flip (gint32 vectors_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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-vectors-stroke-flip",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-stroke-flip",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -601,6 +673,7 @@ gimp_vectors_stroke_flip_free (gint32 vectors_ID,
gdouble x2,
gdouble y2)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -619,8 +692,13 @@ gimp_vectors_stroke_flip_free (gint32 vectors_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-vectors-stroke-flip-free",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-stroke-flip-free",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -656,6 +734,7 @@ gimp_vectors_stroke_get_points (gint32 vectors_ID,
gdouble **controlpoints,
gboolean *closed)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpVectorsStrokeType type = 0;
@@ -666,8 +745,13 @@ gimp_vectors_stroke_get_points (gint32 vectors_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-vectors-stroke-get-points",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-stroke-get-points",
+ args);
gimp_value_array_unref (args);
*num_points = 0;
@@ -715,6 +799,7 @@ gimp_vectors_stroke_new_from_points (gint32 vectors_ID,
const gdouble *controlpoints,
gboolean closed)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint stroke_id = 0;
@@ -731,8 +816,13 @@ gimp_vectors_stroke_new_from_points (gint32 vectors_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-vectors-stroke-new-from-points",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-stroke-new-from-points",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -768,6 +858,7 @@ gimp_vectors_stroke_interpolate (gint32 vectors_ID,
gint *num_coords,
gboolean *closed)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble *coords = NULL;
@@ -780,8 +871,13 @@ gimp_vectors_stroke_interpolate (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-vectors-stroke-interpolate",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-stroke-interpolate",
+ args);
gimp_value_array_unref (args);
*num_coords = 0;
@@ -817,6 +913,7 @@ gimp_vectors_bezier_stroke_new_moveto (gint32 vectors_ID,
gdouble x0,
gdouble y0)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint stroke_id = 0;
@@ -829,8 +926,13 @@ gimp_vectors_bezier_stroke_new_moveto (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-vectors-bezier-stroke-new-moveto",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-bezier-stroke-new-moveto",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@@ -862,6 +964,7 @@ gimp_vectors_bezier_stroke_lineto (gint32 vectors_ID,
gdouble x0,
gdouble y0)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -876,8 +979,13 @@ gimp_vectors_bezier_stroke_lineto (gint32 vectors_ID,
g_value_set_double (gimp_value_array_index (args, 2), x0);
g_value_set_double (gimp_value_array_index (args, 3), y0);
- return_vals = gimp_run_procedure_with_array ("gimp-vectors-bezier-stroke-lineto",
- args);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-vectors-bezier-stroke-lineto",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-bezier-stroke-lineto",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -914,6 +1022,7 @@ gimp_vectors_bezier_stroke_conicto (gint32 vectors_ID,
gdouble x1,
gdouble y1)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -932,8 +1041,13 @@ gimp_vectors_bezier_stroke_conicto (gint32 vectors_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-vectors-bezier-stroke-conicto",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-bezier-stroke-conicto",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -972,6 +1086,7 @@ gimp_vectors_bezier_stroke_cubicto (gint32 vectors_ID,
gdouble x2,
gdouble y2)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -994,8 +1109,13 @@ gimp_vectors_bezier_stroke_cubicto (gint32 vectors_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-vectors-bezier-stroke-cubicto",
+ args);
+ else
+ 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;
@@ -1030,6 +1150,7 @@ gimp_vectors_bezier_stroke_new_ellipse (gint32 vectors_ID,
gdouble radius_y,
gdouble angle)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint stroke_id = 0;
@@ -1048,8 +1169,13 @@ gimp_vectors_bezier_stroke_new_ellipse (gint32 vectors_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-vectors-bezier-stroke-new-ellipse",
+ args);
+ else
+ 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)
@@ -1086,6 +1212,7 @@ gimp_vectors_import_from_file (gint32 image_ID,
gint *num_vectors,
gint **vectors_ids)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1100,8 +1227,13 @@ gimp_vectors_import_from_file (gint32 image_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-vectors-import-from-file",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-import-from-file",
+ args);
gimp_value_array_unref (args);
*num_vectors = 0;
@@ -1149,6 +1281,7 @@ gimp_vectors_import_from_string (gint32 image_ID,
gint *num_vectors,
gint **vectors_ids)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1165,8 +1298,13 @@ gimp_vectors_import_from_string (gint32 image_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-vectors-import-from-string",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-import-from-string",
+ args);
gimp_value_array_unref (args);
*num_vectors = 0;
@@ -1207,6 +1345,7 @@ gimp_vectors_export_to_file (gint32 image_ID,
const gchar *filename,
gint32 vectors_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@@ -1219,8 +1358,13 @@ gimp_vectors_export_to_file (gint32 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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-vectors-export-to-file",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-export-to-file",
+ args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@@ -1252,6 +1396,7 @@ gchar *
gimp_vectors_export_to_string (gint32 image_ID,
gint32 vectors_ID)
{
+ GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *string = NULL;
@@ -1262,8 +1407,13 @@ gimp_vectors_export_to_string (gint32 image_ID,
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-vectors-export-to-string",
+ args);
+ else
+ return_vals = gimp_run_procedure_with_array ("gimp-vectors-export-to-string",
+ args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
diff --git a/pdb/lib.pl b/pdb/lib.pl
index 3b1ee8f091..2ab26c02d8 100644
--- a/pdb/lib.pl
+++ b/pdb/lib.pl
@@ -528,13 +528,19 @@ $retdesc$sincedesc
$rettype
$wrapped$funcname ($clist)
{
+ GimpPDB *pdb = gimp_get_pdb ();
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);
+ if (pdb)
+ return_vals = gimp_pdb_run_procedure_array (pdb,
+ "gimp-$proc->{canonical_name}",
+ args);
+ else
+ 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]
