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

Remove the entire old plug-in interface

This commit is contained in:
Michael Natterer 2019-09-03 23:55:49 +02:00
parent 7257cc8abc
commit a351ce9126
75 changed files with 2028 additions and 7393 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
app/pdb/gimppdb-query.c
View File

@ -425,7 +425,6 @@ gimp_pdb_print_entry (gpointer key,
GOutputStream *output = pdb_dump->output;
const gchar *proc_name;
GList *list;
GEnumClass *arg_class;
GEnumClass *proc_class;
GString *buf;
GString *string;
@ -441,7 +440,6 @@ gimp_pdb_print_entry (gpointer key,
else
list = value;
arg_class = g_type_class_ref (GIMP_TYPE_PDB_ARG_TYPE);
proc_class = g_type_class_ref (GIMP_TYPE_PDB_PROC_TYPE);
buf = g_string_new (NULL);
@ -586,7 +584,6 @@ gimp_pdb_print_entry (gpointer key,
g_string_free (string, TRUE);
g_string_free (buf, TRUE);
g_type_class_unref (arg_class);
g_type_class_unref (proc_class);
}

6
libgimp/Makefile.am
View File

@ -110,13 +110,8 @@ libgimp_private_sources = \
gimp-private.h \
gimp-shm.c \
gimp-shm.h \
gimpgpcompat.c \
gimpgpcompat.h \
gimpgpparams.c \
gimpgpparams.h \
gimplegacy.c \
gimplegacy.h \
gimplegacy-private.h \
gimppdb-private.h \
gimppdbprocedure.c \
gimppdbprocedure.h \
@ -154,7 +149,6 @@ libgimpui_@GIMP_API_VERSION@_la_SOURCES = \
gimpinclude_HEADERS = \
$(libgimp_introspectable_headers) \
gimplegacy.h \
gimpprocedure-params.h \
$(libgimpui_introspectable_headers)

6
libgimp/gimp-private.h
View File

@ -24,11 +24,7 @@
G_BEGIN_DECLS
gint _gimp_main_internal (GType plug_in_type,
const GimpPlugInInfo *info,
gint argc,
gchar *argv[]);
void _gimp_config (GPConfig *config);
void _gimp_config (GPConfig *config);
G_END_DECLS

69
libgimp/gimp.c
View File

@ -99,9 +99,7 @@
#include "gimp-debug.h"
#include "gimp-private.h"
#include "gimp-shm.h"
#include "gimpgpcompat.h"
#include "gimpgpparams.h"
#include "gimplegacy-private.h"
#include "gimppdb-private.h"
#include "gimpplugin-private.h"
#include "gimpunitcache.h"
@ -176,15 +174,6 @@ gint
gimp_main (GType plug_in_type,
gint argc,
gchar *argv[])
{
return _gimp_main_internal (plug_in_type, NULL, argc, argv);
}
gint
_gimp_main_internal (GType plug_in_type,
const GimpPlugInInfo *info,
gint argc,
gchar *argv[])
{
enum
{
@ -220,8 +209,9 @@ _gimp_main_internal (GType plug_in_type,
}
/* On Windows, set DLL search path to $INSTALLDIR/bin so that GEGL
file operations can find their respective file library DLLs (such
as jasper, etc.) without needing to set external PATH. */
* file operations can find their respective file library DLLs (such
* as jasper, etc.) without needing to set external PATH.
*/
{
const gchar *install_dir;
gchar *bin_dir;
@ -260,8 +250,9 @@ _gimp_main_internal (GType plug_in_type,
gchar *dir;
/* This has to be the non-roaming directory (i.e., the local
directory) as backtraces correspond to the binaries on this
system. */
* directory) as backtraces correspond to the binaries on this
* system.
*/
dir = g_build_filename (g_get_user_data_dir (),
GIMPDIR, GIMP_USER_VERSION, "CrashLog",
NULL);
@ -313,7 +304,6 @@ _gimp_main_internal (GType plug_in_type,
* by buggy NT C runtime, or something. I don't know why this happens
* on NT (including w2k), but not on w95/98.
*/
for (i = 1; i < argc; i++)
{
k = strlen (argv[i]);
@ -351,8 +341,7 @@ _gimp_main_internal (GType plug_in_type,
#endif /* G_OS_WIN32 */
g_assert ((plug_in_type != G_TYPE_NONE && info == NULL) ||
(plug_in_type == G_TYPE_NONE && info != NULL));
g_assert (plug_in_type != G_TYPE_NONE);
if ((argc != N_ARGS) || (strcmp (argv[ARG_GIMP], "-gimp") != 0))
{
@ -559,31 +548,19 @@ _gimp_main_internal (GType plug_in_type,
NULL);
}
if (plug_in_type != G_TYPE_NONE)
{
PLUG_IN = g_object_new (plug_in_type,
"read-channel", read_channel,
"write-channel", write_channel,
NULL);
PLUG_IN = g_object_new (plug_in_type,
"read-channel", read_channel,
"write-channel", write_channel,
NULL);
g_assert (GIMP_IS_PLUG_IN (PLUG_IN));
}
else
{
_gimp_legacy_initialize (info,
read_channel,
write_channel);
}
g_assert (GIMP_IS_PLUG_IN (PLUG_IN));
if (strcmp (argv[ARG_MODE], "-query") == 0)
{
if (_gimp_debug_flags () & GIMP_DEBUG_QUERY)
_gimp_debug_stop ();
if (PLUG_IN)
_gimp_plug_in_query (PLUG_IN);
else
_gimp_legacy_query ();
_gimp_plug_in_query (PLUG_IN);
gimp_close ();
@ -595,10 +572,7 @@ _gimp_main_internal (GType plug_in_type,
if (_gimp_debug_flags () & GIMP_DEBUG_INIT)
_gimp_debug_stop ();
if (PLUG_IN)
_gimp_plug_in_init (PLUG_IN);
else
_gimp_legacy_init ();
_gimp_plug_in_init (PLUG_IN);
gimp_close ();
@ -610,10 +584,7 @@ _gimp_main_internal (GType plug_in_type,
else if (_gimp_debug_flags () & GIMP_DEBUG_PID)
g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Here I am!");
if (PLUG_IN)
_gimp_plug_in_run (PLUG_IN);
else
_gimp_legacy_run ();
_gimp_plug_in_run (PLUG_IN);
gimp_close ();
@ -650,10 +621,7 @@ GimpPDB *
gimp_get_pdb (void)
{
if (! PDB)
{
if (PLUG_IN)
PDB = _gimp_pdb_new (PLUG_IN);
}
PDB = _gimp_pdb_new (PLUG_IN);
return PDB;
}
@ -948,10 +916,7 @@ gimp_close (void)
if (_gimp_debug_flags () & GIMP_DEBUG_QUIT)
_gimp_debug_stop ();
if (PLUG_IN)
_gimp_plug_in_quit (PLUG_IN);
else
_gimp_legacy_quit ();
_gimp_plug_in_quit (PLUG_IN);
}
static void

4
libgimp/gimp.def
View File

@ -486,7 +486,6 @@ EXPORTS
gimp_image_undo_thaw
gimp_image_unset_active_channel
gimp_image_width
gimp_install_procedure
gimp_item_attach_parasite
gimp_item_delete
gimp_item_detach_parasite
@ -594,7 +593,6 @@ EXPORTS
gimp_load_procedure_set_handles_raw
gimp_load_procedure_set_thumbnail_loader
gimp_main
gimp_main_legacy
gimp_message
gimp_message_get_handler
gimp_message_set_handler
@ -678,7 +676,6 @@ EXPORTS
gimp_plug_in_set_help_domain
gimp_plug_in_set_pdb_error_handler
gimp_plug_in_set_translation_domain
gimp_plugin_menu_register
gimp_procedure_add_argument
gimp_procedure_add_argument_from_property
gimp_procedure_add_menu_path
@ -727,7 +724,6 @@ EXPORTS
gimp_progress_uninstall
gimp_progress_update
gimp_quit
gimp_run_procedure_array
gimp_save_procedure_get_type
gimp_save_procedure_new
gimp_selection_all

1
libgimp/gimp.h
View File

@ -49,7 +49,6 @@
#include <libgimp/gimplayer.h>
#include <libgimp/gimplayermask.h>
#include <libgimp/gimploadprocedure.h>
#include <libgimp/gimplegacy.h>
#include <libgimp/gimppaletteselect.h>
#include <libgimp/gimpparamspecs.h>
#include <libgimp/gimppatternselect.h>

77
libgimp/gimp_pdb.c
View File

@ -52,7 +52,6 @@
gchar *
gimp_version (void)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *version = NULL;
@ -60,13 +59,9 @@ gimp_version (void)
args = gimp_value_array_new_from_types (NULL,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-version",
args);
else
return_vals = gimp_run_procedure_array ("gimp-version",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-version",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -91,7 +86,6 @@ gimp_version (void)
gint
gimp_getpid (void)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint pid = 0;
@ -99,13 +93,9 @@ gimp_getpid (void)
args = gimp_value_array_new_from_types (NULL,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-getpid",
args);
else
return_vals = gimp_run_procedure_array ("gimp-getpid",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-getpid",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -131,7 +121,6 @@ gimp_getpid (void)
gboolean
gimp_attach_parasite (const GimpParasite *parasite)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -140,13 +129,9 @@ gimp_attach_parasite (const GimpParasite *parasite)
GIMP_TYPE_PARASITE, parasite,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-attach-parasite",
args);
else
return_vals = gimp_run_procedure_array ("gimp-attach-parasite",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-attach-parasite",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -172,7 +157,6 @@ 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;
@ -181,13 +165,9 @@ gimp_detach_parasite (const gchar *name)
G_TYPE_STRING, name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-detach-parasite",
args);
else
return_vals = gimp_run_procedure_array ("gimp-detach-parasite",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-detach-parasite",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -212,7 +192,6 @@ 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;
@ -221,13 +200,9 @@ gimp_get_parasite (const gchar *name)
G_TYPE_STRING, name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-get-parasite",
args);
else
return_vals = gimp_run_procedure_array ("gimp-get-parasite",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-get-parasite",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -255,7 +230,6 @@ 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;
@ -263,13 +237,9 @@ gimp_get_parasite_list (gint *num_parasites)
args = gimp_value_array_new_from_types (NULL,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-get-parasite-list",
args);
else
return_vals = gimp_run_procedure_array ("gimp-get-parasite-list",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-get-parasite-list",
args);
gimp_value_array_unref (args);
*num_parasites = 0;
@ -300,7 +270,6 @@ 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;
@ -309,13 +278,9 @@ gimp_temp_name (const gchar *extension)
G_TYPE_STRING, extension,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-temp-name",
args);
else
return_vals = gimp_run_procedure_array ("gimp-temp-name",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-temp-name",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)

242
libgimp/gimpbrush_pdb.c
View File

@ -50,7 +50,6 @@
gchar *
gimp_brush_new (const gchar *name)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *actual_name = NULL;
@ -59,13 +58,9 @@ gimp_brush_new (const gchar *name)
G_TYPE_STRING, name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-brush-new",
args);
else
return_vals = gimp_run_procedure_array ("gimp-brush-new",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-brush-new",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -92,7 +87,6 @@ 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;
@ -101,13 +95,9 @@ gimp_brush_duplicate (const gchar *name)
G_TYPE_STRING, name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-brush-duplicate",
args);
else
return_vals = gimp_run_procedure_array ("gimp-brush-duplicate",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-brush-duplicate",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -133,7 +123,6 @@ 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;
@ -142,13 +131,9 @@ gimp_brush_is_generated (const gchar *name)
G_TYPE_STRING, name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-brush-is-generated",
args);
else
return_vals = gimp_run_procedure_array ("gimp-brush-is-generated",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -177,7 +162,6 @@ 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;
@ -187,13 +171,9 @@ gimp_brush_rename (const gchar *name,
G_TYPE_STRING, new_name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-brush-rename",
args);
else
return_vals = gimp_run_procedure_array ("gimp-brush-rename",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-brush-rename",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -219,7 +199,6 @@ 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;
@ -228,13 +207,9 @@ gimp_brush_delete (const gchar *name)
G_TYPE_STRING, name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-brush-delete",
args);
else
return_vals = gimp_run_procedure_array ("gimp-brush-delete",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-brush-delete",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -259,7 +234,6 @@ 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;
@ -268,13 +242,9 @@ gimp_brush_is_editable (const gchar *name)
G_TYPE_STRING, name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-brush-is-editable",
args);
else
return_vals = gimp_run_procedure_array ("gimp-brush-is-editable",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -309,7 +279,6 @@ 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;
@ -318,13 +287,9 @@ gimp_brush_get_info (const gchar *name,
G_TYPE_STRING, name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-brush-get-info",
args);
else
return_vals = gimp_run_procedure_array ("gimp-brush-get-info",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-brush-get-info",
args);
gimp_value_array_unref (args);
*width = 0;
@ -379,7 +344,6 @@ 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;
@ -388,13 +352,9 @@ gimp_brush_get_pixels (const gchar *name,
G_TYPE_STRING, name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-brush-get-pixels",
args);
else
return_vals = gimp_run_procedure_array ("gimp-brush-get-pixels",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-brush-get-pixels",
args);
gimp_value_array_unref (args);
*width = 0;
@ -444,7 +404,6 @@ gboolean
gimp_brush_get_spacing (const gchar *name,
gint *spacing)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -453,13 +412,9 @@ gimp_brush_get_spacing (const gchar *name,
G_TYPE_STRING, name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-brush-get-spacing",
args);
else
return_vals = gimp_run_procedure_array ("gimp-brush-get-spacing",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-brush-get-spacing",
args);
gimp_value_array_unref (args);
*spacing = 0;
@ -492,7 +447,6 @@ gboolean
gimp_brush_set_spacing (const gchar *name,
gint spacing)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -502,13 +456,9 @@ gimp_brush_set_spacing (const gchar *name,
G_TYPE_INT, spacing,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-brush-set-spacing",
args);
else
return_vals = gimp_run_procedure_array ("gimp-brush-set-spacing",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -538,7 +488,6 @@ 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;
@ -547,13 +496,9 @@ gimp_brush_get_shape (const gchar *name)
G_TYPE_STRING, name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-brush-get-shape",
args);
else
return_vals = gimp_run_procedure_array ("gimp-brush-get-shape",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -586,7 +531,6 @@ 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;
@ -596,13 +540,9 @@ gimp_brush_set_shape (const gchar *name,
GIMP_TYPE_BRUSH_GENERATED_SHAPE, shape_in,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-brush-set-shape",
args);
else
return_vals = gimp_run_procedure_array ("gimp-brush-set-shape",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -629,7 +569,6 @@ 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;
@ -638,13 +577,9 @@ gimp_brush_get_radius (const gchar *name)
G_TYPE_STRING, name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-brush-get-radius",
args);
else
return_vals = gimp_run_procedure_array ("gimp-brush-get-radius",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -673,7 +608,6 @@ 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;
@ -683,13 +617,9 @@ gimp_brush_set_radius (const gchar *name,
G_TYPE_DOUBLE, radius_in,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-brush-set-radius",
args);
else
return_vals = gimp_run_procedure_array ("gimp-brush-set-radius",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -716,7 +646,6 @@ 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;
@ -725,13 +654,9 @@ gimp_brush_get_spikes (const gchar *name)
G_TYPE_STRING, name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-brush-get-spikes",
args);
else
return_vals = gimp_run_procedure_array ("gimp-brush-get-spikes",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -760,7 +685,6 @@ 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;
@ -770,13 +694,9 @@ gimp_brush_set_spikes (const gchar *name,
G_TYPE_INT, spikes_in,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-brush-set-spikes",
args);
else
return_vals = gimp_run_procedure_array ("gimp-brush-set-spikes",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -805,7 +725,6 @@ 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;
@ -814,13 +733,9 @@ gimp_brush_get_hardness (const gchar *name)
G_TYPE_STRING, name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-brush-get-hardness",
args);
else
return_vals = gimp_run_procedure_array ("gimp-brush-get-hardness",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -850,7 +765,6 @@ 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;
@ -860,13 +774,9 @@ gimp_brush_set_hardness (const gchar *name,
G_TYPE_DOUBLE, hardness_in,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-brush-set-hardness",
args);
else
return_vals = gimp_run_procedure_array ("gimp-brush-set-hardness",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -894,7 +804,6 @@ 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;
@ -903,13 +812,9 @@ gimp_brush_get_aspect_ratio (const gchar *name)
G_TYPE_STRING, name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-brush-get-aspect-ratio",
args);
else
return_vals = gimp_run_procedure_array ("gimp-brush-get-aspect-ratio",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -939,7 +844,6 @@ 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;
@ -949,13 +853,9 @@ gimp_brush_set_aspect_ratio (const gchar *name,
G_TYPE_DOUBLE, aspect_ratio_in,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-brush-set-aspect-ratio",
args);
else
return_vals = gimp_run_procedure_array ("gimp-brush-set-aspect-ratio",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -982,7 +882,6 @@ 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;
@ -991,13 +890,9 @@ gimp_brush_get_angle (const gchar *name)
G_TYPE_STRING, name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-brush-get-angle",
args);
else
return_vals = gimp_run_procedure_array ("gimp-brush-get-angle",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -1026,7 +921,6 @@ 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;
@ -1036,13 +930,9 @@ gimp_brush_set_angle (const gchar *name,
G_TYPE_DOUBLE, angle_in,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-brush-set-angle",
args);
else
return_vals = gimp_run_procedure_array ("gimp-brush-set-angle",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)

22
libgimp/gimpbrushes_pdb.c
View File

@ -47,7 +47,6 @@
gboolean
gimp_brushes_refresh (void)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -55,13 +54,9 @@ gimp_brushes_refresh (void)
args = gimp_value_array_new_from_types (NULL,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-brushes-refresh",
args);
else
return_vals = gimp_run_procedure_array ("gimp-brushes-refresh",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-brushes-refresh",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -90,7 +85,6 @@ 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;
@ -99,13 +93,9 @@ gimp_brushes_get_list (const gchar *filter,
G_TYPE_STRING, filter,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-brushes-get-list",
args);
else
return_vals = gimp_run_procedure_array ("gimp-brushes-get-list",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-brushes-get-list",
args);
gimp_value_array_unref (args);
*num_brushes = 0;

33
libgimp/gimpbrushselect_pdb.c
View File

@ -57,7 +57,6 @@ 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;
@ -71,13 +70,9 @@ gimp_brushes_popup (const gchar *brush_callback,
GIMP_TYPE_LAYER_MODE, paint_mode,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-brushes-popup",
args);
else
return_vals = gimp_run_procedure_array ("gimp-brushes-popup",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-brushes-popup",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -100,7 +95,6 @@ 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;
@ -109,13 +103,9 @@ gimp_brushes_close_popup (const gchar *brush_callback)
G_TYPE_STRING, brush_callback,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-brushes-close-popup",
args);
else
return_vals = gimp_run_procedure_array ("gimp-brushes-close-popup",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -146,7 +136,6 @@ 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;
@ -159,13 +148,9 @@ gimp_brushes_set_popup (const gchar *brush_callback,
GIMP_TYPE_LAYER_MODE, paint_mode,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-brushes-set-popup",
args);
else
return_vals = gimp_run_procedure_array ("gimp-brushes-set-popup",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;

77
libgimp/gimpbuffer_pdb.c
View File

@ -54,7 +54,6 @@ 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;
@ -63,13 +62,9 @@ gimp_buffers_get_list (const gchar *filter,
G_TYPE_STRING, filter,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-buffers-get-list",
args);
else
return_vals = gimp_run_procedure_array ("gimp-buffers-get-list",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-buffers-get-list",
args);
gimp_value_array_unref (args);
*num_buffers = 0;
@ -103,7 +98,6 @@ 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;
@ -113,13 +107,9 @@ gimp_buffer_rename (const gchar *buffer_name,
G_TYPE_STRING, new_name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-buffer-rename",
args);
else
return_vals = gimp_run_procedure_array ("gimp-buffer-rename",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-buffer-rename",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -145,7 +135,6 @@ 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;
@ -154,13 +143,9 @@ gimp_buffer_delete (const gchar *buffer_name)
G_TYPE_STRING, buffer_name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-buffer-delete",
args);
else
return_vals = gimp_run_procedure_array ("gimp-buffer-delete",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-buffer-delete",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -185,7 +170,6 @@ 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;
@ -194,13 +178,9 @@ gimp_buffer_get_width (const gchar *buffer_name)
G_TYPE_STRING, buffer_name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-buffer-get-width",
args);
else
return_vals = gimp_run_procedure_array ("gimp-buffer-get-width",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -226,7 +206,6 @@ 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;
@ -235,13 +214,9 @@ gimp_buffer_get_height (const gchar *buffer_name)
G_TYPE_STRING, buffer_name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-buffer-get-height",
args);
else
return_vals = gimp_run_procedure_array ("gimp-buffer-get-height",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -267,7 +242,6 @@ 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;
@ -276,13 +250,9 @@ gimp_buffer_get_bytes (const gchar *buffer_name)
G_TYPE_STRING, buffer_name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-buffer-get-bytes",
args);
else
return_vals = gimp_run_procedure_array ("gimp-buffer-get-bytes",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -308,7 +278,6 @@ 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;
@ -317,13 +286,9 @@ gimp_buffer_get_image_type (const gchar *buffer_name)
G_TYPE_STRING, buffer_name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-buffer-get-image-type",
args);
else
return_vals = gimp_run_procedure_array ("gimp-buffer-get-image-type",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)

110
libgimp/gimpchannel_pdb.c
View File

@ -63,7 +63,6 @@ _gimp_channel_new (GimpImage *image,
gdouble opacity,
const GimpRGB *color)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpChannel *channel = NULL;
@ -77,13 +76,9 @@ _gimp_channel_new (GimpImage *image,
GIMP_TYPE_RGB, color,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-channel-new",
args);
else
return_vals = gimp_run_procedure_array ("gimp-channel-new",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-channel-new",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -117,7 +112,6 @@ gimp_channel_new_from_component (GimpImage *image,
GimpChannelType component,
const gchar *name)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpChannel *channel = NULL;
@ -128,13 +122,9 @@ gimp_channel_new_from_component (GimpImage *image,
G_TYPE_STRING, name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-channel-new-from-component",
args);
else
return_vals = gimp_run_procedure_array ("gimp-channel-new-from-component",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -160,7 +150,6 @@ gimp_channel_new_from_component (GimpImage *image,
GimpChannel *
gimp_channel_copy (GimpChannel *channel)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpChannel *channel_copy = NULL;
@ -169,13 +158,9 @@ gimp_channel_copy (GimpChannel *channel)
GIMP_TYPE_CHANNEL, channel,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-channel-copy",
args);
else
return_vals = gimp_run_procedure_array ("gimp-channel-copy",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-channel-copy",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -208,7 +193,6 @@ gimp_channel_combine_masks (GimpChannel *channel1,
gint offx,
gint offy)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -221,13 +205,9 @@ gimp_channel_combine_masks (GimpChannel *channel1,
G_TYPE_INT, offy,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-channel-combine-masks",
args);
else
return_vals = gimp_run_procedure_array ("gimp-channel-combine-masks",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -252,7 +232,6 @@ gimp_channel_combine_masks (GimpChannel *channel1,
gboolean
gimp_channel_get_show_masked (GimpChannel *channel)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean show_masked = FALSE;
@ -261,13 +240,9 @@ gimp_channel_get_show_masked (GimpChannel *channel)
GIMP_TYPE_CHANNEL, channel,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-channel-get-show-masked",
args);
else
return_vals = gimp_run_procedure_array ("gimp-channel-get-show-masked",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -295,7 +270,6 @@ gboolean
gimp_channel_set_show_masked (GimpChannel *channel,
gboolean show_masked)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -305,13 +279,9 @@ gimp_channel_set_show_masked (GimpChannel *channel,
G_TYPE_BOOLEAN, show_masked,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-channel-set-show-masked",
args);
else
return_vals = gimp_run_procedure_array ("gimp-channel-set-show-masked",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -334,7 +304,6 @@ gimp_channel_set_show_masked (GimpChannel *channel,
gdouble
gimp_channel_get_opacity (GimpChannel *channel)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble opacity = 0.0;
@ -343,13 +312,9 @@ gimp_channel_get_opacity (GimpChannel *channel)
GIMP_TYPE_CHANNEL, channel,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-channel-get-opacity",
args);
else
return_vals = gimp_run_procedure_array ("gimp-channel-get-opacity",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -375,7 +340,6 @@ gboolean
gimp_channel_set_opacity (GimpChannel *channel,
gdouble opacity)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -385,13 +349,9 @@ gimp_channel_set_opacity (GimpChannel *channel,
G_TYPE_DOUBLE, opacity,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-channel-set-opacity",
args);
else
return_vals = gimp_run_procedure_array ("gimp-channel-set-opacity",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -416,7 +376,6 @@ gboolean
gimp_channel_get_color (GimpChannel *channel,
GimpRGB *color)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -425,13 +384,9 @@ gimp_channel_get_color (GimpChannel *channel,
GIMP_TYPE_CHANNEL, channel,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-channel-get-color",
args);
else
return_vals = gimp_run_procedure_array ("gimp-channel-get-color",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -459,7 +414,6 @@ gboolean
gimp_channel_set_color (GimpChannel *channel,
const GimpRGB *color)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -469,13 +423,9 @@ gimp_channel_set_color (GimpChannel *channel,
GIMP_TYPE_RGB, color,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-channel-set-color",
args);
else
return_vals = gimp_run_procedure_array ("gimp-channel-set-color",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;

1243
libgimp/gimpcontext_pdb.c
View File

File diff suppressed because it is too large Load Diff

22
libgimp/gimpdebug_pdb.c
View File

@ -54,7 +54,6 @@
gboolean
gimp_debug_timer_start (void)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -62,13 +61,9 @@ gimp_debug_timer_start (void)
args = gimp_value_array_new_from_types (NULL,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-debug-timer-start",
args);
else
return_vals = gimp_run_procedure_array ("gimp-debug-timer-start",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -97,7 +92,6 @@ 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;
@ -105,13 +99,9 @@ gimp_debug_timer_end (void)
args = gimp_value_array_new_from_types (NULL,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-debug-timer-end",
args);
else
return_vals = gimp_run_procedure_array ("gimp-debug-timer-end",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)

14
libgimp/gimpdisplay.c
View File

@ -160,18 +160,10 @@ gimp_display_get_by_id (gint32 display_id)
{
if (display_id > 0)
{
GimpPlugIn *plug_in = gimp_get_plug_in ();
GimpPlugIn *plug_in = gimp_get_plug_in ();
GimpProcedure *procedure = _gimp_plug_in_get_procedure (plug_in);
if (plug_in)
{
GimpProcedure *procedure = _gimp_plug_in_get_procedure (plug_in);
return _gimp_procedure_get_display (procedure, display_id);
}
return g_object_new (GIMP_TYPE_DISPLAY,
"id", display_id,
NULL);
return _gimp_procedure_get_display (procedure, display_id);
}
return NULL;

66
libgimp/gimpdisplay_pdb.c
View File

@ -50,7 +50,6 @@
gboolean
gimp_display_id_is_valid (gint display_id)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean valid = FALSE;
@ -59,13 +58,9 @@ gimp_display_id_is_valid (gint display_id)
G_TYPE_INT, display_id,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-display-id-is-valid",
args);
else
return_vals = gimp_run_procedure_array ("gimp-display-id-is-valid",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-display-id-is-valid",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -94,7 +89,6 @@ gimp_display_id_is_valid (gint display_id)
GimpDisplay *
gimp_display_new (GimpImage *image)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpDisplay *display = NULL;
@ -103,13 +97,9 @@ gimp_display_new (GimpImage *image)
GIMP_TYPE_IMAGE, image,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-display-new",
args);
else
return_vals = gimp_run_procedure_array ("gimp-display-new",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-display-new",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -137,7 +127,6 @@ gimp_display_new (GimpImage *image)
gboolean
gimp_display_delete (GimpDisplay *display)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -146,13 +135,9 @@ gimp_display_delete (GimpDisplay *display)
GIMP_TYPE_DISPLAY, display,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-display-delete",
args);
else
return_vals = gimp_run_procedure_array ("gimp-display-delete",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-display-delete",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -181,7 +166,6 @@ gimp_display_delete (GimpDisplay *display)
gint
gimp_display_get_window_handle (GimpDisplay *display)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint window = 0;
@ -190,13 +174,9 @@ gimp_display_get_window_handle (GimpDisplay *display)
GIMP_TYPE_DISPLAY, display,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-display-get-window-handle",
args);
else
return_vals = gimp_run_procedure_array ("gimp-display-get-window-handle",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -222,7 +202,6 @@ gimp_display_get_window_handle (GimpDisplay *display)
gboolean
gimp_displays_flush (void)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -230,13 +209,9 @@ gimp_displays_flush (void)
args = gimp_value_array_new_from_types (NULL,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-displays-flush",
args);
else
return_vals = gimp_run_procedure_array ("gimp-displays-flush",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-displays-flush",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -264,7 +239,6 @@ gboolean
gimp_displays_reconnect (GimpImage *old_image,
GimpImage *new_image)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -274,13 +248,9 @@ gimp_displays_reconnect (GimpImage *old_image,
GIMP_TYPE_IMAGE, new_image,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-displays-reconnect",
args);
else
return_vals = gimp_run_procedure_array ("gimp-displays-reconnect",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-displays-reconnect",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;

264
libgimp/gimpdrawable_pdb.c
View File

@ -53,7 +53,6 @@
gchar *
_gimp_drawable_get_format (GimpDrawable *drawable)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *format = NULL;
@ -62,13 +61,9 @@ _gimp_drawable_get_format (GimpDrawable *drawable)
GIMP_TYPE_DRAWABLE, drawable,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-drawable-get-format",
args);
else
return_vals = gimp_run_procedure_array ("gimp-drawable-get-format",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -97,7 +92,6 @@ _gimp_drawable_get_format (GimpDrawable *drawable)
gchar *
_gimp_drawable_get_thumbnail_format (GimpDrawable *drawable)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *format = NULL;
@ -106,13 +100,9 @@ _gimp_drawable_get_thumbnail_format (GimpDrawable *drawable)
GIMP_TYPE_DRAWABLE, drawable,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-drawable-get-thumbnail-format",
args);
else
return_vals = gimp_run_procedure_array ("gimp-drawable-get-thumbnail-format",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -136,7 +126,6 @@ _gimp_drawable_get_thumbnail_format (GimpDrawable *drawable)
GimpImageType
gimp_drawable_type (GimpDrawable *drawable)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpImageType type = 0;
@ -145,13 +134,9 @@ gimp_drawable_type (GimpDrawable *drawable)
GIMP_TYPE_DRAWABLE, drawable,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-drawable-type",
args);
else
return_vals = gimp_run_procedure_array ("gimp-drawable-type",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-drawable-type",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -178,7 +163,6 @@ gimp_drawable_type (GimpDrawable *drawable)
GimpImageType
gimp_drawable_type_with_alpha (GimpDrawable *drawable)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpImageType type_with_alpha = 0;
@ -187,13 +171,9 @@ gimp_drawable_type_with_alpha (GimpDrawable *drawable)
GIMP_TYPE_DRAWABLE, drawable,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-drawable-type-with-alpha",
args);
else
return_vals = gimp_run_procedure_array ("gimp-drawable-type-with-alpha",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -219,7 +199,6 @@ gimp_drawable_type_with_alpha (GimpDrawable *drawable)
gboolean
gimp_drawable_has_alpha (GimpDrawable *drawable)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean has_alpha = FALSE;
@ -228,13 +207,9 @@ gimp_drawable_has_alpha (GimpDrawable *drawable)
GIMP_TYPE_DRAWABLE, drawable,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-drawable-has-alpha",
args);
else
return_vals = gimp_run_procedure_array ("gimp-drawable-has-alpha",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -259,7 +234,6 @@ gimp_drawable_has_alpha (GimpDrawable *drawable)
gboolean
gimp_drawable_is_rgb (GimpDrawable *drawable)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean is_rgb = FALSE;
@ -268,13 +242,9 @@ gimp_drawable_is_rgb (GimpDrawable *drawable)
GIMP_TYPE_DRAWABLE, drawable,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-drawable-is-rgb",
args);
else
return_vals = gimp_run_procedure_array ("gimp-drawable-is-rgb",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -299,7 +269,6 @@ gimp_drawable_is_rgb (GimpDrawable *drawable)
gboolean
gimp_drawable_is_gray (GimpDrawable *drawable)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean is_gray = FALSE;
@ -308,13 +277,9 @@ gimp_drawable_is_gray (GimpDrawable *drawable)
GIMP_TYPE_DRAWABLE, drawable,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-drawable-is-gray",
args);
else
return_vals = gimp_run_procedure_array ("gimp-drawable-is-gray",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -339,7 +304,6 @@ gimp_drawable_is_gray (GimpDrawable *drawable)
gboolean
gimp_drawable_is_indexed (GimpDrawable *drawable)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean is_indexed = FALSE;
@ -348,13 +312,9 @@ gimp_drawable_is_indexed (GimpDrawable *drawable)
GIMP_TYPE_DRAWABLE, drawable,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-drawable-is-indexed",
args);
else
return_vals = gimp_run_procedure_array ("gimp-drawable-is-indexed",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -378,7 +338,6 @@ gimp_drawable_is_indexed (GimpDrawable *drawable)
gint
gimp_drawable_bpp (GimpDrawable *drawable)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint bpp = 0;
@ -387,13 +346,9 @@ gimp_drawable_bpp (GimpDrawable *drawable)
GIMP_TYPE_DRAWABLE, drawable,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-drawable-bpp",
args);
else
return_vals = gimp_run_procedure_array ("gimp-drawable-bpp",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-drawable-bpp",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -417,7 +372,6 @@ gimp_drawable_bpp (GimpDrawable *drawable)
gint
gimp_drawable_width (GimpDrawable *drawable)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint width = 0;
@ -426,13 +380,9 @@ gimp_drawable_width (GimpDrawable *drawable)
GIMP_TYPE_DRAWABLE, drawable,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-drawable-width",
args);
else
return_vals = gimp_run_procedure_array ("gimp-drawable-width",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-drawable-width",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -456,7 +406,6 @@ gimp_drawable_width (GimpDrawable *drawable)
gint
gimp_drawable_height (GimpDrawable *drawable)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint height = 0;
@ -465,13 +414,9 @@ gimp_drawable_height (GimpDrawable *drawable)
GIMP_TYPE_DRAWABLE, drawable,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-drawable-height",
args);
else
return_vals = gimp_run_procedure_array ("gimp-drawable-height",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-drawable-height",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -501,7 +446,6 @@ gimp_drawable_offsets (GimpDrawable *drawable,
gint *offset_x,
gint *offset_y)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -510,13 +454,9 @@ gimp_drawable_offsets (GimpDrawable *drawable,
GIMP_TYPE_DRAWABLE, drawable,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-drawable-offsets",
args);
else
return_vals = gimp_run_procedure_array ("gimp-drawable-offsets",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-drawable-offsets",
args);
gimp_value_array_unref (args);
*offset_x = 0;
@ -568,7 +508,6 @@ gimp_drawable_mask_bounds (GimpDrawable *drawable,
gint *x2,
gint *y2)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean non_empty = FALSE;
@ -577,13 +516,9 @@ gimp_drawable_mask_bounds (GimpDrawable *drawable,
GIMP_TYPE_DRAWABLE, drawable,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-drawable-mask-bounds",
args);
else
return_vals = gimp_run_procedure_array ("gimp-drawable-mask-bounds",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -628,7 +563,6 @@ gimp_drawable_mask_intersect (GimpDrawable *drawable,
gint *width,
gint *height)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean non_empty = FALSE;
@ -637,13 +571,9 @@ gimp_drawable_mask_intersect (GimpDrawable *drawable,
GIMP_TYPE_DRAWABLE, drawable,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-drawable-mask-intersect",
args);
else
return_vals = gimp_run_procedure_array ("gimp-drawable-mask-intersect",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -678,7 +608,6 @@ gboolean
gimp_drawable_merge_shadow (GimpDrawable *drawable,
gboolean undo)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -688,13 +617,9 @@ gimp_drawable_merge_shadow (GimpDrawable *drawable,
G_TYPE_BOOLEAN, undo,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-drawable-merge-shadow",
args);
else
return_vals = gimp_run_procedure_array ("gimp-drawable-merge-shadow",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -722,7 +647,6 @@ gimp_drawable_merge_shadow (GimpDrawable *drawable,
gboolean
gimp_drawable_free_shadow (GimpDrawable *drawable)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -731,13 +655,9 @@ gimp_drawable_free_shadow (GimpDrawable *drawable)
GIMP_TYPE_DRAWABLE, drawable,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-drawable-free-shadow",
args);
else
return_vals = gimp_run_procedure_array ("gimp-drawable-free-shadow",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -771,7 +691,6 @@ gimp_drawable_update (GimpDrawable *drawable,
gint width,
gint height)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -784,13 +703,9 @@ gimp_drawable_update (GimpDrawable *drawable,
G_TYPE_INT, height,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-drawable-update",
args);
else
return_vals = gimp_run_procedure_array ("gimp-drawable-update",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-drawable-update",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -823,7 +738,6 @@ gimp_drawable_get_pixel (GimpDrawable *drawable,
gint y_coord,
gint *num_channels)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
guint8 *pixel = NULL;
@ -834,13 +748,9 @@ gimp_drawable_get_pixel (GimpDrawable *drawable,
G_TYPE_INT, y_coord,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-drawable-get-pixel",
args);
else
return_vals = gimp_run_procedure_array ("gimp-drawable-get-pixel",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-drawable-get-pixel",
args);
gimp_value_array_unref (args);
*num_channels = 0;
@ -881,7 +791,6 @@ gimp_drawable_set_pixel (GimpDrawable *drawable,
gint num_channels,
const guint8 *pixel)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -895,13 +804,9 @@ gimp_drawable_set_pixel (GimpDrawable *drawable,
G_TYPE_NONE);
gimp_value_set_uint8_array (gimp_value_array_index (args, 4), pixel, num_channels);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-drawable-set-pixel",
args);
else
return_vals = gimp_run_procedure_array ("gimp-drawable-set-pixel",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -936,7 +841,6 @@ gboolean
gimp_drawable_fill (GimpDrawable *drawable,
GimpFillType fill_type)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -946,13 +850,9 @@ gimp_drawable_fill (GimpDrawable *drawable,
GIMP_TYPE_FILL_TYPE, fill_type,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-drawable-fill",
args);
else
return_vals = gimp_run_procedure_array ("gimp-drawable-fill",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-drawable-fill",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -989,7 +889,6 @@ gimp_drawable_offset (GimpDrawable *drawable,
gint offset_x,
gint offset_y)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -1002,13 +901,9 @@ gimp_drawable_offset (GimpDrawable *drawable,
G_TYPE_INT, offset_y,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-drawable-offset",
args);
else
return_vals = gimp_run_procedure_array ("gimp-drawable-offset",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-drawable-offset",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -1048,7 +943,6 @@ _gimp_drawable_thumbnail (GimpDrawable *drawable,
gint *thumbnail_data_count,
guint8 **thumbnail_data)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -1059,13 +953,9 @@ _gimp_drawable_thumbnail (GimpDrawable *drawable,
G_TYPE_INT, height,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-drawable-thumbnail",
args);
else
return_vals = gimp_run_procedure_array ("gimp-drawable-thumbnail",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-drawable-thumbnail",
args);
gimp_value_array_unref (args);
*actual_width = 0;
@ -1130,7 +1020,6 @@ _gimp_drawable_sub_thumbnail (GimpDrawable *drawable,
gint *thumbnail_data_count,
guint8 **thumbnail_data)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -1145,13 +1034,9 @@ _gimp_drawable_sub_thumbnail (GimpDrawable *drawable,
G_TYPE_INT, dest_height,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-drawable-sub-thumbnail",
args);
else
return_vals = gimp_run_procedure_array ("gimp-drawable-sub-thumbnail",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-drawable-sub-thumbnail",
args);
gimp_value_array_unref (args);
*width = 0;
@ -1196,7 +1081,6 @@ gimp_drawable_foreground_extract (GimpDrawable *drawable,
GimpForegroundExtractMode mode,
GimpDrawable *mask)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -1207,13 +1091,9 @@ gimp_drawable_foreground_extract (GimpDrawable *drawable,
GIMP_TYPE_DRAWABLE, mask,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-drawable-foreground-extract",
args);
else
return_vals = gimp_run_procedure_array ("gimp-drawable-foreground-extract",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;

154
libgimp/gimpdrawablecolor_pdb.c
View File

@ -56,7 +56,6 @@ gimp_drawable_brightness_contrast (GimpDrawable *drawable,
gdouble brightness,
gdouble contrast)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -67,13 +66,9 @@ gimp_drawable_brightness_contrast (GimpDrawable *drawable,
G_TYPE_DOUBLE, contrast,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-drawable-brightness-contrast",
args);
else
return_vals = gimp_run_procedure_array ("gimp-drawable-brightness-contrast",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -115,7 +110,6 @@ gimp_drawable_color_balance (GimpDrawable *drawable,
gdouble magenta_green,
gdouble yellow_blue)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -129,13 +123,9 @@ gimp_drawable_color_balance (GimpDrawable *drawable,
G_TYPE_DOUBLE, yellow_blue,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-drawable-color-balance",
args);
else
return_vals = gimp_run_procedure_array ("gimp-drawable-color-balance",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -169,7 +159,6 @@ gimp_drawable_colorize_hsl (GimpDrawable *drawable,
gdouble saturation,
gdouble lightness)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -181,13 +170,9 @@ gimp_drawable_colorize_hsl (GimpDrawable *drawable,
G_TYPE_DOUBLE, lightness,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-drawable-colorize-hsl",
args);
else
return_vals = gimp_run_procedure_array ("gimp-drawable-colorize-hsl",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -223,7 +208,6 @@ gimp_drawable_curves_explicit (GimpDrawable *drawable,
gint num_values,
const gdouble *values)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -236,13 +220,9 @@ gimp_drawable_curves_explicit (GimpDrawable *drawable,
G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 3), values, num_values);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-drawable-curves-explicit",
args);
else
return_vals = gimp_run_procedure_array ("gimp-drawable-curves-explicit",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -278,7 +258,6 @@ gimp_drawable_curves_spline (GimpDrawable *drawable,
gint num_points,
const gdouble *points)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -291,13 +270,9 @@ gimp_drawable_curves_spline (GimpDrawable *drawable,
G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 3), points, num_points);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-drawable-curves-spline",
args);
else
return_vals = gimp_run_procedure_array ("gimp-drawable-curves-spline",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -327,7 +302,6 @@ gboolean
gimp_drawable_desaturate (GimpDrawable *drawable,
GimpDesaturateMode desaturate_mode)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -337,13 +311,9 @@ gimp_drawable_desaturate (GimpDrawable *drawable,
GIMP_TYPE_DESATURATE_MODE, desaturate_mode,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-drawable-desaturate",
args);
else
return_vals = gimp_run_procedure_array ("gimp-drawable-desaturate",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-drawable-desaturate",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -376,7 +346,6 @@ gboolean
gimp_drawable_equalize (GimpDrawable *drawable,
gboolean mask_only)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -386,13 +355,9 @@ gimp_drawable_equalize (GimpDrawable *drawable,
G_TYPE_BOOLEAN, mask_only,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-drawable-equalize",
args);
else
return_vals = gimp_run_procedure_array ("gimp-drawable-equalize",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-drawable-equalize",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -450,7 +415,6 @@ gimp_drawable_histogram (GimpDrawable *drawable,
gdouble *count,
gdouble *percentile)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -462,13 +426,9 @@ gimp_drawable_histogram (GimpDrawable *drawable,
G_TYPE_DOUBLE, end_range,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-drawable-histogram",
args);
else
return_vals = gimp_run_procedure_array ("gimp-drawable-histogram",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-drawable-histogram",
args);
gimp_value_array_unref (args);
*mean = 0.0;
@ -524,7 +484,6 @@ gimp_drawable_hue_saturation (GimpDrawable *drawable,
gdouble saturation,
gdouble overlap)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -538,13 +497,9 @@ gimp_drawable_hue_saturation (GimpDrawable *drawable,
G_TYPE_DOUBLE, overlap,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-drawable-hue-saturation",
args);
else
return_vals = gimp_run_procedure_array ("gimp-drawable-hue-saturation",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -574,7 +529,6 @@ gboolean
gimp_drawable_invert (GimpDrawable *drawable,
gboolean linear)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -584,13 +538,9 @@ gimp_drawable_invert (GimpDrawable *drawable,
G_TYPE_BOOLEAN, linear,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-drawable-invert",
args);
else
return_vals = gimp_run_procedure_array ("gimp-drawable-invert",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-drawable-invert",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -642,7 +592,6 @@ gimp_drawable_levels (GimpDrawable *drawable,
gdouble high_output,
gboolean clamp_output)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -659,13 +608,9 @@ gimp_drawable_levels (GimpDrawable *drawable,
G_TYPE_BOOLEAN, clamp_output,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-drawable-levels",
args);
else
return_vals = gimp_run_procedure_array ("gimp-drawable-levels",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-drawable-levels",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -692,7 +637,6 @@ gimp_drawable_levels (GimpDrawable *drawable,
gboolean
gimp_drawable_levels_stretch (GimpDrawable *drawable)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -701,13 +645,9 @@ gimp_drawable_levels_stretch (GimpDrawable *drawable)
GIMP_TYPE_DRAWABLE, drawable,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-drawable-levels-stretch",
args);
else
return_vals = gimp_run_procedure_array ("gimp-drawable-levels-stretch",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -735,7 +675,6 @@ gboolean
gimp_drawable_posterize (GimpDrawable *drawable,
gint levels)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -745,13 +684,9 @@ gimp_drawable_posterize (GimpDrawable *drawable,
G_TYPE_INT, levels,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-drawable-posterize",
args);
else
return_vals = gimp_run_procedure_array ("gimp-drawable-posterize",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-drawable-posterize",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -785,7 +720,6 @@ gimp_drawable_threshold (GimpDrawable *drawable,
gdouble low_threshold,
gdouble high_threshold)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -797,13 +731,9 @@ gimp_drawable_threshold (GimpDrawable *drawable,
G_TYPE_DOUBLE, high_threshold,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-drawable-threshold",
args);
else
return_vals = gimp_run_procedure_array ("gimp-drawable-threshold",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-drawable-threshold",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;

66
libgimp/gimpdrawableedit_pdb.c
View File

@ -54,7 +54,6 @@
gboolean
gimp_drawable_edit_clear (GimpDrawable *drawable)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -63,13 +62,9 @@ gimp_drawable_edit_clear (GimpDrawable *drawable)
GIMP_TYPE_DRAWABLE, drawable,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-drawable-edit-clear",
args);
else
return_vals = gimp_run_procedure_array ("gimp-drawable-edit-clear",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -102,7 +97,6 @@ gboolean
gimp_drawable_edit_fill (GimpDrawable *drawable,
GimpFillType fill_type)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -112,13 +106,9 @@ gimp_drawable_edit_fill (GimpDrawable *drawable,
GIMP_TYPE_FILL_TYPE, fill_type,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-drawable-edit-fill",
args);
else
return_vals = gimp_run_procedure_array ("gimp-drawable-edit-fill",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -161,7 +151,6 @@ gimp_drawable_edit_bucket_fill (GimpDrawable *drawable,
gdouble x,
gdouble y)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -173,13 +162,9 @@ gimp_drawable_edit_bucket_fill (GimpDrawable *drawable,
G_TYPE_DOUBLE, y,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-drawable-edit-bucket-fill",
args);
else
return_vals = gimp_run_procedure_array ("gimp-drawable-edit-bucket-fill",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -235,7 +220,6 @@ gimp_drawable_edit_gradient_fill (GimpDrawable *drawable,
gdouble x2,
gdouble y2)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -254,13 +238,9 @@ gimp_drawable_edit_gradient_fill (GimpDrawable *drawable,
G_TYPE_DOUBLE, y2,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-drawable-edit-gradient-fill",
args);
else
return_vals = gimp_run_procedure_array ("gimp-drawable-edit-gradient-fill",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -294,7 +274,6 @@ gimp_drawable_edit_gradient_fill (GimpDrawable *drawable,
gboolean
gimp_drawable_edit_stroke_selection (GimpDrawable *drawable)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -303,13 +282,9 @@ gimp_drawable_edit_stroke_selection (GimpDrawable *drawable)
GIMP_TYPE_DRAWABLE, drawable,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-drawable-edit-stroke-selection",
args);
else
return_vals = gimp_run_procedure_array ("gimp-drawable-edit-stroke-selection",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -347,7 +322,6 @@ gboolean
gimp_drawable_edit_stroke_item (GimpDrawable *drawable,
GimpItem *item)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -357,13 +331,9 @@ gimp_drawable_edit_stroke_item (GimpDrawable *drawable,
GIMP_TYPE_ITEM, item,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-drawable-edit-stroke-item",
args);
else
return_vals = gimp_run_procedure_array ("gimp-drawable-edit-stroke-item",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;

22
libgimp/gimpdynamics_pdb.c
View File

@ -50,7 +50,6 @@
gboolean
gimp_dynamics_refresh (void)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -58,13 +57,9 @@ gimp_dynamics_refresh (void)
args = gimp_value_array_new_from_types (NULL,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-dynamics-refresh",
args);
else
return_vals = gimp_run_procedure_array ("gimp-dynamics-refresh",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-dynamics-refresh",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -94,7 +89,6 @@ 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;
@ -103,13 +97,9 @@ gimp_dynamics_get_list (const gchar *filter,
G_TYPE_STRING, filter,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-dynamics-get-list",
args);
else
return_vals = gimp_run_procedure_array ("gimp-dynamics-get-list",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-dynamics-get-list",
args);
gimp_value_array_unref (args);
*num_dynamics = 0;

110
libgimp/gimpedit_pdb.c
View File

@ -54,7 +54,6 @@
gboolean
gimp_edit_cut (GimpDrawable *drawable)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean non_empty = FALSE;
@ -63,13 +62,9 @@ gimp_edit_cut (GimpDrawable *drawable)
GIMP_TYPE_DRAWABLE, drawable,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-edit-cut",
args);
else
return_vals = gimp_run_procedure_array ("gimp-edit-cut",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-edit-cut",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -100,7 +95,6 @@ gimp_edit_cut (GimpDrawable *drawable)
gboolean
gimp_edit_copy (GimpDrawable *drawable)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean non_empty = FALSE;
@ -109,13 +103,9 @@ gimp_edit_copy (GimpDrawable *drawable)
GIMP_TYPE_DRAWABLE, drawable,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-edit-copy",
args);
else
return_vals = gimp_run_procedure_array ("gimp-edit-copy",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-edit-copy",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -146,7 +136,6 @@ gimp_edit_copy (GimpDrawable *drawable)
gboolean
gimp_edit_copy_visible (GimpImage *image)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean non_empty = FALSE;
@ -155,13 +144,9 @@ gimp_edit_copy_visible (GimpImage *image)
GIMP_TYPE_IMAGE, image,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-edit-copy-visible",
args);
else
return_vals = gimp_run_procedure_array ("gimp-edit-copy-visible",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -201,7 +186,6 @@ GimpLayer *
gimp_edit_paste (GimpDrawable *drawable,
gboolean paste_into)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpLayer *floating_sel = NULL;
@ -211,13 +195,9 @@ gimp_edit_paste (GimpDrawable *drawable,
G_TYPE_BOOLEAN, paste_into,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-edit-paste",
args);
else
return_vals = gimp_run_procedure_array ("gimp-edit-paste",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-edit-paste",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -245,7 +225,6 @@ gimp_edit_paste (GimpDrawable *drawable,
GimpImage *
gimp_edit_paste_as_new_image (void)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpImage *image = NULL;
@ -253,13 +232,9 @@ gimp_edit_paste_as_new_image (void)
args = gimp_value_array_new_from_types (NULL,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-edit-paste-as-new-image",
args);
else
return_vals = gimp_run_procedure_array ("gimp-edit-paste-as-new-image",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -292,7 +267,6 @@ gchar *
gimp_edit_named_cut (GimpDrawable *drawable,
const gchar *buffer_name)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *real_name = NULL;
@ -302,13 +276,9 @@ gimp_edit_named_cut (GimpDrawable *drawable,
G_TYPE_STRING, buffer_name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-edit-named-cut",
args);
else
return_vals = gimp_run_procedure_array ("gimp-edit-named-cut",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -341,7 +311,6 @@ gchar *
gimp_edit_named_copy (GimpDrawable *drawable,
const gchar *buffer_name)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *real_name = NULL;
@ -351,13 +320,9 @@ gimp_edit_named_copy (GimpDrawable *drawable,
G_TYPE_STRING, buffer_name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-edit-named-copy",
args);
else
return_vals = gimp_run_procedure_array ("gimp-edit-named-copy",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -390,7 +355,6 @@ gchar *
gimp_edit_named_copy_visible (GimpImage *image,
const gchar *buffer_name)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *real_name = NULL;
@ -400,13 +364,9 @@ gimp_edit_named_copy_visible (GimpImage *image,
G_TYPE_STRING, buffer_name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-edit-named-copy-visible",
args);
else
return_vals = gimp_run_procedure_array ("gimp-edit-named-copy-visible",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -437,7 +397,6 @@ gimp_edit_named_paste (GimpDrawable *drawable,
const gchar *buffer_name,
gboolean paste_into)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpLayer *floating_sel = NULL;
@ -448,13 +407,9 @@ gimp_edit_named_paste (GimpDrawable *drawable,
G_TYPE_BOOLEAN, paste_into,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-edit-named-paste",
args);
else
return_vals = gimp_run_procedure_array ("gimp-edit-named-paste",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -481,7 +436,6 @@ gimp_edit_named_paste (GimpDrawable *drawable,
GimpImage *
gimp_edit_named_paste_as_new_image (const gchar *buffer_name)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpImage *image = NULL;
@ -490,13 +444,9 @@ gimp_edit_named_paste_as_new_image (const gchar *buffer_name)
G_TYPE_STRING, buffer_name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-edit-named-paste-as-new-image",
args);
else
return_vals = gimp_run_procedure_array ("gimp-edit-named-paste-as-new-image",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)

2
libgimp/gimpenums.c.tail
View File

@ -44,7 +44,6 @@ static const GimpGetTypeFunc get_type_funcs[] =
gimp_message_handler_type_get_type,
gimp_offset_type_get_type,
gimp_orientation_type_get_type,
gimp_pdb_arg_type_get_type,
gimp_pdb_error_handler_get_type,
gimp_pdb_proc_type_get_type,
gimp_pdb_status_type_get_type,
@ -110,7 +109,6 @@ static const gchar * const type_names[] =
"GimpMessageHandlerType",
"GimpOffsetType",
"GimpOrientationType",
"GimpPDBArgType",
"GimpPDBErrorHandler",
"GimpPDBProcType",
"GimpPDBStatusType",

143
libgimp/gimpfileops_pdb.c
View File

@ -57,7 +57,6 @@ gimp_file_load (GimpRunMode run_mode,
const gchar *filename,
const gchar *raw_filename)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpImage *image = NULL;
@ -68,13 +67,9 @@ gimp_file_load (GimpRunMode run_mode,
G_TYPE_STRING, raw_filename,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-file-load",
args);
else
return_vals = gimp_run_procedure_array ("gimp-file-load",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-file-load",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -107,7 +102,6 @@ gimp_file_load_layer (GimpRunMode run_mode,
GimpImage *image,
const gchar *filename)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpLayer *layer = NULL;
@ -118,13 +112,9 @@ gimp_file_load_layer (GimpRunMode run_mode,
G_TYPE_STRING, filename,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-file-load-layer",
args);
else
return_vals = gimp_run_procedure_array ("gimp-file-load-layer",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -161,7 +151,6 @@ 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;
@ -172,13 +161,9 @@ gimp_file_load_layers (GimpRunMode run_mode,
G_TYPE_STRING, filename,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-file-load-layers",
args);
else
return_vals = gimp_run_procedure_array ("gimp-file-load-layers",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-file-load-layers",
args);
gimp_value_array_unref (args);
*num_layers = 0;
@ -221,7 +206,6 @@ 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;
@ -234,13 +218,9 @@ gimp_file_save (GimpRunMode run_mode,
G_TYPE_STRING, raw_filename,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-file-save",
args);
else
return_vals = gimp_run_procedure_array ("gimp-file-save",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-file-save",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -270,7 +250,6 @@ gboolean
gimp_file_save_thumbnail (GimpImage *image,
const gchar *filename)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -280,13 +259,9 @@ gimp_file_save_thumbnail (GimpImage *image,
G_TYPE_STRING, filename,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-file-save-thumbnail",
args);
else
return_vals = gimp_run_procedure_array ("gimp-file-save-thumbnail",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -316,7 +291,6 @@ _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;
@ -328,13 +302,9 @@ _gimp_register_magic_load_handler (const gchar *procedure_name,
G_TYPE_STRING, magics,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-register-magic-load-handler",
args);
else
return_vals = gimp_run_procedure_array ("gimp-register-magic-load-handler",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -362,7 +332,6 @@ _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;
@ -373,13 +342,9 @@ _gimp_register_load_handler (const gchar *procedure_name,
G_TYPE_STRING, prefixes,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-register-load-handler",
args);
else
return_vals = gimp_run_procedure_array ("gimp-register-load-handler",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -407,7 +372,6 @@ _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;
@ -418,13 +382,9 @@ _gimp_register_save_handler (const gchar *procedure_name,
G_TYPE_STRING, prefixes,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-register-save-handler",
args);
else
return_vals = gimp_run_procedure_array ("gimp-register-save-handler",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -455,7 +415,6 @@ 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;
@ -465,13 +424,9 @@ _gimp_register_file_handler_priority (const gchar *procedure_name,
G_TYPE_INT, priority,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-register-file-handler-priority",
args);
else
return_vals = gimp_run_procedure_array ("gimp-register-file-handler-priority",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -503,7 +458,6 @@ 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;
@ -513,13 +467,9 @@ _gimp_register_file_handler_mime (const gchar *procedure_name,
G_TYPE_STRING, mime_types,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-register-file-handler-mime",
args);
else
return_vals = gimp_run_procedure_array ("gimp-register-file-handler-mime",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -547,7 +497,6 @@ _gimp_register_file_handler_mime (const gchar *procedure_name,
gboolean
_gimp_register_file_handler_remote (const gchar *procedure_name)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -556,13 +505,9 @@ _gimp_register_file_handler_remote (const gchar *procedure_name)
G_TYPE_STRING, procedure_name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-register-file-handler-remote",
args);
else
return_vals = gimp_run_procedure_array ("gimp-register-file-handler-remote",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-register-file-handler-remote",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -590,7 +535,6 @@ _gimp_register_file_handler_remote (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;
@ -599,13 +543,9 @@ _gimp_register_file_handler_raw (const gchar *procedure_name)
G_TYPE_STRING, procedure_name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-register-file-handler-raw",
args);
else
return_vals = gimp_run_procedure_array ("gimp-register-file-handler-raw",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -637,7 +577,6 @@ 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;
@ -647,13 +586,9 @@ _gimp_register_thumbnail_loader (const gchar *load_proc,
G_TYPE_STRING, thumb_proc,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-register-thumbnail-loader",
args);
else
return_vals = gimp_run_procedure_array ("gimp-register-thumbnail-loader",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;

44
libgimp/gimpfloatingsel_pdb.c
View File

@ -49,7 +49,6 @@
gboolean
gimp_floating_sel_remove (GimpLayer *floating_sel)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -58,13 +57,9 @@ gimp_floating_sel_remove (GimpLayer *floating_sel)
GIMP_TYPE_LAYER, floating_sel,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-floating-sel-remove",
args);
else
return_vals = gimp_run_procedure_array ("gimp-floating-sel-remove",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -90,7 +85,6 @@ gimp_floating_sel_remove (GimpLayer *floating_sel)
gboolean
gimp_floating_sel_anchor (GimpLayer *floating_sel)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -99,13 +93,9 @@ gimp_floating_sel_anchor (GimpLayer *floating_sel)
GIMP_TYPE_LAYER, floating_sel,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-floating-sel-anchor",
args);
else
return_vals = gimp_run_procedure_array ("gimp-floating-sel-anchor",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -135,7 +125,6 @@ gimp_floating_sel_anchor (GimpLayer *floating_sel)
gboolean
gimp_floating_sel_to_layer (GimpLayer *floating_sel)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -144,13 +133,9 @@ gimp_floating_sel_to_layer (GimpLayer *floating_sel)
GIMP_TYPE_LAYER, floating_sel,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-floating-sel-to-layer",
args);
else
return_vals = gimp_run_procedure_array ("gimp-floating-sel-to-layer",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -176,7 +161,6 @@ gboolean
gimp_floating_sel_attach (GimpLayer *layer,
GimpDrawable *drawable)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -186,13 +170,9 @@ gimp_floating_sel_attach (GimpLayer *layer,
GIMP_TYPE_DRAWABLE, drawable,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-floating-sel-attach",
args);
else
return_vals = gimp_run_procedure_array ("gimp-floating-sel-attach",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;

22
libgimp/gimpfonts_pdb.c
View File

@ -48,7 +48,6 @@
gboolean
gimp_fonts_refresh (void)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -56,13 +55,9 @@ gimp_fonts_refresh (void)
args = gimp_value_array_new_from_types (NULL,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-fonts-refresh",
args);
else
return_vals = gimp_run_procedure_array ("gimp-fonts-refresh",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-fonts-refresh",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -90,7 +85,6 @@ 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;
@ -99,13 +93,9 @@ gimp_fonts_get_list (const gchar *filter,
G_TYPE_STRING, filter,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-fonts-get-list",
args);
else
return_vals = gimp_run_procedure_array ("gimp-fonts-get-list",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-fonts-get-list",
args);
gimp_value_array_unref (args);
*num_fonts = 0;

33
libgimp/gimpfontselect_pdb.c
View File

@ -51,7 +51,6 @@ 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;
@ -62,13 +61,9 @@ gimp_fonts_popup (const gchar *font_callback,
G_TYPE_STRING, initial_font,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-fonts-popup",
args);
else
return_vals = gimp_run_procedure_array ("gimp-fonts-popup",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-fonts-popup",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -91,7 +86,6 @@ 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;
@ -100,13 +94,9 @@ gimp_fonts_close_popup (const gchar *font_callback)
G_TYPE_STRING, font_callback,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-fonts-close-popup",
args);
else
return_vals = gimp_run_procedure_array ("gimp-fonts-close-popup",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -131,7 +121,6 @@ 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;
@ -141,13 +130,9 @@ gimp_fonts_set_popup (const gchar *font_callback,
G_TYPE_STRING, font_name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-fonts-set-popup",
args);
else
return_vals = gimp_run_procedure_array ("gimp-fonts-set-popup",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;

77
libgimp/gimpgimprc_pdb.c
View File

@ -56,7 +56,6 @@
gchar *
gimp_gimprc_query (const gchar *token)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *value = NULL;
@ -65,13 +64,9 @@ gimp_gimprc_query (const gchar *token)
G_TYPE_STRING, token,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-gimprc-query",
args);
else
return_vals = gimp_run_procedure_array ("gimp-gimprc-query",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-gimprc-query",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -101,7 +96,6 @@ gboolean
gimp_gimprc_set (const gchar *token,
const gchar *value)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -111,13 +105,9 @@ gimp_gimprc_set (const gchar *token,
G_TYPE_STRING, value,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-gimprc-set",
args);
else
return_vals = gimp_run_procedure_array ("gimp-gimprc-set",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-gimprc-set",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -140,7 +130,6 @@ 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;
@ -148,13 +137,9 @@ gimp_get_default_comment (void)
args = gimp_value_array_new_from_types (NULL,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-get-default-comment",
args);
else
return_vals = gimp_run_procedure_array ("gimp-get-default-comment",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -179,7 +164,6 @@ gimp_get_default_comment (void)
GimpUnit
gimp_get_default_unit (void)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpUnit unit_id = GIMP_UNIT_PIXEL;
@ -187,13 +171,9 @@ gimp_get_default_unit (void)
args = gimp_value_array_new_from_types (NULL,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-get-default-unit",
args);
else
return_vals = gimp_run_procedure_array ("gimp-get-default-unit",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -222,7 +202,6 @@ gboolean
gimp_get_monitor_resolution (gdouble *xres,
gdouble *yres)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -230,13 +209,9 @@ gimp_get_monitor_resolution (gdouble *xres,
args = gimp_value_array_new_from_types (NULL,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-get-monitor-resolution",
args);
else
return_vals = gimp_run_procedure_array ("gimp-get-monitor-resolution",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-get-monitor-resolution",
args);
gimp_value_array_unref (args);
*xres = 0.0;
@ -271,7 +246,6 @@ 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;
@ -279,13 +253,9 @@ _gimp_get_color_configuration (void)
args = gimp_value_array_new_from_types (NULL,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-get-color-configuration",
args);
else
return_vals = gimp_run_procedure_array ("gimp-get-color-configuration",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -309,7 +279,6 @@ _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;
@ -317,13 +286,9 @@ gimp_get_module_load_inhibit (void)
args = gimp_value_array_new_from_types (NULL,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-get-module-load-inhibit",
args);
else
return_vals = gimp_run_procedure_array ("gimp-get-module-load-inhibit",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)

743
libgimp/gimpgpcompat.c
View File

@ -1,743 +0,0 @@
/* LIBGIMP - The GIMP Library
* Copyright (C) 1995-2003 Peter Mattis and Spencer Kimball
*
* gimpgpcompat.c
* Copyright (C) 2019 Michael Natterer <mitch@gimp.org>
*
* This library is free software: you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see
* <https://www.gnu.org/licenses/>.
*/
#include "config.h"
#include "gimp.h"
#include "gimpgpcompat.h"
/* local function prototypes */
static gchar * _gimp_pdb_arg_type_to_string (GimpPDBArgType type);
/* public functions */
GParamSpec *
_gimp_gp_compat_param_spec (GimpPDBArgType arg_type,
const gchar *name,
const gchar *nick,
const gchar *blurb)
{
GParamSpec *pspec = NULL;
g_return_val_if_fail (name != NULL, NULL);
switch (arg_type)
{
case GIMP_PDB_INT32:
pspec = g_param_spec_int (name, nick, blurb,
G_MININT32, G_MAXINT32, 0,
G_PARAM_READWRITE);
break;
case GIMP_PDB_INT16:
pspec = g_param_spec_int (name, nick, blurb,
G_MININT16, G_MAXINT16, 0,
G_PARAM_READWRITE);
break;
case GIMP_PDB_INT8:
pspec = g_param_spec_uchar (name, nick, blurb,
0, G_MAXUINT8, 0,
G_PARAM_READWRITE);
break;
case GIMP_PDB_FLOAT:
pspec = g_param_spec_double (name, nick, blurb,
-G_MAXDOUBLE, G_MAXDOUBLE, 0.0,
G_PARAM_READWRITE);
break;
case GIMP_PDB_STRING:
pspec = g_param_spec_string (name, nick, blurb,
NULL,
G_PARAM_READWRITE);
break;
case GIMP_PDB_INT32ARRAY:
pspec = gimp_param_spec_int32_array (name, nick, blurb,
G_PARAM_READWRITE);
break;
case GIMP_PDB_INT16ARRAY:
pspec = gimp_param_spec_int16_array (name, nick, blurb,
G_PARAM_READWRITE);
break;
case GIMP_PDB_INT8ARRAY:
pspec = gimp_param_spec_uint8_array (name, nick, blurb,
G_PARAM_READWRITE);
break;
case GIMP_PDB_FLOATARRAY:
pspec = gimp_param_spec_float_array (name, nick, blurb,
G_PARAM_READWRITE);
break;
case GIMP_PDB_STRINGARRAY:
pspec = gimp_param_spec_string_array (name, nick, blurb,
G_PARAM_READWRITE);
break;
case GIMP_PDB_COLOR:
pspec = gimp_param_spec_rgb (name, nick, blurb,
TRUE, NULL,
G_PARAM_READWRITE);
break;
case GIMP_PDB_ITEM:
pspec = gimp_param_spec_item (name, nick, blurb,
TRUE,
G_PARAM_READWRITE);
break;
case GIMP_PDB_DISPLAY:
pspec = gimp_param_spec_display (name, nick, blurb,
TRUE,
G_PARAM_READWRITE);
break;
case GIMP_PDB_IMAGE:
pspec = gimp_param_spec_image (name, nick, blurb,
TRUE,
G_PARAM_READWRITE);
break;
case GIMP_PDB_LAYER:
pspec = gimp_param_spec_layer (name, nick, blurb,
TRUE,
G_PARAM_READWRITE);
break;
case GIMP_PDB_CHANNEL:
pspec = gimp_param_spec_channel (name, nick, blurb,
TRUE,
G_PARAM_READWRITE);
break;
case GIMP_PDB_DRAWABLE:
pspec = gimp_param_spec_drawable (name, nick, blurb,
TRUE,
G_PARAM_READWRITE);
break;
case GIMP_PDB_SELECTION:
pspec = gimp_param_spec_selection (name, nick, blurb,
TRUE,
G_PARAM_READWRITE);
break;
case GIMP_PDB_COLORARRAY:
pspec = gimp_param_spec_rgb_array (name, nick, blurb,
G_PARAM_READWRITE);
break;
case GIMP_PDB_VECTORS:
pspec = gimp_param_spec_vectors (name, nick, blurb,
TRUE,
G_PARAM_READWRITE);
break;
case GIMP_PDB_PARASITE:
pspec = gimp_param_spec_parasite (name, nick, blurb,
G_PARAM_READWRITE);
break;
case GIMP_PDB_STATUS:
pspec = g_param_spec_enum (name, nick, blurb,
GIMP_TYPE_PDB_STATUS_TYPE,
GIMP_PDB_EXECUTION_ERROR,
G_PARAM_READWRITE);
break;
case GIMP_PDB_END:
break;
}
if (! pspec)
g_warning ("%s: returning NULL for %s (%s)",
G_STRFUNC, name, _gimp_pdb_arg_type_to_string (arg_type));
return pspec;
}
GType
_gimp_pdb_arg_type_to_gtype (GimpPDBArgType type)
{
switch (type)
{
case GIMP_PDB_INT32:
return G_TYPE_INT;
case GIMP_PDB_INT16:
return G_TYPE_INT;
case GIMP_PDB_INT8:
return G_TYPE_UCHAR;
case GIMP_PDB_FLOAT:
return G_TYPE_DOUBLE;
case GIMP_PDB_STRING:
return G_TYPE_STRING;
case GIMP_PDB_INT32ARRAY:
return GIMP_TYPE_INT32_ARRAY;
case GIMP_PDB_INT16ARRAY:
return GIMP_TYPE_INT16_ARRAY;
case GIMP_PDB_INT8ARRAY:
return GIMP_TYPE_UINT8_ARRAY;
case GIMP_PDB_FLOATARRAY:
return GIMP_TYPE_FLOAT_ARRAY;
case GIMP_PDB_STRINGARRAY:
return GIMP_TYPE_STRING_ARRAY;
case GIMP_PDB_COLOR:
return GIMP_TYPE_RGB;
case GIMP_PDB_ITEM:
return GIMP_TYPE_ITEM;
case GIMP_PDB_DISPLAY:
return GIMP_TYPE_DISPLAY;
case GIMP_PDB_IMAGE:
return GIMP_TYPE_IMAGE;
case GIMP_PDB_LAYER:
return GIMP_TYPE_LAYER;
case GIMP_PDB_CHANNEL:
return GIMP_TYPE_CHANNEL;
case GIMP_PDB_DRAWABLE:
return GIMP_TYPE_DRAWABLE;
case GIMP_PDB_SELECTION:
return GIMP_TYPE_SELECTION;
case GIMP_PDB_COLORARRAY:
return GIMP_TYPE_RGB_ARRAY;
case GIMP_PDB_VECTORS:
return GIMP_TYPE_VECTORS;
case GIMP_PDB_PARASITE:
return GIMP_TYPE_PARASITE;
case GIMP_PDB_STATUS:
return GIMP_TYPE_PDB_STATUS_TYPE;
case GIMP_PDB_END:
break;
}
g_warning ("%s: returning G_TYPE_NONE for %d (%s)",
G_STRFUNC, type, _gimp_pdb_arg_type_to_string (type));
return G_TYPE_NONE;
}
GimpPDBArgType
_gimp_pdb_gtype_to_arg_type (GType type)
{
static GQuark pdb_type_quark = 0;
GimpPDBArgType pdb_type;
if (! pdb_type_quark)
{
struct
{
GType g_type;
GimpPDBArgType pdb_type;
}
type_mapping[] =
{
{ G_TYPE_INT, GIMP_PDB_INT32 },
{ G_TYPE_UINT, GIMP_PDB_INT32 },
{ G_TYPE_ENUM, GIMP_PDB_INT32 },
{ G_TYPE_BOOLEAN, GIMP_PDB_INT32 },
{ G_TYPE_UCHAR, GIMP_PDB_INT8 },
{ G_TYPE_DOUBLE, GIMP_PDB_FLOAT },
{ G_TYPE_STRING, GIMP_PDB_STRING },
{ GIMP_TYPE_RGB, GIMP_PDB_COLOR },
{ GIMP_TYPE_INT32_ARRAY, GIMP_PDB_INT32ARRAY },
{ GIMP_TYPE_INT16_ARRAY, GIMP_PDB_INT16ARRAY },
{ GIMP_TYPE_UINT8_ARRAY, GIMP_PDB_INT8ARRAY },
{ GIMP_TYPE_FLOAT_ARRAY, GIMP_PDB_FLOATARRAY },
{ GIMP_TYPE_STRING_ARRAY, GIMP_PDB_STRINGARRAY },
{ GIMP_TYPE_RGB_ARRAY, GIMP_PDB_COLORARRAY },
{ GIMP_TYPE_ITEM, GIMP_PDB_ITEM },
{ GIMP_TYPE_DISPLAY, GIMP_PDB_DISPLAY },
{ GIMP_TYPE_IMAGE, GIMP_PDB_IMAGE },
{ GIMP_TYPE_LAYER, GIMP_PDB_LAYER },
{ GIMP_TYPE_CHANNEL, GIMP_PDB_CHANNEL },
{ GIMP_TYPE_DRAWABLE, GIMP_PDB_DRAWABLE },
{ GIMP_TYPE_SELECTION, GIMP_PDB_SELECTION },
{ GIMP_TYPE_LAYER_MASK, GIMP_PDB_CHANNEL },
{ GIMP_TYPE_VECTORS, GIMP_PDB_VECTORS },
{ GIMP_TYPE_PARASITE, GIMP_PDB_PARASITE },
{ GIMP_TYPE_PDB_STATUS_TYPE, GIMP_PDB_STATUS }
};
gint i;
pdb_type_quark = g_quark_from_static_string ("gimp-pdb-type");
for (i = 0; i < G_N_ELEMENTS (type_mapping); i++)
g_type_set_qdata (type_mapping[i].g_type, pdb_type_quark,
GINT_TO_POINTER (type_mapping[i].pdb_type));
}
pdb_type = GPOINTER_TO_INT (g_type_get_qdata (type, pdb_type_quark));
#if 0
g_printerr ("%s: arg_type = %p (%s) -> %d (%s)\n",
G_STRFUNC,
(gpointer) type, g_type_name (type),
pdb_type, _gimp_pdb_arg_type_to_string (pdb_type));
#endif
return pdb_type;
}
GimpValueArray *
_gimp_params_to_value_array (const GimpParam *params,
gint n_params,
gboolean full_copy)
{
GimpValueArray *args;
gint i;
g_return_val_if_fail ((params != NULL && n_params > 0) ||
(params == NULL && n_params == 0), NULL);
args = gimp_value_array_new (n_params);
for (i = 0; i < n_params; i++)
{
GValue value = G_VALUE_INIT;
GType type = _gimp_pdb_arg_type_to_gtype (params[i].type);
gint count;
g_value_init (&value, type);
switch (_gimp_pdb_gtype_to_arg_type (type))
{
case GIMP_PDB_INT32:
if (G_VALUE_HOLDS_INT (&value))
g_value_set_int (&value, params[i].data.d_int32);
else if (G_VALUE_HOLDS_UINT (&value))
g_value_set_uint (&value, params[i].data.d_int32);
else if (G_VALUE_HOLDS_ENUM (&value))
g_value_set_enum (&value, params[i].data.d_int32);
else if (G_VALUE_HOLDS_BOOLEAN (&value))
g_value_set_boolean (&value, params[i].data.d_int32 ? TRUE : FALSE);
else
{
g_printerr ("%s: unhandled GIMP_PDB_INT32 type: %s\n",
G_STRFUNC, g_type_name (G_VALUE_TYPE (&value)));
g_return_val_if_reached (args);
}
break;
case GIMP_PDB_INT16:
g_value_set_int (&value, params[i].data.d_int16);
break;
case GIMP_PDB_INT8:
g_value_set_uchar (&value, params[i].data.d_int8);
break;
case GIMP_PDB_FLOAT:
g_value_set_double (&value, params[i].data.d_float);
break;
case GIMP_PDB_STRING:
if (full_copy)
g_value_set_string (&value, params[i].data.d_string);
else
g_value_set_static_string (&value, params[i].data.d_string);
break;
case GIMP_PDB_INT32ARRAY:
count = GIMP_VALUES_GET_INT (args, i - 1);
if (full_copy)
gimp_value_set_int32_array (&value,
params[i].data.d_int32array,
count);
else
gimp_value_set_static_int32_array (&value,
params[i].data.d_int32array,
count);
break;
case GIMP_PDB_INT16ARRAY:
count = GIMP_VALUES_GET_INT (args, i - 1);
if (full_copy)
gimp_value_set_int16_array (&value,
params[i].data.d_int16array,
count);
else
gimp_value_set_static_int16_array (&value,
params[i].data.d_int16array,
count);
break;
case GIMP_PDB_INT8ARRAY:
count = GIMP_VALUES_GET_INT (args, i - 1);
if (full_copy)
gimp_value_set_uint8_array (&value,
params[i].data.d_int8array,
count);
else
gimp_value_set_static_uint8_array (&value,
params[i].data.d_int8array,
count);
break;
case GIMP_PDB_FLOATARRAY:
count = GIMP_VALUES_GET_INT (args, i - 1);
if (full_copy)
gimp_value_set_float_array (&value,
params[i].data.d_floatarray,
count);
else
gimp_value_set_static_float_array (&value,
params[i].data.d_floatarray,
count);
break;
case GIMP_PDB_STRINGARRAY:
count = GIMP_VALUES_GET_INT (args, i - 1);
if (full_copy)
gimp_value_set_string_array (&value,
(const gchar **) params[i].data.d_stringarray,
count);
else
gimp_value_set_static_string_array (&value,
(const gchar **) params[i].data.d_stringarray,
count);
break;
case GIMP_PDB_COLOR:
gimp_value_set_rgb (&value, &params[i].data.d_color);
break;
case GIMP_PDB_ITEM:
g_value_set_object (&value,
gimp_item_get_by_id (params[i].data.d_item));
break;
case GIMP_PDB_DISPLAY:
g_value_set_object (&value,
gimp_display_get_by_id (params[i].data.d_display));
break;
case GIMP_PDB_IMAGE:
g_value_set_object (&value,
gimp_image_get_by_id (params[i].data.d_image));
break;
case GIMP_PDB_LAYER:
g_value_set_object (&value,
gimp_item_get_by_id (params[i].data.d_layer));
break;
case GIMP_PDB_CHANNEL:
g_value_set_object (&value,
gimp_item_get_by_id (params[i].data.d_channel));
break;
case GIMP_PDB_DRAWABLE:
g_value_set_object (&value,
gimp_item_get_by_id (params[i].data.d_drawable));
break;
case GIMP_PDB_SELECTION:
g_value_set_object (&value,
gimp_item_get_by_id (params[i].data.d_selection));
break;
case GIMP_PDB_COLORARRAY:
count = GIMP_VALUES_GET_INT (args, i - 1);
if (full_copy)
gimp_value_set_rgb_array (&value,
params[i].data.d_colorarray,
count);
else
gimp_value_set_static_rgb_array (&value,
params[i].data.d_colorarray,
count);
break;
case GIMP_PDB_VECTORS:
g_value_set_int (&value, params[i].data.d_vectors);
break;
case GIMP_PDB_PARASITE:
if (full_copy)
g_value_set_boxed (&value, &params[i].data.d_parasite);
else
g_value_set_static_boxed (&value, &params[i].data.d_parasite);
break;
case GIMP_PDB_STATUS:
g_value_set_enum (&value, params[i].data.d_status);
break;
case GIMP_PDB_END:
break;
}
gimp_value_array_append (args, &value);
g_value_unset (&value);
}
return args;
}
GimpParam *
_gimp_value_array_to_params (GimpValueArray *args,
gboolean full_copy)
{
GimpParam *params;
gint length;
gint i;
g_return_val_if_fail (args != NULL, NULL);
params = g_new0 (GimpParam, gimp_value_array_length (args));
length = gimp_value_array_length (args);
for (i = 0; i < length; i++)
{
GValue *value = gimp_value_array_index (args, i);
GObject *object;
params[i].type = _gimp_pdb_gtype_to_arg_type (G_VALUE_TYPE (value));
switch (params[i].type)
{
case GIMP_PDB_INT32:
if (G_VALUE_HOLDS_INT (value))
params[i].data.d_int32 = g_value_get_int (value);
else if (G_VALUE_HOLDS_UINT (value))
params[i].data.d_int32 = g_value_get_uint (value);
else if (G_VALUE_HOLDS_ENUM (value))
params[i].data.d_int32 = g_value_get_enum (value);
else if (G_VALUE_HOLDS_BOOLEAN (value))
params[i].data.d_int32 = g_value_get_boolean (value);
else
{
g_printerr ("%s: unhandled GIMP_PDB_INT32 type: %s\n",
G_STRFUNC, g_type_name (G_VALUE_TYPE (value)));
g_return_val_if_reached (params);
}
break;
case GIMP_PDB_INT16:
params[i].data.d_int16 = g_value_get_int (value);
break;
case GIMP_PDB_INT8:
params[i].data.d_int8 = g_value_get_uchar (value);
break;
case GIMP_PDB_FLOAT:
params[i].data.d_float = g_value_get_double (value);
break;
case GIMP_PDB_STRING:
if (full_copy)
params[i].data.d_string = g_value_dup_string (value);
else
params[i].data.d_string = (gchar *) g_value_get_string (value);
break;
case GIMP_PDB_INT32ARRAY:
if (full_copy)
params[i].data.d_int32array = gimp_value_dup_int32_array (value);
else
params[i].data.d_int32array = (gint32 *) gimp_value_get_int32_array (value);
break;
case GIMP_PDB_INT16ARRAY:
if (full_copy)
params[i].data.d_int16array = gimp_value_dup_int16_array (value);
else
params[i].data.d_int16array = (gint16 *) gimp_value_get_int16_array (value);
break;
case GIMP_PDB_INT8ARRAY:
if (full_copy)
params[i].data.d_int8array = gimp_value_dup_uint8_array (value);
else
params[i].data.d_int8array = (guint8 *) gimp_value_get_uint8_array (value);
break;
case GIMP_PDB_FLOATARRAY:
if (full_copy)
params[i].data.d_floatarray = gimp_value_dup_float_array (value);
else
params[i].data.d_floatarray = (gdouble *) gimp_value_get_float_array (value);
break;
case GIMP_PDB_STRINGARRAY:
if (full_copy)
params[i].data.d_stringarray = gimp_value_dup_string_array (value);
else
params[i].data.d_stringarray = (gchar **) gimp_value_get_string_array (value);
break;
case GIMP_PDB_COLOR:
gimp_value_get_rgb (value, &params[i].data.d_color);
break;
case GIMP_PDB_ITEM:
object = g_value_get_object (value);
params[i].data.d_item =
object ? gimp_item_get_id (GIMP_ITEM (object)) : -1;
break;
case GIMP_PDB_DISPLAY:
object = g_value_get_object (value);
params[i].data.d_display =
object ? gimp_display_get_id (GIMP_DISPLAY (object)) : -1;
break;
case GIMP_PDB_IMAGE:
object = g_value_get_object (value);
params[i].data.d_image =
object ? gimp_image_get_id (GIMP_IMAGE (object)) : -1;
break;
case GIMP_PDB_LAYER:
object = g_value_get_object (value);
params[i].data.d_layer =
object ? gimp_item_get_id (GIMP_ITEM (object)) : -1;
break;
case GIMP_PDB_CHANNEL:
object = g_value_get_object (value);
params[i].data.d_channel =
object ? gimp_item_get_id (GIMP_ITEM (object)) : -1;
break;
case GIMP_PDB_DRAWABLE:
object = g_value_get_object (value);
params[i].data.d_drawable =
object ? gimp_item_get_id (GIMP_ITEM (object)) : -1;
break;
case GIMP_PDB_SELECTION:
object = g_value_get_object (value);
params[i].data.d_selection =
object ? gimp_item_get_id (GIMP_ITEM (object)) : -1;
break;
case GIMP_PDB_COLORARRAY:
if (full_copy)
params[i].data.d_colorarray = gimp_value_dup_rgb_array (value);
else
params[i].data.d_colorarray = (GimpRGB *) gimp_value_get_rgb_array (value);
break;
case GIMP_PDB_VECTORS:
params[i].data.d_vectors = g_value_get_int (value);
break;
case GIMP_PDB_PARASITE:
{
GimpParasite *parasite = (full_copy ?
g_value_dup_boxed (value) :
g_value_get_boxed (value));
if (parasite)
{
params[i].data.d_parasite.name = parasite->name;
params[i].data.d_parasite.flags = parasite->flags;
params[i].data.d_parasite.size = parasite->size;
params[i].data.d_parasite.data = parasite->data;
if (full_copy)
{
parasite->name = NULL;
parasite->flags = 0;
parasite->size = 0;
parasite->data = NULL;
gimp_parasite_free (parasite);
}
}
else
{
params[i].data.d_parasite.name = NULL;
params[i].data.d_parasite.flags = 0;
params[i].data.d_parasite.size = 0;
params[i].data.d_parasite.data = NULL;
}
}
break;
case GIMP_PDB_STATUS:
params[i].data.d_status = g_value_get_enum (value);
break;
case GIMP_PDB_END:
break;
}
}
return params;
}
/* private functions */
gchar *
_gimp_pdb_arg_type_to_string (GimpPDBArgType type)
{
const gchar *name;
if (! gimp_enum_get_value (GIMP_TYPE_PDB_ARG_TYPE, type,
&name, NULL, NULL, NULL))
{
return g_strdup_printf ("(PDB type %d unknown)", type);
}
return g_strdup (name);
}

41
libgimp/gimpgpcompat.h
View File

@ -1,41 +0,0 @@
/* LIBGIMP - The GIMP Library
* Copyright (C) 1995-2003 Peter Mattis and Spencer Kimball
*
* gimpgpcompat.c
* Copyright (C) 2019 Michael Natterer <mitch@gimp.org>
*
* This library is free software: you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see
* <https://www.gnu.org/licenses/>.
*/
#ifndef __GIMP_GP_COMPAT_H__
#define __GIMP_GP_COMPAT_H__
GParamSpec * _gimp_gp_compat_param_spec (GimpPDBArgType arg_type,
const gchar *name,
const gchar *nick,
const gchar *blurb);
GType _gimp_pdb_arg_type_to_gtype (GimpPDBArgType type);
GimpPDBArgType _gimp_pdb_gtype_to_arg_type (GType type);
GimpValueArray * _gimp_params_to_value_array (const GimpParam *params,
gint n_params,
gboolean full_copy);
GimpParam * _gimp_value_array_to_params (GimpValueArray *args,
gboolean full_copy);
#endif /* __GIMP_GP_COMPAT_H__ */

341
libgimp/gimpgradient_pdb.c
View File

@ -50,7 +50,6 @@
gchar *
gimp_gradient_new (const gchar *name)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *actual_name = NULL;
@ -59,13 +58,9 @@ gimp_gradient_new (const gchar *name)
G_TYPE_STRING, name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-gradient-new",
args);
else
return_vals = gimp_run_procedure_array ("gimp-gradient-new",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-gradient-new",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -92,7 +87,6 @@ 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;
@ -101,13 +95,9 @@ gimp_gradient_duplicate (const gchar *name)
G_TYPE_STRING, name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-gradient-duplicate",
args);
else
return_vals = gimp_run_procedure_array ("gimp-gradient-duplicate",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-gradient-duplicate",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -133,7 +123,6 @@ 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;
@ -142,13 +131,9 @@ gimp_gradient_is_editable (const gchar *name)
G_TYPE_STRING, name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-gradient-is-editable",
args);
else
return_vals = gimp_run_procedure_array ("gimp-gradient-is-editable",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -177,7 +162,6 @@ 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;
@ -187,13 +171,9 @@ gimp_gradient_rename (const gchar *name,
G_TYPE_STRING, new_name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-gradient-rename",
args);
else
return_vals = gimp_run_procedure_array ("gimp-gradient-rename",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-gradient-rename",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -219,7 +199,6 @@ 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;
@ -228,13 +207,9 @@ gimp_gradient_delete (const gchar *name)
G_TYPE_STRING, name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-gradient-delete",
args);
else
return_vals = gimp_run_procedure_array ("gimp-gradient-delete",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-gradient-delete",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -260,7 +235,6 @@ 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;
@ -269,13 +243,9 @@ gimp_gradient_get_number_of_segments (const gchar *name)
G_TYPE_STRING, name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-gradient-get-number-of-segments",
args);
else
return_vals = gimp_run_procedure_array ("gimp-gradient-get-number-of-segments",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -315,7 +285,6 @@ 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;
@ -326,13 +295,9 @@ gimp_gradient_get_uniform_samples (const gchar *name,
G_TYPE_BOOLEAN, reverse,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-gradient-get-uniform-samples",
args);
else
return_vals = gimp_run_procedure_array ("gimp-gradient-get-uniform-samples",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-gradient-get-uniform-samples",
args);
gimp_value_array_unref (args);
*num_color_samples = 0;
@ -381,7 +346,6 @@ 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;
@ -394,13 +358,9 @@ gimp_gradient_get_custom_samples (const gchar *name,
G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 2), positions, num_samples);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-gradient-get-custom-samples",
args);
else
return_vals = gimp_run_procedure_array ("gimp-gradient-get-custom-samples",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-gradient-get-custom-samples",
args);
gimp_value_array_unref (args);
*num_color_samples = 0;
@ -441,7 +401,6 @@ 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;
@ -451,13 +410,9 @@ gimp_gradient_segment_get_left_color (const gchar *name,
G_TYPE_INT, segment,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-gradient-segment-get-left-color",
args);
else
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-get-left-color",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-gradient-segment-get-left-color",
args);
gimp_value_array_unref (args);
*opacity = 0.0;
@ -497,7 +452,6 @@ 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;
@ -509,13 +463,9 @@ gimp_gradient_segment_set_left_color (const gchar *name,
G_TYPE_DOUBLE, opacity,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-gradient-segment-set-left-color",
args);
else
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-set-left-color",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -547,7 +497,6 @@ 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;
@ -557,13 +506,9 @@ gimp_gradient_segment_get_right_color (const gchar *name,
G_TYPE_INT, segment,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-gradient-segment-get-right-color",
args);
else
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-get-right-color",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-gradient-segment-get-right-color",
args);
gimp_value_array_unref (args);
*opacity = 0.0;
@ -603,7 +548,6 @@ 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;
@ -615,13 +559,9 @@ gimp_gradient_segment_set_right_color (const gchar *name,
G_TYPE_DOUBLE, opacity,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-gradient-segment-set-right-color",
args);
else
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-set-right-color",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -651,7 +591,6 @@ 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;
@ -661,13 +600,9 @@ gimp_gradient_segment_get_left_pos (const gchar *name,
G_TYPE_INT, segment,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-gradient-segment-get-left-pos",
args);
else
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-get-left-pos",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-gradient-segment-get-left-pos",
args);
gimp_value_array_unref (args);
*pos = 0.0;
@ -707,7 +642,6 @@ 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;
@ -718,13 +652,9 @@ gimp_gradient_segment_set_left_pos (const gchar *name,
G_TYPE_DOUBLE, pos,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-gradient-segment-set-left-pos",
args);
else
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-set-left-pos",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-gradient-segment-set-left-pos",
args);
gimp_value_array_unref (args);
*final_pos = 0.0;
@ -759,7 +689,6 @@ 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;
@ -769,13 +698,9 @@ gimp_gradient_segment_get_middle_pos (const gchar *name,
G_TYPE_INT, segment,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-gradient-segment-get-middle-pos",
args);
else
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-get-middle-pos",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-gradient-segment-get-middle-pos",
args);
gimp_value_array_unref (args);
*pos = 0.0;
@ -814,7 +739,6 @@ 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;
@ -825,13 +749,9 @@ gimp_gradient_segment_set_middle_pos (const gchar *name,
G_TYPE_DOUBLE, pos,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-gradient-segment-set-middle-pos",
args);
else
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-set-middle-pos",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-gradient-segment-set-middle-pos",
args);
gimp_value_array_unref (args);
*final_pos = 0.0;
@ -866,7 +786,6 @@ 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;
@ -876,13 +795,9 @@ gimp_gradient_segment_get_right_pos (const gchar *name,
G_TYPE_INT, segment,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-gradient-segment-get-right-pos",
args);
else
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-get-right-pos",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-gradient-segment-get-right-pos",
args);
gimp_value_array_unref (args);
*pos = 0.0;
@ -922,7 +837,6 @@ 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;
@ -933,13 +847,9 @@ gimp_gradient_segment_set_right_pos (const gchar *name,
G_TYPE_DOUBLE, pos,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-gradient-segment-set-right-pos",
args);
else
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-set-right-pos",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-gradient-segment-set-right-pos",
args);
gimp_value_array_unref (args);
*final_pos = 0.0;
@ -974,7 +884,6 @@ 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;
@ -984,13 +893,9 @@ gimp_gradient_segment_get_blending_function (const gchar *name,
G_TYPE_INT, segment,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-gradient-segment-get-blending-function",
args);
else
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-get-blending-function",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-gradient-segment-get-blending-function",
args);
gimp_value_array_unref (args);
*blend_func = 0;
@ -1025,7 +930,6 @@ 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;
@ -1035,13 +939,9 @@ gimp_gradient_segment_get_coloring_type (const gchar *name,
G_TYPE_INT, segment,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-gradient-segment-get-coloring-type",
args);
else
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-get-coloring-type",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-gradient-segment-get-coloring-type",
args);
gimp_value_array_unref (args);
*coloring_type = 0;
@ -1078,7 +978,6 @@ 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;
@ -1090,13 +989,9 @@ gimp_gradient_segment_range_set_blending_function (const gchar *name
GIMP_TYPE_GRADIENT_SEGMENT_TYPE, blending_function,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-gradient-segment-range-set-blending-function",
args);
else
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-range-set-blending-function",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -1128,7 +1023,6 @@ 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;
@ -1140,13 +1034,9 @@ gimp_gradient_segment_range_set_coloring_type (const gchar *name,
GIMP_TYPE_GRADIENT_SEGMENT_COLOR, coloring_type,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-gradient-segment-range-set-coloring-type",
args);
else
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-range-set-coloring-type",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -1175,7 +1065,6 @@ 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;
@ -1186,13 +1075,9 @@ gimp_gradient_segment_range_flip (const gchar *name,
G_TYPE_INT, end_segment,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-gradient-segment-range-flip",
args);
else
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-range-flip",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -1225,7 +1110,6 @@ 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;
@ -1237,13 +1121,9 @@ gimp_gradient_segment_range_replicate (const gchar *name,
G_TYPE_INT, replicate_times,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-gradient-segment-range-replicate",
args);
else
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-range-replicate",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -1273,7 +1153,6 @@ 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;
@ -1284,13 +1163,9 @@ gimp_gradient_segment_range_split_midpoint (const gchar *name,
G_TYPE_INT, end_segment,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-gradient-segment-range-split-midpoint",
args);
else
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-range-split-midpoint",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -1322,7 +1197,6 @@ 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;
@ -1334,13 +1208,9 @@ gimp_gradient_segment_range_split_uniform (const gchar *name,
G_TYPE_INT, split_parts,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-gradient-segment-range-split-uniform",
args);
else
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-range-split-uniform",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -1369,7 +1239,6 @@ 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;
@ -1380,13 +1249,9 @@ gimp_gradient_segment_range_delete (const gchar *name,
G_TYPE_INT, end_segment,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-gradient-segment-range-delete",
args);
else
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-range-delete",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -1416,7 +1281,6 @@ 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;
@ -1427,13 +1291,9 @@ gimp_gradient_segment_range_redistribute_handles (const gchar *name,
G_TYPE_INT, end_segment,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-gradient-segment-range-redistribute-handles",
args);
else
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-range-redistribute-handles",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -1464,7 +1324,6 @@ 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;
@ -1475,13 +1334,9 @@ gimp_gradient_segment_range_blend_colors (const gchar *name,
G_TYPE_INT, end_segment,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-gradient-segment-range-blend-colors",
args);
else
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-range-blend-colors",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -1512,7 +1367,6 @@ 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;
@ -1523,13 +1377,9 @@ gimp_gradient_segment_range_blend_opacity (const gchar *name,
G_TYPE_INT, end_segment,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-gradient-segment-range-blend-opacity",
args);
else
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-range-blend-opacity",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -1564,7 +1414,6 @@ 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;
@ -1577,13 +1426,9 @@ gimp_gradient_segment_range_move (const gchar *name,
G_TYPE_BOOLEAN, control_compress,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-gradient-segment-range-move",
args);
else
return_vals = gimp_run_procedure_array ("gimp-gradient-segment-range-move",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)

22
libgimp/gimpgradients_pdb.c
View File

@ -47,7 +47,6 @@
gboolean
gimp_gradients_refresh (void)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -55,13 +54,9 @@ gimp_gradients_refresh (void)
args = gimp_value_array_new_from_types (NULL,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-gradients-refresh",
args);
else
return_vals = gimp_run_procedure_array ("gimp-gradients-refresh",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-gradients-refresh",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -90,7 +85,6 @@ 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;
@ -99,13 +93,9 @@ gimp_gradients_get_list (const gchar *filter,
G_TYPE_STRING, filter,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-gradients-get-list",
args);
else
return_vals = gimp_run_procedure_array ("gimp-gradients-get-list",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-gradients-get-list",
args);
gimp_value_array_unref (args);
*num_gradients = 0;

33
libgimp/gimpgradientselect_pdb.c
View File

@ -53,7 +53,6 @@ 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;
@ -65,13 +64,9 @@ gimp_gradients_popup (const gchar *gradient_callback,
G_TYPE_INT, sample_size,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-gradients-popup",
args);
else
return_vals = gimp_run_procedure_array ("gimp-gradients-popup",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-gradients-popup",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -94,7 +89,6 @@ 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;
@ -103,13 +97,9 @@ gimp_gradients_close_popup (const gchar *gradient_callback)
G_TYPE_STRING, gradient_callback,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-gradients-close-popup",
args);
else
return_vals = gimp_run_procedure_array ("gimp-gradients-close-popup",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -134,7 +124,6 @@ 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;
@ -144,13 +133,9 @@ gimp_gradients_set_popup (const gchar *gradient_callback,
G_TYPE_STRING, gradient_name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-gradients-set-popup",
args);
else
return_vals = gimp_run_procedure_array ("gimp-gradients-set-popup",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;

11
libgimp/gimphelp_pdb.c
View File

@ -54,7 +54,6 @@ 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,13 +63,9 @@ gimp_help (const gchar *help_domain,
G_TYPE_STRING, help_id,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-help",
args);
else
return_vals = gimp_run_procedure_array ("gimp-help",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-help",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;

14
libgimp/gimpimage.c
View File

@ -158,18 +158,10 @@ gimp_image_get_by_id (gint32 image_id)
{
if (image_id > 0)
{
GimpPlugIn *plug_in = gimp_get_plug_in ();
GimpPlugIn *plug_in = gimp_get_plug_in ();
GimpProcedure *procedure = _gimp_plug_in_get_procedure (plug_in);
if (plug_in)
{
GimpProcedure *procedure = _gimp_plug_in_get_procedure (plug_in);
return _gimp_procedure_get_image (procedure, image_id);
}
return g_object_new (GIMP_TYPE_IMAGE,
"id", image_id,
NULL);
return _gimp_procedure_get_image (procedure, image_id);
}
return NULL;

902
libgimp/gimpimage_pdb.c
View File

File diff suppressed because it is too large Load Diff

66
libgimp/gimpimagecolorprofile_pdb.c
View File

@ -54,7 +54,6 @@ guint8 *
_gimp_image_get_color_profile (GimpImage *image,
gint *num_bytes)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
guint8 *profile_data = NULL;
@ -63,13 +62,9 @@ _gimp_image_get_color_profile (GimpImage *image,
GIMP_TYPE_IMAGE, image,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-get-color-profile",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-get-color-profile",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-image-get-color-profile",
args);
gimp_value_array_unref (args);
*num_bytes = 0;
@ -108,7 +103,6 @@ guint8 *
_gimp_image_get_effective_color_profile (GimpImage *image,
gint *num_bytes)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
guint8 *profile_data = NULL;
@ -117,13 +111,9 @@ _gimp_image_get_effective_color_profile (GimpImage *image,
GIMP_TYPE_IMAGE, image,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-get-effective-color-profile",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-get-effective-color-profile",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-image-get-effective-color-profile",
args);
gimp_value_array_unref (args);
*num_bytes = 0;
@ -162,7 +152,6 @@ _gimp_image_set_color_profile (GimpImage *image,
gint num_bytes,
const guint8 *color_profile)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -174,13 +163,9 @@ _gimp_image_set_color_profile (GimpImage *image,
G_TYPE_NONE);
gimp_value_set_uint8_array (gimp_value_array_index (args, 2), color_profile, num_bytes);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-set-color-profile",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-set-color-profile",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -212,7 +197,6 @@ gboolean
gimp_image_set_color_profile_from_file (GimpImage *image,
const gchar *uri)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -222,13 +206,9 @@ gimp_image_set_color_profile_from_file (GimpImage *image,
G_TYPE_STRING, uri,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-set-color-profile-from-file",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-set-color-profile-from-file",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -264,7 +244,6 @@ _gimp_image_convert_color_profile (GimpImage *image,
GimpColorRenderingIntent intent,
gboolean bpc)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -278,13 +257,9 @@ _gimp_image_convert_color_profile (GimpImage *image,
G_TYPE_NONE);
gimp_value_set_uint8_array (gimp_value_array_index (args, 2), color_profile, num_bytes);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-convert-color-profile",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-convert-color-profile",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -318,7 +293,6 @@ gimp_image_convert_color_profile_from_file (GimpImage *image,
GimpColorRenderingIntent intent,
gboolean bpc)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -330,13 +304,9 @@ gimp_image_convert_color_profile_from_file (GimpImage *image,
G_TYPE_BOOLEAN, bpc,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-convert-color-profile-from-file",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-convert-color-profile-from-file",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;

55
libgimp/gimpimageconvert_pdb.c
View File

@ -50,7 +50,6 @@
gboolean
gimp_image_convert_rgb (GimpImage *image)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -59,13 +58,9 @@ gimp_image_convert_rgb (GimpImage *image)
GIMP_TYPE_IMAGE, image,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-convert-rgb",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-convert-rgb",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -89,7 +84,6 @@ gimp_image_convert_rgb (GimpImage *image)
gboolean
gimp_image_convert_grayscale (GimpImage *image)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -98,13 +92,9 @@ gimp_image_convert_grayscale (GimpImage *image)
GIMP_TYPE_IMAGE, image,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-convert-grayscale",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-convert-grayscale",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -151,7 +141,6 @@ gimp_image_convert_indexed (GimpImage *image,
gboolean remove_unused,
const gchar *palette)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -166,13 +155,9 @@ gimp_image_convert_indexed (GimpImage *image,
G_TYPE_STRING, palette,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-convert-indexed",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-convert-indexed",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -204,7 +189,6 @@ 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;
@ -217,13 +201,9 @@ gimp_image_convert_set_dither_matrix (gint width,
G_TYPE_NONE);
gimp_value_set_uint8_array (gimp_value_array_index (args, 3), matrix, matrix_length);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-convert-set-dither-matrix",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-convert-set-dither-matrix",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -252,7 +232,6 @@ gboolean
gimp_image_convert_precision (GimpImage *image,
GimpPrecision precision)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -262,13 +241,9 @@ gimp_image_convert_precision (GimpImage *image,
GIMP_TYPE_PRECISION, precision,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-convert-precision",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-convert-precision",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;

110
libgimp/gimpimagegrid_pdb.c
View File

@ -54,7 +54,6 @@ gimp_image_grid_get_spacing (GimpImage *image,
gdouble *xspacing,
gdouble *yspacing)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -63,13 +62,9 @@ gimp_image_grid_get_spacing (GimpImage *image,
GIMP_TYPE_IMAGE, image,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-grid-get-spacing",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-grid-get-spacing",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-image-grid-get-spacing",
args);
gimp_value_array_unref (args);
*xspacing = 0.0;
@ -108,7 +103,6 @@ gimp_image_grid_set_spacing (GimpImage *image,
gdouble xspacing,
gdouble yspacing)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -119,13 +113,9 @@ gimp_image_grid_set_spacing (GimpImage *image,
G_TYPE_DOUBLE, yspacing,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-grid-set-spacing",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-grid-set-spacing",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -155,7 +145,6 @@ gimp_image_grid_get_offset (GimpImage *image,
gdouble *xoffset,
gdouble *yoffset)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -164,13 +153,9 @@ gimp_image_grid_get_offset (GimpImage *image,
GIMP_TYPE_IMAGE, image,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-grid-get-offset",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-grid-get-offset",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-image-grid-get-offset",
args);
gimp_value_array_unref (args);
*xoffset = 0.0;
@ -209,7 +194,6 @@ gimp_image_grid_set_offset (GimpImage *image,
gdouble xoffset,
gdouble yoffset)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -220,13 +204,9 @@ gimp_image_grid_set_offset (GimpImage *image,
G_TYPE_DOUBLE, yoffset,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-grid-set-offset",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-grid-set-offset",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -253,7 +233,6 @@ gboolean
gimp_image_grid_get_foreground_color (GimpImage *image,
GimpRGB *fgcolor)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -262,13 +241,9 @@ gimp_image_grid_get_foreground_color (GimpImage *image,
GIMP_TYPE_IMAGE, image,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-grid-get-foreground-color",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-grid-get-foreground-color",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -298,7 +273,6 @@ gboolean
gimp_image_grid_set_foreground_color (GimpImage *image,
const GimpRGB *fgcolor)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -308,13 +282,9 @@ gimp_image_grid_set_foreground_color (GimpImage *image,
GIMP_TYPE_RGB, fgcolor,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-grid-set-foreground-color",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-grid-set-foreground-color",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -341,7 +311,6 @@ gboolean
gimp_image_grid_get_background_color (GimpImage *image,
GimpRGB *bgcolor)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -350,13 +319,9 @@ gimp_image_grid_get_background_color (GimpImage *image,
GIMP_TYPE_IMAGE, image,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-grid-get-background-color",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-grid-get-background-color",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -386,7 +351,6 @@ gboolean
gimp_image_grid_set_background_color (GimpImage *image,
const GimpRGB *bgcolor)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -396,13 +360,9 @@ gimp_image_grid_set_background_color (GimpImage *image,
GIMP_TYPE_RGB, bgcolor,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-grid-set-background-color",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-grid-set-background-color",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -427,7 +387,6 @@ gimp_image_grid_set_background_color (GimpImage *image,
GimpGridStyle
gimp_image_grid_get_style (GimpImage *image)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpGridStyle style = 0;
@ -436,13 +395,9 @@ gimp_image_grid_get_style (GimpImage *image)
GIMP_TYPE_IMAGE, image,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-grid-get-style",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-grid-get-style",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -471,7 +426,6 @@ gboolean
gimp_image_grid_set_style (GimpImage *image,
GimpGridStyle style)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -481,13 +435,9 @@ gimp_image_grid_set_style (GimpImage *image,
GIMP_TYPE_GRID_STYLE, style,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-grid-set-style",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-grid-set-style",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;

66
libgimp/gimpimageguides_pdb.c
View File

@ -51,7 +51,6 @@ guint
gimp_image_add_hguide (GimpImage *image,
gint yposition)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
guint guide = 0;
@ -61,13 +60,9 @@ gimp_image_add_hguide (GimpImage *image,
G_TYPE_INT, yposition,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-add-hguide",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-add-hguide",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -95,7 +90,6 @@ guint
gimp_image_add_vguide (GimpImage *image,
gint xposition)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
guint guide = 0;
@ -105,13 +99,9 @@ gimp_image_add_vguide (GimpImage *image,
G_TYPE_INT, xposition,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-add-vguide",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-add-vguide",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -138,7 +128,6 @@ gboolean
gimp_image_delete_guide (GimpImage *image,
guint guide)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -148,13 +137,9 @@ gimp_image_delete_guide (GimpImage *image,
G_TYPE_UINT, guide,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-delete-guide",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-delete-guide",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -183,7 +168,6 @@ guint
gimp_image_find_next_guide (GimpImage *image,
guint guide)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
guint next_guide = 0;
@ -193,13 +177,9 @@ gimp_image_find_next_guide (GimpImage *image,
G_TYPE_UINT, guide,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-find-next-guide",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-find-next-guide",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -226,7 +206,6 @@ GimpOrientationType
gimp_image_get_guide_orientation (GimpImage *image,
guint guide)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpOrientationType orientation = GIMP_ORIENTATION_UNKNOWN;
@ -236,13 +215,9 @@ gimp_image_get_guide_orientation (GimpImage *image,
G_TYPE_UINT, guide,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-get-guide-orientation",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-get-guide-orientation",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -269,7 +244,6 @@ gint
gimp_image_get_guide_position (GimpImage *image,
guint guide)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint position = G_MININT /* GIMP_GUIDE_POSITION_UNDEFINED */;
@ -279,13 +253,9 @@ gimp_image_get_guide_position (GimpImage *image,
G_TYPE_UINT, guide,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-get-guide-position",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-get-guide-position",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)

44
libgimp/gimpimagesamplepoints_pdb.c
View File

@ -55,7 +55,6 @@ gimp_image_add_sample_point (GimpImage *image,
gint position_x,
gint position_y)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
guint sample_point = 0;
@ -66,13 +65,9 @@ gimp_image_add_sample_point (GimpImage *image,
G_TYPE_INT, position_y,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-add-sample-point",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-add-sample-point",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -101,7 +96,6 @@ gboolean
gimp_image_delete_sample_point (GimpImage *image,
guint sample_point)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -111,13 +105,9 @@ gimp_image_delete_sample_point (GimpImage *image,
G_TYPE_UINT, sample_point,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-delete-sample-point",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-delete-sample-point",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -149,7 +139,6 @@ guint
gimp_image_find_next_sample_point (GimpImage *image,
guint sample_point)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
guint next_sample_point = 0;
@ -159,13 +148,9 @@ gimp_image_find_next_sample_point (GimpImage *image,
G_TYPE_UINT, sample_point,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-find-next-sample-point",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-find-next-sample-point",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -197,7 +182,6 @@ gimp_image_get_sample_point_position (GimpImage *image,
guint sample_point,
gint *position_y)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint position_x = G_MININT;
@ -207,13 +191,9 @@ gimp_image_get_sample_point_position (GimpImage *image,
G_TYPE_UINT, sample_point,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-get-sample-point-position",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-get-sample-point-position",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)

77
libgimp/gimpimageselect_pdb.c
View File

@ -71,7 +71,6 @@ gimp_image_select_color (GimpImage *image,
GimpDrawable *drawable,
const GimpRGB *color)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -83,13 +82,9 @@ gimp_image_select_color (GimpImage *image,
GIMP_TYPE_RGB, color,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-select-color",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-select-color",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -147,7 +142,6 @@ gimp_image_select_contiguous_color (GimpImage *image,
gdouble x,
gdouble y)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -160,13 +154,9 @@ gimp_image_select_contiguous_color (GimpImage *image,
G_TYPE_DOUBLE, y,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-select-contiguous-color",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-select-contiguous-color",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -206,7 +196,6 @@ gimp_image_select_rectangle (GimpImage *image,
gdouble width,
gdouble height)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -220,13 +209,9 @@ gimp_image_select_rectangle (GimpImage *image,
G_TYPE_DOUBLE, height,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-select-rectangle",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-select-rectangle",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -273,7 +258,6 @@ gimp_image_select_round_rectangle (GimpImage *image,
gdouble corner_radius_x,
gdouble corner_radius_y)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -289,13 +273,9 @@ gimp_image_select_round_rectangle (GimpImage *image,
G_TYPE_DOUBLE, corner_radius_y,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-select-round-rectangle",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-select-round-rectangle",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -336,7 +316,6 @@ gimp_image_select_ellipse (GimpImage *image,
gdouble width,
gdouble height)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -350,13 +329,9 @@ gimp_image_select_ellipse (GimpImage *image,
G_TYPE_DOUBLE, height,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-select-ellipse",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-select-ellipse",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -398,7 +373,6 @@ gimp_image_select_polygon (GimpImage *image,
gint num_segs,
const gdouble *segs)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -411,13 +385,9 @@ gimp_image_select_polygon (GimpImage *image,
G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 3), segs, num_segs);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-select-polygon",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-select-polygon",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -453,7 +423,6 @@ gimp_image_select_item (GimpImage *image,
GimpChannelOps operation,
GimpItem *item)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -464,13 +433,9 @@ gimp_image_select_item (GimpImage *image,
GIMP_TYPE_ITEM, item,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-select-item",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-select-item",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;

66
libgimp/gimpimagetransform_pdb.c
View File

@ -61,7 +61,6 @@ gimp_image_resize (GimpImage *image,
gint offx,
gint offy)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -74,13 +73,9 @@ gimp_image_resize (GimpImage *image,
G_TYPE_INT, offy,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-resize",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-resize",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-image-resize",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -108,7 +103,6 @@ gimp_image_resize (GimpImage *image,
gboolean
gimp_image_resize_to_layers (GimpImage *image)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -117,13 +111,9 @@ gimp_image_resize_to_layers (GimpImage *image)
GIMP_TYPE_IMAGE, image,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-resize-to-layers",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-resize-to-layers",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -154,7 +144,6 @@ gimp_image_scale (GimpImage *image,
gint new_width,
gint new_height)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -165,13 +154,9 @@ gimp_image_scale (GimpImage *image,
G_TYPE_INT, new_height,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-scale",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-scale",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-image-scale",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -207,7 +192,6 @@ gimp_image_crop (GimpImage *image,
gint offx,
gint offy)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -220,13 +204,9 @@ gimp_image_crop (GimpImage *image,
G_TYPE_INT, offy,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-crop",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-crop",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-image-crop",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -251,7 +231,6 @@ gboolean
gimp_image_flip (GimpImage *image,
GimpOrientationType flip_type)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -261,13 +240,9 @@ gimp_image_flip (GimpImage *image,
GIMP_TYPE_ORIENTATION_TYPE, flip_type,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-flip",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-flip",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-image-flip",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -292,7 +267,6 @@ gboolean
gimp_image_rotate (GimpImage *image,
GimpRotationType rotate_type)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -302,13 +276,9 @@ gimp_image_rotate (GimpImage *image,
GIMP_TYPE_ROTATION_TYPE, rotate_type,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-rotate",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-rotate",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-image-rotate",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;

77
libgimp/gimpimageundo_pdb.c
View File

@ -50,7 +50,6 @@
gboolean
gimp_image_undo_group_start (GimpImage *image)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -59,13 +58,9 @@ gimp_image_undo_group_start (GimpImage *image)
GIMP_TYPE_IMAGE, image,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-undo-group-start",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-undo-group-start",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -89,7 +84,6 @@ gimp_image_undo_group_start (GimpImage *image)
gboolean
gimp_image_undo_group_end (GimpImage *image)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -98,13 +92,9 @@ gimp_image_undo_group_end (GimpImage *image)
GIMP_TYPE_IMAGE, image,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-undo-group-end",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-undo-group-end",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -130,7 +120,6 @@ gimp_image_undo_group_end (GimpImage *image)
gboolean
gimp_image_undo_is_enabled (GimpImage *image)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean enabled = FALSE;
@ -139,13 +128,9 @@ gimp_image_undo_is_enabled (GimpImage *image)
GIMP_TYPE_IMAGE, image,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-undo-is-enabled",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-undo-is-enabled",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -173,7 +158,6 @@ gimp_image_undo_is_enabled (GimpImage *image)
gboolean
gimp_image_undo_disable (GimpImage *image)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean disabled = FALSE;
@ -182,13 +166,9 @@ gimp_image_undo_disable (GimpImage *image)
GIMP_TYPE_IMAGE, image,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-undo-disable",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-undo-disable",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -215,7 +195,6 @@ gimp_image_undo_disable (GimpImage *image)
gboolean
gimp_image_undo_enable (GimpImage *image)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean enabled = FALSE;
@ -224,13 +203,9 @@ gimp_image_undo_enable (GimpImage *image)
GIMP_TYPE_IMAGE, image,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-undo-enable",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-undo-enable",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -264,7 +239,6 @@ gimp_image_undo_enable (GimpImage *image)
gboolean
gimp_image_undo_freeze (GimpImage *image)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean frozen = FALSE;
@ -273,13 +247,9 @@ gimp_image_undo_freeze (GimpImage *image)
GIMP_TYPE_IMAGE, image,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-undo-freeze",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-undo-freeze",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -312,7 +282,6 @@ gimp_image_undo_freeze (GimpImage *image)
gboolean
gimp_image_undo_thaw (GimpImage *image)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean thawed = FALSE;
@ -321,13 +290,9 @@ gimp_image_undo_thaw (GimpImage *image)
GIMP_TYPE_IMAGE, image,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-image-undo-thaw",
args);
else
return_vals = gimp_run_procedure_array ("gimp-image-undo-thaw",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)

41
libgimp/gimpitem.c
View File

@ -163,45 +163,10 @@ gimp_item_get_by_id (gint32 item_id)
{
if (item_id > 0)
{
GimpPlugIn *plug_in = gimp_get_plug_in ();
GimpPlugIn *plug_in = gimp_get_plug_in ();
GimpProcedure *procedure = _gimp_plug_in_get_procedure (plug_in);
if (plug_in)
{
GimpProcedure *procedure = _gimp_plug_in_get_procedure (plug_in);
return _gimp_procedure_get_item (procedure, item_id);
}
if (gimp_item_id_is_layer (item_id))
{
return g_object_new (GIMP_TYPE_LAYER,
"id", item_id,
NULL);
}
else if (gimp_item_id_is_layer_mask (item_id))
{
return g_object_new (GIMP_TYPE_LAYER_MASK,
"id", item_id,
NULL);
}
else if (gimp_item_id_is_selection (item_id))
{
return g_object_new (GIMP_TYPE_SELECTION,
"id", item_id,
NULL);
}
else if (gimp_item_id_is_channel (item_id))
{
return g_object_new (GIMP_TYPE_CHANNEL,
"id", item_id,
NULL);
}
else if (gimp_item_id_is_vectors (item_id))
{
return g_object_new (GIMP_TYPE_VECTORS,
"id", item_id,
NULL);
}
return _gimp_procedure_get_item (procedure, item_id);
}
return NULL;

363
libgimp/gimpitem_pdb.c
View File

@ -50,7 +50,6 @@
gboolean
gimp_item_id_is_valid (gint item_id)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean valid = FALSE;
@ -59,13 +58,9 @@ gimp_item_id_is_valid (gint item_id)
G_TYPE_INT, item_id,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-item-id-is-valid",
args);
else
return_vals = gimp_run_procedure_array ("gimp-item-id-is-valid",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-item-id-is-valid",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -91,7 +86,6 @@ gimp_item_id_is_valid (gint item_id)
gboolean
gimp_item_id_is_drawable (gint item_id)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean drawable = FALSE;
@ -100,13 +94,9 @@ gimp_item_id_is_drawable (gint item_id)
G_TYPE_INT, item_id,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-item-id-is-drawable",
args);
else
return_vals = gimp_run_procedure_array ("gimp-item-id-is-drawable",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-item-id-is-drawable",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -132,7 +122,6 @@ gimp_item_id_is_drawable (gint item_id)
gboolean
gimp_item_id_is_layer (gint item_id)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean layer = FALSE;
@ -141,13 +130,9 @@ gimp_item_id_is_layer (gint item_id)
G_TYPE_INT, item_id,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-item-id-is-layer",
args);
else
return_vals = gimp_run_procedure_array ("gimp-item-id-is-layer",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-item-id-is-layer",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -174,7 +159,6 @@ gimp_item_id_is_layer (gint item_id)
gboolean
gimp_item_id_is_text_layer (gint item_id)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean text_layer = FALSE;
@ -183,13 +167,9 @@ gimp_item_id_is_text_layer (gint item_id)
G_TYPE_INT, item_id,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-item-id-is-text-layer",
args);
else
return_vals = gimp_run_procedure_array ("gimp-item-id-is-text-layer",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-item-id-is-text-layer",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -215,7 +195,6 @@ gimp_item_id_is_text_layer (gint item_id)
gboolean
gimp_item_id_is_channel (gint item_id)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean channel = FALSE;
@ -224,13 +203,9 @@ gimp_item_id_is_channel (gint item_id)
G_TYPE_INT, item_id,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-item-id-is-channel",
args);
else
return_vals = gimp_run_procedure_array ("gimp-item-id-is-channel",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-item-id-is-channel",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -257,7 +232,6 @@ gimp_item_id_is_channel (gint item_id)
gboolean
gimp_item_id_is_layer_mask (gint item_id)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean layer_mask = FALSE;
@ -266,13 +240,9 @@ gimp_item_id_is_layer_mask (gint item_id)
G_TYPE_INT, item_id,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-item-id-is-layer-mask",
args);
else
return_vals = gimp_run_procedure_array ("gimp-item-id-is-layer-mask",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-item-id-is-layer-mask",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -298,7 +268,6 @@ gimp_item_id_is_layer_mask (gint item_id)
gboolean
gimp_item_id_is_selection (gint item_id)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean selection = FALSE;
@ -307,13 +276,9 @@ gimp_item_id_is_selection (gint item_id)
G_TYPE_INT, item_id,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-item-id-is-selection",
args);
else
return_vals = gimp_run_procedure_array ("gimp-item-id-is-selection",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-item-id-is-selection",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -339,7 +304,6 @@ gimp_item_id_is_selection (gint item_id)
gboolean
gimp_item_id_is_vectors (gint item_id)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean vectors = FALSE;
@ -348,13 +312,9 @@ gimp_item_id_is_vectors (gint item_id)
G_TYPE_INT, item_id,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-item-id-is-vectors",
args);
else
return_vals = gimp_run_procedure_array ("gimp-item-id-is-vectors",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-item-id-is-vectors",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -380,7 +340,6 @@ gimp_item_id_is_vectors (gint item_id)
GimpImage *
gimp_item_get_image (GimpItem *item)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpImage *image = NULL;
@ -389,13 +348,9 @@ gimp_item_get_image (GimpItem *item)
GIMP_TYPE_ITEM, item,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-item-get-image",
args);
else
return_vals = gimp_run_procedure_array ("gimp-item-get-image",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -425,7 +380,6 @@ gimp_item_get_image (GimpItem *item)
gboolean
gimp_item_delete (GimpItem *item)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -434,13 +388,9 @@ gimp_item_delete (GimpItem *item)
GIMP_TYPE_ITEM, item,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-item-delete",
args);
else
return_vals = gimp_run_procedure_array ("gimp-item-delete",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-item-delete",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -466,7 +416,6 @@ gimp_item_delete (GimpItem *item)
gboolean
gimp_item_is_group (GimpItem *item)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean group = FALSE;
@ -475,13 +424,9 @@ gimp_item_is_group (GimpItem *item)
GIMP_TYPE_ITEM, item,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-item-is-group",
args);
else
return_vals = gimp_run_procedure_array ("gimp-item-is-group",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -507,7 +452,6 @@ gimp_item_is_group (GimpItem *item)
GimpItem *
gimp_item_get_parent (GimpItem *item)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpItem *parent = NULL;
@ -516,13 +460,9 @@ gimp_item_get_parent (GimpItem *item)
GIMP_TYPE_ITEM, item,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-item-get-parent",
args);
else
return_vals = gimp_run_procedure_array ("gimp-item-get-parent",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -553,7 +493,6 @@ gint *
_gimp_item_get_children (GimpItem *item,
gint *num_children)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint *child_ids = NULL;
@ -562,13 +501,9 @@ _gimp_item_get_children (GimpItem *item,
GIMP_TYPE_ITEM, item,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-item-get-children",
args);
else
return_vals = gimp_run_procedure_array ("gimp-item-get-children",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-item-get-children",
args);
gimp_value_array_unref (args);
*num_children = 0;
@ -599,7 +534,6 @@ _gimp_item_get_children (GimpItem *item,
gboolean
gimp_item_get_expanded (GimpItem *item)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean expanded = FALSE;
@ -608,13 +542,9 @@ gimp_item_get_expanded (GimpItem *item)
GIMP_TYPE_ITEM, item,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-item-get-expanded",
args);
else
return_vals = gimp_run_procedure_array ("gimp-item-get-expanded",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -642,7 +572,6 @@ gboolean
gimp_item_set_expanded (GimpItem *item,
gboolean expanded)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -652,13 +581,9 @@ gimp_item_set_expanded (GimpItem *item,
G_TYPE_BOOLEAN, expanded,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-item-set-expanded",
args);
else
return_vals = gimp_run_procedure_array ("gimp-item-set-expanded",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -684,7 +609,6 @@ gimp_item_set_expanded (GimpItem *item,
gchar *
gimp_item_get_name (GimpItem *item)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *name = NULL;
@ -693,13 +617,9 @@ gimp_item_get_name (GimpItem *item)
GIMP_TYPE_ITEM, item,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-item-get-name",
args);
else
return_vals = gimp_run_procedure_array ("gimp-item-get-name",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -727,7 +647,6 @@ gboolean
gimp_item_set_name (GimpItem *item,
const gchar *name)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -737,13 +656,9 @@ gimp_item_set_name (GimpItem *item,
G_TYPE_STRING, name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-item-set-name",
args);
else
return_vals = gimp_run_procedure_array ("gimp-item-set-name",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -768,7 +683,6 @@ gimp_item_set_name (GimpItem *item,
gboolean
gimp_item_get_visible (GimpItem *item)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean visible = FALSE;
@ -777,13 +691,9 @@ gimp_item_get_visible (GimpItem *item)
GIMP_TYPE_ITEM, item,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-item-get-visible",
args);
else
return_vals = gimp_run_procedure_array ("gimp-item-get-visible",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -811,7 +721,6 @@ gboolean
gimp_item_set_visible (GimpItem *item,
gboolean visible)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -821,13 +730,9 @@ gimp_item_set_visible (GimpItem *item,
G_TYPE_BOOLEAN, visible,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-item-set-visible",
args);
else
return_vals = gimp_run_procedure_array ("gimp-item-set-visible",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -852,7 +757,6 @@ gimp_item_set_visible (GimpItem *item,
gboolean
gimp_item_get_linked (GimpItem *item)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean linked = FALSE;
@ -861,13 +765,9 @@ gimp_item_get_linked (GimpItem *item)
GIMP_TYPE_ITEM, item,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-item-get-linked",
args);
else
return_vals = gimp_run_procedure_array ("gimp-item-get-linked",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -895,7 +795,6 @@ gboolean
gimp_item_set_linked (GimpItem *item,
gboolean linked)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -905,13 +804,9 @@ gimp_item_set_linked (GimpItem *item,
G_TYPE_BOOLEAN, linked,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-item-set-linked",
args);
else
return_vals = gimp_run_procedure_array ("gimp-item-set-linked",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -936,7 +831,6 @@ gimp_item_set_linked (GimpItem *item,
gboolean
gimp_item_get_lock_content (GimpItem *item)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean lock_content = FALSE;
@ -945,13 +839,9 @@ gimp_item_get_lock_content (GimpItem *item)
GIMP_TYPE_ITEM, item,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-item-get-lock-content",
args);
else
return_vals = gimp_run_procedure_array ("gimp-item-get-lock-content",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -979,7 +869,6 @@ gboolean
gimp_item_set_lock_content (GimpItem *item,
gboolean lock_content)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -989,13 +878,9 @@ gimp_item_set_lock_content (GimpItem *item,
G_TYPE_BOOLEAN, lock_content,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-item-set-lock-content",
args);
else
return_vals = gimp_run_procedure_array ("gimp-item-set-lock-content",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -1020,7 +905,6 @@ gimp_item_set_lock_content (GimpItem *item,
gboolean
gimp_item_get_lock_position (GimpItem *item)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean lock_position = FALSE;
@ -1029,13 +913,9 @@ gimp_item_get_lock_position (GimpItem *item)
GIMP_TYPE_ITEM, item,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-item-get-lock-position",
args);
else
return_vals = gimp_run_procedure_array ("gimp-item-get-lock-position",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -1063,7 +943,6 @@ gboolean
gimp_item_set_lock_position (GimpItem *item,
gboolean lock_position)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -1073,13 +952,9 @@ gimp_item_set_lock_position (GimpItem *item,
G_TYPE_BOOLEAN, lock_position,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-item-set-lock-position",
args);
else
return_vals = gimp_run_procedure_array ("gimp-item-set-lock-position",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -1104,7 +979,6 @@ gimp_item_set_lock_position (GimpItem *item,
GimpColorTag
gimp_item_get_color_tag (GimpItem *item)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpColorTag color_tag = 0;
@ -1113,13 +987,9 @@ gimp_item_get_color_tag (GimpItem *item)
GIMP_TYPE_ITEM, item,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-item-get-color-tag",
args);
else
return_vals = gimp_run_procedure_array ("gimp-item-get-color-tag",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -1147,7 +1017,6 @@ gboolean
gimp_item_set_color_tag (GimpItem *item,
GimpColorTag color_tag)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -1157,13 +1026,9 @@ gimp_item_set_color_tag (GimpItem *item,
GIMP_TYPE_COLOR_TAG, color_tag,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-item-set-color-tag",
args);
else
return_vals = gimp_run_procedure_array ("gimp-item-set-color-tag",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -1190,7 +1055,6 @@ gimp_item_set_color_tag (GimpItem *item,
guint
gimp_item_get_tattoo (GimpItem *item)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
guint tattoo = 0;
@ -1199,13 +1063,9 @@ gimp_item_get_tattoo (GimpItem *item)
GIMP_TYPE_ITEM, item,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-item-get-tattoo",
args);
else
return_vals = gimp_run_procedure_array ("gimp-item-get-tattoo",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -1235,7 +1095,6 @@ gboolean
gimp_item_set_tattoo (GimpItem *item,
guint tattoo)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -1245,13 +1104,9 @@ gimp_item_set_tattoo (GimpItem *item,
G_TYPE_UINT, tattoo,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-item-set-tattoo",
args);
else
return_vals = gimp_run_procedure_array ("gimp-item-set-tattoo",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -1279,7 +1134,6 @@ gboolean
gimp_item_attach_parasite (GimpItem *item,
const GimpParasite *parasite)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -1289,13 +1143,9 @@ gimp_item_attach_parasite (GimpItem *item,
GIMP_TYPE_PARASITE, parasite,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-item-attach-parasite",
args);
else
return_vals = gimp_run_procedure_array ("gimp-item-attach-parasite",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -1323,7 +1173,6 @@ gboolean
gimp_item_detach_parasite (GimpItem *item,
const gchar *name)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -1333,13 +1182,9 @@ gimp_item_detach_parasite (GimpItem *item,
G_TYPE_STRING, name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-item-detach-parasite",
args);
else
return_vals = gimp_run_procedure_array ("gimp-item-detach-parasite",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -1366,7 +1211,6 @@ GimpParasite *
gimp_item_get_parasite (GimpItem *item,
const gchar *name)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpParasite *parasite = NULL;
@ -1376,13 +1220,9 @@ gimp_item_get_parasite (GimpItem *item,
G_TYPE_STRING, name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-item-get-parasite",
args);
else
return_vals = gimp_run_procedure_array ("gimp-item-get-parasite",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -1412,7 +1252,6 @@ gchar **
gimp_item_get_parasite_list (GimpItem *item,
gint *num_parasites)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar **parasites = NULL;
@ -1421,13 +1260,9 @@ gimp_item_get_parasite_list (GimpItem *item,
GIMP_TYPE_ITEM, item,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-item-get-parasite-list",
args);
else
return_vals = gimp_run_procedure_array ("gimp-item-get-parasite-list",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-item-get-parasite-list",
args);
gimp_value_array_unref (args);
*num_parasites = 0;

110
libgimp/gimpitemtransform_pdb.c
View File

@ -61,7 +61,6 @@ gimp_item_transform_translate (GimpItem *item,
gdouble off_x,
gdouble off_y)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpItem *ret_item = NULL;
@ -72,13 +71,9 @@ gimp_item_transform_translate (GimpItem *item,
G_TYPE_DOUBLE, off_y,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-item-transform-translate",
args);
else
return_vals = gimp_run_procedure_array ("gimp-item-transform-translate",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -128,7 +123,6 @@ gimp_item_transform_flip_simple (GimpItem *item,
gboolean auto_center,
gdouble axis)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpItem *ret_item = NULL;
@ -140,13 +134,9 @@ gimp_item_transform_flip_simple (GimpItem *item,
G_TYPE_DOUBLE, axis,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-item-transform-flip-simple",
args);
else
return_vals = gimp_run_procedure_array ("gimp-item-transform-flip-simple",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -198,7 +188,6 @@ gimp_item_transform_flip (GimpItem *item,
gdouble x1,
gdouble y1)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpItem *ret_item = NULL;
@ -211,13 +200,9 @@ gimp_item_transform_flip (GimpItem *item,
G_TYPE_DOUBLE, y1,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-item-transform-flip",
args);
else
return_vals = gimp_run_procedure_array ("gimp-item-transform-flip",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -286,7 +271,6 @@ gimp_item_transform_perspective (GimpItem *item,
gdouble x3,
gdouble y3)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpItem *ret_item = NULL;
@ -303,13 +287,9 @@ gimp_item_transform_perspective (GimpItem *item,
G_TYPE_DOUBLE, y3,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-item-transform-perspective",
args);
else
return_vals = gimp_run_procedure_array ("gimp-item-transform-perspective",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -364,7 +344,6 @@ gimp_item_transform_rotate_simple (GimpItem *item,
gdouble center_x,
gdouble center_y)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpItem *ret_item = NULL;
@ -377,13 +356,9 @@ gimp_item_transform_rotate_simple (GimpItem *item,
G_TYPE_DOUBLE, center_y,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-item-transform-rotate-simple",
args);
else
return_vals = gimp_run_procedure_array ("gimp-item-transform-rotate-simple",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -440,7 +415,6 @@ gimp_item_transform_rotate (GimpItem *item,
gdouble center_x,
gdouble center_y)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpItem *ret_item = NULL;
@ -453,13 +427,9 @@ gimp_item_transform_rotate (GimpItem *item,
G_TYPE_DOUBLE, center_y,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-item-transform-rotate",
args);
else
return_vals = gimp_run_procedure_array ("gimp-item-transform-rotate",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -513,7 +483,6 @@ gimp_item_transform_scale (GimpItem *item,
gdouble x1,
gdouble y1)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpItem *ret_item = NULL;
@ -526,13 +495,9 @@ gimp_item_transform_scale (GimpItem *item,
G_TYPE_DOUBLE, y1,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-item-transform-scale",
args);
else
return_vals = gimp_run_procedure_array ("gimp-item-transform-scale",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -584,7 +549,6 @@ gimp_item_transform_shear (GimpItem *item,
GimpOrientationType shear_type,
gdouble magnitude)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpItem *ret_item = NULL;
@ -595,13 +559,9 @@ gimp_item_transform_shear (GimpItem *item,
G_TYPE_DOUBLE, magnitude,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-item-transform-shear",
args);
else
return_vals = gimp_run_procedure_array ("gimp-item-transform-shear",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -664,7 +624,6 @@ gimp_item_transform_2d (GimpItem *item,
gdouble dest_x,
gdouble dest_y)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpItem *ret_item = NULL;
@ -680,13 +639,9 @@ gimp_item_transform_2d (GimpItem *item,
G_TYPE_DOUBLE, dest_y,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-item-transform-2d",
args);
else
return_vals = gimp_run_procedure_array ("gimp-item-transform-2d",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -751,7 +706,6 @@ gimp_item_transform_matrix (GimpItem *item,
gdouble coeff_2_1,
gdouble coeff_2_2)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpItem *ret_item = NULL;
@ -769,13 +723,9 @@ gimp_item_transform_matrix (GimpItem *item,
G_TYPE_DOUBLE, coeff_2_2,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-item-transform-matrix",
args);
else
return_vals = gimp_run_procedure_array ("gimp-item-transform-matrix",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)

385
libgimp/gimplayer_pdb.c
View File

@ -64,7 +64,6 @@ _gimp_layer_new (GimpImage *image,
gdouble opacity,
GimpLayerMode mode)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpLayer *layer = NULL;
@ -79,13 +78,9 @@ _gimp_layer_new (GimpImage *image,
GIMP_TYPE_LAYER_MODE, mode,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-layer-new",
args);
else
return_vals = gimp_run_procedure_array ("gimp-layer-new",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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,7 +114,6 @@ gimp_layer_new_from_visible (GimpImage *image,
GimpImage *dest_image,
const gchar *name)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpLayer *layer = NULL;
@ -130,13 +124,9 @@ gimp_layer_new_from_visible (GimpImage *image,
G_TYPE_STRING, name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-layer-new-from-visible",
args);
else
return_vals = gimp_run_procedure_array ("gimp-layer-new-from-visible",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -166,7 +156,6 @@ GimpLayer *
gimp_layer_new_from_drawable (GimpDrawable *drawable,
GimpImage *dest_image)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpLayer *layer_copy = NULL;
@ -176,13 +165,9 @@ gimp_layer_new_from_drawable (GimpDrawable *drawable,
GIMP_TYPE_IMAGE, dest_image,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-layer-new-from-drawable",
args);
else
return_vals = gimp_run_procedure_array ("gimp-layer-new-from-drawable",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -214,7 +199,6 @@ gimp_layer_new_from_drawable (GimpDrawable *drawable,
GimpLayer *
gimp_layer_group_new (GimpImage *image)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpLayer *layer_group = NULL;
@ -223,13 +207,9 @@ gimp_layer_group_new (GimpImage *image)
GIMP_TYPE_IMAGE, image,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-layer-group-new",
args);
else
return_vals = gimp_run_procedure_array ("gimp-layer-group-new",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -260,7 +240,6 @@ GimpLayer *
_gimp_layer_copy (GimpLayer *layer,
gboolean add_alpha)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpLayer *layer_copy = NULL;
@ -270,13 +249,9 @@ _gimp_layer_copy (GimpLayer *layer,
G_TYPE_BOOLEAN, add_alpha,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-layer-copy",
args);
else
return_vals = gimp_run_procedure_array ("gimp-layer-copy",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-layer-copy",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -304,7 +279,6 @@ _gimp_layer_copy (GimpLayer *layer,
gboolean
gimp_layer_add_alpha (GimpLayer *layer)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -313,13 +287,9 @@ gimp_layer_add_alpha (GimpLayer *layer)
GIMP_TYPE_LAYER, layer,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-layer-add-alpha",
args);
else
return_vals = gimp_run_procedure_array ("gimp-layer-add-alpha",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -347,7 +317,6 @@ gimp_layer_add_alpha (GimpLayer *layer)
gboolean
gimp_layer_flatten (GimpLayer *layer)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -356,13 +325,9 @@ gimp_layer_flatten (GimpLayer *layer)
GIMP_TYPE_LAYER, layer,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-layer-flatten",
args);
else
return_vals = gimp_run_procedure_array ("gimp-layer-flatten",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-layer-flatten",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -396,7 +361,6 @@ gimp_layer_scale (GimpLayer *layer,
gint new_height,
gboolean local_origin)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -408,13 +372,9 @@ gimp_layer_scale (GimpLayer *layer,
G_TYPE_BOOLEAN, local_origin,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-layer-scale",
args);
else
return_vals = gimp_run_procedure_array ("gimp-layer-scale",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-layer-scale",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -448,7 +408,6 @@ gimp_layer_resize (GimpLayer *layer,
gint offx,
gint offy)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -461,13 +420,9 @@ gimp_layer_resize (GimpLayer *layer,
G_TYPE_INT, offy,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-layer-resize",
args);
else
return_vals = gimp_run_procedure_array ("gimp-layer-resize",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-layer-resize",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -491,7 +446,6 @@ gimp_layer_resize (GimpLayer *layer,
gboolean
gimp_layer_resize_to_image_size (GimpLayer *layer)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -500,13 +454,9 @@ gimp_layer_resize_to_image_size (GimpLayer *layer)
GIMP_TYPE_LAYER, layer,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-layer-resize-to-image-size",
args);
else
return_vals = gimp_run_procedure_array ("gimp-layer-resize-to-image-size",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -535,7 +485,6 @@ gimp_layer_set_offsets (GimpLayer *layer,
gint offx,
gint offy)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -546,13 +495,9 @@ gimp_layer_set_offsets (GimpLayer *layer,
G_TYPE_INT, offy,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-layer-set-offsets",
args);
else
return_vals = gimp_run_procedure_array ("gimp-layer-set-offsets",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -596,7 +541,6 @@ GimpLayerMask *
gimp_layer_create_mask (GimpLayer *layer,
GimpAddMaskType mask_type)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpLayerMask *mask = NULL;
@ -606,13 +550,9 @@ gimp_layer_create_mask (GimpLayer *layer,
GIMP_TYPE_ADD_MASK_TYPE, mask_type,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-layer-create-mask",
args);
else
return_vals = gimp_run_procedure_array ("gimp-layer-create-mask",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -637,7 +577,6 @@ gimp_layer_create_mask (GimpLayer *layer,
GimpLayerMask *
gimp_layer_get_mask (GimpLayer *layer)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpLayerMask *mask = NULL;
@ -646,13 +585,9 @@ gimp_layer_get_mask (GimpLayer *layer)
GIMP_TYPE_LAYER, layer,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-layer-get-mask",
args);
else
return_vals = gimp_run_procedure_array ("gimp-layer-get-mask",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -679,7 +614,6 @@ gimp_layer_get_mask (GimpLayer *layer)
GimpLayer *
gimp_layer_from_mask (GimpLayerMask *mask)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpLayer *layer = NULL;
@ -688,13 +622,9 @@ gimp_layer_from_mask (GimpLayerMask *mask)
GIMP_TYPE_LAYER_MASK, mask,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-layer-from-mask",
args);
else
return_vals = gimp_run_procedure_array ("gimp-layer-from-mask",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -726,7 +656,6 @@ gboolean
gimp_layer_add_mask (GimpLayer *layer,
GimpLayerMask *mask)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -736,13 +665,9 @@ gimp_layer_add_mask (GimpLayer *layer,
GIMP_TYPE_LAYER_MASK, mask,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-layer-add-mask",
args);
else
return_vals = gimp_run_procedure_array ("gimp-layer-add-mask",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -768,7 +693,6 @@ gboolean
gimp_layer_remove_mask (GimpLayer *layer,
GimpMaskApplyMode mode)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -778,13 +702,9 @@ gimp_layer_remove_mask (GimpLayer *layer,
GIMP_TYPE_MASK_APPLY_MODE, mode,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-layer-remove-mask",
args);
else
return_vals = gimp_run_procedure_array ("gimp-layer-remove-mask",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -809,7 +729,6 @@ gimp_layer_remove_mask (GimpLayer *layer,
gboolean
gimp_layer_is_floating_sel (GimpLayer *layer)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean is_floating_sel = FALSE;
@ -818,13 +737,9 @@ gimp_layer_is_floating_sel (GimpLayer *layer)
GIMP_TYPE_LAYER, layer,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-layer-is-floating-sel",
args);
else
return_vals = gimp_run_procedure_array ("gimp-layer-is-floating-sel",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -849,7 +764,6 @@ gimp_layer_is_floating_sel (GimpLayer *layer)
gboolean
gimp_layer_get_lock_alpha (GimpLayer *layer)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean lock_alpha = FALSE;
@ -858,13 +772,9 @@ gimp_layer_get_lock_alpha (GimpLayer *layer)
GIMP_TYPE_LAYER, layer,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-layer-get-lock-alpha",
args);
else
return_vals = gimp_run_procedure_array ("gimp-layer-get-lock-alpha",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -891,7 +801,6 @@ gboolean
gimp_layer_set_lock_alpha (GimpLayer *layer,
gboolean lock_alpha)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -901,13 +810,9 @@ gimp_layer_set_lock_alpha (GimpLayer *layer,
G_TYPE_BOOLEAN, lock_alpha,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-layer-set-lock-alpha",
args);
else
return_vals = gimp_run_procedure_array ("gimp-layer-set-lock-alpha",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -932,7 +837,6 @@ gimp_layer_set_lock_alpha (GimpLayer *layer,
gboolean
gimp_layer_get_apply_mask (GimpLayer *layer)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean apply_mask = FALSE;
@ -941,13 +845,9 @@ gimp_layer_get_apply_mask (GimpLayer *layer)
GIMP_TYPE_LAYER, layer,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-layer-get-apply-mask",
args);
else
return_vals = gimp_run_procedure_array ("gimp-layer-get-apply-mask",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -976,7 +876,6 @@ gboolean
gimp_layer_set_apply_mask (GimpLayer *layer,
gboolean apply_mask)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -986,13 +885,9 @@ gimp_layer_set_apply_mask (GimpLayer *layer,
G_TYPE_BOOLEAN, apply_mask,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-layer-set-apply-mask",
args);
else
return_vals = gimp_run_procedure_array ("gimp-layer-set-apply-mask",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -1018,7 +913,6 @@ gimp_layer_set_apply_mask (GimpLayer *layer,
gboolean
gimp_layer_get_show_mask (GimpLayer *layer)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean show_mask = FALSE;
@ -1027,13 +921,9 @@ gimp_layer_get_show_mask (GimpLayer *layer)
GIMP_TYPE_LAYER, layer,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-layer-get-show-mask",
args);
else
return_vals = gimp_run_procedure_array ("gimp-layer-get-show-mask",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -1062,7 +952,6 @@ gboolean
gimp_layer_set_show_mask (GimpLayer *layer,
gboolean show_mask)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -1072,13 +961,9 @@ gimp_layer_set_show_mask (GimpLayer *layer,
G_TYPE_BOOLEAN, show_mask,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-layer-set-show-mask",
args);
else
return_vals = gimp_run_procedure_array ("gimp-layer-set-show-mask",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -1103,7 +988,6 @@ gimp_layer_set_show_mask (GimpLayer *layer,
gboolean
gimp_layer_get_edit_mask (GimpLayer *layer)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean edit_mask = FALSE;
@ -1112,13 +996,9 @@ gimp_layer_get_edit_mask (GimpLayer *layer)
GIMP_TYPE_LAYER, layer,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-layer-get-edit-mask",
args);
else
return_vals = gimp_run_procedure_array ("gimp-layer-get-edit-mask",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -1147,7 +1027,6 @@ gboolean
gimp_layer_set_edit_mask (GimpLayer *layer,
gboolean edit_mask)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -1157,13 +1036,9 @@ gimp_layer_set_edit_mask (GimpLayer *layer,
G_TYPE_BOOLEAN, edit_mask,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-layer-set-edit-mask",
args);
else
return_vals = gimp_run_procedure_array ("gimp-layer-set-edit-mask",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -1186,7 +1061,6 @@ gimp_layer_set_edit_mask (GimpLayer *layer,
gdouble
gimp_layer_get_opacity (GimpLayer *layer)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble opacity = 0.0;
@ -1195,13 +1069,9 @@ gimp_layer_get_opacity (GimpLayer *layer)
GIMP_TYPE_LAYER, layer,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-layer-get-opacity",
args);
else
return_vals = gimp_run_procedure_array ("gimp-layer-get-opacity",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -1227,7 +1097,6 @@ gboolean
gimp_layer_set_opacity (GimpLayer *layer,
gdouble opacity)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -1237,13 +1106,9 @@ gimp_layer_set_opacity (GimpLayer *layer,
G_TYPE_DOUBLE, opacity,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-layer-set-opacity",
args);
else
return_vals = gimp_run_procedure_array ("gimp-layer-set-opacity",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -1266,7 +1131,6 @@ gimp_layer_set_opacity (GimpLayer *layer,
GimpLayerMode
gimp_layer_get_mode (GimpLayer *layer)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpLayerMode mode = 0;
@ -1275,13 +1139,9 @@ gimp_layer_get_mode (GimpLayer *layer)
GIMP_TYPE_LAYER, layer,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-layer-get-mode",
args);
else
return_vals = gimp_run_procedure_array ("gimp-layer-get-mode",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -1307,7 +1167,6 @@ gboolean
gimp_layer_set_mode (GimpLayer *layer,
GimpLayerMode mode)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -1317,13 +1176,9 @@ gimp_layer_set_mode (GimpLayer *layer,
GIMP_TYPE_LAYER_MODE, mode,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-layer-set-mode",
args);
else
return_vals = gimp_run_procedure_array ("gimp-layer-set-mode",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -1348,7 +1203,6 @@ gimp_layer_set_mode (GimpLayer *layer,
GimpLayerColorSpace
gimp_layer_get_blend_space (GimpLayer *layer)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpLayerColorSpace blend_space = 0;
@ -1357,13 +1211,9 @@ gimp_layer_get_blend_space (GimpLayer *layer)
GIMP_TYPE_LAYER, layer,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-layer-get-blend-space",
args);
else
return_vals = gimp_run_procedure_array ("gimp-layer-get-blend-space",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -1391,7 +1241,6 @@ gboolean
gimp_layer_set_blend_space (GimpLayer *layer,
GimpLayerColorSpace blend_space)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -1401,13 +1250,9 @@ gimp_layer_set_blend_space (GimpLayer *layer,
GIMP_TYPE_LAYER_COLOR_SPACE, blend_space,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-layer-set-blend-space",
args);
else
return_vals = gimp_run_procedure_array ("gimp-layer-set-blend-space",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -1432,7 +1277,6 @@ gimp_layer_set_blend_space (GimpLayer *layer,
GimpLayerColorSpace
gimp_layer_get_composite_space (GimpLayer *layer)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpLayerColorSpace composite_space = 0;
@ -1441,13 +1285,9 @@ gimp_layer_get_composite_space (GimpLayer *layer)
GIMP_TYPE_LAYER, layer,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-layer-get-composite-space",
args);
else
return_vals = gimp_run_procedure_array ("gimp-layer-get-composite-space",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -1475,7 +1315,6 @@ gboolean
gimp_layer_set_composite_space (GimpLayer *layer,
GimpLayerColorSpace composite_space)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -1485,13 +1324,9 @@ gimp_layer_set_composite_space (GimpLayer *layer,
GIMP_TYPE_LAYER_COLOR_SPACE, composite_space,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-layer-set-composite-space",
args);
else
return_vals = gimp_run_procedure_array ("gimp-layer-set-composite-space",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -1516,7 +1351,6 @@ gimp_layer_set_composite_space (GimpLayer *layer,
GimpLayerCompositeMode
gimp_layer_get_composite_mode (GimpLayer *layer)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpLayerCompositeMode composite_mode = 0;
@ -1525,13 +1359,9 @@ gimp_layer_get_composite_mode (GimpLayer *layer)
GIMP_TYPE_LAYER, layer,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-layer-get-composite-mode",
args);
else
return_vals = gimp_run_procedure_array ("gimp-layer-get-composite-mode",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -1559,7 +1389,6 @@ gboolean
gimp_layer_set_composite_mode (GimpLayer *layer,
GimpLayerCompositeMode composite_mode)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -1569,13 +1398,9 @@ gimp_layer_set_composite_mode (GimpLayer *layer,
GIMP_TYPE_LAYER_COMPOSITE_MODE, composite_mode,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-layer-set-composite-mode",
args);
else
return_vals = gimp_run_procedure_array ("gimp-layer-set-composite-mode",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;

42
libgimp/gimplegacy-private.h
View File

@ -1,42 +0,0 @@
/* LIBGIMP - The GIMP Library
* Copyright (C) 1995-1997 Peter Mattis and Spencer Kimball
*
* gimplegacy-private.h
*
* This library is free software: you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see
* <https://www.gnu.org/licenses/>.
*/
#ifndef __GIMP_LEGACY_PRIVATE_H__
#define __GIMP_LEGACY_PRIVATE_H__
G_BEGIN_DECLS
void _gimp_legacy_initialize (const GimpPlugInInfo *info,
GIOChannel *read_channel,
GIOChannel *write_channel);
void _gimp_legacy_query (void);
void _gimp_legacy_init (void);
void _gimp_legacy_run (void);
void _gimp_legacy_quit (void);
void _gimp_legacy_read_expect_msg (GimpWireMessage *msg,
gint type);
G_END_DECLS
#endif /* __GIMP_PRIVATE_H__ */

628
libgimp/gimplegacy.c
View File

@ -1,628 +0,0 @@
/* LIBGIMP - The GIMP Library
* Copyright (C) 1995-1997 Peter Mattis and Spencer Kimball
*
* gimplegacy.c
*
* This library is free software: you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see
* <https://www.gnu.org/licenses/>.
*/
#include "config.h"
#include "errno.h"
#include "gimp.h"
#include "libgimpbase/gimpprotocol.h"
#include "libgimpbase/gimpwire.h"
#include "gimp-shm.h"
#include "gimp-private.h"
#include "gimpgpcompat.h"
#include "gimpgpparams.h"
#include "gimppdb_pdb.h"
#include "gimpplugin_pdb.h"
#include "gimplegacy-private.h"
#include "libgimp-intl.h"
#define WRITE_BUFFER_SIZE 1024
#define ASSERT_NO_PLUG_IN_EXISTS(strfunc) \
if (gimp_get_plug_in ()) \
{ \
g_printerr ("%s ERROR: %s() cannot be called when using the " \
"new plug-in API\n", \
g_get_prgname (), strfunc); \
gimp_quit (); \
}
static void gimp_loop (GimpRunProc run_proc);
static void gimp_process_message (GimpWireMessage *msg);
static void gimp_proc_run (GPProcRun *proc_run,
GimpRunProc run_proc);
static gboolean gimp_plugin_io_error_handler (GIOChannel *channel,
GIOCondition cond,
gpointer data);
static gboolean gimp_write (GIOChannel *channel,
const guint8 *buf,
gulong count,
gpointer user_data);
static gboolean gimp_flush (GIOChannel *channel,
gpointer user_data);
GIOChannel *_gimp_readchannel = NULL;
GIOChannel *_gimp_writechannel = NULL;
static gchar write_buffer[WRITE_BUFFER_SIZE];
static gulong write_buffer_index = 0;
static GimpPlugInInfo PLUG_IN_INFO = { 0, };
/**
* gimp_main_legacy:
* @info: the #GimpPlugInInfo structure
* @argc: the number of arguments
* @argv: (array length=argc): the arguments
*
* The main procedure that must be called with the #GimpPlugInInfo
* structure and the 'argc' and 'argv' that are passed to "main".
*
* Returns: an exit status as defined by the C library,
* on success EXIT_SUCCESS.
**/
gint
gimp_main_legacy (const GimpPlugInInfo *info,
gint argc,
gchar *argv[])
{
return _gimp_main_internal (G_TYPE_NONE, info, argc, argv);
}
/**
* gimp_install_procedure:
* @name: the procedure's name.
* @blurb: a short text describing what the procedure does.
* @help: the help text for the procedure (usually considerably
* longer than @blurb).
* @authors: the procedure's authors.
* @copyright: the procedure's copyright.
* @date: the date the procedure was added.
* @menu_label: the label to use for the procedure's menu entry,
* or %NULL if the procedure has no menu entry.
* @image_types: the drawable types the procedure can handle.
* @type: the type of the procedure.
* @n_params: the number of parameters the procedure takes.
* @n_return_vals: the number of return values the procedure returns.
* @params: (array length=n_params): the procedure's parameters.
* @return_vals: (array length=n_return_vals): the procedure's return values.
*
* Installs a new procedure with the PDB (procedural database).
*
* Call this function from within your plug-in's query() function for
* each procedure your plug-in implements.
*
* The @name parameter is mandatory and should be unique, or it will
* overwrite an already existing procedure (overwrite procedures only
* if you know what you're doing).
*
* The @blurb, @help, @authors, @copyright and @date parameters are
* optional but then you shouldn't write procedures without proper
* documentation, should you.
*
* @menu_label defines the label that should be used for the
* procedure's menu entry. The position where to register in the menu
* hierarchy is chosen using gimp_plugin_menu_register().
*
* It is possible to register a procedure only for keyboard-shortcut
* activation by passing a @menu_label to gimp_install_procedure() but
* not registering any menu path with gimp_plugin_menu_register(). In
* this case, the given @menu_label will only be used as the
* procedure's user-visible name in the keyboard shortcut editor.
*
* @image_types is a comma separated list of image types, or actually
* drawable types, that this procedure can deal with. Wildcards are
* possible here, so you could say "RGB*" instead of "RGB, RGBA" or
* "*" for all image types. If the procedure doesn't need an image to
* run, use the empty string.
*
* @type must be one of %GIMP_PDB_PROC_TYPE_PLUGIN or
* %GIMP_PDB_PROC_TYPE_EXTENSION. Note that temporary procedures must
* be installed using gimp_install_temp_proc().
*
* NOTE: Unlike the GIMP 1.2 API, %GIMP_PDB_PROC_TYPE_EXTENSION no
* longer means that the procedure's menu prefix is &lt;Toolbox&gt;,
* but that it will install temporary procedures. Therefore, the GIMP
* core will wait until the %GIMP_PDB_PROC_TYPE_EXTENSION procedure
* has called gimp_extension_ack(), which means that the procedure has
* done its initialization, installed its temporary procedures and is
* ready to run.
*
* <emphasis>Not calling gimp_extension_ack() from a
* %GIMP_PDB_PROC_TYPE_EXTENSION procedure will cause the GIMP core to
* lock up.</emphasis>
*
* Additionally, a %GIMP_PDB_PROC_TYPE_EXTENSION procedure with no
* parameters (@n_params == 0 and @params == %NULL) is an "automatic"
* extension that will be automatically started on each GIMP startup.
**/
void
gimp_install_procedure (const gchar *name,
const gchar *blurb,
const gchar *help,
const gchar *authors,
const gchar *copyright,
const gchar *date,
const gchar *menu_label,
const gchar *image_types,
GimpPDBProcType type,
gint n_params,
gint n_return_vals,
const GimpParamDef *params,
const GimpParamDef *return_vals)
{
GPProcInstall proc_install;
GList *pspecs = NULL;
gint i;
g_return_if_fail (name != NULL);
g_return_if_fail (type != GIMP_PDB_PROC_TYPE_INTERNAL);
g_return_if_fail ((n_params == 0 && params == NULL) ||
(n_params > 0 && params != NULL));
g_return_if_fail ((n_return_vals == 0 && return_vals == NULL) ||
(n_return_vals > 0 && return_vals != NULL));
ASSERT_NO_PLUG_IN_EXISTS (G_STRFUNC);
proc_install.name = (gchar *) name;
proc_install.blurb = (gchar *) blurb;
proc_install.help = (gchar *) help;
proc_install.help_id = (gchar *) name;
proc_install.authors = (gchar *) authors;
proc_install.copyright = (gchar *) copyright;
proc_install.date = (gchar *) date;
proc_install.menu_label = (gchar *) menu_label;
proc_install.image_types = (gchar *) image_types;
proc_install.type = type;
proc_install.nparams = n_params;
proc_install.nreturn_vals = n_return_vals;
proc_install.params = g_new0 (GPParamDef, n_params);
proc_install.return_vals = g_new0 (GPParamDef, n_return_vals);
for (i = 0; i < n_params; i++)
{
GParamSpec *pspec = _gimp_gp_compat_param_spec (params[i].type,
params[i].name,
params[i].name,
params[i].description);
_gimp_param_spec_to_gp_param_def (pspec, &proc_install.params[i]);
pspecs = g_list_prepend (pspecs, pspec);
}
for (i = 0; i < n_return_vals; i++)
{
GParamSpec *pspec = _gimp_gp_compat_param_spec (return_vals[i].type,
return_vals[i].name,
return_vals[i].name,
return_vals[i].description);
_gimp_param_spec_to_gp_param_def (pspec, &proc_install.return_vals[i]);
pspecs = g_list_prepend (pspecs, pspec);
}
if (! gp_proc_install_write (_gimp_writechannel, &proc_install, NULL))
gimp_quit ();
g_list_foreach (pspecs, (GFunc) g_param_spec_ref_sink, NULL);
g_list_free_full (pspecs, (GDestroyNotify) g_param_spec_unref);
g_free (proc_install.params);
g_free (proc_install.return_vals);
}
void
_gimp_legacy_read_expect_msg (GimpWireMessage *msg,
gint type)
{
ASSERT_NO_PLUG_IN_EXISTS (G_STRFUNC);
while (TRUE)
{
if (! gimp_wire_read_msg (_gimp_readchannel, msg, NULL))
gimp_quit ();
if (msg->type == type)
return; /* up to the caller to call wire_destroy() */
if (msg->type == GP_TEMP_PROC_RUN || msg->type == GP_QUIT)
{
gimp_process_message (msg);
}
else
{
g_error ("unexpected message: %d", msg->type);
}
gimp_wire_destroy (msg);
}
}
GimpValueArray *
gimp_run_procedure_array (const gchar *name,
const GimpValueArray *arguments)
{
GPProcRun proc_run;
GPProcReturn *proc_return;
GimpWireMessage msg;
GimpValueArray *return_values;
g_return_val_if_fail (name != NULL, NULL);
g_return_val_if_fail (arguments != NULL, NULL);
ASSERT_NO_PLUG_IN_EXISTS (G_STRFUNC);
proc_run.name = (gchar *) name;
proc_run.nparams = gimp_value_array_length (arguments);
proc_run.params = _gimp_value_array_to_gp_params (arguments, FALSE);
if (! gp_proc_run_write (_gimp_writechannel, &proc_run, NULL))
gimp_quit ();
_gimp_legacy_read_expect_msg (&msg, GP_PROC_RETURN);
proc_return = msg.data;
return_values = _gimp_gp_params_to_value_array (NULL,
NULL, 0,
proc_return->params,
proc_return->nparams,
TRUE, FALSE);
gimp_wire_destroy (&msg);
return return_values;
}
void
_gimp_legacy_initialize (const GimpPlugInInfo *info,
GIOChannel *read_channel,
GIOChannel *write_channel)
{
ASSERT_NO_PLUG_IN_EXISTS (G_STRFUNC);
PLUG_IN_INFO = *info;
_gimp_readchannel = read_channel;
_gimp_writechannel = write_channel;
gp_init ();
gimp_wire_set_writer (gimp_write);
gimp_wire_set_flusher (gimp_flush);
}
void
_gimp_legacy_query (void)
{
ASSERT_NO_PLUG_IN_EXISTS (G_STRFUNC);
if (PLUG_IN_INFO.init_proc)
gp_has_init_write (_gimp_writechannel, NULL);
if (PLUG_IN_INFO.query_proc)
PLUG_IN_INFO.query_proc ();
}
void
_gimp_legacy_init (void)
{
ASSERT_NO_PLUG_IN_EXISTS (G_STRFUNC);
if (PLUG_IN_INFO.init_proc)
PLUG_IN_INFO.init_proc ();
}
void
_gimp_legacy_run (void)
{
ASSERT_NO_PLUG_IN_EXISTS (G_STRFUNC);
g_io_add_watch (_gimp_readchannel,
G_IO_ERR | G_IO_HUP,
gimp_plugin_io_error_handler,
NULL);
gimp_loop (PLUG_IN_INFO.run_proc);
}
void
_gimp_legacy_quit (void)
{
ASSERT_NO_PLUG_IN_EXISTS (G_STRFUNC);
if (PLUG_IN_INFO.quit_proc)
PLUG_IN_INFO.quit_proc ();
_gimp_shm_close ();
gp_quit_write (_gimp_writechannel, NULL);
}
/* cruft from other places */
/**
* gimp_plugin_menu_register:
* @procedure_name: The procedure for which to install the menu path.
* @menu_path: The procedure's additional menu path.
*
* Register an additional menu path for a plug-in procedure.
*
* This procedure installs an additional menu entry for the given
* procedure.
*
* Returns: TRUE on success.
*
* Since: 2.2
**/
gboolean
gimp_plugin_menu_register (const gchar *procedure_name,
const gchar *menu_path)
{
ASSERT_NO_PLUG_IN_EXISTS (G_STRFUNC);
return _gimp_plugin_menu_register (procedure_name, menu_path);
}
/* private functions */
static void
gimp_loop (GimpRunProc run_proc)
{
GimpWireMessage msg;
while (TRUE)
{
if (! gimp_wire_read_msg (_gimp_readchannel, &msg, NULL))
return;
switch (msg.type)
{
case GP_QUIT:
gimp_wire_destroy (&msg);
return;
case GP_CONFIG:
_gimp_config (msg.data);
break;
case GP_TILE_REQ:
case GP_TILE_ACK:
case GP_TILE_DATA:
g_warning ("unexpected tile message received (should not happen)");
break;
case GP_PROC_RUN:
gimp_proc_run (msg.data, run_proc);
gimp_wire_destroy (&msg);
return;
case GP_PROC_RETURN:
g_warning ("unexpected proc return message received (should not happen)");
break;
case GP_TEMP_PROC_RUN:
g_warning ("unexpected temp proc run message received (should not happen");
break;
case GP_TEMP_PROC_RETURN:
g_warning ("unexpected temp proc return message received (should not happen");
break;
case GP_PROC_INSTALL:
g_warning ("unexpected proc install message received (should not happen)");
break;
case GP_HAS_INIT:
g_warning ("unexpected has init message received (should not happen)");
break;
}
gimp_wire_destroy (&msg);
}
}
static void
gimp_process_message (GimpWireMessage *msg)
{
switch (msg->type)
{
case GP_QUIT:
gimp_quit ();
break;
case GP_CONFIG:
_gimp_config (msg->data);
break;
case GP_TILE_REQ:
case GP_TILE_ACK:
case GP_TILE_DATA:
g_warning ("unexpected tile message received (should not happen)");
break;
case GP_PROC_RUN:
g_warning ("unexpected proc run message received (should not happen)");
break;
case GP_PROC_RETURN:
g_warning ("unexpected proc return message received (should not happen)");
break;
case GP_TEMP_PROC_RUN:
g_warning ("unexpected temp proc run message received (support removed)");
break;
case GP_TEMP_PROC_RETURN:
g_warning ("unexpected temp proc return message received (should not happen)");
break;
case GP_PROC_INSTALL:
g_warning ("unexpected proc install message received (should not happen)");
break;
case GP_HAS_INIT:
g_warning ("unexpected has init message received (should not happen)");
break;
}
}
static void
gimp_proc_run (GPProcRun *proc_run,
GimpRunProc run_proc)
{
GPProcReturn proc_return;
GimpValueArray *arguments;
GimpValueArray *return_values = NULL;
GimpParam *params;
GimpParam *return_vals;
gint n_params;
gint n_return_vals;
arguments = _gimp_gp_params_to_value_array (NULL,
NULL, 0,
proc_run->params,
proc_run->nparams,
FALSE, FALSE);
n_params = gimp_value_array_length (arguments);
params = _gimp_value_array_to_params (arguments, FALSE);
run_proc (proc_run->name,
n_params, params,
&n_return_vals, &return_vals);
return_values = _gimp_params_to_value_array (return_vals,
n_return_vals,
FALSE);
g_free (params);
gimp_value_array_unref (arguments);
proc_return.name = proc_run->name;
proc_return.nparams = gimp_value_array_length (return_values);
proc_return.params = _gimp_value_array_to_gp_params (return_values, TRUE);
gimp_value_array_unref (return_values);
if (! gp_proc_return_write (_gimp_writechannel, &proc_return, NULL))
gimp_quit ();
}
static gboolean
gimp_plugin_io_error_handler (GIOChannel *channel,
GIOCondition cond,
gpointer data)
{
g_printerr ("%s: fatal error: GIMP crashed\n",
gimp_get_progname ());
gimp_quit ();
/* never reached */
return TRUE;
}
static gboolean
gimp_write (GIOChannel *channel,
const guint8 *buf,
gulong count,
gpointer user_data)
{
gulong bytes;
while (count > 0)
{
if ((write_buffer_index + count) >= WRITE_BUFFER_SIZE)
{
bytes = WRITE_BUFFER_SIZE - write_buffer_index;
memcpy (&write_buffer[write_buffer_index], buf, bytes);
write_buffer_index += bytes;
if (! gimp_wire_flush (channel, NULL))
return FALSE;
}
else
{
bytes = count;
memcpy (&write_buffer[write_buffer_index], buf, bytes);
write_buffer_index += bytes;
}
buf += bytes;
count -= bytes;
}
return TRUE;
}
static gboolean
gimp_flush (GIOChannel *channel,
gpointer user_data)
{
GIOStatus status;
GError *error = NULL;
gsize count;
gsize bytes;
if (write_buffer_index > 0)
{
count = 0;
while (count != write_buffer_index)
{
do
{
bytes = 0;
status = g_io_channel_write_chars (channel,
&write_buffer[count],
(write_buffer_index - count),
&bytes,
&error);
}
while (status == G_IO_STATUS_AGAIN);
if (status != G_IO_STATUS_NORMAL)
{
if (error)
{
g_warning ("%s: gimp_flush(): error: %s",
g_get_prgname (), error->message);
g_error_free (error);
}
else
{
g_warning ("%s: gimp_flush(): error", g_get_prgname ());
}
return FALSE;
}
count += bytes;
}
write_buffer_index = 0;
}
return TRUE;
}

274
libgimp/gimplegacy.h
View File

@ -1,274 +0,0 @@
/* LIBGIMP - The GIMP Library
* Copyright (C) 1995-1997 Peter Mattis and Spencer Kimball
*
* gimplegacy.h
*
* This library is free software: you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see
* <https://www.gnu.org/licenses/>.
*/
#if !defined (__GIMP_H_INSIDE__) && !defined (GIMP_COMPILATION)
#error "Only <libgimp/gimp.h> can be included directly."
#endif
#ifndef __GIMP_LEGACY_H__
#define __GIMP_LEGACY_H__
G_BEGIN_DECLS
#ifdef GIMP_DEPRECATED_REPLACE_NEW_API
#define GIMP_PLUGIN GIMP_PDB_PROC_TYPE_PLUGIN
#endif
/**
* GimpInitProc:
*
* The init procedure is run at every GIMP startup.
*/
typedef void (* GimpInitProc) (void);
/**
* GimpQuitProc:
*
* The quit procedure is run each time the plug-in ends.
*/
typedef void (* GimpQuitProc) (void);
/**
* GimpQueryProc:
*
* The initialization procedure is run at GIMP startup, only the first
* time after a plug-in is installed, or if it has been updated.
*/
typedef void (* GimpQueryProc) (void);
/**
* GimpRunProc:
* @name: the name of the procedure which has been called.
* @n_params: the number of parameters passed to the procedure.
* @param: (array length=n_params): the parameters passed to @name.
* @n_return_vals: (out caller-allocates): the number of values returned by @name.
* @return_vals: (array length=n_return_vals) (out callee-allocates): the returned values.
*
* The run procedure is run during the lifetime of the GIMP session,
* each time a plug-in procedure is called.
*/
typedef void (* GimpRunProc) (const gchar *name,
gint n_params,
const GimpParam *param,
gint *n_return_vals,
GimpParam **return_vals);
/**
* GimpPlugInInfo:
* @init_proc: called when the gimp application initially starts up
* @quit_proc: called when the gimp application exits
* @query_proc: called by gimp so that the plug-in can inform the
* gimp of what it does. (ie. installing a procedure database
* procedure).
* @run_proc: called to run a procedure the plug-in installed in the
* procedure database.
**/
struct _GimpPlugInInfo
{
GimpInitProc init_proc;
GimpQuitProc quit_proc;
GimpQueryProc query_proc;
GimpRunProc run_proc;
};
/**
* GimpParamDef:
* @type: the parameter's type.
* @name: the parameter's name.
* @description: the parameter's description.
**/
struct _GimpParamDef
{
GimpPDBArgType type;
gchar *name;
gchar *description;
};
/**
* GimpParamData:
* @d_int32: a 32-bit integer.
* @d_int16: a 16-bit integer.
* @d_int8: an 8-bit unsigned integer.
* @d_float: a double.
* @d_string: a string.
* @d_color: a #GimpRGB.
* @d_int32array: an array of int32.
* @d_int16array: an array of int16.
* @d_int8array: an array of int8.
* @d_floatarray: an array of floats.
* @d_stringarray: an array of strings.
* @d_colorarray: an array of colors.
* @d_display: a display id.
* @d_image: an image id.
* @d_item: an item id.
* @d_drawable: a drawable id.
* @d_layer: a layer id.
* @d_channel: a channel id.
* @d_layer_mask: a layer mask id.
* @d_selection: a selection id.
* @d_vectors: a vectors id.
* @d_unit: a GimpUnit.
* @d_parasite: a GimpParasite.
* @d_tattoo: a tattoo.
* @d_status: a return status.
**/
union _GimpParamData
{
gint32 d_int32;
gint16 d_int16;
guint8 d_int8;
gdouble d_float;
gchar *d_string;
GimpRGB d_color;
gint32 *d_int32array;
gint16 *d_int16array;
guint8 *d_int8array;
gdouble *d_floatarray;
gchar **d_stringarray;
GimpRGB *d_colorarray;
gint32 d_display;
gint32 d_image;
gint32 d_item;
gint32 d_drawable;
gint32 d_layer;
gint32 d_channel;
gint32 d_layer_mask;
gint32 d_selection;
gint32 d_vectors;
gint32 d_unit;
GimpParasite d_parasite;
gint32 d_tattoo;
GimpPDBStatusType d_status;
};
/**
* GimpParam:
* @type: the parameter's type.
* @data: the parameter's data.
**/
struct _GimpParam
{
GimpPDBArgType type;
GimpParamData data;
};
/**
* MAIN:
*
* A macro that expands to the appropriate main() function for the
* platform being compiled for.
*
* To use this macro, simply place a line that contains just the code
* MAIN() at the toplevel of your file. No semicolon should be used.
**/
#ifdef G_OS_WIN32
/* Define WinMain() because plug-ins are built as GUI applications. Also
* define a main() in case some plug-in still is built as a console
* application.
*/
# ifdef __GNUC__
# ifndef _stdcall
# define _stdcall __attribute__((stdcall))
# endif
# endif
# define MAIN() \
struct HINSTANCE__; \
\
int _stdcall \
WinMain (struct HINSTANCE__ *hInstance, \
struct HINSTANCE__ *hPrevInstance, \
char *lpszCmdLine, \
int nCmdShow); \
\
int _stdcall \
WinMain (struct HINSTANCE__ *hInstance, \
struct HINSTANCE__ *hPrevInstance, \
char *lpszCmdLine, \
int nCmdShow) \
{ \
return gimp_main_legacy (&PLUG_IN_INFO, \
__argc, __argv); \
} \
\
int \
main (int argc, char *argv[]) \
{ \
/* Use __argc and __argv here, too, as they work \
* better with mingw-w64. \
*/ \
return gimp_main_legacy (&PLUG_IN_INFO, \
__argc, __argv); \
}
#else
# define MAIN() \
int \
main (int argc, char *argv[]) \
{ \
return gimp_main_legacy (&PLUG_IN_INFO, \
argc, argv); \
}
#endif
/* The main procedure that must be called with the PLUG_IN_INFO
* structure and the 'argc' and 'argv' that are passed to "main".
*/
gint gimp_main_legacy (const GimpPlugInInfo *info,
gint argc,
gchar *argv[]);
/* Install a procedure in the procedure database.
*/
void gimp_install_procedure (const gchar *name,
const gchar *blurb,
const gchar *help,
const gchar *authors,
const gchar *copyright,
const gchar *date,
const gchar *menu_label,
const gchar *image_types,
GimpPDBProcType type,
gint n_params,
gint n_return_vals,
const GimpParamDef *params,
const GimpParamDef *return_vals);
/* Run a procedure in the procedure database. The parameters are
* specified as a GimpValueArray, so are the return values.
*/
GimpValueArray * gimp_run_procedure_array (const gchar *name,
const GimpValueArray *arguments);
/* gimp_plugin API that should now be done by using GimpProcedure
*/
gboolean gimp_plugin_menu_register (const gchar *procedure_name,
const gchar *menu_path);
G_END_DECLS
#endif /* __GIMP_LEGACY_H__ */

33
libgimp/gimpmessage_pdb.c
View File

@ -48,7 +48,6 @@
gboolean
gimp_message (const gchar *message)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -57,13 +56,9 @@ gimp_message (const gchar *message)
G_TYPE_STRING, message,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-message",
args);
else
return_vals = gimp_run_procedure_array ("gimp-message",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-message",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -87,7 +82,6 @@ gimp_message (const gchar *message)
GimpMessageHandlerType
gimp_message_get_handler (void)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpMessageHandlerType handler = 0;
@ -95,13 +89,9 @@ gimp_message_get_handler (void)
args = gimp_value_array_new_from_types (NULL,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-message-get-handler",
args);
else
return_vals = gimp_run_procedure_array ("gimp-message-get-handler",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -127,7 +117,6 @@ 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;
@ -136,13 +125,9 @@ gimp_message_set_handler (GimpMessageHandlerType handler)
GIMP_TYPE_MESSAGE_HANDLER_TYPE, handler,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-message-set-handler",
args);
else
return_vals = gimp_run_procedure_array ("gimp-message-set-handler",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;

187
libgimp/gimppainttools_pdb.c
View File

@ -57,7 +57,6 @@ gimp_airbrush (GimpDrawable *drawable,
gint num_strokes,
const gdouble *strokes)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -70,13 +69,9 @@ gimp_airbrush (GimpDrawable *drawable,
G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 3), strokes, num_strokes);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-airbrush",
args);
else
return_vals = gimp_run_procedure_array ("gimp-airbrush",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-airbrush",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -107,7 +102,6 @@ gimp_airbrush_default (GimpDrawable *drawable,
gint num_strokes,
const gdouble *strokes)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -119,13 +113,9 @@ gimp_airbrush_default (GimpDrawable *drawable,
G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-airbrush-default",
args);
else
return_vals = gimp_run_procedure_array ("gimp-airbrush-default",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-airbrush-default",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -171,7 +161,6 @@ gimp_clone (GimpDrawable *drawable,
gint num_strokes,
const gdouble *strokes)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -187,13 +176,9 @@ gimp_clone (GimpDrawable *drawable,
G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 6), strokes, num_strokes);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-clone",
args);
else
return_vals = gimp_run_procedure_array ("gimp-clone",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-clone",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -225,7 +210,6 @@ gimp_clone_default (GimpDrawable *drawable,
gint num_strokes,
const gdouble *strokes)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -237,13 +221,9 @@ gimp_clone_default (GimpDrawable *drawable,
G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-clone-default",
args);
else
return_vals = gimp_run_procedure_array ("gimp-clone-default",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-clone-default",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -277,7 +257,6 @@ gimp_convolve (GimpDrawable *drawable,
gint num_strokes,
const gdouble *strokes)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -291,13 +270,9 @@ gimp_convolve (GimpDrawable *drawable,
G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 4), strokes, num_strokes);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-convolve",
args);
else
return_vals = gimp_run_procedure_array ("gimp-convolve",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-convolve",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -328,7 +303,6 @@ gimp_convolve_default (GimpDrawable *drawable,
gint num_strokes,
const gdouble *strokes)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -340,13 +314,9 @@ gimp_convolve_default (GimpDrawable *drawable,
G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-convolve-default",
args);
else
return_vals = gimp_run_procedure_array ("gimp-convolve-default",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-convolve-default",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -379,7 +349,6 @@ gimp_dodgeburn (GimpDrawable *drawable,
gint num_strokes,
const gdouble *strokes)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -394,13 +363,9 @@ gimp_dodgeburn (GimpDrawable *drawable,
G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 5), strokes, num_strokes);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-dodgeburn",
args);
else
return_vals = gimp_run_procedure_array ("gimp-dodgeburn",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-dodgeburn",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -430,7 +395,6 @@ gimp_dodgeburn_default (GimpDrawable *drawable,
gint num_strokes,
const gdouble *strokes)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -442,13 +406,9 @@ gimp_dodgeburn_default (GimpDrawable *drawable,
G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-dodgeburn-default",
args);
else
return_vals = gimp_run_procedure_array ("gimp-dodgeburn-default",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-dodgeburn-default",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -483,7 +443,6 @@ gimp_eraser (GimpDrawable *drawable,
GimpBrushApplicationMode hardness,
GimpPaintApplicationMode method)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -497,13 +456,9 @@ gimp_eraser (GimpDrawable *drawable,
G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-eraser",
args);
else
return_vals = gimp_run_procedure_array ("gimp-eraser",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-eraser",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -534,7 +489,6 @@ gimp_eraser_default (GimpDrawable *drawable,
gint num_strokes,
const gdouble *strokes)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -546,13 +500,9 @@ gimp_eraser_default (GimpDrawable *drawable,
G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-eraser-default",
args);
else
return_vals = gimp_run_procedure_array ("gimp-eraser-default",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-eraser-default",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -592,7 +542,6 @@ gimp_heal (GimpDrawable *drawable,
gint num_strokes,
const gdouble *strokes)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -607,13 +556,9 @@ gimp_heal (GimpDrawable *drawable,
G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 5), strokes, num_strokes);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-heal",
args);
else
return_vals = gimp_run_procedure_array ("gimp-heal",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-heal",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -647,7 +592,6 @@ gimp_heal_default (GimpDrawable *drawable,
gint num_strokes,
const gdouble *strokes)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -659,13 +603,9 @@ gimp_heal_default (GimpDrawable *drawable,
G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-heal-default",
args);
else
return_vals = gimp_run_procedure_array ("gimp-heal-default",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-heal-default",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -707,7 +647,6 @@ gimp_paintbrush (GimpDrawable *drawable,
GimpPaintApplicationMode method,
gdouble gradient_length)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -722,13 +661,9 @@ gimp_paintbrush (GimpDrawable *drawable,
G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 3), strokes, num_strokes);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-paintbrush",
args);
else
return_vals = gimp_run_procedure_array ("gimp-paintbrush",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-paintbrush",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -768,7 +703,6 @@ gimp_paintbrush_default (GimpDrawable *drawable,
gint num_strokes,
const gdouble *strokes)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -780,13 +714,9 @@ gimp_paintbrush_default (GimpDrawable *drawable,
G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-paintbrush-default",
args);
else
return_vals = gimp_run_procedure_array ("gimp-paintbrush-default",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-paintbrush-default",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -818,7 +748,6 @@ gimp_pencil (GimpDrawable *drawable,
gint num_strokes,
const gdouble *strokes)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -830,13 +759,9 @@ gimp_pencil (GimpDrawable *drawable,
G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-pencil",
args);
else
return_vals = gimp_run_procedure_array ("gimp-pencil",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-pencil",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -867,7 +792,6 @@ gimp_smudge (GimpDrawable *drawable,
gint num_strokes,
const gdouble *strokes)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -880,13 +804,9 @@ gimp_smudge (GimpDrawable *drawable,
G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 3), strokes, num_strokes);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-smudge",
args);
else
return_vals = gimp_run_procedure_array ("gimp-smudge",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-smudge",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -916,7 +836,6 @@ gimp_smudge_default (GimpDrawable *drawable,
gint num_strokes,
const gdouble *strokes)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -928,13 +847,9 @@ gimp_smudge_default (GimpDrawable *drawable,
G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-smudge-default",
args);
else
return_vals = gimp_run_procedure_array ("gimp-smudge-default",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-smudge-default",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;

165
libgimp/gimppalette_pdb.c
View File

@ -50,7 +50,6 @@
gchar *
gimp_palette_new (const gchar *name)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *actual_name = NULL;
@ -59,13 +58,9 @@ gimp_palette_new (const gchar *name)
G_TYPE_STRING, name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-palette-new",
args);
else
return_vals = gimp_run_procedure_array ("gimp-palette-new",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-palette-new",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -92,7 +87,6 @@ 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;
@ -101,13 +95,9 @@ gimp_palette_duplicate (const gchar *name)
G_TYPE_STRING, name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-palette-duplicate",
args);
else
return_vals = gimp_run_procedure_array ("gimp-palette-duplicate",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-palette-duplicate",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -136,7 +126,6 @@ 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;
@ -146,13 +135,9 @@ gimp_palette_rename (const gchar *name,
G_TYPE_STRING, new_name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-palette-rename",
args);
else
return_vals = gimp_run_procedure_array ("gimp-palette-rename",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-palette-rename",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -178,7 +163,6 @@ 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;
@ -187,13 +171,9 @@ gimp_palette_delete (const gchar *name)
G_TYPE_STRING, name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-palette-delete",
args);
else
return_vals = gimp_run_procedure_array ("gimp-palette-delete",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-palette-delete",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -218,7 +198,6 @@ 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;
@ -227,13 +206,9 @@ gimp_palette_is_editable (const gchar *name)
G_TYPE_STRING, name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-palette-is-editable",
args);
else
return_vals = gimp_run_procedure_array ("gimp-palette-is-editable",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -262,7 +237,6 @@ gboolean
gimp_palette_get_info (const gchar *name,
gint *num_colors)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -271,13 +245,9 @@ gimp_palette_get_info (const gchar *name,
G_TYPE_STRING, name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-palette-get-info",
args);
else
return_vals = gimp_run_procedure_array ("gimp-palette-get-info",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-palette-get-info",
args);
gimp_value_array_unref (args);
*num_colors = 0;
@ -311,7 +281,6 @@ GimpRGB *
gimp_palette_get_colors (const gchar *name,
gint *num_colors)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpRGB *colors = NULL;
@ -320,13 +289,9 @@ gimp_palette_get_colors (const gchar *name,
G_TYPE_STRING, name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-palette-get-colors",
args);
else
return_vals = gimp_run_procedure_array ("gimp-palette-get-colors",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-palette-get-colors",
args);
gimp_value_array_unref (args);
*num_colors = 0;
@ -358,7 +323,6 @@ 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;
@ -367,13 +331,9 @@ gimp_palette_get_columns (const gchar *name)
G_TYPE_STRING, name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-palette-get-columns",
args);
else
return_vals = gimp_run_procedure_array ("gimp-palette-get-columns",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -403,7 +363,6 @@ gboolean
gimp_palette_set_columns (const gchar *name,
gint columns)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -413,13 +372,9 @@ gimp_palette_set_columns (const gchar *name,
G_TYPE_INT, columns,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-palette-set-columns",
args);
else
return_vals = gimp_run_procedure_array ("gimp-palette-set-columns",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -451,7 +406,6 @@ 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;
@ -462,13 +416,9 @@ gimp_palette_add_entry (const gchar *name,
GIMP_TYPE_RGB, color,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-palette-add-entry",
args);
else
return_vals = gimp_run_procedure_array ("gimp-palette-add-entry",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-palette-add-entry",
args);
gimp_value_array_unref (args);
*entry_num = 0;
@ -501,7 +451,6 @@ gboolean
gimp_palette_delete_entry (const gchar *name,
gint entry_num)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -511,13 +460,9 @@ gimp_palette_delete_entry (const gchar *name,
G_TYPE_INT, entry_num,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-palette-delete-entry",
args);
else
return_vals = gimp_run_procedure_array ("gimp-palette-delete-entry",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -548,7 +493,6 @@ 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;
@ -558,13 +502,9 @@ gimp_palette_entry_get_color (const gchar *name,
G_TYPE_INT, entry_num,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-palette-entry-get-color",
args);
else
return_vals = gimp_run_procedure_array ("gimp-palette-entry-get-color",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -598,7 +538,6 @@ 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;
@ -609,13 +548,9 @@ gimp_palette_entry_set_color (const gchar *name,
GIMP_TYPE_RGB, color,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-palette-entry-set-color",
args);
else
return_vals = gimp_run_procedure_array ("gimp-palette-entry-set-color",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -646,7 +581,6 @@ 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;
@ -656,13 +590,9 @@ gimp_palette_entry_get_name (const gchar *name,
G_TYPE_INT, entry_num,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-palette-entry-get-name",
args);
else
return_vals = gimp_run_procedure_array ("gimp-palette-entry-get-name",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-palette-entry-get-name",
args);
gimp_value_array_unref (args);
*entry_name = NULL;
@ -698,7 +628,6 @@ 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;
@ -709,13 +638,9 @@ gimp_palette_entry_set_name (const gchar *name,
G_TYPE_STRING, entry_name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-palette-entry-set-name",
args);
else
return_vals = gimp_run_procedure_array ("gimp-palette-entry-set-name",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;

22
libgimp/gimppalettes_pdb.c
View File

@ -47,7 +47,6 @@
gboolean
gimp_palettes_refresh (void)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -55,13 +54,9 @@ gimp_palettes_refresh (void)
args = gimp_value_array_new_from_types (NULL,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-palettes-refresh",
args);
else
return_vals = gimp_run_procedure_array ("gimp-palettes-refresh",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-palettes-refresh",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -90,7 +85,6 @@ 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;
@ -99,13 +93,9 @@ gimp_palettes_get_list (const gchar *filter,
G_TYPE_STRING, filter,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-palettes-get-list",
args);
else
return_vals = gimp_run_procedure_array ("gimp-palettes-get-list",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-palettes-get-list",
args);
gimp_value_array_unref (args);
*num_palettes = 0;

33
libgimp/gimppaletteselect_pdb.c
View File

@ -51,7 +51,6 @@ 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;
@ -62,13 +61,9 @@ gimp_palettes_popup (const gchar *palette_callback,
G_TYPE_STRING, initial_palette,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-palettes-popup",
args);
else
return_vals = gimp_run_procedure_array ("gimp-palettes-popup",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-palettes-popup",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -91,7 +86,6 @@ 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;
@ -100,13 +94,9 @@ gimp_palettes_close_popup (const gchar *palette_callback)
G_TYPE_STRING, palette_callback,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-palettes-close-popup",
args);
else
return_vals = gimp_run_procedure_array ("gimp-palettes-close-popup",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -131,7 +121,6 @@ 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;
@ -141,13 +130,9 @@ gimp_palettes_set_popup (const gchar *palette_callback,
G_TYPE_STRING, palette_name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-palettes-set-popup",
args);
else
return_vals = gimp_run_procedure_array ("gimp-palettes-set-popup",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;

22
libgimp/gimppattern_pdb.c
View File

@ -56,7 +56,6 @@ gimp_pattern_get_info (const gchar *name,
gint *height,
gint *bpp)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -65,13 +64,9 @@ gimp_pattern_get_info (const gchar *name,
G_TYPE_STRING, name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-pattern-get-info",
args);
else
return_vals = gimp_run_procedure_array ("gimp-pattern-get-info",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-pattern-get-info",
args);
gimp_value_array_unref (args);
*width = 0;
@ -119,7 +114,6 @@ 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;
@ -128,13 +122,9 @@ gimp_pattern_get_pixels (const gchar *name,
G_TYPE_STRING, name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-pattern-get-pixels",
args);
else
return_vals = gimp_run_procedure_array ("gimp-pattern-get-pixels",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-pattern-get-pixels",
args);
gimp_value_array_unref (args);
*width = 0;

22
libgimp/gimppatterns_pdb.c
View File

@ -47,7 +47,6 @@
gboolean
gimp_patterns_refresh (void)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -55,13 +54,9 @@ gimp_patterns_refresh (void)
args = gimp_value_array_new_from_types (NULL,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-patterns-refresh",
args);
else
return_vals = gimp_run_procedure_array ("gimp-patterns-refresh",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-patterns-refresh",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -90,7 +85,6 @@ 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;
@ -99,13 +93,9 @@ gimp_patterns_get_list (const gchar *filter,
G_TYPE_STRING, filter,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-patterns-get-list",
args);
else
return_vals = gimp_run_procedure_array ("gimp-patterns-get-list",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-patterns-get-list",
args);
gimp_value_array_unref (args);
*num_patterns = 0;

33
libgimp/gimppatternselect_pdb.c
View File

@ -51,7 +51,6 @@ 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;
@ -62,13 +61,9 @@ gimp_patterns_popup (const gchar *pattern_callback,
G_TYPE_STRING, initial_pattern,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-patterns-popup",
args);
else
return_vals = gimp_run_procedure_array ("gimp-patterns-popup",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-patterns-popup",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -91,7 +86,6 @@ 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;
@ -100,13 +94,9 @@ gimp_patterns_close_popup (const gchar *pattern_callback)
G_TYPE_STRING, pattern_callback,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-patterns-close-popup",
args);
else
return_vals = gimp_run_procedure_array ("gimp-patterns-close-popup",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -131,7 +121,6 @@ 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;
@ -141,13 +130,9 @@ gimp_patterns_set_popup (const gchar *pattern_callback,
G_TYPE_STRING, pattern_name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-patterns-set-popup",
args);
else
return_vals = gimp_run_procedure_array ("gimp-patterns-set-popup",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;

110
libgimp/gimppdb_pdb.c
View File

@ -39,7 +39,6 @@
gchar *
_gimp_pdb_temp_name (void)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *temp_name = NULL;
@ -47,13 +46,9 @@ _gimp_pdb_temp_name (void)
args = gimp_value_array_new_from_types (NULL,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-pdb-temp-name",
args);
else
return_vals = gimp_run_procedure_array ("gimp-pdb-temp-name",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -79,7 +74,6 @@ _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;
@ -88,13 +82,9 @@ _gimp_pdb_dump (const gchar *filename)
G_TYPE_STRING, filename,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-pdb-dump",
args);
else
return_vals = gimp_run_procedure_array ("gimp-pdb-dump",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-pdb-dump",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -145,7 +135,6 @@ _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;
@ -160,13 +149,9 @@ _gimp_pdb_query (const gchar *name,
G_TYPE_STRING, proc_type,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-pdb-query",
args);
else
return_vals = gimp_run_procedure_array ("gimp-pdb-query",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-pdb-query",
args);
gimp_value_array_unref (args);
*num_matches = 0;
@ -201,7 +186,6 @@ _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;
@ -210,13 +194,9 @@ _gimp_pdb_proc_exists (const gchar *procedure_name)
G_TYPE_STRING, procedure_name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-pdb-proc-exists",
args);
else
return_vals = gimp_run_procedure_array ("gimp-pdb-proc-exists",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -262,7 +242,6 @@ _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;
@ -271,13 +250,9 @@ _gimp_pdb_proc_info (const gchar *procedure_name,
G_TYPE_STRING, procedure_name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-pdb-proc-info",
args);
else
return_vals = gimp_run_procedure_array ("gimp-pdb-proc-info",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-pdb-proc-info",
args);
gimp_value_array_unref (args);
*blurb = NULL;
@ -327,7 +302,6 @@ 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;
@ -337,13 +311,9 @@ _gimp_pdb_proc_argument (const gchar *procedure_name,
G_TYPE_INT, arg_num,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-pdb-proc-argument",
args);
else
return_vals = gimp_run_procedure_array ("gimp-pdb-proc-argument",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -374,7 +344,6 @@ 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;
@ -384,13 +353,9 @@ _gimp_pdb_proc_return_value (const gchar *procedure_name,
G_TYPE_INT, val_num,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-pdb-proc-return-value",
args);
else
return_vals = gimp_run_procedure_array ("gimp-pdb-proc-return-value",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -421,7 +386,6 @@ _gimp_pdb_get_data (const gchar *identifier,
gint *bytes,
guint8 **data)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -430,13 +394,9 @@ _gimp_pdb_get_data (const gchar *identifier,
G_TYPE_STRING, identifier,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-pdb-get-data",
args);
else
return_vals = gimp_run_procedure_array ("gimp-pdb-get-data",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-pdb-get-data",
args);
gimp_value_array_unref (args);
*bytes = 0;
@ -470,7 +430,6 @@ _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;
@ -479,13 +438,9 @@ _gimp_pdb_get_data_size (const gchar *identifier)
G_TYPE_STRING, identifier,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-pdb-get-data-size",
args);
else
return_vals = gimp_run_procedure_array ("gimp-pdb-get-data-size",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -515,7 +470,6 @@ _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;
@ -527,13 +481,9 @@ _gimp_pdb_set_data (const gchar *identifier,
G_TYPE_NONE);
gimp_value_set_uint8_array (gimp_value_array_index (args, 2), data, bytes);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-pdb-set-data",
args);
else
return_vals = gimp_run_procedure_array ("gimp-pdb-set-data",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;

77
libgimp/gimpplugin_pdb.c
View File

@ -47,7 +47,6 @@ 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;
@ -57,13 +56,9 @@ _gimp_plugin_domain_register (const gchar *domain_name,
G_TYPE_STRING, domain_path,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-plugin-domain-register",
args);
else
return_vals = gimp_run_procedure_array ("gimp-plugin-domain-register",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -92,7 +87,6 @@ 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;
@ -102,13 +96,9 @@ _gimp_plugin_help_register (const gchar *domain_name,
G_TYPE_STRING, domain_uri,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-plugin-help-register",
args);
else
return_vals = gimp_run_procedure_array ("gimp-plugin-help-register",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -138,7 +128,6 @@ 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;
@ -148,13 +137,9 @@ _gimp_plugin_menu_branch_register (const gchar *menu_path,
G_TYPE_STRING, menu_name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-plugin-menu-branch-register",
args);
else
return_vals = gimp_run_procedure_array ("gimp-plugin-menu-branch-register",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -182,7 +167,6 @@ 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;
@ -192,13 +176,9 @@ _gimp_plugin_menu_register (const gchar *procedure_name,
G_TYPE_STRING, menu_path,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-plugin-menu-register",
args);
else
return_vals = gimp_run_procedure_array ("gimp-plugin-menu-register",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -229,7 +209,6 @@ _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;
@ -242,13 +221,9 @@ _gimp_plugin_icon_register (const gchar *procedure_name,
G_TYPE_NONE);
gimp_value_set_uint8_array (gimp_value_array_index (args, 3), icon_data, icon_data_length);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-plugin-icon-register",
args);
else
return_vals = gimp_run_procedure_array ("gimp-plugin-icon-register",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -280,7 +255,6 @@ _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;
@ -289,13 +263,9 @@ _gimp_plugin_set_pdb_error_handler (GimpPDBErrorHandler handler)
GIMP_TYPE_PDB_ERROR_HANDLER, handler,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-plugin-set-pdb-error-handler",
args);
else
return_vals = gimp_run_procedure_array ("gimp-plugin-set-pdb-error-handler",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -321,7 +291,6 @@ _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;
@ -329,13 +298,9 @@ _gimp_plugin_get_pdb_error_handler (void)
args = gimp_value_array_new_from_types (NULL,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-plugin-get-pdb-error-handler",
args);
else
return_vals = gimp_run_procedure_array ("gimp-plugin-get-pdb-error-handler",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)

2
libgimp/gimpprocedure-private.h
View File

@ -28,8 +28,6 @@
G_BEGIN_DECLS
/* For information look into the C source or the html documentation */
GimpDisplay * _gimp_procedure_get_display (GimpProcedure *procedure,
gint32 display_id);

99
libgimp/gimpprogress_pdb.c
View File

@ -50,7 +50,6 @@ gboolean
_gimp_progress_init (const gchar *message,
GimpDisplay *gdisplay)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -60,13 +59,9 @@ _gimp_progress_init (const gchar *message,
GIMP_TYPE_DISPLAY, gdisplay,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-progress-init",
args);
else
return_vals = gimp_run_procedure_array ("gimp-progress-init",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-progress-init",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -90,7 +85,6 @@ _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;
@ -99,13 +93,9 @@ _gimp_progress_update (gdouble percentage)
G_TYPE_DOUBLE, percentage,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-progress-update",
args);
else
return_vals = gimp_run_procedure_array ("gimp-progress-update",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-progress-update",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -133,7 +123,6 @@ _gimp_progress_update (gdouble percentage)
gboolean
gimp_progress_pulse (void)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -141,13 +130,9 @@ gimp_progress_pulse (void)
args = gimp_value_array_new_from_types (NULL,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-progress-pulse",
args);
else
return_vals = gimp_run_procedure_array ("gimp-progress-pulse",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-progress-pulse",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -174,7 +159,6 @@ 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;
@ -183,13 +167,9 @@ gimp_progress_set_text (const gchar *message)
G_TYPE_STRING, message,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-progress-set-text",
args);
else
return_vals = gimp_run_procedure_array ("gimp-progress-set-text",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -215,7 +195,6 @@ 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;
@ -223,13 +202,9 @@ gimp_progress_end (void)
args = gimp_value_array_new_from_types (NULL,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-progress-end",
args);
else
return_vals = gimp_run_procedure_array ("gimp-progress-end",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-progress-end",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -255,7 +230,6 @@ gimp_progress_end (void)
gint
gimp_progress_get_window_handle (void)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint window = 0;
@ -263,13 +237,9 @@ gimp_progress_get_window_handle (void)
args = gimp_value_array_new_from_types (NULL,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-progress-get-window-handle",
args);
else
return_vals = gimp_run_procedure_array ("gimp-progress-get-window-handle",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -298,7 +268,6 @@ 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;
@ -307,13 +276,9 @@ _gimp_progress_install (const gchar *progress_callback)
G_TYPE_STRING, progress_callback,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-progress-install",
args);
else
return_vals = gimp_run_procedure_array ("gimp-progress-install",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-progress-install",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -339,7 +304,6 @@ _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;
@ -348,13 +312,9 @@ _gimp_progress_uninstall (const gchar *progress_callback)
G_TYPE_STRING, progress_callback,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-progress-uninstall",
args);
else
return_vals = gimp_run_procedure_array ("gimp-progress-uninstall",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-progress-uninstall",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -379,7 +339,6 @@ _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;
@ -388,13 +347,9 @@ gimp_progress_cancel (const gchar *progress_callback)
G_TYPE_STRING, progress_callback,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-progress-cancel",
args);
else
return_vals = gimp_run_procedure_array ("gimp-progress-cancel",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-progress-cancel",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;

165
libgimp/gimpselection_pdb.c
View File

@ -64,7 +64,6 @@ gimp_selection_bounds (GimpImage *image,
gint *x2,
gint *y2)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -73,13 +72,9 @@ gimp_selection_bounds (GimpImage *image,
GIMP_TYPE_IMAGE, image,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-selection-bounds",
args);
else
return_vals = gimp_run_procedure_array ("gimp-selection-bounds",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-selection-bounds",
args);
gimp_value_array_unref (args);
*non_empty = FALSE;
@ -122,7 +117,6 @@ gimp_selection_value (GimpImage *image,
gint x,
gint y)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint value = 0;
@ -133,13 +127,9 @@ gimp_selection_value (GimpImage *image,
G_TYPE_INT, y,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-selection-value",
args);
else
return_vals = gimp_run_procedure_array ("gimp-selection-value",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-selection-value",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -164,7 +154,6 @@ gimp_selection_value (GimpImage *image,
gboolean
gimp_selection_is_empty (GimpImage *image)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean is_empty = FALSE;
@ -173,13 +162,9 @@ gimp_selection_is_empty (GimpImage *image)
GIMP_TYPE_IMAGE, image,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-selection-is-empty",
args);
else
return_vals = gimp_run_procedure_array ("gimp-selection-is-empty",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -211,7 +196,6 @@ gimp_selection_translate (GimpImage *image,
gint offx,
gint offy)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -222,13 +206,9 @@ gimp_selection_translate (GimpImage *image,
G_TYPE_INT, offy,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-selection-translate",
args);
else
return_vals = gimp_run_procedure_array ("gimp-selection-translate",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-selection-translate",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -260,7 +240,6 @@ _gimp_selection_float (GimpDrawable *drawable,
gint offx,
gint offy)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpLayer *layer = NULL;
@ -271,13 +250,9 @@ _gimp_selection_float (GimpDrawable *drawable,
G_TYPE_INT, offy,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-selection-float",
args);
else
return_vals = gimp_run_procedure_array ("gimp-selection-float",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-selection-float",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -302,7 +277,6 @@ _gimp_selection_float (GimpDrawable *drawable,
gboolean
gimp_selection_invert (GimpImage *image)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -311,13 +285,9 @@ gimp_selection_invert (GimpImage *image)
GIMP_TYPE_IMAGE, image,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-selection-invert",
args);
else
return_vals = gimp_run_procedure_array ("gimp-selection-invert",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-selection-invert",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -343,7 +313,6 @@ gimp_selection_invert (GimpImage *image)
gboolean
gimp_selection_sharpen (GimpImage *image)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -352,13 +321,9 @@ gimp_selection_sharpen (GimpImage *image)
GIMP_TYPE_IMAGE, image,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-selection-sharpen",
args);
else
return_vals = gimp_run_procedure_array ("gimp-selection-sharpen",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-selection-sharpen",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -382,7 +347,6 @@ gimp_selection_sharpen (GimpImage *image)
gboolean
gimp_selection_all (GimpImage *image)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -391,13 +355,9 @@ gimp_selection_all (GimpImage *image)
GIMP_TYPE_IMAGE, image,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-selection-all",
args);
else
return_vals = gimp_run_procedure_array ("gimp-selection-all",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-selection-all",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -421,7 +381,6 @@ gimp_selection_all (GimpImage *image)
gboolean
gimp_selection_none (GimpImage *image)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -430,13 +389,9 @@ gimp_selection_none (GimpImage *image)
GIMP_TYPE_IMAGE, image,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-selection-none",
args);
else
return_vals = gimp_run_procedure_array ("gimp-selection-none",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-selection-none",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -462,7 +417,6 @@ gboolean
gimp_selection_feather (GimpImage *image,
gdouble radius)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -472,13 +426,9 @@ gimp_selection_feather (GimpImage *image,
G_TYPE_DOUBLE, radius,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-selection-feather",
args);
else
return_vals = gimp_run_procedure_array ("gimp-selection-feather",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-selection-feather",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -505,7 +455,6 @@ gboolean
gimp_selection_border (GimpImage *image,
gint radius)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -515,13 +464,9 @@ gimp_selection_border (GimpImage *image,
G_TYPE_INT, radius,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-selection-border",
args);
else
return_vals = gimp_run_procedure_array ("gimp-selection-border",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-selection-border",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -547,7 +492,6 @@ gboolean
gimp_selection_grow (GimpImage *image,
gint steps)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -557,13 +501,9 @@ gimp_selection_grow (GimpImage *image,
G_TYPE_INT, steps,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-selection-grow",
args);
else
return_vals = gimp_run_procedure_array ("gimp-selection-grow",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-selection-grow",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -590,7 +530,6 @@ gboolean
gimp_selection_shrink (GimpImage *image,
gint steps)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -600,13 +539,9 @@ gimp_selection_shrink (GimpImage *image,
G_TYPE_INT, steps,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-selection-shrink",
args);
else
return_vals = gimp_run_procedure_array ("gimp-selection-shrink",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-selection-shrink",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -634,7 +569,6 @@ gimp_selection_shrink (GimpImage *image,
gboolean
gimp_selection_flood (GimpImage *image)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -643,13 +577,9 @@ gimp_selection_flood (GimpImage *image)
GIMP_TYPE_IMAGE, image,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-selection-flood",
args);
else
return_vals = gimp_run_procedure_array ("gimp-selection-flood",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-selection-flood",
args);
gimp_value_array_unref (args);
success = g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS;
@ -674,7 +604,6 @@ gimp_selection_flood (GimpImage *image)
GimpChannel *
gimp_selection_save (GimpImage *image)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpChannel *channel = NULL;
@ -683,13 +612,9 @@ gimp_selection_save (GimpImage *image)
GIMP_TYPE_IMAGE, image,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-selection-save",
args);
else
return_vals = gimp_run_procedure_array ("gimp-selection-save",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-selection-save",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)

319
libgimp/gimptextlayer_pdb.c
View File

@ -62,7 +62,6 @@ gimp_text_layer_new (GimpImage *image,
gdouble size,
GimpUnit unit)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpLayer *layer = NULL;
@ -75,13 +74,9 @@ gimp_text_layer_new (GimpImage *image,
GIMP_TYPE_UNIT, unit,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-text-layer-new",
args);
else
return_vals = gimp_run_procedure_array ("gimp-text-layer-new",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -108,7 +103,6 @@ gimp_text_layer_new (GimpImage *image,
gchar *
gimp_text_layer_get_text (GimpLayer *layer)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *text = NULL;
@ -117,13 +111,9 @@ gimp_text_layer_get_text (GimpLayer *layer)
GIMP_TYPE_LAYER, layer,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-text-layer-get-text",
args);
else
return_vals = gimp_run_procedure_array ("gimp-text-layer-get-text",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -151,7 +141,6 @@ gboolean
gimp_text_layer_set_text (GimpLayer *layer,
const gchar *text)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -161,13 +150,9 @@ gimp_text_layer_set_text (GimpLayer *layer,
G_TYPE_STRING, text,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-text-layer-set-text",
args);
else
return_vals = gimp_run_procedure_array ("gimp-text-layer-set-text",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -198,7 +183,6 @@ gimp_text_layer_set_text (GimpLayer *layer,
gchar *
gimp_text_layer_get_markup (GimpLayer *layer)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *markup = NULL;
@ -207,13 +191,9 @@ gimp_text_layer_get_markup (GimpLayer *layer)
GIMP_TYPE_LAYER, layer,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-text-layer-get-markup",
args);
else
return_vals = gimp_run_procedure_array ("gimp-text-layer-get-markup",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -241,7 +221,6 @@ gimp_text_layer_get_markup (GimpLayer *layer)
gchar *
gimp_text_layer_get_font (GimpLayer *layer)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *font = NULL;
@ -250,13 +229,9 @@ gimp_text_layer_get_font (GimpLayer *layer)
GIMP_TYPE_LAYER, layer,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-text-layer-get-font",
args);
else
return_vals = gimp_run_procedure_array ("gimp-text-layer-get-font",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -284,7 +259,6 @@ gboolean
gimp_text_layer_set_font (GimpLayer *layer,
const gchar *font)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -294,13 +268,9 @@ gimp_text_layer_set_font (GimpLayer *layer,
G_TYPE_STRING, font,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-text-layer-set-font",
args);
else
return_vals = gimp_run_procedure_array ("gimp-text-layer-set-font",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -329,7 +299,6 @@ gdouble
gimp_text_layer_get_font_size (GimpLayer *layer,
GimpUnit *unit)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble font_size = 0.0;
@ -338,13 +307,9 @@ gimp_text_layer_get_font_size (GimpLayer *layer,
GIMP_TYPE_LAYER, layer,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-text-layer-get-font-size",
args);
else
return_vals = gimp_run_procedure_array ("gimp-text-layer-get-font-size",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -378,7 +343,6 @@ gimp_text_layer_set_font_size (GimpLayer *layer,
gdouble font_size,
GimpUnit unit)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -389,13 +353,9 @@ gimp_text_layer_set_font_size (GimpLayer *layer,
GIMP_TYPE_UNIT, unit,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-text-layer-set-font-size",
args);
else
return_vals = gimp_run_procedure_array ("gimp-text-layer-set-font-size",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -421,7 +381,6 @@ gimp_text_layer_set_font_size (GimpLayer *layer,
gboolean
gimp_text_layer_get_antialias (GimpLayer *layer)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean antialias = FALSE;
@ -430,13 +389,9 @@ gimp_text_layer_get_antialias (GimpLayer *layer)
GIMP_TYPE_LAYER, layer,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-text-layer-get-antialias",
args);
else
return_vals = gimp_run_procedure_array ("gimp-text-layer-get-antialias",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -465,7 +420,6 @@ gboolean
gimp_text_layer_set_antialias (GimpLayer *layer,
gboolean antialias)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -475,13 +429,9 @@ gimp_text_layer_set_antialias (GimpLayer *layer,
G_TYPE_BOOLEAN, antialias,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-text-layer-set-antialias",
args);
else
return_vals = gimp_run_procedure_array ("gimp-text-layer-set-antialias",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -508,7 +458,6 @@ gimp_text_layer_set_antialias (GimpLayer *layer,
GimpTextHintStyle
gimp_text_layer_get_hint_style (GimpLayer *layer)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpTextHintStyle style = 0;
@ -517,13 +466,9 @@ gimp_text_layer_get_hint_style (GimpLayer *layer)
GIMP_TYPE_LAYER, layer,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-text-layer-get-hint-style",
args);
else
return_vals = gimp_run_procedure_array ("gimp-text-layer-get-hint-style",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -553,7 +498,6 @@ gboolean
gimp_text_layer_set_hint_style (GimpLayer *layer,
GimpTextHintStyle style)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -563,13 +507,9 @@ gimp_text_layer_set_hint_style (GimpLayer *layer,
GIMP_TYPE_TEXT_HINT_STYLE, style,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-text-layer-set-hint-style",
args);
else
return_vals = gimp_run_procedure_array ("gimp-text-layer-set-hint-style",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -595,7 +535,6 @@ gimp_text_layer_set_hint_style (GimpLayer *layer,
gboolean
gimp_text_layer_get_kerning (GimpLayer *layer)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean kerning = FALSE;
@ -604,13 +543,9 @@ gimp_text_layer_get_kerning (GimpLayer *layer)
GIMP_TYPE_LAYER, layer,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-text-layer-get-kerning",
args);
else
return_vals = gimp_run_procedure_array ("gimp-text-layer-get-kerning",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -638,7 +573,6 @@ gboolean
gimp_text_layer_set_kerning (GimpLayer *layer,
gboolean kerning)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -648,13 +582,9 @@ gimp_text_layer_set_kerning (GimpLayer *layer,
G_TYPE_BOOLEAN, kerning,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-text-layer-set-kerning",
args);
else
return_vals = gimp_run_procedure_array ("gimp-text-layer-set-kerning",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -681,7 +611,6 @@ gimp_text_layer_set_kerning (GimpLayer *layer,
gchar *
gimp_text_layer_get_language (GimpLayer *layer)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *language = NULL;
@ -690,13 +619,9 @@ gimp_text_layer_get_language (GimpLayer *layer)
GIMP_TYPE_LAYER, layer,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-text-layer-get-language",
args);
else
return_vals = gimp_run_procedure_array ("gimp-text-layer-get-language",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -725,7 +650,6 @@ gboolean
gimp_text_layer_set_language (GimpLayer *layer,
const gchar *language)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -735,13 +659,9 @@ gimp_text_layer_set_language (GimpLayer *layer,
G_TYPE_STRING, language,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-text-layer-set-language",
args);
else
return_vals = gimp_run_procedure_array ("gimp-text-layer-set-language",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -767,7 +687,6 @@ gimp_text_layer_set_language (GimpLayer *layer,
GimpTextDirection
gimp_text_layer_get_base_direction (GimpLayer *layer)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpTextDirection direction = 0;
@ -776,13 +695,9 @@ gimp_text_layer_get_base_direction (GimpLayer *layer)
GIMP_TYPE_LAYER, layer,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-text-layer-get-base-direction",
args);
else
return_vals = gimp_run_procedure_array ("gimp-text-layer-get-base-direction",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -811,7 +726,6 @@ gboolean
gimp_text_layer_set_base_direction (GimpLayer *layer,
GimpTextDirection direction)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -821,13 +735,9 @@ gimp_text_layer_set_base_direction (GimpLayer *layer,
GIMP_TYPE_TEXT_DIRECTION, direction,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-text-layer-set-base-direction",
args);
else
return_vals = gimp_run_procedure_array ("gimp-text-layer-set-base-direction",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -853,7 +763,6 @@ gimp_text_layer_set_base_direction (GimpLayer *layer,
GimpTextJustification
gimp_text_layer_get_justification (GimpLayer *layer)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpTextJustification justify = 0;
@ -862,13 +771,9 @@ gimp_text_layer_get_justification (GimpLayer *layer)
GIMP_TYPE_LAYER, layer,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-text-layer-get-justification",
args);
else
return_vals = gimp_run_procedure_array ("gimp-text-layer-get-justification",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -897,7 +802,6 @@ gboolean
gimp_text_layer_set_justification (GimpLayer *layer,
GimpTextJustification justify)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -907,13 +811,9 @@ gimp_text_layer_set_justification (GimpLayer *layer,
GIMP_TYPE_TEXT_JUSTIFICATION, justify,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-text-layer-set-justification",
args);
else
return_vals = gimp_run_procedure_array ("gimp-text-layer-set-justification",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -940,7 +840,6 @@ gboolean
gimp_text_layer_get_color (GimpLayer *layer,
GimpRGB *color)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -949,13 +848,9 @@ gimp_text_layer_get_color (GimpLayer *layer,
GIMP_TYPE_LAYER, layer,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-text-layer-get-color",
args);
else
return_vals = gimp_run_procedure_array ("gimp-text-layer-get-color",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -985,7 +880,6 @@ gboolean
gimp_text_layer_set_color (GimpLayer *layer,
const GimpRGB *color)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -995,13 +889,9 @@ gimp_text_layer_set_color (GimpLayer *layer,
GIMP_TYPE_RGB, color,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-text-layer-set-color",
args);
else
return_vals = gimp_run_procedure_array ("gimp-text-layer-set-color",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -1027,7 +917,6 @@ gimp_text_layer_set_color (GimpLayer *layer,
gdouble
gimp_text_layer_get_indent (GimpLayer *layer)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble indent = 0.0;
@ -1036,13 +925,9 @@ gimp_text_layer_get_indent (GimpLayer *layer)
GIMP_TYPE_LAYER, layer,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-text-layer-get-indent",
args);
else
return_vals = gimp_run_procedure_array ("gimp-text-layer-get-indent",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -1071,7 +956,6 @@ gboolean
gimp_text_layer_set_indent (GimpLayer *layer,
gdouble indent)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -1081,13 +965,9 @@ gimp_text_layer_set_indent (GimpLayer *layer,
G_TYPE_DOUBLE, indent,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-text-layer-set-indent",
args);
else
return_vals = gimp_run_procedure_array ("gimp-text-layer-set-indent",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -1113,7 +993,6 @@ gimp_text_layer_set_indent (GimpLayer *layer,
gdouble
gimp_text_layer_get_line_spacing (GimpLayer *layer)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble line_spacing = 0.0;
@ -1122,13 +1001,9 @@ gimp_text_layer_get_line_spacing (GimpLayer *layer)
GIMP_TYPE_LAYER, layer,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-text-layer-get-line-spacing",
args);
else
return_vals = gimp_run_procedure_array ("gimp-text-layer-get-line-spacing",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -1157,7 +1032,6 @@ gboolean
gimp_text_layer_set_line_spacing (GimpLayer *layer,
gdouble line_spacing)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -1167,13 +1041,9 @@ gimp_text_layer_set_line_spacing (GimpLayer *layer,
G_TYPE_DOUBLE, line_spacing,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-text-layer-set-line-spacing",
args);
else
return_vals = gimp_run_procedure_array ("gimp-text-layer-set-line-spacing",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -1199,7 +1069,6 @@ gimp_text_layer_set_line_spacing (GimpLayer *layer,
gdouble
gimp_text_layer_get_letter_spacing (GimpLayer *layer)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble letter_spacing = 0.0;
@ -1208,13 +1077,9 @@ gimp_text_layer_get_letter_spacing (GimpLayer *layer)
GIMP_TYPE_LAYER, layer,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-text-layer-get-letter-spacing",
args);
else
return_vals = gimp_run_procedure_array ("gimp-text-layer-get-letter-spacing",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -1243,7 +1108,6 @@ gboolean
gimp_text_layer_set_letter_spacing (GimpLayer *layer,
gdouble letter_spacing)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -1253,13 +1117,9 @@ gimp_text_layer_set_letter_spacing (GimpLayer *layer,
G_TYPE_DOUBLE, letter_spacing,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-text-layer-set-letter-spacing",
args);
else
return_vals = gimp_run_procedure_array ("gimp-text-layer-set-letter-spacing",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -1290,7 +1150,6 @@ gimp_text_layer_resize (GimpLayer *layer,
gdouble width,
gdouble height)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -1301,13 +1160,9 @@ gimp_text_layer_resize (GimpLayer *layer,
G_TYPE_DOUBLE, height,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-text-layer-resize",
args);
else
return_vals = gimp_run_procedure_array ("gimp-text-layer-resize",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;

22
libgimp/gimptexttool_pdb.c
View File

@ -79,7 +79,6 @@ gimp_text_fontname (GimpImage *image,
GimpSizeType size_type,
const gchar *fontname)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpLayer *text_layer = NULL;
@ -97,13 +96,9 @@ gimp_text_fontname (GimpImage *image,
G_TYPE_STRING, fontname,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-text-fontname",
args);
else
return_vals = gimp_run_procedure_array ("gimp-text-fontname",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-text-fontname",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -147,7 +142,6 @@ 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;
@ -159,13 +153,9 @@ gimp_text_get_extents_fontname (const gchar *text,
G_TYPE_STRING, fontname,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-text-get-extents-fontname",
args);
else
return_vals = gimp_run_procedure_array ("gimp-text-get-extents-fontname",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-text-get-extents-fontname",
args);
gimp_value_array_unref (args);
*width = 0;

74
libgimp/gimptilebackendplugin.c
View File

@ -30,7 +30,6 @@
#include "libgimpbase/gimpwire.h"
#include "gimp-shm.h"
#include "gimplegacy-private.h"
#include "gimpplugin-private.h"
#include "gimptilebackendplugin.h"
@ -97,9 +96,6 @@ G_DEFINE_TYPE_WITH_PRIVATE (GimpTileBackendPlugin, _gimp_tile_backend_plugin,
#define parent_class _gimp_tile_backend_plugin_parent_class
extern GIOChannel *_gimp_readchannel;
extern GIOChannel *_gimp_writechannel;
static GMutex backend_plugin_mutex;
@ -351,22 +347,11 @@ gimp_tile_get (GimpTileBackendPlugin *backend_plugin,
tile_req.tile_num = tile->tile_num;
tile_req.shadow = priv->shadow;
if (! gp_tile_req_write (_gimp_plug_in_get_write_channel (plug_in),
&tile_req, plug_in))
gimp_quit ();
if (plug_in)
{
if (! gp_tile_req_write (_gimp_plug_in_get_write_channel (plug_in),
&tile_req, plug_in))
gimp_quit ();
_gimp_plug_in_read_expect_msg (plug_in, &msg, GP_TILE_DATA);
}
else
{
if (! gp_tile_req_write (_gimp_writechannel, &tile_req, NULL))
gimp_quit ();
_gimp_legacy_read_expect_msg (&msg, GP_TILE_DATA);
}
_gimp_plug_in_read_expect_msg (plug_in, &msg, GP_TILE_DATA);
tile_data = msg.data;
if (tile_data->drawable_id != priv->drawable_id ||
@ -407,17 +392,9 @@ gimp_tile_get (GimpTileBackendPlugin *backend_plugin,
tile_data->data = NULL;
}
if (plug_in)
{
if (! gp_tile_ack_write (_gimp_plug_in_get_write_channel (plug_in),
plug_in))
gimp_quit ();
}
else
{
if (! gp_tile_ack_write (_gimp_writechannel, NULL))
gimp_quit ();
}
if (! gp_tile_ack_write (_gimp_plug_in_get_write_channel (plug_in),
plug_in))
gimp_quit ();
gimp_wire_destroy (&msg);
}
@ -437,21 +414,11 @@ gimp_tile_put (GimpTileBackendPlugin *backend_plugin,
tile_req.tile_num = 0;
tile_req.shadow = 0;
if (plug_in)
{
if (! gp_tile_req_write (_gimp_plug_in_get_write_channel (plug_in),
&tile_req, plug_in))
gimp_quit ();
if (! gp_tile_req_write (_gimp_plug_in_get_write_channel (plug_in),
&tile_req, plug_in))
gimp_quit ();
_gimp_plug_in_read_expect_msg (plug_in, &msg, GP_TILE_DATA);
}
else
{
if (! gp_tile_req_write (_gimp_writechannel, &tile_req, NULL))
gimp_quit ();
_gimp_legacy_read_expect_msg (&msg, GP_TILE_DATA);
}
_gimp_plug_in_read_expect_msg (plug_in, &msg, GP_TILE_DATA);
tile_info = msg.data;
@ -475,27 +442,16 @@ gimp_tile_put (GimpTileBackendPlugin *backend_plugin,
tile_data.data = tile->data;
}
if (plug_in)
{
if (! gp_tile_data_write (_gimp_plug_in_get_write_channel (plug_in),
&tile_data, plug_in))
gimp_quit ();
}
else
{
if (! gp_tile_data_write (_gimp_writechannel, &tile_data, NULL))
gimp_quit ();
}
if (! gp_tile_data_write (_gimp_plug_in_get_write_channel (plug_in),
&tile_data, plug_in))
gimp_quit ();
if (! tile_info->use_shm)
tile_data.data = NULL;
gimp_wire_destroy (&msg);
if (plug_in)
_gimp_plug_in_read_expect_msg (plug_in, &msg, GP_TILE_ACK);
else
_gimp_legacy_read_expect_msg (&msg, GP_TILE_ACK);
_gimp_plug_in_read_expect_msg (plug_in, &msg, GP_TILE_ACK);
gimp_wire_destroy (&msg);
}

5
libgimp/gimptypes.h
View File

@ -32,11 +32,6 @@ typedef struct _GimpPDB GimpPDB;
typedef struct _GimpPlugIn GimpPlugIn;
typedef struct _GimpProcedure GimpProcedure;
typedef struct _GimpPlugInInfo GimpPlugInInfo;
typedef struct _GimpParamDef GimpParamDef;
typedef union _GimpParamData GimpParamData;
typedef struct _GimpParam GimpParam;
typedef struct _GimpImage GimpImage;
typedef struct _GimpItem GimpItem;
typedef struct _GimpDrawable GimpDrawable;

132
libgimp/gimpunit_pdb.c
View File

@ -37,7 +37,6 @@
gint
_gimp_unit_get_number_of_units (void)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint num_units = GIMP_UNIT_END;
@ -45,13 +44,9 @@ _gimp_unit_get_number_of_units (void)
args = gimp_value_array_new_from_types (NULL,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-unit-get-number-of-units",
args);
else
return_vals = gimp_run_procedure_array ("gimp-unit-get-number-of-units",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -74,7 +69,6 @@ _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;
@ -82,13 +76,9 @@ _gimp_unit_get_number_of_built_in_units (void)
args = gimp_value_array_new_from_types (NULL,
G_TYPE_NONE);
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_array ("gimp-unit-get-number-of-built-in-units",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -127,7 +117,6 @@ _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;
@ -142,13 +131,9 @@ _gimp_unit_new (const gchar *identifier,
G_TYPE_STRING, plural,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-unit-new",
args);
else
return_vals = gimp_run_procedure_array ("gimp-unit-new",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-unit-new",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -174,7 +159,6 @@ _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;
@ -183,13 +167,9 @@ _gimp_unit_get_deletion_flag (GimpUnit unit_id)
GIMP_TYPE_UNIT, unit_id,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-unit-get-deletion-flag",
args);
else
return_vals = gimp_run_procedure_array ("gimp-unit-get-deletion-flag",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -217,7 +197,6 @@ 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;
@ -227,13 +206,9 @@ _gimp_unit_set_deletion_flag (GimpUnit unit_id,
G_TYPE_BOOLEAN, deletion_flag,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-unit-set-deletion-flag",
args);
else
return_vals = gimp_run_procedure_array ("gimp-unit-set-deletion-flag",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -259,7 +234,6 @@ _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;
@ -268,13 +242,9 @@ _gimp_unit_get_identifier (GimpUnit unit_id)
GIMP_TYPE_UNIT, unit_id,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-unit-get-identifier",
args);
else
return_vals = gimp_run_procedure_array ("gimp-unit-get-identifier",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -300,7 +270,6 @@ _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;
@ -309,13 +278,9 @@ _gimp_unit_get_factor (GimpUnit unit_id)
GIMP_TYPE_UNIT, unit_id,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-unit-get-factor",
args);
else
return_vals = gimp_run_procedure_array ("gimp-unit-get-factor",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -342,7 +307,6 @@ _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;
@ -351,13 +315,9 @@ _gimp_unit_get_digits (GimpUnit unit_id)
GIMP_TYPE_UNIT, unit_id,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-unit-get-digits",
args);
else
return_vals = gimp_run_procedure_array ("gimp-unit-get-digits",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -382,7 +342,6 @@ _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;
@ -391,13 +350,9 @@ _gimp_unit_get_symbol (GimpUnit unit_id)
GIMP_TYPE_UNIT, unit_id,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-unit-get-symbol",
args);
else
return_vals = gimp_run_procedure_array ("gimp-unit-get-symbol",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -423,7 +378,6 @@ _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;
@ -432,13 +386,9 @@ _gimp_unit_get_abbreviation (GimpUnit unit_id)
GIMP_TYPE_UNIT, unit_id,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-unit-get-abbreviation",
args);
else
return_vals = gimp_run_procedure_array ("gimp-unit-get-abbreviation",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -463,7 +413,6 @@ _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;
@ -472,13 +421,9 @@ _gimp_unit_get_singular (GimpUnit unit_id)
GIMP_TYPE_UNIT, unit_id,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-unit-get-singular",
args);
else
return_vals = gimp_run_procedure_array ("gimp-unit-get-singular",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -503,7 +448,6 @@ _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;
@ -512,13 +456,9 @@ _gimp_unit_get_plural (GimpUnit unit_id)
GIMP_TYPE_UNIT, unit_id,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-unit-get-plural",
args);
else
return_vals = gimp_run_procedure_array ("gimp-unit-get-plural",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)

275
libgimp/gimpvectors_pdb.c
View File

@ -53,7 +53,6 @@ GimpVectors *
gimp_vectors_new (GimpImage *image,
const gchar *name)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpVectors *vectors = NULL;
@ -63,13 +62,9 @@ gimp_vectors_new (GimpImage *image,
G_TYPE_STRING, name,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-vectors-new",
args);
else
return_vals = gimp_run_procedure_array ("gimp-vectors-new",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-vectors-new",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -98,7 +93,6 @@ GimpVectors *
gimp_vectors_new_from_text_layer (GimpImage *image,
GimpLayer *layer)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpVectors *vectors = NULL;
@ -108,13 +102,9 @@ gimp_vectors_new_from_text_layer (GimpImage *image,
GIMP_TYPE_LAYER, layer,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-vectors-new-from-text-layer",
args);
else
return_vals = gimp_run_procedure_array ("gimp-vectors-new-from-text-layer",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -141,7 +131,6 @@ gimp_vectors_new_from_text_layer (GimpImage *image,
GimpVectors *
gimp_vectors_copy (GimpVectors *vectors)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpVectors *vectors_copy = NULL;
@ -150,13 +139,9 @@ gimp_vectors_copy (GimpVectors *vectors)
GIMP_TYPE_VECTORS, vectors,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-vectors-copy",
args);
else
return_vals = gimp_run_procedure_array ("gimp-vectors-copy",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-vectors-copy",
args);
gimp_value_array_unref (args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) == GIMP_PDB_SUCCESS)
@ -187,7 +172,6 @@ gint *
gimp_vectors_get_strokes (GimpVectors *vectors,
gint *num_strokes)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint *stroke_ids = NULL;
@ -196,13 +180,9 @@ gimp_vectors_get_strokes (GimpVectors *vectors,
GIMP_TYPE_VECTORS, vectors,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-vectors-get-strokes",
args);
else
return_vals = gimp_run_procedure_array ("gimp-vectors-get-strokes",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-vectors-get-strokes",
args);
gimp_value_array_unref (args);
*num_strokes = 0;
@ -237,7 +217,6 @@ gimp_vectors_stroke_get_length (GimpVectors *vectors,
gint stroke_id,
gdouble precision)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble length = 0.0;
@ -248,13 +227,9 @@ gimp_vectors_stroke_get_length (GimpVectors *vectors,
G_TYPE_DOUBLE, precision,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-vectors-stroke-get-length",
args);
else
return_vals = gimp_run_procedure_array ("gimp-vectors-stroke-get-length",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -299,7 +274,6 @@ gimp_vectors_stroke_get_point_at_dist (GimpVectors *vectors,
gdouble *slope,
gboolean *valid)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -311,13 +285,9 @@ gimp_vectors_stroke_get_point_at_dist (GimpVectors *vectors,
G_TYPE_DOUBLE, precision,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-vectors-stroke-get-point-at-dist",
args);
else
return_vals = gimp_run_procedure_array ("gimp-vectors-stroke-get-point-at-dist",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-vectors-stroke-get-point-at-dist",
args);
gimp_value_array_unref (args);
*x_point = 0.0;
@ -357,7 +327,6 @@ gboolean
gimp_vectors_remove_stroke (GimpVectors *vectors,
gint stroke_id)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -367,13 +336,9 @@ gimp_vectors_remove_stroke (GimpVectors *vectors,
G_TYPE_INT, stroke_id,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-vectors-remove-stroke",
args);
else
return_vals = gimp_run_procedure_array ("gimp-vectors-remove-stroke",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -400,7 +365,6 @@ gboolean
gimp_vectors_stroke_close (GimpVectors *vectors,
gint stroke_id)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -410,13 +374,9 @@ gimp_vectors_stroke_close (GimpVectors *vectors,
G_TYPE_INT, stroke_id,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-vectors-stroke-close",
args);
else
return_vals = gimp_run_procedure_array ("gimp-vectors-stroke-close",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -447,7 +407,6 @@ gimp_vectors_stroke_translate (GimpVectors *vectors,
gint off_x,
gint off_y)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -459,13 +418,9 @@ gimp_vectors_stroke_translate (GimpVectors *vectors,
G_TYPE_INT, off_y,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-vectors-stroke-translate",
args);
else
return_vals = gimp_run_procedure_array ("gimp-vectors-stroke-translate",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -496,7 +451,6 @@ gimp_vectors_stroke_scale (GimpVectors *vectors,
gdouble scale_x,
gdouble scale_y)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -508,13 +462,9 @@ gimp_vectors_stroke_scale (GimpVectors *vectors,
G_TYPE_DOUBLE, scale_y,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-vectors-stroke-scale",
args);
else
return_vals = gimp_run_procedure_array ("gimp-vectors-stroke-scale",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -547,7 +497,6 @@ gimp_vectors_stroke_rotate (GimpVectors *vectors,
gdouble center_y,
gdouble angle)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -560,13 +509,9 @@ gimp_vectors_stroke_rotate (GimpVectors *vectors,
G_TYPE_DOUBLE, angle,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-vectors-stroke-rotate",
args);
else
return_vals = gimp_run_procedure_array ("gimp-vectors-stroke-rotate",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -597,7 +542,6 @@ gimp_vectors_stroke_flip (GimpVectors *vectors,
GimpOrientationType flip_type,
gdouble axis)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -609,13 +553,9 @@ gimp_vectors_stroke_flip (GimpVectors *vectors,
G_TYPE_DOUBLE, axis,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-vectors-stroke-flip",
args);
else
return_vals = gimp_run_procedure_array ("gimp-vectors-stroke-flip",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -652,7 +592,6 @@ gimp_vectors_stroke_flip_free (GimpVectors *vectors,
gdouble x2,
gdouble y2)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -666,13 +605,9 @@ gimp_vectors_stroke_flip_free (GimpVectors *vectors,
G_TYPE_DOUBLE, y2,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-vectors-stroke-flip-free",
args);
else
return_vals = gimp_run_procedure_array ("gimp-vectors-stroke-flip-free",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -708,7 +643,6 @@ gimp_vectors_stroke_get_points (GimpVectors *vectors,
gdouble **controlpoints,
gboolean *closed)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
GimpVectorsStrokeType type = 0;
@ -718,13 +652,9 @@ gimp_vectors_stroke_get_points (GimpVectors *vectors,
G_TYPE_INT, stroke_id,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-vectors-stroke-get-points",
args);
else
return_vals = gimp_run_procedure_array ("gimp-vectors-stroke-get-points",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-vectors-stroke-get-points",
args);
gimp_value_array_unref (args);
*num_points = 0;
@ -772,7 +702,6 @@ gimp_vectors_stroke_new_from_points (GimpVectors *vectors,
const gdouble *controlpoints,
gboolean closed)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint stroke_id = 0;
@ -786,13 +715,9 @@ gimp_vectors_stroke_new_from_points (GimpVectors *vectors,
G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 3), controlpoints, num_points);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-vectors-stroke-new-from-points",
args);
else
return_vals = gimp_run_procedure_array ("gimp-vectors-stroke-new-from-points",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -828,7 +753,6 @@ gimp_vectors_stroke_interpolate (GimpVectors *vectors,
gint *num_coords,
gboolean *closed)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble *coords = NULL;
@ -839,13 +763,9 @@ gimp_vectors_stroke_interpolate (GimpVectors *vectors,
G_TYPE_DOUBLE, precision,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-vectors-stroke-interpolate",
args);
else
return_vals = gimp_run_procedure_array ("gimp-vectors-stroke-interpolate",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-vectors-stroke-interpolate",
args);
gimp_value_array_unref (args);
*num_coords = 0;
@ -881,7 +801,6 @@ gimp_vectors_bezier_stroke_new_moveto (GimpVectors *vectors,
gdouble x0,
gdouble y0)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint stroke_id = 0;
@ -892,13 +811,9 @@ gimp_vectors_bezier_stroke_new_moveto (GimpVectors *vectors,
G_TYPE_DOUBLE, y0,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-vectors-bezier-stroke-new-moveto",
args);
else
return_vals = gimp_run_procedure_array ("gimp-vectors-bezier-stroke-new-moveto",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -930,7 +845,6 @@ gimp_vectors_bezier_stroke_lineto (GimpVectors *vectors,
gdouble x0,
gdouble y0)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -942,13 +856,9 @@ gimp_vectors_bezier_stroke_lineto (GimpVectors *vectors,
G_TYPE_DOUBLE, y0,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-vectors-bezier-stroke-lineto",
args);
else
return_vals = gimp_run_procedure_array ("gimp-vectors-bezier-stroke-lineto",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -985,7 +895,6 @@ gimp_vectors_bezier_stroke_conicto (GimpVectors *vectors,
gdouble x1,
gdouble y1)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -999,13 +908,9 @@ gimp_vectors_bezier_stroke_conicto (GimpVectors *vectors,
G_TYPE_DOUBLE, y1,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-vectors-bezier-stroke-conicto",
args);
else
return_vals = gimp_run_procedure_array ("gimp-vectors-bezier-stroke-conicto",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -1044,7 +949,6 @@ gimp_vectors_bezier_stroke_cubicto (GimpVectors *vectors,
gdouble x2,
gdouble y2)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -1060,13 +964,9 @@ gimp_vectors_bezier_stroke_cubicto (GimpVectors *vectors,
G_TYPE_DOUBLE, y2,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-vectors-bezier-stroke-cubicto",
args);
else
return_vals = gimp_run_procedure_array ("gimp-vectors-bezier-stroke-cubicto",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -1101,7 +1001,6 @@ gimp_vectors_bezier_stroke_new_ellipse (GimpVectors *vectors,
gdouble radius_y,
gdouble angle)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gint stroke_id = 0;
@ -1115,13 +1014,9 @@ gimp_vectors_bezier_stroke_new_ellipse (GimpVectors *vectors,
G_TYPE_DOUBLE, angle,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-vectors-bezier-stroke-new-ellipse",
args);
else
return_vals = gimp_run_procedure_array ("gimp-vectors-bezier-stroke-new-ellipse",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)
@ -1158,7 +1053,6 @@ gimp_vectors_import_from_file (GimpImage *image,
gint *num_vectors,
gint **vectors_ids)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -1170,13 +1064,9 @@ gimp_vectors_import_from_file (GimpImage *image,
G_TYPE_BOOLEAN, scale,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-vectors-import-from-file",
args);
else
return_vals = gimp_run_procedure_array ("gimp-vectors-import-from-file",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-vectors-import-from-file",
args);
gimp_value_array_unref (args);
*num_vectors = 0;
@ -1224,7 +1114,6 @@ gimp_vectors_import_from_string (GimpImage *image,
gint *num_vectors,
gint **vectors_ids)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -1237,13 +1126,9 @@ gimp_vectors_import_from_string (GimpImage *image,
G_TYPE_BOOLEAN, scale,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-vectors-import-from-string",
args);
else
return_vals = gimp_run_procedure_array ("gimp-vectors-import-from-string",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-vectors-import-from-string",
args);
gimp_value_array_unref (args);
*num_vectors = 0;
@ -1284,7 +1169,6 @@ gimp_vectors_export_to_file (GimpImage *image,
const gchar *filename,
GimpVectors *vectors)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
@ -1295,13 +1179,9 @@ gimp_vectors_export_to_file (GimpImage *image,
GIMP_TYPE_VECTORS, vectors,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-vectors-export-to-file",
args);
else
return_vals = gimp_run_procedure_array ("gimp-vectors-export-to-file",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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;
@ -1333,7 +1213,6 @@ gchar *
gimp_vectors_export_to_string (GimpImage *image,
GimpVectors *vectors)
{
GimpPDB *pdb = gimp_get_pdb ();
GimpValueArray *args;
GimpValueArray *return_vals;
gchar *string = NULL;
@ -1343,13 +1222,9 @@ gimp_vectors_export_to_string (GimpImage *image,
GIMP_TYPE_VECTORS, vectors,
G_TYPE_NONE);
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-vectors-export-to-string",
args);
else
return_vals = gimp_run_procedure_array ("gimp-vectors-export-to-string",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"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)

1
libgimpbase/gimpbase.def
View File

@ -143,7 +143,6 @@ EXPORTS
gimp_path_get_user_writable_dir
gimp_path_parse
gimp_path_to_str
gimp_pdb_arg_type_get_type
gimp_pdb_error_handler_get_type
gimp_pdb_proc_type_get_type
gimp_pdb_status_type_get_type

72
libgimpbase/gimpbaseenums.c
View File

@ -1238,78 +1238,6 @@ gimp_paint_application_mode_get_type (void)
return type;
}
GType
gimp_pdb_arg_type_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_PDB_INT32, "GIMP_PDB_INT32", "int32" },
{ GIMP_PDB_INT16, "GIMP_PDB_INT16", "int16" },
{ GIMP_PDB_INT8, "GIMP_PDB_INT8", "int8" },
{ GIMP_PDB_FLOAT, "GIMP_PDB_FLOAT", "float" },
{ GIMP_PDB_STRING, "GIMP_PDB_STRING", "string" },
{ GIMP_PDB_INT32ARRAY, "GIMP_PDB_INT32ARRAY", "int32array" },
{ GIMP_PDB_INT16ARRAY, "GIMP_PDB_INT16ARRAY", "int16array" },
{ GIMP_PDB_INT8ARRAY, "GIMP_PDB_INT8ARRAY", "int8array" },
{ GIMP_PDB_FLOATARRAY, "GIMP_PDB_FLOATARRAY", "floatarray" },
{ GIMP_PDB_STRINGARRAY, "GIMP_PDB_STRINGARRAY", "stringarray" },
{ GIMP_PDB_COLOR, "GIMP_PDB_COLOR", "color" },
{ GIMP_PDB_ITEM, "GIMP_PDB_ITEM", "item" },
{ GIMP_PDB_DISPLAY, "GIMP_PDB_DISPLAY", "display" },
{ GIMP_PDB_IMAGE, "GIMP_PDB_IMAGE", "image" },
{ GIMP_PDB_LAYER, "GIMP_PDB_LAYER", "layer" },
{ GIMP_PDB_CHANNEL, "GIMP_PDB_CHANNEL", "channel" },
{ GIMP_PDB_DRAWABLE, "GIMP_PDB_DRAWABLE", "drawable" },
{ GIMP_PDB_SELECTION, "GIMP_PDB_SELECTION", "selection" },
{ GIMP_PDB_COLORARRAY, "GIMP_PDB_COLORARRAY", "colorarray" },
{ GIMP_PDB_VECTORS, "GIMP_PDB_VECTORS", "vectors" },
{ GIMP_PDB_PARASITE, "GIMP_PDB_PARASITE", "parasite" },
{ GIMP_PDB_STATUS, "GIMP_PDB_STATUS", "status" },
{ GIMP_PDB_END, "GIMP_PDB_END", "end" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_PDB_INT32, "GIMP_PDB_INT32", NULL },
{ GIMP_PDB_INT16, "GIMP_PDB_INT16", NULL },
{ GIMP_PDB_INT8, "GIMP_PDB_INT8", NULL },
{ GIMP_PDB_FLOAT, "GIMP_PDB_FLOAT", NULL },
{ GIMP_PDB_STRING, "GIMP_PDB_STRING", NULL },
{ GIMP_PDB_INT32ARRAY, "GIMP_PDB_INT32ARRAY", NULL },
{ GIMP_PDB_INT16ARRAY, "GIMP_PDB_INT16ARRAY", NULL },
{ GIMP_PDB_INT8ARRAY, "GIMP_PDB_INT8ARRAY", NULL },
{ GIMP_PDB_FLOATARRAY, "GIMP_PDB_FLOATARRAY", NULL },
{ GIMP_PDB_STRINGARRAY, "GIMP_PDB_STRINGARRAY", NULL },
{ GIMP_PDB_COLOR, "GIMP_PDB_COLOR", NULL },
{ GIMP_PDB_ITEM, "GIMP_PDB_ITEM", NULL },
{ GIMP_PDB_DISPLAY, "GIMP_PDB_DISPLAY", NULL },
{ GIMP_PDB_IMAGE, "GIMP_PDB_IMAGE", NULL },
{ GIMP_PDB_LAYER, "GIMP_PDB_LAYER", NULL },
{ GIMP_PDB_CHANNEL, "GIMP_PDB_CHANNEL", NULL },
{ GIMP_PDB_DRAWABLE, "GIMP_PDB_DRAWABLE", NULL },
{ GIMP_PDB_SELECTION, "GIMP_PDB_SELECTION", NULL },
{ GIMP_PDB_COLORARRAY, "GIMP_PDB_COLORARRAY", NULL },
{ GIMP_PDB_VECTORS, "GIMP_PDB_VECTORS", NULL },
{ GIMP_PDB_PARASITE, "GIMP_PDB_PARASITE", NULL },
{ GIMP_PDB_STATUS, "GIMP_PDB_STATUS", NULL },
{ GIMP_PDB_END, "GIMP_PDB_END", NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (G_UNLIKELY (! type))
{
type = g_enum_register_static ("GimpPDBArgType", values);
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
gimp_type_set_translation_context (type, "pdb-arg-type");
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
GType
gimp_pdb_error_handler_get_type (void)
{

60
libgimpbase/gimpbaseenums.h
View File

@ -828,66 +828,6 @@ typedef enum
} GimpPaintApplicationMode;
/**
* GimpPDBArgType:
* @GIMP_PDB_INT32: 32-bit integer
* @GIMP_PDB_INT16: 16-bit integer
* @GIMP_PDB_INT8: 8-bit integer
* @GIMP_PDB_FLOAT: Float
* @GIMP_PDB_STRING: String
* @GIMP_PDB_INT32ARRAY: Array of INT32
* @GIMP_PDB_INT16ARRAY: Array of INT16
* @GIMP_PDB_INT8ARRAY: Array of INT8
* @GIMP_PDB_FLOATARRAY: Array of floats
* @GIMP_PDB_STRINGARRAY: Array of strings
* @GIMP_PDB_COLOR: Color
* @GIMP_PDB_ITEM: Item ID
* @GIMP_PDB_DISPLAY: Display ID
* @GIMP_PDB_IMAGE: Image ID
* @GIMP_PDB_LAYER: Layer ID
* @GIMP_PDB_CHANNEL: Channel ID
* @GIMP_PDB_DRAWABLE: Drawable ID
* @GIMP_PDB_SELECTION: Selection ID
* @GIMP_PDB_COLORARRAY: Array of colors
* @GIMP_PDB_VECTORS: Vectors (psath) ID
* @GIMP_PDB_PARASITE: Parasite
* @GIMP_PDB_STATUS: Procedure return status
* @GIMP_PDB_END: Marker for last enum value
*
* Parameter types of the PDB.
**/
#define GIMP_TYPE_PDB_ARG_TYPE (gimp_pdb_arg_type_get_type ())
GType gimp_pdb_arg_type_get_type (void) G_GNUC_CONST;
typedef enum
{
GIMP_PDB_INT32,
GIMP_PDB_INT16,
GIMP_PDB_INT8,
GIMP_PDB_FLOAT,
GIMP_PDB_STRING,
GIMP_PDB_INT32ARRAY,
GIMP_PDB_INT16ARRAY,
GIMP_PDB_INT8ARRAY,
GIMP_PDB_FLOATARRAY,
GIMP_PDB_STRINGARRAY,
GIMP_PDB_COLOR,
GIMP_PDB_ITEM,
GIMP_PDB_DISPLAY,
GIMP_PDB_IMAGE,
GIMP_PDB_LAYER,
GIMP_PDB_CHANNEL,
GIMP_PDB_DRAWABLE,
GIMP_PDB_SELECTION,
GIMP_PDB_COLORARRAY,
GIMP_PDB_VECTORS,
GIMP_PDB_PARASITE,
GIMP_PDB_STATUS,
GIMP_PDB_END
} GimpPDBArgType;
/**
* GimpPDBErrorHandler:
* @GIMP_PDB_ERROR_HANDLER_INTERNAL: Internal

36
pdb/enums.pl
View File

@ -391,42 +391,6 @@ package Gimp::CodeGen::enums;
mapping => { GIMP_PAINT_CONSTANT => '0',
GIMP_PAINT_INCREMENTAL => '1' }
},
GimpPDBArgType =>
{ contig => 1,
header => 'libgimpbase/gimpbaseenums.h',
symbols => [ qw(GIMP_PDB_INT32 GIMP_PDB_INT16 GIMP_PDB_INT8
GIMP_PDB_FLOAT GIMP_PDB_STRING GIMP_PDB_INT32ARRAY
GIMP_PDB_INT16ARRAY GIMP_PDB_INT8ARRAY
GIMP_PDB_FLOATARRAY GIMP_PDB_STRINGARRAY
GIMP_PDB_COLOR GIMP_PDB_ITEM GIMP_PDB_DISPLAY
GIMP_PDB_IMAGE GIMP_PDB_LAYER GIMP_PDB_CHANNEL
GIMP_PDB_DRAWABLE GIMP_PDB_SELECTION
GIMP_PDB_COLORARRAY GIMP_PDB_VECTORS
GIMP_PDB_PARASITE GIMP_PDB_STATUS GIMP_PDB_END) ],
mapping => { GIMP_PDB_INT32 => '0',
GIMP_PDB_INT16 => '1',
GIMP_PDB_INT8 => '2',
GIMP_PDB_FLOAT => '3',
GIMP_PDB_STRING => '4',
GIMP_PDB_INT32ARRAY => '5',
GIMP_PDB_INT16ARRAY => '6',
GIMP_PDB_INT8ARRAY => '7',
GIMP_PDB_FLOATARRAY => '8',
GIMP_PDB_STRINGARRAY => '9',
GIMP_PDB_COLOR => '10',
GIMP_PDB_ITEM => '11',
GIMP_PDB_DISPLAY => '12',
GIMP_PDB_IMAGE => '13',
GIMP_PDB_LAYER => '14',
GIMP_PDB_CHANNEL => '15',
GIMP_PDB_DRAWABLE => '16',
GIMP_PDB_SELECTION => '17',
GIMP_PDB_COLORARRAY => '18',
GIMP_PDB_VECTORS => '19',
GIMP_PDB_PARASITE => '20',
GIMP_PDB_STATUS => '21',
GIMP_PDB_END => '22' }
},
GimpPDBErrorHandler =>
{ contig => 1,
header => 'libgimpbase/gimpbaseenums.h',

11
pdb/lib.pl
View File

@ -523,20 +523,15 @@ $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 (NULL,
${value_array}G_TYPE_NONE);
$arg_array
if (pdb)
return_vals = gimp_pdb_run_procedure_array (pdb,
"gimp-$proc->{canonical_name}",
args);
else
return_vals = gimp_run_procedure_array ("gimp-$proc->{canonical_name}",
args);
return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-$proc->{canonical_name}",
args);
gimp_value_array_unref (args);
$return_marshal

1
po-libgimp/POTFILES.in
View File

@ -9,7 +9,6 @@ libgimp/gimpexport.c
libgimp/gimpfontselectbutton.c
libgimp/gimpgradientselectbutton.c
libgimp/gimpimagemetadata.c
libgimp/gimplegacy.c
libgimp/gimppaletteselectbutton.c
libgimp/gimppatternselectbutton.c
libgimp/gimppdb.c