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

app/plug-in/Makefile.am app/plug-in/plug-in-types.h removed... 

2006-04-06  Michael Natterer  <mitch@gimp.org>

	* app/plug-in/Makefile.am
	* app/plug-in/plug-in-types.h
	* app/plug-in/plug-in-proc-def.[ch]: removed...

	* app/pdb/Makefile.am
	* app/pdb/pdb-types.h
	* app/pdb/gimppluginprocedure.[ch]: ...and added here. Virtualized
	get_progname().

	* app/pdb/gimptemporaryprocedure.[ch]: new class derived from
	GimpPlugInProcedure.

	* app/pdb/gimpprocedure.[ch] (struct GimpProcedure): remove union
	exec_method and all the structs it needed. Procedure execution is
	properly virtualized now. Removed gimp_procedure_initialize() and
	grow the args and values arrays dynamically in
	gimp_procedure_add_argument()/return_value(). Added marshal_func
	parameter to gimp_procedure_new().

	* app/actions/plug-in-actions.c
	* app/actions/plug-in-commands.c
	* app/core/gimp-gui.c
	* app/dialogs/file-save-dialog.c
	* app/file/file-open.c
	* app/file/file-save.c
	* app/file/file-utils.c
	* app/gui/gui-vtable.c
	* app/menus/plug-in-menus.c
	* app/plug-in/plug-in-def.c
	* app/plug-in/plug-in-message.c
	* app/plug-in/plug-in-progress.c
	* app/plug-in/plug-in-rc.c
	* app/plug-in/plug-in-run.c
	* app/plug-in/plug-in.c
	* app/plug-in/plug-ins-query.c
	* app/plug-in/plug-ins.c
	* app/widgets/gimpfiledialog.c
	* app/widgets/gimpfileprocview.c
	* app/widgets/gimppluginaction.c
	* app/xcf/xcf.c
	* tools/pdbgen/pdb/fileops.pdb
	* tools/pdbgen/pdb/plug_in.pdb
	* tools/pdbgen/app.pl: changed accordingly.

	* app/pdb/*_cmds.c: regenerated.

	* app/pdb/gimp-pdb.c: added uglyness to make the app link again.
This commit is contained in:
Michael Natterer 2006-04-06 10:01:30 +00:00 committed by Michael Natterer
parent a883043bac
commit 7e258dfa27
96 changed files with 1249 additions and 2630 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
ChangeLog
View File

@ -1,3 +1,53 @@
2006-04-06 Michael Natterer <mitch@gimp.org>
* app/plug-in/Makefile.am
* app/plug-in/plug-in-types.h
* app/plug-in/plug-in-proc-def.[ch]: removed...
* app/pdb/Makefile.am
* app/pdb/pdb-types.h
* app/pdb/gimppluginprocedure.[ch]: ...and added here. Virtualized
get_progname().
* app/pdb/gimptemporaryprocedure.[ch]: new class derived from
GimpPlugInProcedure.
* app/pdb/gimpprocedure.[ch] (struct GimpProcedure): remove union
exec_method and all the structs it needed. Procedure execution is
properly virtualized now. Removed gimp_procedure_initialize() and
grow the args and values arrays dynamically in
gimp_procedure_add_argument()/return_value(). Added marshal_func
parameter to gimp_procedure_new().
* app/actions/plug-in-actions.c
* app/actions/plug-in-commands.c
* app/core/gimp-gui.c
* app/dialogs/file-save-dialog.c
* app/file/file-open.c
* app/file/file-save.c
* app/file/file-utils.c
* app/gui/gui-vtable.c
* app/menus/plug-in-menus.c
* app/plug-in/plug-in-def.c
* app/plug-in/plug-in-message.c
* app/plug-in/plug-in-progress.c
* app/plug-in/plug-in-rc.c
* app/plug-in/plug-in-run.c
* app/plug-in/plug-in.c
* app/plug-in/plug-ins-query.c
* app/plug-in/plug-ins.c
* app/widgets/gimpfiledialog.c
* app/widgets/gimpfileprocview.c
* app/widgets/gimppluginaction.c
* app/xcf/xcf.c
* tools/pdbgen/pdb/fileops.pdb
* tools/pdbgen/pdb/plug_in.pdb
* tools/pdbgen/app.pl: changed accordingly.
* app/pdb/*_cmds.c: regenerated.
* app/pdb/gimp-pdb.c: added uglyness to make the app link again.
2006-04-06 Sven Neumann <sven@gimp.org>
* plug-ins/common/compose.c: add layers in the expected order.
@ -115,7 +165,7 @@
* app/widgets/gimppluginaction.[ch]
* app/xcf/xcf.c
* tools/pdbgen/pdb/fileops.pdb
* tools/pdbgen/pdb/plug_in.pdb: changed addordingly.
* tools/pdbgen/pdb/plug_in.pdb: changed accordingly.
* app/pdb/fileops_cmds.c
* app/pdb/plug_in_cmds.c: regenerated.

3
app/actions/plug-in-actions.c
View File

@ -33,10 +33,9 @@
#include "core/gimpdrawable.h"
#include "core/gimpimage.h"
#include "pdb/gimpprocedure.h"
#include "pdb/gimppluginprocedure.h"
#include "plug-in/plug-ins.h"
#include "plug-in/plug-in-proc-def.h"
#include "widgets/gimpactiongroup.h"
#include "widgets/gimphelp-ids.h"

1
app/actions/plug-in-commands.c
View File

@ -35,7 +35,6 @@
#include "plug-in/plug-in-data.h"
#include "plug-in/plug-in-run.h"
#include "plug-in/plug-in-proc-def.h"
#include "pdb/gimpprocedure.h"

2
app/core/gimp-gui.c
View File

@ -24,7 +24,7 @@
#include "core-types.h"
#include "plug-in/plug-in-proc-def.h"
#include "pdb/gimppluginprocedure.h"
#include "gimp.h"
#include "gimp-gui.h"

2
app/dialogs/file-save-dialog.c
View File

@ -31,7 +31,7 @@
#include "core/gimpimage.h"
#include "core/gimpprogress.h"
#include "plug-in/plug-in-proc-def.h"
#include "pdb/gimppluginprocedure.h"
#include "file/file-save.h"
#include "file/file-utils.h"

5
app/file/file-open.c
View File

@ -57,10 +57,7 @@
#include "core/gimpprogress.h"
#include "pdb/gimp-pdb.h"
#include "pdb/gimpprocedure.h"
#include "plug-in/plug-in.h"
#include "plug-in/plug-in-proc-def.h"
#include "pdb/gimppluginprocedure.h"
#include "file-open.h"
#include "file-utils.h"

5
app/file/file-save.c
View File

@ -55,10 +55,7 @@
#include "core/gimpprogress.h"
#include "pdb/gimp-pdb.h"
#include "pdb/gimpprocedure.h"
#include "plug-in/plug-in.h"
#include "plug-in/plug-in-proc-def.h"
#include "pdb/gimppluginprocedure.h"
#include "file-save.h"
#include "file-utils.h"

3
app/file/file-utils.c
View File

@ -44,8 +44,7 @@
#include "core/gimp.h"
#include "core/gimpimage.h"
#include "plug-in/plug-in.h"
#include "plug-in/plug-in-proc-def.h"
#include "pdb/gimppluginprocedure.h"
#include "file-utils.h"

3
app/gui/gui-vtable.c
View File

@ -41,8 +41,9 @@
#include "text/gimpfont.h"
#include "pdb/gimppluginprocedure.h"
#include "plug-in/plug-ins.h"
#include "plug-in/plug-in-proc-def.h"
#include "widgets/gimpactiongroup.h"
#include "widgets/gimpbrushselect.h"

5
app/menus/plug-in-menus.c
View File

@ -18,7 +18,7 @@
#include "config.h"
#include "string.h"
#include <string.h>
#include <gtk/gtk.h>
@ -30,11 +30,10 @@
#include "core/gimp.h"
#include "pdb/gimpprocedure.h"
#include "pdb/gimppluginprocedure.h"
#include "plug-in/plug-ins.h"
#include "plug-in/plug-in-def.h"
#include "plug-in/plug-in-proc-def.h"
#include "widgets/gimpuimanager.h"

4
app/pdb/Makefile.am
View File

@ -13,6 +13,10 @@ libapppdb_a_SOURCES = \
gimp-pdb-query.h \
gimpprocedure.c \
gimpprocedure.h \
gimppluginprocedure.c \
gimppluginprocedure.h \
gimptemporaryprocedure.c \
gimptemporaryprocedure.h \
\
internal_procs.c \
internal_procs.h \

88
app/pdb/brush_cmds.c
View File

@ -869,9 +869,7 @@ register_brush_procs (Gimp *gimp)
/*
* gimp-brush-new
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
brush_new_invoker);
procedure = gimp_procedure_new (brush_new_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-brush-new",
"gimp-brush-new",
@ -901,9 +899,7 @@ register_brush_procs (Gimp *gimp)
/*
* gimp-brush-duplicate
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
brush_duplicate_invoker);
procedure = gimp_procedure_new (brush_duplicate_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-brush-duplicate",
"gimp-brush-duplicate",
@ -933,9 +929,7 @@ register_brush_procs (Gimp *gimp)
/*
* gimp-brush-is-generated
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
brush_is_generated_invoker);
procedure = gimp_procedure_new (brush_is_generated_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-brush-is-generated",
"gimp-brush-is-generated",
@ -964,9 +958,7 @@ register_brush_procs (Gimp *gimp)
/*
* gimp-brush-rename
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 1,
brush_rename_invoker);
procedure = gimp_procedure_new (brush_rename_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-brush-rename",
"gimp-brush-rename",
@ -1003,9 +995,7 @@ register_brush_procs (Gimp *gimp)
/*
* gimp-brush-delete
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
brush_delete_invoker);
procedure = gimp_procedure_new (brush_delete_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-brush-delete",
"gimp-brush-delete",
@ -1028,9 +1018,7 @@ register_brush_procs (Gimp *gimp)
/*
* gimp-brush-is-editable
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
brush_is_editable_invoker);
procedure = gimp_procedure_new (brush_is_editable_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-brush-is-editable",
"gimp-brush-is-editable",
@ -1059,9 +1047,7 @@ register_brush_procs (Gimp *gimp)
/*
* gimp-brush-get-info
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 4,
brush_get_info_invoker);
procedure = gimp_procedure_new (brush_get_info_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-brush-get-info",
"gimp-brush-get-info",
@ -1108,9 +1094,7 @@ register_brush_procs (Gimp *gimp)
/*
* gimp-brush-get-pixels
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 8,
brush_get_pixels_invoker);
procedure = gimp_procedure_new (brush_get_pixels_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-brush-get-pixels",
"gimp-brush-get-pixels",
@ -1179,9 +1163,7 @@ register_brush_procs (Gimp *gimp)
/*
* gimp-brush-get-spacing
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
brush_get_spacing_invoker);
procedure = gimp_procedure_new (brush_get_spacing_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-brush-get-spacing",
"gimp-brush-get-spacing",
@ -1210,9 +1192,7 @@ register_brush_procs (Gimp *gimp)
/*
* gimp-brush-set-spacing
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
brush_set_spacing_invoker);
procedure = gimp_procedure_new (brush_set_spacing_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-brush-set-spacing",
"gimp-brush-set-spacing",
@ -1241,9 +1221,7 @@ register_brush_procs (Gimp *gimp)
/*
* gimp-brush-get-shape
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
brush_get_shape_invoker);
procedure = gimp_procedure_new (brush_get_shape_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-brush-get-shape",
"gimp-brush-get-shape",
@ -1273,9 +1251,7 @@ register_brush_procs (Gimp *gimp)
/*
* gimp-brush-get-radius
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
brush_get_radius_invoker);
procedure = gimp_procedure_new (brush_get_radius_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-brush-get-radius",
"gimp-brush-get-radius",
@ -1304,9 +1280,7 @@ register_brush_procs (Gimp *gimp)
/*
* gimp-brush-get-spikes
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
brush_get_spikes_invoker);
procedure = gimp_procedure_new (brush_get_spikes_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-brush-get-spikes",
"gimp-brush-get-spikes",
@ -1335,9 +1309,7 @@ register_brush_procs (Gimp *gimp)
/*
* gimp-brush-get-hardness
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
brush_get_hardness_invoker);
procedure = gimp_procedure_new (brush_get_hardness_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-brush-get-hardness",
"gimp-brush-get-hardness",
@ -1366,9 +1338,7 @@ register_brush_procs (Gimp *gimp)
/*
* gimp-brush-get-aspect-ratio
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
brush_get_aspect_ratio_invoker);
procedure = gimp_procedure_new (brush_get_aspect_ratio_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-brush-get-aspect-ratio",
"gimp-brush-get-aspect-ratio",
@ -1397,9 +1367,7 @@ register_brush_procs (Gimp *gimp)
/*
* gimp-brush-get-angle
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
brush_get_angle_invoker);
procedure = gimp_procedure_new (brush_get_angle_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-brush-get-angle",
"gimp-brush-get-angle",
@ -1428,9 +1396,7 @@ register_brush_procs (Gimp *gimp)
/*
* gimp-brush-set-shape
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 1,
brush_set_shape_invoker);
procedure = gimp_procedure_new (brush_set_shape_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-brush-set-shape",
"gimp-brush-set-shape",
@ -1467,9 +1433,7 @@ register_brush_procs (Gimp *gimp)
/*
* gimp-brush-set-radius
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 1,
brush_set_radius_invoker);
procedure = gimp_procedure_new (brush_set_radius_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-brush-set-radius",
"gimp-brush-set-radius",
@ -1504,9 +1468,7 @@ register_brush_procs (Gimp *gimp)
/*
* gimp-brush-set-spikes
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 1,
brush_set_spikes_invoker);
procedure = gimp_procedure_new (brush_set_spikes_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-brush-set-spikes",
"gimp-brush-set-spikes",
@ -1541,9 +1503,7 @@ register_brush_procs (Gimp *gimp)
/*
* gimp-brush-set-hardness
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 1,
brush_set_hardness_invoker);
procedure = gimp_procedure_new (brush_set_hardness_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-brush-set-hardness",
"gimp-brush-set-hardness",
@ -1578,9 +1538,7 @@ register_brush_procs (Gimp *gimp)
/*
* gimp-brush-set-aspect-ratio
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 1,
brush_set_aspect_ratio_invoker);
procedure = gimp_procedure_new (brush_set_aspect_ratio_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-brush-set-aspect-ratio",
"gimp-brush-set-aspect-ratio",
@ -1615,9 +1573,7 @@ register_brush_procs (Gimp *gimp)
/*
* gimp-brush-set-angle
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 1,
brush_set_angle_invoker);
procedure = gimp_procedure_new (brush_set_angle_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-brush-set-angle",
"gimp-brush-set-angle",

12
app/pdb/brush_select_cmds.c
View File

@ -138,9 +138,7 @@ register_brush_select_procs (Gimp *gimp)
/*
* gimp-brushes-popup
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 6, 0,
brushes_popup_invoker);
procedure = gimp_procedure_new (brushes_popup_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-brushes-popup",
"gimp-brushes-popup",
@ -196,9 +194,7 @@ register_brush_select_procs (Gimp *gimp)
/*
* gimp-brushes-close-popup
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
brushes_close_popup_invoker);
procedure = gimp_procedure_new (brushes_close_popup_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-brushes-close-popup",
"gimp-brushes-close-popup",
@ -221,9 +217,7 @@ register_brush_select_procs (Gimp *gimp)
/*
* gimp-brushes-set-popup
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 5, 0,
brushes_set_popup_invoker);
procedure = gimp_procedure_new (brushes_set_popup_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-brushes-set-popup",
"gimp-brushes-set-popup",

24
app/pdb/brushes_cmds.c
View File

@ -241,9 +241,7 @@ register_brushes_procs (Gimp *gimp)
/*
* gimp-brushes-refresh
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 0, 0,
brushes_refresh_invoker);
procedure = gimp_procedure_new (brushes_refresh_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-brushes-refresh",
"gimp-brushes-refresh",
@ -259,9 +257,7 @@ register_brushes_procs (Gimp *gimp)
/*
* gimp-brushes-get-list
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 2,
brushes_get_list_invoker);
procedure = gimp_procedure_new (brushes_get_list_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-brushes-get-list",
"gimp-brushes-get-list",
@ -295,9 +291,7 @@ register_brushes_procs (Gimp *gimp)
/*
* gimp-brushes-get-brush
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 0, 4,
brushes_get_brush_invoker);
procedure = gimp_procedure_new (brushes_get_brush_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-brushes-get-brush",
"gimp-brushes-get-brush",
@ -338,9 +332,7 @@ register_brushes_procs (Gimp *gimp)
/*
* gimp-brushes-get-spacing
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 0, 1,
brushes_get_spacing_invoker);
procedure = gimp_procedure_new (brushes_get_spacing_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-brushes-get-spacing",
"gimp-brushes-get-spacing",
@ -362,9 +354,7 @@ register_brushes_procs (Gimp *gimp)
/*
* gimp-brushes-set-spacing
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
brushes_set_spacing_invoker);
procedure = gimp_procedure_new (brushes_set_spacing_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-brushes-set-spacing",
"gimp-brushes-set-spacing",
@ -386,9 +376,7 @@ register_brushes_procs (Gimp *gimp)
/*
* gimp-brushes-get-brush-data
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 8,
brushes_get_brush_data_invoker);
procedure = gimp_procedure_new (brushes_get_brush_data_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-brushes-get-brush-data",
"gimp-brushes-get-brush-data",

28
app/pdb/buffer_cmds.c
View File

@ -272,9 +272,7 @@ register_buffer_procs (Gimp *gimp)
/*
* gimp-buffers-get-list
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 2,
buffers_get_list_invoker);
procedure = gimp_procedure_new (buffers_get_list_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-buffers-get-list",
"gimp-buffers-get-list",
@ -308,9 +306,7 @@ register_buffer_procs (Gimp *gimp)
/*
* gimp-buffer-rename
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 1,
buffer_rename_invoker);
procedure = gimp_procedure_new (buffer_rename_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-buffer-rename",
"gimp-buffer-rename",
@ -347,9 +343,7 @@ register_buffer_procs (Gimp *gimp)
/*
* gimp-buffer-delete
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
buffer_delete_invoker);
procedure = gimp_procedure_new (buffer_delete_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-buffer-delete",
"gimp-buffer-delete",
@ -372,9 +366,7 @@ register_buffer_procs (Gimp *gimp)
/*
* gimp-buffer-get-width
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
buffer_get_width_invoker);
procedure = gimp_procedure_new (buffer_get_width_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-buffer-get-width",
"gimp-buffer-get-width",
@ -403,9 +395,7 @@ register_buffer_procs (Gimp *gimp)
/*
* gimp-buffer-get-height
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
buffer_get_height_invoker);
procedure = gimp_procedure_new (buffer_get_height_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-buffer-get-height",
"gimp-buffer-get-height",
@ -434,9 +424,7 @@ register_buffer_procs (Gimp *gimp)
/*
* gimp-buffer-get-bytes
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
buffer_get_bytes_invoker);
procedure = gimp_procedure_new (buffer_get_bytes_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-buffer-get-bytes",
"gimp-buffer-get-bytes",
@ -465,9 +453,7 @@ register_buffer_procs (Gimp *gimp)
/*
* gimp-buffer-get-image-type
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
buffer_get_image_type_invoker);
procedure = gimp_procedure_new (buffer_get_image_type_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-buffer-get-image-type",
"gimp-buffer-get-image-type",

40
app/pdb/channel_cmds.c
View File

@ -333,9 +333,7 @@ register_channel_procs (Gimp *gimp)
/*
* gimp-channel-new
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 6, 1,
channel_new_invoker);
procedure = gimp_procedure_new (channel_new_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-channel-new",
"gimp-channel-new",
@ -394,9 +392,7 @@ register_channel_procs (Gimp *gimp)
/*
* gimp-channel-new-from-component
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 1,
channel_new_from_component_invoker);
procedure = gimp_procedure_new (channel_new_from_component_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-channel-new-from-component",
"gimp-channel-new-from-component",
@ -438,9 +434,7 @@ register_channel_procs (Gimp *gimp)
/*
* gimp-channel-copy
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
channel_copy_invoker);
procedure = gimp_procedure_new (channel_copy_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-channel-copy",
"gimp-channel-copy",
@ -468,9 +462,7 @@ register_channel_procs (Gimp *gimp)
/*
* gimp-channel-combine-masks
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 5, 0,
channel_combine_masks_invoker);
procedure = gimp_procedure_new (channel_combine_masks_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-channel-combine-masks",
"gimp-channel-combine-masks",
@ -517,9 +509,7 @@ register_channel_procs (Gimp *gimp)
/*
* gimp-channel-get-show-masked
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
channel_get_show_masked_invoker);
procedure = gimp_procedure_new (channel_get_show_masked_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-channel-get-show-masked",
"gimp-channel-get-show-masked",
@ -547,9 +537,7 @@ register_channel_procs (Gimp *gimp)
/*
* gimp-channel-set-show-masked
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
channel_set_show_masked_invoker);
procedure = gimp_procedure_new (channel_set_show_masked_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-channel-set-show-masked",
"gimp-channel-set-show-masked",
@ -577,9 +565,7 @@ register_channel_procs (Gimp *gimp)
/*
* gimp-channel-get-opacity
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
channel_get_opacity_invoker);
procedure = gimp_procedure_new (channel_get_opacity_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-channel-get-opacity",
"gimp-channel-get-opacity",
@ -607,9 +593,7 @@ register_channel_procs (Gimp *gimp)
/*
* gimp-channel-set-opacity
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
channel_set_opacity_invoker);
procedure = gimp_procedure_new (channel_set_opacity_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-channel-set-opacity",
"gimp-channel-set-opacity",
@ -637,9 +621,7 @@ register_channel_procs (Gimp *gimp)
/*
* gimp-channel-get-color
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
channel_get_color_invoker);
procedure = gimp_procedure_new (channel_get_color_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-channel-get-color",
"gimp-channel-get-color",
@ -667,9 +649,7 @@ register_channel_procs (Gimp *gimp)
/*
* gimp-channel-set-color
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
channel_set_color_invoker);
procedure = gimp_procedure_new (channel_set_color_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-channel-set-color",
"gimp-channel-set-color",

64
app/pdb/color_cmds.c
View File

@ -839,9 +839,7 @@ register_color_procs (Gimp *gimp)
/*
* gimp-brightness-contrast
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 0,
brightness_contrast_invoker);
procedure = gimp_procedure_new (brightness_contrast_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-brightness-contrast",
"gimp-brightness-contrast",
@ -875,9 +873,7 @@ register_color_procs (Gimp *gimp)
/*
* gimp-levels
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 7, 0,
levels_invoker);
procedure = gimp_procedure_new (levels_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-levels",
"gimp-levels",
@ -936,9 +932,7 @@ register_color_procs (Gimp *gimp)
/*
* gimp-levels-auto
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
levels_auto_invoker);
procedure = gimp_procedure_new (levels_auto_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-levels-auto",
"gimp-levels-auto",
@ -960,9 +954,7 @@ register_color_procs (Gimp *gimp)
/*
* gimp-levels-stretch
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
levels_stretch_invoker);
procedure = gimp_procedure_new (levels_stretch_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-levels-stretch",
"gimp-levels-stretch",
@ -984,9 +976,7 @@ register_color_procs (Gimp *gimp)
/*
* gimp-posterize
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
posterize_invoker);
procedure = gimp_procedure_new (posterize_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-posterize",
"gimp-posterize",
@ -1014,9 +1004,7 @@ register_color_procs (Gimp *gimp)
/*
* gimp-desaturate
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
desaturate_invoker);
procedure = gimp_procedure_new (desaturate_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-desaturate",
"gimp-desaturate",
@ -1038,9 +1026,7 @@ register_color_procs (Gimp *gimp)
/*
* gimp-desaturate-full
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
desaturate_full_invoker);
procedure = gimp_procedure_new (desaturate_full_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-desaturate-full",
"gimp-desaturate-full",
@ -1069,9 +1055,7 @@ register_color_procs (Gimp *gimp)
/*
* gimp-equalize
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
equalize_invoker);
procedure = gimp_procedure_new (equalize_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-equalize",
"gimp-equalize",
@ -1099,9 +1083,7 @@ register_color_procs (Gimp *gimp)
/*
* gimp-invert
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
invert_invoker);
procedure = gimp_procedure_new (invert_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-invert",
"gimp-invert",
@ -1123,9 +1105,7 @@ register_color_procs (Gimp *gimp)
/*
* gimp-curves-spline
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 4, 0,
curves_spline_invoker);
procedure = gimp_procedure_new (curves_spline_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-curves-spline",
"gimp-curves-spline",
@ -1165,9 +1145,7 @@ register_color_procs (Gimp *gimp)
/*
* gimp-curves-explicit
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 4, 0,
curves_explicit_invoker);
procedure = gimp_procedure_new (curves_explicit_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-curves-explicit",
"gimp-curves-explicit",
@ -1207,9 +1185,7 @@ register_color_procs (Gimp *gimp)
/*
* gimp-color-balance
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 6, 0,
color_balance_invoker);
procedure = gimp_procedure_new (color_balance_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-color-balance",
"gimp-color-balance",
@ -1262,9 +1238,7 @@ register_color_procs (Gimp *gimp)
/*
* gimp-colorize
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 4, 0,
colorize_invoker);
procedure = gimp_procedure_new (colorize_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-colorize",
"gimp-colorize",
@ -1304,9 +1278,7 @@ register_color_procs (Gimp *gimp)
/*
* gimp-histogram
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 4, 6,
histogram_invoker);
procedure = gimp_procedure_new (histogram_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-histogram",
"gimp-histogram",
@ -1383,9 +1355,7 @@ register_color_procs (Gimp *gimp)
/*
* gimp-hue-saturation
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 5, 0,
hue_saturation_invoker);
procedure = gimp_procedure_new (hue_saturation_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-hue-saturation",
"gimp-hue-saturation",
@ -1432,9 +1402,7 @@ register_color_procs (Gimp *gimp)
/*
* gimp-threshold
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 0,
threshold_invoker);
procedure = gimp_procedure_new (threshold_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-threshold",
"gimp-threshold",

96
app/pdb/context_cmds.c
View File

@ -564,9 +564,7 @@ register_context_procs (Gimp *gimp)
/*
* gimp-context-push
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 0, 0,
context_push_invoker);
procedure = gimp_procedure_new (context_push_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-context-push",
"gimp-context-push",
@ -582,9 +580,7 @@ register_context_procs (Gimp *gimp)
/*
* gimp-context-pop
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 0, 0,
context_pop_invoker);
procedure = gimp_procedure_new (context_pop_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-context-pop",
"gimp-context-pop",
@ -600,9 +596,7 @@ register_context_procs (Gimp *gimp)
/*
* gimp-context-get-paint-method
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 0, 1,
context_get_paint_method_invoker);
procedure = gimp_procedure_new (context_get_paint_method_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-context-get-paint-method",
"gimp-context-get-paint-method",
@ -625,9 +619,7 @@ register_context_procs (Gimp *gimp)
/*
* gimp-context-set-paint-method
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
context_set_paint_method_invoker);
procedure = gimp_procedure_new (context_set_paint_method_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-context-set-paint-method",
"gimp-context-set-paint-method",
@ -650,9 +642,7 @@ register_context_procs (Gimp *gimp)
/*
* gimp-context-get-foreground
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 0, 1,
context_get_foreground_invoker);
procedure = gimp_procedure_new (context_get_foreground_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-context-get-foreground",
"gimp-context-get-foreground",
@ -674,9 +664,7 @@ register_context_procs (Gimp *gimp)
/*
* gimp-context-set-foreground
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
context_set_foreground_invoker);
procedure = gimp_procedure_new (context_set_foreground_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-context-set-foreground",
"gimp-context-set-foreground",
@ -698,9 +686,7 @@ register_context_procs (Gimp *gimp)
/*
* gimp-context-get-background
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 0, 1,
context_get_background_invoker);
procedure = gimp_procedure_new (context_get_background_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-context-get-background",
"gimp-context-get-background",
@ -722,9 +708,7 @@ register_context_procs (Gimp *gimp)
/*
* gimp-context-set-background
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
context_set_background_invoker);
procedure = gimp_procedure_new (context_set_background_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-context-set-background",
"gimp-context-set-background",
@ -746,9 +730,7 @@ register_context_procs (Gimp *gimp)
/*
* gimp-context-set-default-colors
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 0, 0,
context_set_default_colors_invoker);
procedure = gimp_procedure_new (context_set_default_colors_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-context-set-default-colors",
"gimp-context-set-default-colors",
@ -764,9 +746,7 @@ register_context_procs (Gimp *gimp)
/*
* gimp-context-swap-colors
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 0, 0,
context_swap_colors_invoker);
procedure = gimp_procedure_new (context_swap_colors_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-context-swap-colors",
"gimp-context-swap-colors",
@ -782,9 +762,7 @@ register_context_procs (Gimp *gimp)
/*
* gimp-context-get-opacity
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 0, 1,
context_get_opacity_invoker);
procedure = gimp_procedure_new (context_get_opacity_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-context-get-opacity",
"gimp-context-get-opacity",
@ -806,9 +784,7 @@ register_context_procs (Gimp *gimp)
/*
* gimp-context-set-opacity
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
context_set_opacity_invoker);
procedure = gimp_procedure_new (context_set_opacity_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-context-set-opacity",
"gimp-context-set-opacity",
@ -830,9 +806,7 @@ register_context_procs (Gimp *gimp)
/*
* gimp-context-get-paint-mode
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 0, 1,
context_get_paint_mode_invoker);
procedure = gimp_procedure_new (context_get_paint_mode_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-context-get-paint-mode",
"gimp-context-get-paint-mode",
@ -855,9 +829,7 @@ register_context_procs (Gimp *gimp)
/*
* gimp-context-set-paint-mode
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
context_set_paint_mode_invoker);
procedure = gimp_procedure_new (context_set_paint_mode_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-context-set-paint-mode",
"gimp-context-set-paint-mode",
@ -880,9 +852,7 @@ register_context_procs (Gimp *gimp)
/*
* gimp-context-get-brush
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 0, 1,
context_get_brush_invoker);
procedure = gimp_procedure_new (context_get_brush_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-context-get-brush",
"gimp-context-get-brush",
@ -905,9 +875,7 @@ register_context_procs (Gimp *gimp)
/*
* gimp-context-set-brush
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
context_set_brush_invoker);
procedure = gimp_procedure_new (context_set_brush_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-context-set-brush",
"gimp-context-set-brush",
@ -930,9 +898,7 @@ register_context_procs (Gimp *gimp)
/*
* gimp-context-get-pattern
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 0, 1,
context_get_pattern_invoker);
procedure = gimp_procedure_new (context_get_pattern_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-context-get-pattern",
"gimp-context-get-pattern",
@ -955,9 +921,7 @@ register_context_procs (Gimp *gimp)
/*
* gimp-context-set-pattern
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
context_set_pattern_invoker);
procedure = gimp_procedure_new (context_set_pattern_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-context-set-pattern",
"gimp-context-set-pattern",
@ -980,9 +944,7 @@ register_context_procs (Gimp *gimp)
/*
* gimp-context-get-gradient
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 0, 1,
context_get_gradient_invoker);
procedure = gimp_procedure_new (context_get_gradient_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-context-get-gradient",
"gimp-context-get-gradient",
@ -1005,9 +967,7 @@ register_context_procs (Gimp *gimp)
/*
* gimp-context-set-gradient
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
context_set_gradient_invoker);
procedure = gimp_procedure_new (context_set_gradient_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-context-set-gradient",
"gimp-context-set-gradient",
@ -1030,9 +990,7 @@ register_context_procs (Gimp *gimp)
/*
* gimp-context-get-palette
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 0, 1,
context_get_palette_invoker);
procedure = gimp_procedure_new (context_get_palette_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-context-get-palette",
"gimp-context-get-palette",
@ -1055,9 +1013,7 @@ register_context_procs (Gimp *gimp)
/*
* gimp-context-set-palette
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
context_set_palette_invoker);
procedure = gimp_procedure_new (context_set_palette_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-context-set-palette",
"gimp-context-set-palette",
@ -1080,9 +1036,7 @@ register_context_procs (Gimp *gimp)
/*
* gimp-context-get-font
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 0, 1,
context_get_font_invoker);
procedure = gimp_procedure_new (context_get_font_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-context-get-font",
"gimp-context-get-font",
@ -1105,9 +1059,7 @@ register_context_procs (Gimp *gimp)
/*
* gimp-context-set-font
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
context_set_font_invoker);
procedure = gimp_procedure_new (context_set_font_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-context-set-font",
"gimp-context-set-font",

12
app/pdb/convert_cmds.c
View File

@ -151,9 +151,7 @@ register_convert_procs (Gimp *gimp)
/*
* gimp-image-convert-rgb
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
image_convert_rgb_invoker);
procedure = gimp_procedure_new (image_convert_rgb_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-convert-rgb",
"gimp-image-convert-rgb",
@ -175,9 +173,7 @@ register_convert_procs (Gimp *gimp)
/*
* gimp-image-convert-grayscale
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
image_convert_grayscale_invoker);
procedure = gimp_procedure_new (image_convert_grayscale_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-convert-grayscale",
"gimp-image-convert-grayscale",
@ -199,9 +195,7 @@ register_convert_procs (Gimp *gimp)
/*
* gimp-image-convert-indexed
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 7, 0,
image_convert_indexed_invoker);
procedure = gimp_procedure_new (image_convert_indexed_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-convert-indexed",
"gimp-image-convert-indexed",

20
app/pdb/display_cmds.c
View File

@ -168,9 +168,7 @@ register_display_procs (Gimp *gimp)
/*
* gimp-display-new
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
display_new_invoker);
procedure = gimp_procedure_new (display_new_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-display-new",
"gimp-display-new",
@ -198,9 +196,7 @@ register_display_procs (Gimp *gimp)
/*
* gimp-display-delete
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
display_delete_invoker);
procedure = gimp_procedure_new (display_delete_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-display-delete",
"gimp-display-delete",
@ -222,9 +218,7 @@ register_display_procs (Gimp *gimp)
/*
* gimp-display-get-window-handle
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
display_get_window_handle_invoker);
procedure = gimp_procedure_new (display_get_window_handle_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-display-get-window-handle",
"gimp-display-get-window-handle",
@ -252,9 +246,7 @@ register_display_procs (Gimp *gimp)
/*
* gimp-displays-flush
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 0, 0,
displays_flush_invoker);
procedure = gimp_procedure_new (displays_flush_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-displays-flush",
"gimp-displays-flush",
@ -270,9 +262,7 @@ register_display_procs (Gimp *gimp)
/*
* gimp-displays-reconnect
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
displays_reconnect_invoker);
procedure = gimp_procedure_new (displays_reconnect_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-displays-reconnect",
"gimp-displays-reconnect",

140
app/pdb/drawable_cmds.c
View File

@ -1161,9 +1161,7 @@ register_drawable_procs (Gimp *gimp)
/*
* gimp-drawable-delete
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
drawable_delete_invoker);
procedure = gimp_procedure_new (drawable_delete_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-delete",
"gimp-drawable-delete",
@ -1185,9 +1183,7 @@ register_drawable_procs (Gimp *gimp)
/*
* gimp-drawable-is-layer
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
drawable_is_layer_invoker);
procedure = gimp_procedure_new (drawable_is_layer_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-is-layer",
"gimp-drawable-is-layer",
@ -1215,9 +1211,7 @@ register_drawable_procs (Gimp *gimp)
/*
* gimp-drawable-is-layer-mask
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
drawable_is_layer_mask_invoker);
procedure = gimp_procedure_new (drawable_is_layer_mask_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-is-layer-mask",
"gimp-drawable-is-layer-mask",
@ -1245,9 +1239,7 @@ register_drawable_procs (Gimp *gimp)
/*
* gimp-drawable-is-channel
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
drawable_is_channel_invoker);
procedure = gimp_procedure_new (drawable_is_channel_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-is-channel",
"gimp-drawable-is-channel",
@ -1275,9 +1267,7 @@ register_drawable_procs (Gimp *gimp)
/*
* gimp-drawable-type
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
drawable_type_invoker);
procedure = gimp_procedure_new (drawable_type_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-type",
"gimp-drawable-type",
@ -1306,9 +1296,7 @@ register_drawable_procs (Gimp *gimp)
/*
* gimp-drawable-type-with-alpha
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
drawable_type_with_alpha_invoker);
procedure = gimp_procedure_new (drawable_type_with_alpha_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-type-with-alpha",
"gimp-drawable-type-with-alpha",
@ -1343,9 +1331,7 @@ register_drawable_procs (Gimp *gimp)
/*
* gimp-drawable-has-alpha
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
drawable_has_alpha_invoker);
procedure = gimp_procedure_new (drawable_has_alpha_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-has-alpha",
"gimp-drawable-has-alpha",
@ -1373,9 +1359,7 @@ register_drawable_procs (Gimp *gimp)
/*
* gimp-drawable-is-rgb
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
drawable_is_rgb_invoker);
procedure = gimp_procedure_new (drawable_is_rgb_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-is-rgb",
"gimp-drawable-is-rgb",
@ -1403,9 +1387,7 @@ register_drawable_procs (Gimp *gimp)
/*
* gimp-drawable-is-gray
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
drawable_is_gray_invoker);
procedure = gimp_procedure_new (drawable_is_gray_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-is-gray",
"gimp-drawable-is-gray",
@ -1433,9 +1415,7 @@ register_drawable_procs (Gimp *gimp)
/*
* gimp-drawable-is-indexed
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
drawable_is_indexed_invoker);
procedure = gimp_procedure_new (drawable_is_indexed_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-is-indexed",
"gimp-drawable-is-indexed",
@ -1463,9 +1443,7 @@ register_drawable_procs (Gimp *gimp)
/*
* gimp-drawable-bpp
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
drawable_bpp_invoker);
procedure = gimp_procedure_new (drawable_bpp_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-bpp",
"gimp-drawable-bpp",
@ -1493,9 +1471,7 @@ register_drawable_procs (Gimp *gimp)
/*
* gimp-drawable-width
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
drawable_width_invoker);
procedure = gimp_procedure_new (drawable_width_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-width",
"gimp-drawable-width",
@ -1523,9 +1499,7 @@ register_drawable_procs (Gimp *gimp)
/*
* gimp-drawable-height
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
drawable_height_invoker);
procedure = gimp_procedure_new (drawable_height_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-height",
"gimp-drawable-height",
@ -1553,9 +1527,7 @@ register_drawable_procs (Gimp *gimp)
/*
* gimp-drawable-offsets
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 2,
drawable_offsets_invoker);
procedure = gimp_procedure_new (drawable_offsets_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-offsets",
"gimp-drawable-offsets",
@ -1589,9 +1561,7 @@ register_drawable_procs (Gimp *gimp)
/*
* gimp-drawable-get-image
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
drawable_get_image_invoker);
procedure = gimp_procedure_new (drawable_get_image_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-get-image",
"gimp-drawable-get-image",
@ -1619,9 +1589,7 @@ register_drawable_procs (Gimp *gimp)
/*
* gimp-drawable-set-image
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
drawable_set_image_invoker);
procedure = gimp_procedure_new (drawable_set_image_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-set-image",
"gimp-drawable-set-image",
@ -1649,9 +1617,7 @@ register_drawable_procs (Gimp *gimp)
/*
* gimp-drawable-get-name
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
drawable_get_name_invoker);
procedure = gimp_procedure_new (drawable_get_name_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-get-name",
"gimp-drawable-get-name",
@ -1680,9 +1646,7 @@ register_drawable_procs (Gimp *gimp)
/*
* gimp-drawable-set-name
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
drawable_set_name_invoker);
procedure = gimp_procedure_new (drawable_set_name_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-set-name",
"gimp-drawable-set-name",
@ -1711,9 +1675,7 @@ register_drawable_procs (Gimp *gimp)
/*
* gimp-drawable-get-visible
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
drawable_get_visible_invoker);
procedure = gimp_procedure_new (drawable_get_visible_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-get-visible",
"gimp-drawable-get-visible",
@ -1741,9 +1703,7 @@ register_drawable_procs (Gimp *gimp)
/*
* gimp-drawable-set-visible
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
drawable_set_visible_invoker);
procedure = gimp_procedure_new (drawable_set_visible_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-set-visible",
"gimp-drawable-set-visible",
@ -1771,9 +1731,7 @@ register_drawable_procs (Gimp *gimp)
/*
* gimp-drawable-get-linked
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
drawable_get_linked_invoker);
procedure = gimp_procedure_new (drawable_get_linked_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-get-linked",
"gimp-drawable-get-linked",
@ -1801,9 +1759,7 @@ register_drawable_procs (Gimp *gimp)
/*
* gimp-drawable-set-linked
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
drawable_set_linked_invoker);
procedure = gimp_procedure_new (drawable_set_linked_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-set-linked",
"gimp-drawable-set-linked",
@ -1831,9 +1787,7 @@ register_drawable_procs (Gimp *gimp)
/*
* gimp-drawable-get-tattoo
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
drawable_get_tattoo_invoker);
procedure = gimp_procedure_new (drawable_get_tattoo_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-get-tattoo",
"gimp-drawable-get-tattoo",
@ -1861,9 +1815,7 @@ register_drawable_procs (Gimp *gimp)
/*
* gimp-drawable-set-tattoo
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
drawable_set_tattoo_invoker);
procedure = gimp_procedure_new (drawable_set_tattoo_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-set-tattoo",
"gimp-drawable-set-tattoo",
@ -1891,9 +1843,7 @@ register_drawable_procs (Gimp *gimp)
/*
* gimp-drawable-mask-bounds
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 5,
drawable_mask_bounds_invoker);
procedure = gimp_procedure_new (drawable_mask_bounds_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-mask-bounds",
"gimp-drawable-mask-bounds",
@ -1945,9 +1895,7 @@ register_drawable_procs (Gimp *gimp)
/*
* gimp-drawable-mask-intersect
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 5,
drawable_mask_intersect_invoker);
procedure = gimp_procedure_new (drawable_mask_intersect_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-mask-intersect",
"gimp-drawable-mask-intersect",
@ -1999,9 +1947,7 @@ register_drawable_procs (Gimp *gimp)
/*
* gimp-drawable-merge-shadow
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
drawable_merge_shadow_invoker);
procedure = gimp_procedure_new (drawable_merge_shadow_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-merge-shadow",
"gimp-drawable-merge-shadow",
@ -2029,9 +1975,7 @@ register_drawable_procs (Gimp *gimp)
/*
* gimp-drawable-update
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 5, 0,
drawable_update_invoker);
procedure = gimp_procedure_new (drawable_update_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-update",
"gimp-drawable-update",
@ -2077,9 +2021,7 @@ register_drawable_procs (Gimp *gimp)
/*
* gimp-drawable-get-pixel
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 2,
drawable_get_pixel_invoker);
procedure = gimp_procedure_new (drawable_get_pixel_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-get-pixel",
"gimp-drawable-get-pixel",
@ -2124,9 +2066,7 @@ register_drawable_procs (Gimp *gimp)
/*
* gimp-drawable-set-pixel
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 5, 0,
drawable_set_pixel_invoker);
procedure = gimp_procedure_new (drawable_set_pixel_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-set-pixel",
"gimp-drawable-set-pixel",
@ -2171,9 +2111,7 @@ register_drawable_procs (Gimp *gimp)
/*
* gimp-drawable-fill
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
drawable_fill_invoker);
procedure = gimp_procedure_new (drawable_fill_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-fill",
"gimp-drawable-fill",
@ -2202,9 +2140,7 @@ register_drawable_procs (Gimp *gimp)
/*
* gimp-drawable-offset
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 5, 0,
drawable_offset_invoker);
procedure = gimp_procedure_new (drawable_offset_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-offset",
"gimp-drawable-offset",
@ -2251,9 +2187,7 @@ register_drawable_procs (Gimp *gimp)
/*
* gimp-drawable-thumbnail
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 5,
drawable_thumbnail_invoker);
procedure = gimp_procedure_new (drawable_thumbnail_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-thumbnail",
"gimp-drawable-thumbnail",
@ -2316,9 +2250,7 @@ register_drawable_procs (Gimp *gimp)
/*
* gimp-drawable-sub-thumbnail
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 7, 5,
drawable_sub_thumbnail_invoker);
procedure = gimp_procedure_new (drawable_sub_thumbnail_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-sub-thumbnail",
"gimp-drawable-sub-thumbnail",
@ -2405,9 +2337,7 @@ register_drawable_procs (Gimp *gimp)
/*
* gimp-drawable-foreground-extract
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 0,
drawable_foreground_extract_invoker);
procedure = gimp_procedure_new (drawable_foreground_extract_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-foreground-extract",
"gimp-drawable-foreground-extract",

64
app/pdb/drawable_transform_cmds.c
View File

@ -1184,9 +1184,7 @@ register_drawable_transform_procs (Gimp *gimp)
/*
* gimp-drawable-transform-flip-simple
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 5, 1,
drawable_transform_flip_simple_invoker);
procedure = gimp_procedure_new (drawable_transform_flip_simple_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-transform-flip-simple",
"gimp-drawable-transform-flip-simple",
@ -1241,9 +1239,7 @@ register_drawable_transform_procs (Gimp *gimp)
/*
* gimp-drawable-transform-flip
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 10, 1,
drawable_transform_flip_invoker);
procedure = gimp_procedure_new (drawable_transform_flip_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-transform-flip",
"gimp-drawable-transform-flip",
@ -1327,9 +1323,7 @@ register_drawable_transform_procs (Gimp *gimp)
/*
* gimp-drawable-transform-flip-default
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 7, 1,
drawable_transform_flip_default_invoker);
procedure = gimp_procedure_new (drawable_transform_flip_default_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-transform-flip-default",
"gimp-drawable-transform-flip-default",
@ -1393,9 +1387,7 @@ register_drawable_transform_procs (Gimp *gimp)
/*
* gimp-drawable-transform-perspective
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 14, 1,
drawable_transform_perspective_invoker);
procedure = gimp_procedure_new (drawable_transform_perspective_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-transform-perspective",
"gimp-drawable-transform-perspective",
@ -1503,9 +1495,7 @@ register_drawable_transform_procs (Gimp *gimp)
/*
* gimp-drawable-transform-perspective-default
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 11, 1,
drawable_transform_perspective_default_invoker);
procedure = gimp_procedure_new (drawable_transform_perspective_default_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-transform-perspective-default",
"gimp-drawable-transform-perspective-default",
@ -1593,9 +1583,7 @@ register_drawable_transform_procs (Gimp *gimp)
/*
* gimp-drawable-transform-rotate-simple
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 6, 1,
drawable_transform_rotate_simple_invoker);
procedure = gimp_procedure_new (drawable_transform_rotate_simple_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-transform-rotate-simple",
"gimp-drawable-transform-rotate-simple",
@ -1654,9 +1642,7 @@ register_drawable_transform_procs (Gimp *gimp)
/*
* gimp-drawable-transform-rotate
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 10, 1,
drawable_transform_rotate_invoker);
procedure = gimp_procedure_new (drawable_transform_rotate_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-transform-rotate",
"gimp-drawable-transform-rotate",
@ -1740,9 +1726,7 @@ register_drawable_transform_procs (Gimp *gimp)
/*
* gimp-drawable-transform-rotate-default
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 7, 1,
drawable_transform_rotate_default_invoker);
procedure = gimp_procedure_new (drawable_transform_rotate_default_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-transform-rotate-default",
"gimp-drawable-transform-rotate-default",
@ -1806,9 +1790,7 @@ register_drawable_transform_procs (Gimp *gimp)
/*
* gimp-drawable-transform-scale
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 10, 1,
drawable_transform_scale_invoker);
procedure = gimp_procedure_new (drawable_transform_scale_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-transform-scale",
"gimp-drawable-transform-scale",
@ -1892,9 +1874,7 @@ register_drawable_transform_procs (Gimp *gimp)
/*
* gimp-drawable-transform-scale-default
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 7, 1,
drawable_transform_scale_default_invoker);
procedure = gimp_procedure_new (drawable_transform_scale_default_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-transform-scale-default",
"gimp-drawable-transform-scale-default",
@ -1958,9 +1938,7 @@ register_drawable_transform_procs (Gimp *gimp)
/*
* gimp-drawable-transform-shear
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 8, 1,
drawable_transform_shear_invoker);
procedure = gimp_procedure_new (drawable_transform_shear_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-transform-shear",
"gimp-drawable-transform-shear",
@ -2035,9 +2013,7 @@ register_drawable_transform_procs (Gimp *gimp)
/*
* gimp-drawable-transform-shear-default
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 5, 1,
drawable_transform_shear_default_invoker);
procedure = gimp_procedure_new (drawable_transform_shear_default_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-transform-shear-default",
"gimp-drawable-transform-shear-default",
@ -2092,9 +2068,7 @@ register_drawable_transform_procs (Gimp *gimp)
/*
* gimp-drawable-transform-2d
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 13, 1,
drawable_transform_2d_invoker);
procedure = gimp_procedure_new (drawable_transform_2d_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-transform-2d",
"gimp-drawable-transform-2d",
@ -2196,9 +2170,7 @@ register_drawable_transform_procs (Gimp *gimp)
/*
* gimp-drawable-transform-2d-default
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 10, 1,
drawable_transform_2d_default_invoker);
procedure = gimp_procedure_new (drawable_transform_2d_default_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-transform-2d-default",
"gimp-drawable-transform-2d-default",
@ -2280,9 +2252,7 @@ register_drawable_transform_procs (Gimp *gimp)
/*
* gimp-drawable-transform-matrix
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 15, 1,
drawable_transform_matrix_invoker);
procedure = gimp_procedure_new (drawable_transform_matrix_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-transform-matrix",
"gimp-drawable-transform-matrix",
@ -2396,9 +2366,7 @@ register_drawable_transform_procs (Gimp *gimp)
/*
* gimp-drawable-transform-matrix-default
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 12, 1,
drawable_transform_matrix_default_invoker);
procedure = gimp_procedure_new (drawable_transform_matrix_default_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-transform-matrix-default",
"gimp-drawable-transform-matrix-default",

60
app/pdb/edit_cmds.c
View File

@ -637,9 +637,7 @@ register_edit_procs (Gimp *gimp)
/*
* gimp-edit-cut
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
edit_cut_invoker);
procedure = gimp_procedure_new (edit_cut_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-edit-cut",
"gimp-edit-cut",
@ -667,9 +665,7 @@ register_edit_procs (Gimp *gimp)
/*
* gimp-edit-copy
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
edit_copy_invoker);
procedure = gimp_procedure_new (edit_copy_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-edit-copy",
"gimp-edit-copy",
@ -697,9 +693,7 @@ register_edit_procs (Gimp *gimp)
/*
* gimp-edit-copy-visible
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
edit_copy_visible_invoker);
procedure = gimp_procedure_new (edit_copy_visible_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-edit-copy-visible",
"gimp-edit-copy-visible",
@ -727,9 +721,7 @@ register_edit_procs (Gimp *gimp)
/*
* gimp-edit-paste
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 1,
edit_paste_invoker);
procedure = gimp_procedure_new (edit_paste_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-edit-paste",
"gimp-edit-paste",
@ -763,9 +755,7 @@ register_edit_procs (Gimp *gimp)
/*
* gimp-edit-paste-as-new
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 0, 1,
edit_paste_as_new_invoker);
procedure = gimp_procedure_new (edit_paste_as_new_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-edit-paste-as-new",
"gimp-edit-paste-as-new",
@ -787,9 +777,7 @@ register_edit_procs (Gimp *gimp)
/*
* gimp-edit-named-cut
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 1,
edit_named_cut_invoker);
procedure = gimp_procedure_new (edit_named_cut_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-edit-named-cut",
"gimp-edit-named-cut",
@ -825,9 +813,7 @@ register_edit_procs (Gimp *gimp)
/*
* gimp-edit-named-copy
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 1,
edit_named_copy_invoker);
procedure = gimp_procedure_new (edit_named_copy_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-edit-named-copy",
"gimp-edit-named-copy",
@ -863,9 +849,7 @@ register_edit_procs (Gimp *gimp)
/*
* gimp-edit-named-copy-visible
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 1,
edit_named_copy_visible_invoker);
procedure = gimp_procedure_new (edit_named_copy_visible_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-edit-named-copy-visible",
"gimp-edit-named-copy-visible",
@ -901,9 +885,7 @@ register_edit_procs (Gimp *gimp)
/*
* gimp-edit-named-paste
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 1,
edit_named_paste_invoker);
procedure = gimp_procedure_new (edit_named_paste_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-edit-named-paste",
"gimp-edit-named-paste",
@ -944,9 +926,7 @@ register_edit_procs (Gimp *gimp)
/*
* gimp-edit-named-paste-as-new
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
edit_named_paste_as_new_invoker);
procedure = gimp_procedure_new (edit_named_paste_as_new_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-edit-named-paste-as-new",
"gimp-edit-named-paste-as-new",
@ -975,9 +955,7 @@ register_edit_procs (Gimp *gimp)
/*
* gimp-edit-clear
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
edit_clear_invoker);
procedure = gimp_procedure_new (edit_clear_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-edit-clear",
"gimp-edit-clear",
@ -999,9 +977,7 @@ register_edit_procs (Gimp *gimp)
/*
* gimp-edit-fill
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
edit_fill_invoker);
procedure = gimp_procedure_new (edit_fill_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-edit-fill",
"gimp-edit-fill",
@ -1030,9 +1006,7 @@ register_edit_procs (Gimp *gimp)
/*
* gimp-edit-bucket-fill
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 8, 0,
edit_bucket_fill_invoker);
procedure = gimp_procedure_new (edit_bucket_fill_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-edit-bucket-fill",
"gimp-edit-bucket-fill",
@ -1098,9 +1072,7 @@ register_edit_procs (Gimp *gimp)
/*
* gimp-edit-blend
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 16, 0,
edit_blend_invoker);
procedure = gimp_procedure_new (edit_blend_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-edit-blend",
"gimp-edit-blend",
@ -1216,9 +1188,7 @@ register_edit_procs (Gimp *gimp)
/*
* gimp-edit-stroke
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
edit_stroke_invoker);
procedure = gimp_procedure_new (edit_stroke_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-edit-stroke",
"gimp-edit-stroke",

45
app/pdb/fileops_cmds.c
View File

@ -41,7 +41,6 @@
#include "core/gimplayer.h"
#include "file/file-open.h"
#include "file/file-utils.h"
#include "plug-in/plug-in-proc-def.h"
#include "plug-in/plug-in.h"
#include "plug-in/plug-ins.h"
@ -572,9 +571,7 @@ register_fileops_procs (Gimp *gimp)
/*
* gimp-file-load
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 1,
file_load_invoker);
procedure = gimp_procedure_new (file_load_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-file-load",
"gimp-file-load",
@ -619,9 +616,7 @@ register_fileops_procs (Gimp *gimp)
/*
* gimp-file-load-layer
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 1,
file_load_layer_invoker);
procedure = gimp_procedure_new (file_load_layer_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-file-load-layer",
"gimp-file-load-layer",
@ -665,9 +660,7 @@ register_fileops_procs (Gimp *gimp)
/*
* gimp-file-load-thumbnail
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 4,
file_load_thumbnail_invoker);
procedure = gimp_procedure_new (file_load_thumbnail_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-file-load-thumbnail",
"gimp-file-load-thumbnail",
@ -713,9 +706,7 @@ register_fileops_procs (Gimp *gimp)
/*
* gimp-file-save
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 5, 0,
file_save_invoker);
procedure = gimp_procedure_new (file_save_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-file-save",
"gimp-file-save",
@ -764,9 +755,7 @@ register_fileops_procs (Gimp *gimp)
/*
* gimp-file-save-thumbnail
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
file_save_thumbnail_invoker);
procedure = gimp_procedure_new (file_save_thumbnail_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-file-save-thumbnail",
"gimp-file-save-thumbnail",
@ -795,9 +784,7 @@ register_fileops_procs (Gimp *gimp)
/*
* gimp-temp-name
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
temp_name_invoker);
procedure = gimp_procedure_new (temp_name_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-temp-name",
"gimp-temp-name",
@ -827,9 +814,7 @@ register_fileops_procs (Gimp *gimp)
/*
* gimp-register-magic-load-handler
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 4, 0,
register_magic_load_handler_invoker);
procedure = gimp_procedure_new (register_magic_load_handler_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-register-magic-load-handler",
"gimp-register-magic-load-handler",
@ -873,9 +858,7 @@ register_fileops_procs (Gimp *gimp)
/*
* gimp-register-load-handler
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 0,
register_load_handler_invoker);
procedure = gimp_procedure_new (register_load_handler_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-register-load-handler",
"gimp-register-load-handler",
@ -912,9 +895,7 @@ register_fileops_procs (Gimp *gimp)
/*
* gimp-register-save-handler
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 0,
register_save_handler_invoker);
procedure = gimp_procedure_new (register_save_handler_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-register-save-handler",
"gimp-register-save-handler",
@ -951,9 +932,7 @@ register_fileops_procs (Gimp *gimp)
/*
* gimp-register-file-handler-mime
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
register_file_handler_mime_invoker);
procedure = gimp_procedure_new (register_file_handler_mime_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-register-file-handler-mime",
"gimp-register-file-handler-mime",
@ -983,9 +962,7 @@ register_fileops_procs (Gimp *gimp)
/*
* gimp-register-thumbnail-loader
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
register_thumbnail_loader_invoker);
procedure = gimp_procedure_new (register_thumbnail_loader_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-register-thumbnail-loader",
"gimp-register-thumbnail-loader",

24
app/pdb/floating_sel_cmds.c
View File

@ -185,9 +185,7 @@ register_floating_sel_procs (Gimp *gimp)
/*
* gimp-floating-sel-remove
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
floating_sel_remove_invoker);
procedure = gimp_procedure_new (floating_sel_remove_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-floating-sel-remove",
"gimp-floating-sel-remove",
@ -209,9 +207,7 @@ register_floating_sel_procs (Gimp *gimp)
/*
* gimp-floating-sel-anchor
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
floating_sel_anchor_invoker);
procedure = gimp_procedure_new (floating_sel_anchor_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-floating-sel-anchor",
"gimp-floating-sel-anchor",
@ -233,9 +229,7 @@ register_floating_sel_procs (Gimp *gimp)
/*
* gimp-floating-sel-to-layer
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
floating_sel_to_layer_invoker);
procedure = gimp_procedure_new (floating_sel_to_layer_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-floating-sel-to-layer",
"gimp-floating-sel-to-layer",
@ -257,9 +251,7 @@ register_floating_sel_procs (Gimp *gimp)
/*
* gimp-floating-sel-attach
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
floating_sel_attach_invoker);
procedure = gimp_procedure_new (floating_sel_attach_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-floating-sel-attach",
"gimp-floating-sel-attach",
@ -287,9 +279,7 @@ register_floating_sel_procs (Gimp *gimp)
/*
* gimp-floating-sel-rigor
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
floating_sel_rigor_invoker);
procedure = gimp_procedure_new (floating_sel_rigor_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-floating-sel-rigor",
"gimp-floating-sel-rigor",
@ -317,9 +307,7 @@ register_floating_sel_procs (Gimp *gimp)
/*
* gimp-floating-sel-relax
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
floating_sel_relax_invoker);
procedure = gimp_procedure_new (floating_sel_relax_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-floating-sel-relax",
"gimp-floating-sel-relax",

12
app/pdb/font_select_cmds.c
View File

@ -117,9 +117,7 @@ register_font_select_procs (Gimp *gimp)
/*
* gimp-fonts-popup
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 0,
fonts_popup_invoker);
procedure = gimp_procedure_new (fonts_popup_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-fonts-popup",
"gimp-fonts-popup",
@ -156,9 +154,7 @@ register_font_select_procs (Gimp *gimp)
/*
* gimp-fonts-close-popup
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
fonts_close_popup_invoker);
procedure = gimp_procedure_new (fonts_close_popup_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-fonts-close-popup",
"gimp-fonts-close-popup",
@ -181,9 +177,7 @@ register_font_select_procs (Gimp *gimp)
/*
* gimp-fonts-set-popup
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
fonts_set_popup_invoker);
procedure = gimp_procedure_new (fonts_set_popup_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-fonts-set-popup",
"gimp-fonts-set-popup",

8
app/pdb/fonts_cmds.c
View File

@ -85,9 +85,7 @@ register_fonts_procs (Gimp *gimp)
/*
* gimp-fonts-refresh
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 0, 0,
fonts_refresh_invoker);
procedure = gimp_procedure_new (fonts_refresh_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-fonts-refresh",
"gimp-fonts-refresh",
@ -103,9 +101,7 @@ register_fonts_procs (Gimp *gimp)
/*
* gimp-fonts-get-list
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 2,
fonts_get_list_invoker);
procedure = gimp_procedure_new (fonts_get_list_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-fonts-get-list",
"gimp-fonts-get-list",

7
app/pdb/gimp-pdb.c
View File

@ -43,6 +43,7 @@
#include "gimp-pdb.h"
#include "gimpprocedure.h"
#include "gimptemporaryprocedure.h" /* eek */
#include "internal_procs.h"
#include "gimp-intl.h"
@ -64,6 +65,12 @@ gimp_pdb_init (Gimp *gimp)
gimp->procedural_ht = g_hash_table_new (g_str_hash, g_str_equal);
gimp->procedural_compat_ht = g_hash_table_new (g_str_hash, g_str_equal);
{
volatile GType eek;
eek = GIMP_TYPE_TEMPORARY_PROCEDURE;
}
}
void

7
app/pdb/gimppdb.c
View File

@ -43,6 +43,7 @@
#include "gimp-pdb.h"
#include "gimpprocedure.h"
#include "gimptemporaryprocedure.h" /* eek */
#include "internal_procs.h"
#include "gimp-intl.h"
@ -64,6 +65,12 @@ gimp_pdb_init (Gimp *gimp)
gimp->procedural_ht = g_hash_table_new (g_str_hash, g_str_equal);
gimp->procedural_compat_ht = g_hash_table_new (g_str_hash, g_str_equal);
{
volatile GType eek;
eek = GIMP_TYPE_TEMPORARY_PROCEDURE;
}
}
void

79
app/pdb/gimppluginprocedure.c
View File

@ -27,27 +27,28 @@
#include "libgimpbase/gimpbase.h"
#include "plug-in-types.h"
#include "pdb-types.h"
#include "core/gimp.h"
#include "pdb/gimpprocedure.h"
#include "plug-in/plug-in.h"
#include "plug-in/plug-ins.h"
#include "plug-in/plug-in-run.h"
#include "plug-in.h"
#include "plug-ins.h"
#include "plug-in-proc-def.h"
#include "plug-in-run.h"
#include "gimppluginprocedure.h"
#include "gimp-intl.h"
static void gimp_plug_in_procedure_finalize (GObject *object);
static void gimp_plug_in_procedure_finalize (GObject *object);
static GValueArray * gimp_plug_in_procedure_execute (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
GValueArray *args);
static GValueArray * gimp_plug_in_procedure_execute (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
GValueArray *args);
const gchar * gimp_plug_in_procedure_real_get_progname (const GimpPlugInProcedure *procedure);
G_DEFINE_TYPE (GimpPlugInProcedure, gimp_plug_in_procedure,
@ -65,11 +66,15 @@ gimp_plug_in_procedure_class_init (GimpPlugInProcedureClass *klass)
object_class->finalize = gimp_plug_in_procedure_finalize;
proc_class->execute = gimp_plug_in_procedure_execute;
klass->get_progname = gimp_plug_in_procedure_real_get_progname;
}
static void
gimp_plug_in_procedure_init (GimpPlugInProcedure *proc)
{
GIMP_PROCEDURE (proc)->proc_type = GIMP_PLUGIN;
proc->icon_data_length = -1;
}
@ -107,11 +112,11 @@ gimp_plug_in_procedure_finalize (GObject *object)
}
static GValueArray *
gimp_plug_in_procedure_execute (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
GValueArray *args)
gimp_plug_in_procedure_execute (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
GValueArray *args)
{
if (procedure->proc_type == GIMP_INTERNAL)
return GIMP_PROCEDURE_CLASS (parent_class)->execute (procedure, gimp,
@ -122,15 +127,32 @@ gimp_plug_in_procedure_execute (GimpProcedure *procedure,
args, TRUE, FALSE, -1);
}
const gchar *
gimp_plug_in_procedure_real_get_progname (const GimpPlugInProcedure *procedure)
{
return procedure->prog;
}
/* public functions */
GimpPlugInProcedure *
gimp_plug_in_procedure_new (void)
GimpProcedure *
gimp_plug_in_procedure_new (GimpPDBProcType proc_type,
const gchar *prog)
{
GimpPlugInProcedure *proc = g_object_new (GIMP_TYPE_PLUG_IN_PROCEDURE, NULL);
GimpPlugInProcedure *proc;
return proc;
g_return_val_if_fail (proc_type == GIMP_PLUGIN ||
proc_type == GIMP_EXTENSION, NULL);
g_return_val_if_fail (prog != NULL, NULL);
proc = g_object_new (GIMP_TYPE_PLUG_IN_PROCEDURE, NULL);
proc->prog = g_strdup (prog);
GIMP_PROCEDURE (proc)->proc_type = proc_type;
return GIMP_PROCEDURE (proc);
}
GimpPlugInProcedure *
@ -155,20 +177,7 @@ gimp_plug_in_procedure_get_progname (const GimpPlugInProcedure *proc)
{
g_return_val_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc), NULL);
switch (GIMP_PROCEDURE (proc)->proc_type)
{
case GIMP_PLUGIN:
case GIMP_EXTENSION:
return proc->prog;
case GIMP_TEMPORARY:
return ((PlugIn *) GIMP_PROCEDURE (proc)->exec_method.temporary.plug_in)->prog;
default:
break;
}
return NULL;
return GIMP_PLUG_IN_PROCEDURE_GET_CLASS (proc)->get_progname (proc);
}
gchar *

25
app/pdb/gimppluginprocedure.h
View File

@ -25,7 +25,7 @@
#include <gdk-pixbuf/gdk-pixbuf.h>
#include "pdb/gimpprocedure.h"
#include "gimpprocedure.h"
#define GIMP_TYPE_PLUG_IN_PROCEDURE (gimp_plug_in_procedure_get_type ())
@ -69,31 +69,34 @@ struct _GimpPlugInProcedure
struct _GimpPlugInProcedureClass
{
GimpProcedureClass parent_class;
const gchar * (* get_progname) (const GimpPlugInProcedure *procedure);
};
GType gimp_plug_in_procedure_get_type (void) G_GNUC_CONST;
GType gimp_plug_in_procedure_get_type (void) G_GNUC_CONST;
GimpPlugInProcedure * gimp_plug_in_procedure_new (void);
GimpProcedure * gimp_plug_in_procedure_new (GimpPDBProcType proc_type,
const gchar *prog);
GimpPlugInProcedure * gimp_plug_in_procedure_find (GSList *list,
const gchar *proc_name);
GimpPlugInProcedure * gimp_plug_in_procedure_find (GSList *list,
const gchar *proc_name);
const gchar * gimp_plug_in_procedure_get_progname (const GimpPlugInProcedure *proc);
gchar * gimp_plug_in_procedure_get_label (const GimpPlugInProcedure *proc,
const gchar *locale_domain);
const gchar *locale_domain);
void gimp_plug_in_procedure_set_icon (GimpPlugInProcedure *proc,
GimpIconType type,
const guint8 *data,
gint data_length);
GimpIconType type,
const guint8 *data,
gint data_length);
const gchar * gimp_plug_in_procedure_get_stock_id (const GimpPlugInProcedure *proc);
GdkPixbuf * gimp_plug_in_procedure_get_pixbuf (const GimpPlugInProcedure *proc);
gchar * gimp_plug_in_procedure_get_help_id (const GimpPlugInProcedure *proc,
const gchar *help_domain);
const gchar *help_domain);
gboolean gimp_plug_in_procedure_get_sensitive (const GimpPlugInProcedure *proc,
GimpImageType image_type);
GimpImageType image_type);
void gimp_plug_in_procedure_set_image_types (GimpPlugInProcedure *proc,
const gchar *image_types);

93
app/pdb/gimpprocedure.c
View File

@ -74,6 +74,7 @@ gimp_procedure_class_init (GimpProcedureClass *klass)
static void
gimp_procedure_init (GimpProcedure *procedure)
{
procedure->proc_type = GIMP_INTERNAL;
}
static void
@ -114,64 +115,24 @@ gimp_procedure_real_execute (GimpProcedure *procedure,
{
g_return_val_if_fail (args->n_values >= procedure->num_args, NULL);
return procedure->exec_method.internal.marshal_func (procedure, gimp,
context, progress,
args);
return procedure->marshal_func (procedure, gimp,
context, progress,
args);
}
/* public functions */
GimpProcedure *
gimp_procedure_new (void)
gimp_procedure_new (GimpMarshalFunc marshal_func)
{
GimpProcedure *procedure = g_object_new (GIMP_TYPE_PROCEDURE, NULL);
GimpProcedure *procedure;
return procedure;
}
g_return_val_if_fail (marshal_func != NULL, NULL);
GimpProcedure *
gimp_procedure_initialize (GimpProcedure *procedure,
GimpPDBProcType proc_type,
gint n_arguments,
gint n_return_values,
gpointer exec_method)
{
g_return_val_if_fail (GIMP_IS_PROCEDURE (procedure), procedure);
g_return_val_if_fail (procedure->args == NULL, procedure);
g_return_val_if_fail (procedure->values == NULL, procedure);
g_return_val_if_fail (n_arguments >= 0, procedure);
g_return_val_if_fail (n_return_values >= 0, procedure);
procedure = g_object_new (GIMP_TYPE_PROCEDURE, NULL);
procedure->proc_type = proc_type;
procedure->num_args = n_arguments;
procedure->args = g_new0 (GParamSpec *, n_arguments);
procedure->num_values = n_return_values;
procedure->values = g_new0 (GParamSpec *, n_return_values);
if (exec_method)
{
switch (proc_type)
{
case GIMP_INTERNAL:
procedure->exec_method.internal.marshal_func = exec_method;
break;
case GIMP_PLUGIN:
procedure->exec_method.plug_in.filename = g_strdup (exec_method);
break;
case GIMP_EXTENSION:
procedure->exec_method.extension.filename = g_strdup (exec_method);
break;
case GIMP_TEMPORARY:
procedure->exec_method.temporary.plug_in = exec_method;
break;
}
}
procedure->marshal_func = marshal_func;
return procedure;
}
@ -427,48 +388,36 @@ void
gimp_procedure_add_argument (GimpProcedure *procedure,
GParamSpec *pspec)
{
gint i;
g_return_if_fail (GIMP_IS_PROCEDURE (procedure));
g_return_if_fail (G_IS_PARAM_SPEC (pspec));
for (i = 0; i < procedure->num_args; i++)
if (procedure->args[i] == NULL)
{
procedure->args[i] = pspec;
procedure->args = g_renew (GParamSpec *, procedure->args,
procedure->num_args + 1);
g_param_spec_ref (pspec);
g_param_spec_sink (pspec);
procedure->args[procedure->num_args] = pspec;
return;
}
g_param_spec_ref (pspec);
g_param_spec_sink (pspec);
g_warning ("%s: can't register more than %d arguments for procedure %s",
G_STRFUNC, procedure->num_args, procedure->name);
procedure->num_args++;
}
void
gimp_procedure_add_return_value (GimpProcedure *procedure,
GParamSpec *pspec)
{
gint i;
g_return_if_fail (GIMP_IS_PROCEDURE (procedure));
g_return_if_fail (G_IS_PARAM_SPEC (pspec));
for (i = 0; i < procedure->num_values; i++)
if (procedure->values[i] == NULL)
{
procedure->values[i] = pspec;
procedure->values = g_renew (GParamSpec *, procedure->values,
procedure->num_values + 1);
g_param_spec_ref (pspec);
g_param_spec_sink (pspec);
procedure->values[procedure->num_values] = pspec;
return;
}
g_param_spec_ref (pspec);
g_param_spec_sink (pspec);
g_warning ("%s: can't register more than %d return values for procedure %s",
G_STRFUNC, procedure->num_values, procedure->name);
procedure->num_values++;
}

90
app/pdb/gimpprocedure.h
View File

@ -23,40 +23,11 @@
#include "core/gimpobject.h"
/* Execution types */
typedef struct _IntExec IntExec;
typedef struct _PlugInExec PlugInExec;
typedef struct _ExtExec ExtExec;
typedef struct _TempExec TempExec;
struct _IntExec
{
/* Function called to marshal arguments */
GValueArray * (* marshal_func) (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GValueArray *args);
};
struct _PlugInExec
{
/* Where is the executable on disk? */
gchar *filename;
};
struct _ExtExec
{
/* Where is the executable on disk? */
gchar *filename;
};
struct _TempExec
{
/* Plug-in that registered this temp proc */
void *plug_in;
};
typedef GValueArray * (* GimpMarshalFunc) (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GValueArray *args);
#define GIMP_TYPE_PROCEDURE (gimp_procedure_get_type ())
@ -71,40 +42,28 @@ typedef struct _GimpProcedureClass GimpProcedureClass;
struct _GimpProcedure
{
GimpObject parent_instance;
GimpObject parent_instance;
/* Flags */
gboolean static_strings; /* Are the procedure's strings allocated? */
GimpPDBProcType proc_type; /* Type of procedure */
/* Procedure information */
gchar *name; /* Procedure name */
gchar *original_name; /* Procedure name before canonicalization */
gchar *blurb; /* Short procedure description */
gchar *help; /* Detailed help instructions */
gchar *author; /* Author field */
gchar *copyright; /* Copyright field */
gchar *date; /* Date field */
gchar *deprecated; /* Replacement if the procedure is deprecated */
gboolean static_strings; /* Are the strings allocated? */
/* Procedure type */
GimpPDBProcType proc_type; /* Type of procedure */
gchar *name; /* Procedure name */
gchar *original_name; /* Uncanonicalized procedure name */
gchar *blurb; /* Short procedure description */
gchar *help; /* Detailed help instructions */
gchar *author; /* Author field */
gchar *copyright; /* Copyright field */
gchar *date; /* Date field */
gchar *deprecated; /* Replacement if deprecated */
/* Input arguments */
gint32 num_args; /* Number of procedure arguments */
GParamSpec **args; /* Array of procedure arguments */
gint32 num_args; /* Number of procedure arguments */
GParamSpec **args; /* Array of procedure arguments */
/* Output values */
gint32 num_values; /* Number of return values */
GParamSpec **values; /* Array of return values */
gint32 num_values; /* Number of return values */
GParamSpec **values; /* Array of return values */
/* Method of procedure execution */
union _ExecMethod
{
IntExec internal; /* Execution information for internal procs */
PlugInExec plug_in; /* ..................... for plug-ins */
ExtExec extension; /* ..................... for extensions */
TempExec temporary; /* ..................... for temp procs */
} exec_method;
GimpMarshalFunc marshal_func; /* Marshaller for internal procs */
};
struct _GimpProcedureClass
@ -121,12 +80,7 @@ struct _GimpProcedureClass
GType gimp_procedure_get_type (void) G_GNUC_CONST;
GimpProcedure * gimp_procedure_new (void);
GimpProcedure * gimp_procedure_initialize (GimpProcedure *procedure,
GimpPDBProcType proc_type,
gint n_arguments,
gint n_return_vals,
gpointer exec_method);
GimpProcedure * gimp_procedure_new (GimpMarshalFunc marshal_func);
void gimp_procedure_set_strings (GimpProcedure *procedure,
gchar *name,

28
app/pdb/gimprc_cmds.c
View File

@ -203,9 +203,7 @@ register_gimprc_procs (Gimp *gimp)
/*
* gimp-gimprc-query
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
gimprc_query_invoker);
procedure = gimp_procedure_new (gimprc_query_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-gimprc-query",
"gimp-gimprc-query",
@ -235,9 +233,7 @@ register_gimprc_procs (Gimp *gimp)
/*
* gimp-gimprc-set
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
gimprc_set_invoker);
procedure = gimp_procedure_new (gimprc_set_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-gimprc-set",
"gimp-gimprc-set",
@ -267,9 +263,7 @@ register_gimprc_procs (Gimp *gimp)
/*
* gimp-get-default-comment
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 0, 1,
get_default_comment_invoker);
procedure = gimp_procedure_new (get_default_comment_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-get-default-comment",
"gimp-get-default-comment",
@ -292,9 +286,7 @@ register_gimprc_procs (Gimp *gimp)
/*
* gimp-get-monitor-resolution
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 0, 2,
get_monitor_resolution_invoker);
procedure = gimp_procedure_new (get_monitor_resolution_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-get-monitor-resolution",
"gimp-get-monitor-resolution",
@ -322,9 +314,7 @@ register_gimprc_procs (Gimp *gimp)
/*
* gimp-get-theme-dir
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 0, 1,
get_theme_dir_invoker);
procedure = gimp_procedure_new (get_theme_dir_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-get-theme-dir",
"gimp-get-theme-dir",
@ -347,9 +337,7 @@ register_gimprc_procs (Gimp *gimp)
/*
* gimp-get-color-configuration
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 0, 1,
get_color_configuration_invoker);
procedure = gimp_procedure_new (get_color_configuration_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-get-color-configuration",
"gimp-get-color-configuration",
@ -372,9 +360,7 @@ register_gimprc_procs (Gimp *gimp)
/*
* gimp-get-module-load-inhibit
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 0, 1,
get_module_load_inhibit_invoker);
procedure = gimp_procedure_new (get_module_load_inhibit_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-get-module-load-inhibit",
"gimp-get-module-load-inhibit",

114
app/pdb/gimptemporaryprocedure.c Normal file
View File

@ -0,0 +1,114 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimptemporaryprocedure.c
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <glib-object.h>
#include "pdb-types.h"
#include "plug-in/plug-in.h"
#include "gimptemporaryprocedure.h"
#include "gimp-intl.h"
static void gimp_temporary_procedure_finalize (GObject *object);
static GValueArray * gimp_temporary_procedure_execute (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
GValueArray *args);
const gchar * gimp_temporary_procedure_get_progname (const GimpPlugInProcedure *procedure);
G_DEFINE_TYPE (GimpTemporaryProcedure, gimp_temporary_procedure,
GIMP_TYPE_PLUG_IN_PROCEDURE);
#define parent_class gimp_temporary_procedure_parent_class
static void
gimp_temporary_procedure_class_init (GimpTemporaryProcedureClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GimpProcedureClass *proc_class = GIMP_PROCEDURE_CLASS (klass);
GimpPlugInProcedureClass *plug_class = GIMP_PLUG_IN_PROCEDURE_CLASS (klass);
object_class->finalize = gimp_temporary_procedure_finalize;
proc_class->execute = gimp_temporary_procedure_execute;
plug_class->get_progname = gimp_temporary_procedure_get_progname;
}
static void
gimp_temporary_procedure_init (GimpTemporaryProcedure *proc)
{
GIMP_PROCEDURE (proc)->proc_type = GIMP_TEMPORARY;
}
static void
gimp_temporary_procedure_finalize (GObject *object)
{
/* GimpTemporaryProcedure *proc = GIMP_TEMPORARY_PROCEDURE (object); */
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static GValueArray *
gimp_temporary_procedure_execute (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
GValueArray *args)
{
return GIMP_PROCEDURE_CLASS (parent_class)->execute (procedure, gimp,
context, progress,
args);
}
const gchar *
gimp_temporary_procedure_get_progname (const GimpPlugInProcedure *procedure)
{
return GIMP_TEMPORARY_PROCEDURE (procedure)->plug_in->prog;
}
/* public functions */
GimpProcedure *
gimp_temporary_procedure_new (PlugIn *plug_in)
{
GimpTemporaryProcedure *proc;
g_return_val_if_fail (plug_in != NULL, NULL);
proc = g_object_new (GIMP_TYPE_TEMPORARY_PROCEDURE, NULL);
proc->plug_in = plug_in;
GIMP_PLUG_IN_PROCEDURE (proc)->prog = g_strdup ("none");
return GIMP_PROCEDURE (proc);
}

56
app/pdb/gimptemporaryprocedure.h Normal file
View File

@ -0,0 +1,56 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimptemporaryprocedure.h
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_TEMPORARY_PROCEDURE_H__
#define __GIMP_TEMPORARY_PROCEDURE_H__
#include "gimppluginprocedure.h"
#define GIMP_TYPE_TEMPORARY_PROCEDURE (gimp_temporary_procedure_get_type ())
#define GIMP_TEMPORARY_PROCEDURE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_TEMPORARY_PROCEDURE, GimpTemporaryProcedure))
#define GIMP_TEMPORARY_PROCEDURE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_TEMPORARY_PROCEDURE, GimpTemporaryProcedureClass))
#define GIMP_IS_TEMPORARY_PROCEDURE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_TEMPORARY_PROCEDURE))
#define GIMP_IS_TEMPORARY_PROCEDURE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_TEMPORARY_PROCEDURE))
#define GIMP_TEMPORARY_PROCEDURE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_TEMPORARY_PROCEDURE, GimpTemporaryProcedureClass))
typedef struct _GimpTemporaryProcedureClass GimpTemporaryProcedureClass;
struct _GimpTemporaryProcedure
{
GimpPlugInProcedure parent_instance;
PlugIn *plug_in;
};
struct _GimpTemporaryProcedureClass
{
GimpPlugInProcedureClass parent_class;
};
GType gimp_temporary_procedure_get_type (void) G_GNUC_CONST;
GimpProcedure * gimp_temporary_procedure_new (PlugIn *plug_in);
#endif /* __GIMP_TEMPORARY_PROCEDURE_H__ */

120
app/pdb/gradient_cmds.c
View File

@ -1337,9 +1337,7 @@ register_gradient_procs (Gimp *gimp)
/*
* gimp-gradient-new
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
gradient_new_invoker);
procedure = gimp_procedure_new (gradient_new_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-new",
"gimp-gradient-new",
@ -1369,9 +1367,7 @@ register_gradient_procs (Gimp *gimp)
/*
* gimp-gradient-duplicate
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
gradient_duplicate_invoker);
procedure = gimp_procedure_new (gradient_duplicate_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-duplicate",
"gimp-gradient-duplicate",
@ -1401,9 +1397,7 @@ register_gradient_procs (Gimp *gimp)
/*
* gimp-gradient-is-editable
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
gradient_is_editable_invoker);
procedure = gimp_procedure_new (gradient_is_editable_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-is-editable",
"gimp-gradient-is-editable",
@ -1432,9 +1426,7 @@ register_gradient_procs (Gimp *gimp)
/*
* gimp-gradient-rename
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 1,
gradient_rename_invoker);
procedure = gimp_procedure_new (gradient_rename_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-rename",
"gimp-gradient-rename",
@ -1471,9 +1463,7 @@ register_gradient_procs (Gimp *gimp)
/*
* gimp-gradient-delete
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
gradient_delete_invoker);
procedure = gimp_procedure_new (gradient_delete_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-delete",
"gimp-gradient-delete",
@ -1496,9 +1486,7 @@ register_gradient_procs (Gimp *gimp)
/*
* gimp-gradient-get-uniform-samples
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 2,
gradient_get_uniform_samples_invoker);
procedure = gimp_procedure_new (gradient_get_uniform_samples_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-get-uniform-samples",
"gimp-gradient-get-uniform-samples",
@ -1544,9 +1532,7 @@ register_gradient_procs (Gimp *gimp)
/*
* gimp-gradient-get-custom-samples
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 4, 2,
gradient_get_custom_samples_invoker);
procedure = gimp_procedure_new (gradient_get_custom_samples_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-get-custom-samples",
"gimp-gradient-get-custom-samples",
@ -1597,9 +1583,7 @@ register_gradient_procs (Gimp *gimp)
/*
* gimp-gradient-segment-get-left-color
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 2,
gradient_segment_get_left_color_invoker);
procedure = gimp_procedure_new (gradient_segment_get_left_color_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-get-left-color",
"gimp-gradient-segment-get-left-color",
@ -1640,9 +1624,7 @@ register_gradient_procs (Gimp *gimp)
/*
* gimp-gradient-segment-set-left-color
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 4, 0,
gradient_segment_set_left_color_invoker);
procedure = gimp_procedure_new (gradient_segment_set_left_color_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-set-left-color",
"gimp-gradient-segment-set-left-color",
@ -1683,9 +1665,7 @@ register_gradient_procs (Gimp *gimp)
/*
* gimp-gradient-segment-get-right-color
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 2,
gradient_segment_get_right_color_invoker);
procedure = gimp_procedure_new (gradient_segment_get_right_color_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-get-right-color",
"gimp-gradient-segment-get-right-color",
@ -1726,9 +1706,7 @@ register_gradient_procs (Gimp *gimp)
/*
* gimp-gradient-segment-set-right-color
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 4, 0,
gradient_segment_set_right_color_invoker);
procedure = gimp_procedure_new (gradient_segment_set_right_color_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-set-right-color",
"gimp-gradient-segment-set-right-color",
@ -1769,9 +1747,7 @@ register_gradient_procs (Gimp *gimp)
/*
* gimp-gradient-segment-get-left-pos
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 1,
gradient_segment_get_left_pos_invoker);
procedure = gimp_procedure_new (gradient_segment_get_left_pos_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-get-left-pos",
"gimp-gradient-segment-get-left-pos",
@ -1806,9 +1782,7 @@ register_gradient_procs (Gimp *gimp)
/*
* gimp-gradient-segment-set-left-pos
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 1,
gradient_segment_set_left_pos_invoker);
procedure = gimp_procedure_new (gradient_segment_set_left_pos_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-set-left-pos",
"gimp-gradient-segment-set-left-pos",
@ -1849,9 +1823,7 @@ register_gradient_procs (Gimp *gimp)
/*
* gimp-gradient-segment-get-middle-pos
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 1,
gradient_segment_get_middle_pos_invoker);
procedure = gimp_procedure_new (gradient_segment_get_middle_pos_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-get-middle-pos",
"gimp-gradient-segment-get-middle-pos",
@ -1886,9 +1858,7 @@ register_gradient_procs (Gimp *gimp)
/*
* gimp-gradient-segment-set-middle-pos
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 1,
gradient_segment_set_middle_pos_invoker);
procedure = gimp_procedure_new (gradient_segment_set_middle_pos_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-set-middle-pos",
"gimp-gradient-segment-set-middle-pos",
@ -1929,9 +1899,7 @@ register_gradient_procs (Gimp *gimp)
/*
* gimp-gradient-segment-get-right-pos
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 1,
gradient_segment_get_right_pos_invoker);
procedure = gimp_procedure_new (gradient_segment_get_right_pos_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-get-right-pos",
"gimp-gradient-segment-get-right-pos",
@ -1966,9 +1934,7 @@ register_gradient_procs (Gimp *gimp)
/*
* gimp-gradient-segment-set-right-pos
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 1,
gradient_segment_set_right_pos_invoker);
procedure = gimp_procedure_new (gradient_segment_set_right_pos_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-set-right-pos",
"gimp-gradient-segment-set-right-pos",
@ -2009,9 +1975,7 @@ register_gradient_procs (Gimp *gimp)
/*
* gimp-gradient-segment-get-blending-function
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 1,
gradient_segment_get_blending_function_invoker);
procedure = gimp_procedure_new (gradient_segment_get_blending_function_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-get-blending-function",
"gimp-gradient-segment-get-blending-function",
@ -2047,9 +2011,7 @@ register_gradient_procs (Gimp *gimp)
/*
* gimp-gradient-segment-get-coloring-type
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 1,
gradient_segment_get_coloring_type_invoker);
procedure = gimp_procedure_new (gradient_segment_get_coloring_type_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-get-coloring-type",
"gimp-gradient-segment-get-coloring-type",
@ -2085,9 +2047,7 @@ register_gradient_procs (Gimp *gimp)
/*
* gimp-gradient-segment-range-set-blending-function
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 4, 0,
gradient_segment_range_set_blending_function_invoker);
procedure = gimp_procedure_new (gradient_segment_range_set_blending_function_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-range-set-blending-function",
"gimp-gradient-segment-range-set-blending-function",
@ -2129,9 +2089,7 @@ register_gradient_procs (Gimp *gimp)
/*
* gimp-gradient-segment-range-set-coloring-type
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 4, 0,
gradient_segment_range_set_coloring_type_invoker);
procedure = gimp_procedure_new (gradient_segment_range_set_coloring_type_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-range-set-coloring-type",
"gimp-gradient-segment-range-set-coloring-type",
@ -2173,9 +2131,7 @@ register_gradient_procs (Gimp *gimp)
/*
* gimp-gradient-segment-range-flip
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 0,
gradient_segment_range_flip_invoker);
procedure = gimp_procedure_new (gradient_segment_range_flip_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-range-flip",
"gimp-gradient-segment-range-flip",
@ -2210,9 +2166,7 @@ register_gradient_procs (Gimp *gimp)
/*
* gimp-gradient-segment-range-replicate
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 4, 0,
gradient_segment_range_replicate_invoker);
procedure = gimp_procedure_new (gradient_segment_range_replicate_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-range-replicate",
"gimp-gradient-segment-range-replicate",
@ -2253,9 +2207,7 @@ register_gradient_procs (Gimp *gimp)
/*
* gimp-gradient-segment-range-split-midpoint
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 0,
gradient_segment_range_split_midpoint_invoker);
procedure = gimp_procedure_new (gradient_segment_range_split_midpoint_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-range-split-midpoint",
"gimp-gradient-segment-range-split-midpoint",
@ -2290,9 +2242,7 @@ register_gradient_procs (Gimp *gimp)
/*
* gimp-gradient-segment-range-split-uniform
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 4, 0,
gradient_segment_range_split_uniform_invoker);
procedure = gimp_procedure_new (gradient_segment_range_split_uniform_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-range-split-uniform",
"gimp-gradient-segment-range-split-uniform",
@ -2333,9 +2283,7 @@ register_gradient_procs (Gimp *gimp)
/*
* gimp-gradient-segment-range-delete
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 0,
gradient_segment_range_delete_invoker);
procedure = gimp_procedure_new (gradient_segment_range_delete_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-range-delete",
"gimp-gradient-segment-range-delete",
@ -2370,9 +2318,7 @@ register_gradient_procs (Gimp *gimp)
/*
* gimp-gradient-segment-range-redistribute-handles
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 0,
gradient_segment_range_redistribute_handles_invoker);
procedure = gimp_procedure_new (gradient_segment_range_redistribute_handles_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-range-redistribute-handles",
"gimp-gradient-segment-range-redistribute-handles",
@ -2407,9 +2353,7 @@ register_gradient_procs (Gimp *gimp)
/*
* gimp-gradient-segment-range-blend-colors
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 0,
gradient_segment_range_blend_colors_invoker);
procedure = gimp_procedure_new (gradient_segment_range_blend_colors_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-range-blend-colors",
"gimp-gradient-segment-range-blend-colors",
@ -2444,9 +2388,7 @@ register_gradient_procs (Gimp *gimp)
/*
* gimp-gradient-segment-range-blend-opacity
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 0,
gradient_segment_range_blend_opacity_invoker);
procedure = gimp_procedure_new (gradient_segment_range_blend_opacity_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-range-blend-opacity",
"gimp-gradient-segment-range-blend-opacity",
@ -2481,9 +2423,7 @@ register_gradient_procs (Gimp *gimp)
/*
* gimp-gradient-segment-range-move
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 5, 1,
gradient_segment_range_move_invoker);
procedure = gimp_procedure_new (gradient_segment_range_move_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-gradient-segment-range-move",
"gimp-gradient-segment-range-move",

12
app/pdb/gradient_select_cmds.c
View File

@ -127,9 +127,7 @@ register_gradient_select_procs (Gimp *gimp)
/*
* gimp-gradients-popup
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 4, 0,
gradients_popup_invoker);
procedure = gimp_procedure_new (gradients_popup_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-gradients-popup",
"gimp-gradients-popup",
@ -172,9 +170,7 @@ register_gradient_select_procs (Gimp *gimp)
/*
* gimp-gradients-close-popup
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
gradients_close_popup_invoker);
procedure = gimp_procedure_new (gradients_close_popup_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-gradients-close-popup",
"gimp-gradients-close-popup",
@ -197,9 +193,7 @@ register_gradient_select_procs (Gimp *gimp)
/*
* gimp-gradients-set-popup
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
gradients_set_popup_invoker);
procedure = gimp_procedure_new (gradients_set_popup_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-gradients-set-popup",
"gimp-gradients-set-popup",

20
app/pdb/gradients_cmds.c
View File

@ -285,9 +285,7 @@ register_gradients_procs (Gimp *gimp)
/*
* gimp-gradients-refresh
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 0, 0,
gradients_refresh_invoker);
procedure = gimp_procedure_new (gradients_refresh_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-gradients-refresh",
"gimp-gradients-refresh",
@ -303,9 +301,7 @@ register_gradients_procs (Gimp *gimp)
/*
* gimp-gradients-get-list
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 2,
gradients_get_list_invoker);
procedure = gimp_procedure_new (gradients_get_list_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-gradients-get-list",
"gimp-gradients-get-list",
@ -339,9 +335,7 @@ register_gradients_procs (Gimp *gimp)
/*
* gimp-gradients-sample-uniform
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 2,
gradients_sample_uniform_invoker);
procedure = gimp_procedure_new (gradients_sample_uniform_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-gradients-sample-uniform",
"gimp-gradients-sample-uniform",
@ -380,9 +374,7 @@ register_gradients_procs (Gimp *gimp)
/*
* gimp-gradients-sample-custom
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 2,
gradients_sample_custom_invoker);
procedure = gimp_procedure_new (gradients_sample_custom_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-gradients-sample-custom",
"gimp-gradients-sample-custom",
@ -426,9 +418,7 @@ register_gradients_procs (Gimp *gimp)
/*
* gimp-gradients-get-gradient-data
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 3,
gradients_get_gradient_data_invoker);
procedure = gimp_procedure_new (gradients_get_gradient_data_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-gradients-get-gradient-data",
"gimp-gradients-get-gradient-data",

40
app/pdb/grid_cmds.c
View File

@ -363,9 +363,7 @@ register_grid_procs (Gimp *gimp)
/*
* gimp-image-grid-get-spacing
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 2,
image_grid_get_spacing_invoker);
procedure = gimp_procedure_new (image_grid_get_spacing_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-grid-get-spacing",
"gimp-image-grid-get-spacing",
@ -399,9 +397,7 @@ register_grid_procs (Gimp *gimp)
/*
* gimp-image-grid-set-spacing
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 0,
image_grid_set_spacing_invoker);
procedure = gimp_procedure_new (image_grid_set_spacing_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-grid-set-spacing",
"gimp-image-grid-set-spacing",
@ -435,9 +431,7 @@ register_grid_procs (Gimp *gimp)
/*
* gimp-image-grid-get-offset
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 2,
image_grid_get_offset_invoker);
procedure = gimp_procedure_new (image_grid_get_offset_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-grid-get-offset",
"gimp-image-grid-get-offset",
@ -471,9 +465,7 @@ register_grid_procs (Gimp *gimp)
/*
* gimp-image-grid-set-offset
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 0,
image_grid_set_offset_invoker);
procedure = gimp_procedure_new (image_grid_set_offset_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-grid-set-offset",
"gimp-image-grid-set-offset",
@ -507,9 +499,7 @@ register_grid_procs (Gimp *gimp)
/*
* gimp-image-grid-get-foreground-color
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
image_grid_get_foreground_color_invoker);
procedure = gimp_procedure_new (image_grid_get_foreground_color_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-grid-get-foreground-color",
"gimp-image-grid-get-foreground-color",
@ -537,9 +527,7 @@ register_grid_procs (Gimp *gimp)
/*
* gimp-image-grid-set-foreground-color
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
image_grid_set_foreground_color_invoker);
procedure = gimp_procedure_new (image_grid_set_foreground_color_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-grid-set-foreground-color",
"gimp-image-grid-set-foreground-color",
@ -567,9 +555,7 @@ register_grid_procs (Gimp *gimp)
/*
* gimp-image-grid-get-background-color
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
image_grid_get_background_color_invoker);
procedure = gimp_procedure_new (image_grid_get_background_color_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-grid-get-background-color",
"gimp-image-grid-get-background-color",
@ -597,9 +583,7 @@ register_grid_procs (Gimp *gimp)
/*
* gimp-image-grid-set-background-color
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
image_grid_set_background_color_invoker);
procedure = gimp_procedure_new (image_grid_set_background_color_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-grid-set-background-color",
"gimp-image-grid-set-background-color",
@ -627,9 +611,7 @@ register_grid_procs (Gimp *gimp)
/*
* gimp-image-grid-get-style
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
image_grid_get_style_invoker);
procedure = gimp_procedure_new (image_grid_get_style_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-grid-get-style",
"gimp-image-grid-get-style",
@ -658,9 +640,7 @@ register_grid_procs (Gimp *gimp)
/*
* gimp-image-grid-set-style
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
image_grid_set_style_invoker);
procedure = gimp_procedure_new (image_grid_set_style_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-grid-set-style",
"gimp-image-grid-set-style",

24
app/pdb/guides_cmds.c
View File

@ -242,9 +242,7 @@ register_guides_procs (Gimp *gimp)
/*
* gimp-image-add-hguide
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 1,
image_add_hguide_invoker);
procedure = gimp_procedure_new (image_add_hguide_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-add-hguide",
"gimp-image-add-hguide",
@ -278,9 +276,7 @@ register_guides_procs (Gimp *gimp)
/*
* gimp-image-add-vguide
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 1,
image_add_vguide_invoker);
procedure = gimp_procedure_new (image_add_vguide_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-add-vguide",
"gimp-image-add-vguide",
@ -314,9 +310,7 @@ register_guides_procs (Gimp *gimp)
/*
* gimp-image-delete-guide
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
image_delete_guide_invoker);
procedure = gimp_procedure_new (image_delete_guide_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-delete-guide",
"gimp-image-delete-guide",
@ -344,9 +338,7 @@ register_guides_procs (Gimp *gimp)
/*
* gimp-image-find-next-guide
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 1,
image_find_next_guide_invoker);
procedure = gimp_procedure_new (image_find_next_guide_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-find-next-guide",
"gimp-image-find-next-guide",
@ -380,9 +372,7 @@ register_guides_procs (Gimp *gimp)
/*
* gimp-image-get-guide-orientation
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 1,
image_get_guide_orientation_invoker);
procedure = gimp_procedure_new (image_get_guide_orientation_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-guide-orientation",
"gimp-image-get-guide-orientation",
@ -419,9 +409,7 @@ register_guides_procs (Gimp *gimp)
/*
* gimp-image-get-guide-position
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 1,
image_get_guide_position_invoker);
procedure = gimp_procedure_new (image_get_guide_position_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-guide-position",
"gimp-image-get-guide-position",

4
app/pdb/help_cmds.c
View File

@ -67,9 +67,7 @@ register_help_procs (Gimp *gimp)
/*
* gimp-help
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
help_invoker);
procedure = gimp_procedure_new (help_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-help",
"gimp-help",

288
app/pdb/image_cmds.c
View File

@ -2148,9 +2148,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-list
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 0, 2,
image_list_invoker);
procedure = gimp_procedure_new (image_list_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-list",
"gimp-image-list",
@ -2177,9 +2175,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-new
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 1,
image_new_invoker);
procedure = gimp_procedure_new (image_new_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-new",
"gimp-image-new",
@ -2220,9 +2216,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-duplicate
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
image_duplicate_invoker);
procedure = gimp_procedure_new (image_duplicate_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-duplicate",
"gimp-image-duplicate",
@ -2250,9 +2244,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-delete
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
image_delete_invoker);
procedure = gimp_procedure_new (image_delete_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-delete",
"gimp-image-delete",
@ -2274,9 +2266,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-base-type
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
image_base_type_invoker);
procedure = gimp_procedure_new (image_base_type_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-base-type",
"gimp-image-base-type",
@ -2305,9 +2295,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-width
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
image_width_invoker);
procedure = gimp_procedure_new (image_width_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-width",
"gimp-image-width",
@ -2335,9 +2323,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-height
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
image_height_invoker);
procedure = gimp_procedure_new (image_height_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-height",
"gimp-image-height",
@ -2365,9 +2351,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-free-shadow
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
image_free_shadow_invoker);
procedure = gimp_procedure_new (image_free_shadow_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-free-shadow",
"gimp-image-free-shadow",
@ -2389,9 +2373,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-resize
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 5, 0,
image_resize_invoker);
procedure = gimp_procedure_new (image_resize_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-resize",
"gimp-image-resize",
@ -2437,9 +2419,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-resize-to-layers
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
image_resize_to_layers_invoker);
procedure = gimp_procedure_new (image_resize_to_layers_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-resize-to-layers",
"gimp-image-resize-to-layers",
@ -2461,9 +2441,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-scale
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 0,
image_scale_invoker);
procedure = gimp_procedure_new (image_scale_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-scale",
"gimp-image-scale",
@ -2497,9 +2475,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-crop
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 5, 0,
image_crop_invoker);
procedure = gimp_procedure_new (image_crop_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-crop",
"gimp-image-crop",
@ -2545,9 +2521,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-flip
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
image_flip_invoker);
procedure = gimp_procedure_new (image_flip_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-flip",
"gimp-image-flip",
@ -2578,9 +2552,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-rotate
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
image_rotate_invoker);
procedure = gimp_procedure_new (image_rotate_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-rotate",
"gimp-image-rotate",
@ -2609,9 +2581,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-get-layers
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 2,
image_get_layers_invoker);
procedure = gimp_procedure_new (image_get_layers_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-layers",
"gimp-image-get-layers",
@ -2644,9 +2614,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-get-channels
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 2,
image_get_channels_invoker);
procedure = gimp_procedure_new (image_get_channels_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-channels",
"gimp-image-get-channels",
@ -2679,9 +2647,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-get-vectors
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 2,
image_get_vectors_invoker);
procedure = gimp_procedure_new (image_get_vectors_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-vectors",
"gimp-image-get-vectors",
@ -2714,9 +2680,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-get-active-drawable
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
image_get_active_drawable_invoker);
procedure = gimp_procedure_new (image_get_active_drawable_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-active-drawable",
"gimp-image-get-active-drawable",
@ -2744,9 +2708,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-unset-active-channel
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
image_unset_active_channel_invoker);
procedure = gimp_procedure_new (image_unset_active_channel_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-unset-active-channel",
"gimp-image-unset-active-channel",
@ -2768,9 +2730,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-get-floating-sel
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
image_get_floating_sel_invoker);
procedure = gimp_procedure_new (image_get_floating_sel_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-floating-sel",
"gimp-image-get-floating-sel",
@ -2798,9 +2758,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-floating-sel-attached-to
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
image_floating_sel_attached_to_invoker);
procedure = gimp_procedure_new (image_floating_sel_attached_to_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-floating-sel-attached-to",
"gimp-image-floating-sel-attached-to",
@ -2828,9 +2786,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-pick-color
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 7, 1,
image_pick_color_invoker);
procedure = gimp_procedure_new (image_pick_color_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-pick-color",
"gimp-image-pick-color",
@ -2894,9 +2850,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-pick-correlate-layer
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 1,
image_pick_correlate_layer_invoker);
procedure = gimp_procedure_new (image_pick_correlate_layer_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-pick-correlate-layer",
"gimp-image-pick-correlate-layer",
@ -2936,9 +2890,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-add-layer
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 0,
image_add_layer_invoker);
procedure = gimp_procedure_new (image_add_layer_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-add-layer",
"gimp-image-add-layer",
@ -2972,9 +2924,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-remove-layer
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
image_remove_layer_invoker);
procedure = gimp_procedure_new (image_remove_layer_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-remove-layer",
"gimp-image-remove-layer",
@ -3002,9 +2952,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-raise-layer
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
image_raise_layer_invoker);
procedure = gimp_procedure_new (image_raise_layer_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-raise-layer",
"gimp-image-raise-layer",
@ -3032,9 +2980,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-lower-layer
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
image_lower_layer_invoker);
procedure = gimp_procedure_new (image_lower_layer_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-lower-layer",
"gimp-image-lower-layer",
@ -3062,9 +3008,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-raise-layer-to-top
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
image_raise_layer_to_top_invoker);
procedure = gimp_procedure_new (image_raise_layer_to_top_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-raise-layer-to-top",
"gimp-image-raise-layer-to-top",
@ -3092,9 +3036,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-lower-layer-to-bottom
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
image_lower_layer_to_bottom_invoker);
procedure = gimp_procedure_new (image_lower_layer_to_bottom_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-lower-layer-to-bottom",
"gimp-image-lower-layer-to-bottom",
@ -3122,9 +3064,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-add-channel
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 0,
image_add_channel_invoker);
procedure = gimp_procedure_new (image_add_channel_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-add-channel",
"gimp-image-add-channel",
@ -3158,9 +3098,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-remove-channel
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
image_remove_channel_invoker);
procedure = gimp_procedure_new (image_remove_channel_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-remove-channel",
"gimp-image-remove-channel",
@ -3188,9 +3126,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-raise-channel
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
image_raise_channel_invoker);
procedure = gimp_procedure_new (image_raise_channel_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-raise-channel",
"gimp-image-raise-channel",
@ -3218,9 +3154,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-lower-channel
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
image_lower_channel_invoker);
procedure = gimp_procedure_new (image_lower_channel_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-lower-channel",
"gimp-image-lower-channel",
@ -3248,9 +3182,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-add-vectors
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 0,
image_add_vectors_invoker);
procedure = gimp_procedure_new (image_add_vectors_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-add-vectors",
"gimp-image-add-vectors",
@ -3284,9 +3216,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-remove-vectors
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
image_remove_vectors_invoker);
procedure = gimp_procedure_new (image_remove_vectors_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-remove-vectors",
"gimp-image-remove-vectors",
@ -3314,9 +3244,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-raise-vectors
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
image_raise_vectors_invoker);
procedure = gimp_procedure_new (image_raise_vectors_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-raise-vectors",
"gimp-image-raise-vectors",
@ -3344,9 +3272,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-lower-vectors
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
image_lower_vectors_invoker);
procedure = gimp_procedure_new (image_lower_vectors_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-lower-vectors",
"gimp-image-lower-vectors",
@ -3374,9 +3300,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-raise-vectors-to-top
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
image_raise_vectors_to_top_invoker);
procedure = gimp_procedure_new (image_raise_vectors_to_top_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-raise-vectors-to-top",
"gimp-image-raise-vectors-to-top",
@ -3404,9 +3328,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-lower-vectors-to-bottom
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
image_lower_vectors_to_bottom_invoker);
procedure = gimp_procedure_new (image_lower_vectors_to_bottom_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-lower-vectors-to-bottom",
"gimp-image-lower-vectors-to-bottom",
@ -3434,9 +3356,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-flatten
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
image_flatten_invoker);
procedure = gimp_procedure_new (image_flatten_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-flatten",
"gimp-image-flatten",
@ -3464,9 +3384,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-merge-visible-layers
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 1,
image_merge_visible_layers_invoker);
procedure = gimp_procedure_new (image_merge_visible_layers_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-merge-visible-layers",
"gimp-image-merge-visible-layers",
@ -3503,9 +3421,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-merge-down
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 1,
image_merge_down_invoker);
procedure = gimp_procedure_new (image_merge_down_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-merge-down",
"gimp-image-merge-down",
@ -3548,9 +3464,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-add-layer-mask
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 0,
image_add_layer_mask_invoker);
procedure = gimp_procedure_new (image_add_layer_mask_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-add-layer-mask",
"gimp-image-add-layer-mask",
@ -3584,9 +3498,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-remove-layer-mask
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 0,
image_remove_layer_mask_invoker);
procedure = gimp_procedure_new (image_remove_layer_mask_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-remove-layer-mask",
"gimp-image-remove-layer-mask",
@ -3621,9 +3533,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-get-colormap
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 2,
image_get_colormap_invoker);
procedure = gimp_procedure_new (image_get_colormap_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-colormap",
"gimp-image-get-colormap",
@ -3656,9 +3566,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-set-colormap
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 0,
image_set_colormap_invoker);
procedure = gimp_procedure_new (image_set_colormap_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-set-colormap",
"gimp-image-set-colormap",
@ -3691,9 +3599,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-clean-all
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
image_clean_all_invoker);
procedure = gimp_procedure_new (image_clean_all_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-clean-all",
"gimp-image-clean-all",
@ -3715,9 +3621,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-is-dirty
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
image_is_dirty_invoker);
procedure = gimp_procedure_new (image_is_dirty_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-is-dirty",
"gimp-image-is-dirty",
@ -3745,9 +3649,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-thumbnail
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 5,
image_thumbnail_invoker);
procedure = gimp_procedure_new (image_thumbnail_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-thumbnail",
"gimp-image-thumbnail",
@ -3810,9 +3712,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-get-active-layer
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
image_get_active_layer_invoker);
procedure = gimp_procedure_new (image_get_active_layer_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-active-layer",
"gimp-image-get-active-layer",
@ -3840,9 +3740,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-set-active-layer
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
image_set_active_layer_invoker);
procedure = gimp_procedure_new (image_set_active_layer_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-set-active-layer",
"gimp-image-set-active-layer",
@ -3870,9 +3768,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-get-active-channel
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
image_get_active_channel_invoker);
procedure = gimp_procedure_new (image_get_active_channel_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-active-channel",
"gimp-image-get-active-channel",
@ -3900,9 +3796,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-set-active-channel
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
image_set_active_channel_invoker);
procedure = gimp_procedure_new (image_set_active_channel_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-set-active-channel",
"gimp-image-set-active-channel",
@ -3930,9 +3824,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-get-active-vectors
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
image_get_active_vectors_invoker);
procedure = gimp_procedure_new (image_get_active_vectors_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-active-vectors",
"gimp-image-get-active-vectors",
@ -3960,9 +3852,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-set-active-vectors
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
image_set_active_vectors_invoker);
procedure = gimp_procedure_new (image_set_active_vectors_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-set-active-vectors",
"gimp-image-set-active-vectors",
@ -3990,9 +3880,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-get-selection
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
image_get_selection_invoker);
procedure = gimp_procedure_new (image_get_selection_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-selection",
"gimp-image-get-selection",
@ -4020,9 +3908,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-get-component-active
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 1,
image_get_component_active_invoker);
procedure = gimp_procedure_new (image_get_component_active_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-component-active",
"gimp-image-get-component-active",
@ -4057,9 +3943,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-set-component-active
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 0,
image_set_component_active_invoker);
procedure = gimp_procedure_new (image_set_component_active_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-set-component-active",
"gimp-image-set-component-active",
@ -4094,9 +3978,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-get-component-visible
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 1,
image_get_component_visible_invoker);
procedure = gimp_procedure_new (image_get_component_visible_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-component-visible",
"gimp-image-get-component-visible",
@ -4131,9 +4013,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-set-component-visible
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 0,
image_set_component_visible_invoker);
procedure = gimp_procedure_new (image_set_component_visible_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-set-component-visible",
"gimp-image-set-component-visible",
@ -4168,9 +4048,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-get-filename
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
image_get_filename_invoker);
procedure = gimp_procedure_new (image_get_filename_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-filename",
"gimp-image-get-filename",
@ -4199,9 +4077,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-set-filename
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
image_set_filename_invoker);
procedure = gimp_procedure_new (image_set_filename_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-set-filename",
"gimp-image-set-filename",
@ -4230,9 +4106,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-get-name
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
image_get_name_invoker);
procedure = gimp_procedure_new (image_get_name_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-name",
"gimp-image-get-name",
@ -4261,9 +4135,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-get-resolution
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 2,
image_get_resolution_invoker);
procedure = gimp_procedure_new (image_get_resolution_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-resolution",
"gimp-image-get-resolution",
@ -4297,9 +4169,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-set-resolution
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 0,
image_set_resolution_invoker);
procedure = gimp_procedure_new (image_set_resolution_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-set-resolution",
"gimp-image-set-resolution",
@ -4333,9 +4203,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-get-unit
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
image_get_unit_invoker);
procedure = gimp_procedure_new (image_get_unit_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-unit",
"gimp-image-get-unit",
@ -4365,9 +4233,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-set-unit
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
image_set_unit_invoker);
procedure = gimp_procedure_new (image_set_unit_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-set-unit",
"gimp-image-set-unit",
@ -4397,9 +4263,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-get-tattoo-state
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
image_get_tattoo_state_invoker);
procedure = gimp_procedure_new (image_get_tattoo_state_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-tattoo-state",
"gimp-image-get-tattoo-state",
@ -4427,9 +4291,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-set-tattoo-state
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
image_set_tattoo_state_invoker);
procedure = gimp_procedure_new (image_set_tattoo_state_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-set-tattoo-state",
"gimp-image-set-tattoo-state",
@ -4457,9 +4319,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-get-layer-by-tattoo
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 1,
image_get_layer_by_tattoo_invoker);
procedure = gimp_procedure_new (image_get_layer_by_tattoo_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-layer-by-tattoo",
"gimp-image-get-layer-by-tattoo",
@ -4493,9 +4353,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-get-channel-by-tattoo
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 1,
image_get_channel_by_tattoo_invoker);
procedure = gimp_procedure_new (image_get_channel_by_tattoo_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-channel-by-tattoo",
"gimp-image-get-channel-by-tattoo",
@ -4529,9 +4387,7 @@ register_image_procs (Gimp *gimp)
/*
* gimp-image-get-vectors-by-tattoo
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 1,
image_get_vectors_by_tattoo_invoker);
procedure = gimp_procedure_new (image_get_vectors_by_tattoo_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-get-vectors-by-tattoo",
"gimp-image-get-vectors-by-tattoo",

108
app/pdb/layer_cmds.c
View File

@ -820,9 +820,7 @@ register_layer_procs (Gimp *gimp)
/*
* gimp-layer-new
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 7, 1,
layer_new_invoker);
procedure = gimp_procedure_new (layer_new_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-layer-new",
"gimp-layer-new",
@ -889,9 +887,7 @@ register_layer_procs (Gimp *gimp)
/*
* gimp-layer-new-from-drawable
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 1,
layer_new_from_drawable_invoker);
procedure = gimp_procedure_new (layer_new_from_drawable_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-layer-new-from-drawable",
"gimp-layer-new-from-drawable",
@ -925,9 +921,7 @@ register_layer_procs (Gimp *gimp)
/*
* gimp-layer-copy
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 1,
layer_copy_invoker);
procedure = gimp_procedure_new (layer_copy_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-layer-copy",
"gimp-layer-copy",
@ -961,9 +955,7 @@ register_layer_procs (Gimp *gimp)
/*
* gimp-layer-add-alpha
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
layer_add_alpha_invoker);
procedure = gimp_procedure_new (layer_add_alpha_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-layer-add-alpha",
"gimp-layer-add-alpha",
@ -985,9 +977,7 @@ register_layer_procs (Gimp *gimp)
/*
* gimp-layer-scale
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 4, 0,
layer_scale_invoker);
procedure = gimp_procedure_new (layer_scale_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-layer-scale",
"gimp-layer-scale",
@ -1027,9 +1017,7 @@ register_layer_procs (Gimp *gimp)
/*
* gimp-layer-resize
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 5, 0,
layer_resize_invoker);
procedure = gimp_procedure_new (layer_resize_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-layer-resize",
"gimp-layer-resize",
@ -1075,9 +1063,7 @@ register_layer_procs (Gimp *gimp)
/*
* gimp-layer-resize-to-image-size
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
layer_resize_to_image_size_invoker);
procedure = gimp_procedure_new (layer_resize_to_image_size_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-layer-resize-to-image-size",
"gimp-layer-resize-to-image-size",
@ -1099,9 +1085,7 @@ register_layer_procs (Gimp *gimp)
/*
* gimp-layer-translate
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 0,
layer_translate_invoker);
procedure = gimp_procedure_new (layer_translate_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-layer-translate",
"gimp-layer-translate",
@ -1135,9 +1119,7 @@ register_layer_procs (Gimp *gimp)
/*
* gimp-layer-set-offsets
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 0,
layer_set_offsets_invoker);
procedure = gimp_procedure_new (layer_set_offsets_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-layer-set-offsets",
"gimp-layer-set-offsets",
@ -1171,9 +1153,7 @@ register_layer_procs (Gimp *gimp)
/*
* gimp-layer-create-mask
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 1,
layer_create_mask_invoker);
procedure = gimp_procedure_new (layer_create_mask_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-layer-create-mask",
"gimp-layer-create-mask",
@ -1208,9 +1188,7 @@ register_layer_procs (Gimp *gimp)
/*
* gimp-layer-get-mask
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
layer_get_mask_invoker);
procedure = gimp_procedure_new (layer_get_mask_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-layer-get-mask",
"gimp-layer-get-mask",
@ -1238,9 +1216,7 @@ register_layer_procs (Gimp *gimp)
/*
* gimp-layer-from-mask
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
layer_from_mask_invoker);
procedure = gimp_procedure_new (layer_from_mask_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-layer-from-mask",
"gimp-layer-from-mask",
@ -1268,9 +1244,7 @@ register_layer_procs (Gimp *gimp)
/*
* gimp-layer-add-mask
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
layer_add_mask_invoker);
procedure = gimp_procedure_new (layer_add_mask_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-layer-add-mask",
"gimp-layer-add-mask",
@ -1298,9 +1272,7 @@ register_layer_procs (Gimp *gimp)
/*
* gimp-layer-remove-mask
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
layer_remove_mask_invoker);
procedure = gimp_procedure_new (layer_remove_mask_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-layer-remove-mask",
"gimp-layer-remove-mask",
@ -1329,9 +1301,7 @@ register_layer_procs (Gimp *gimp)
/*
* gimp-layer-is-floating-sel
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
layer_is_floating_sel_invoker);
procedure = gimp_procedure_new (layer_is_floating_sel_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-layer-is-floating-sel",
"gimp-layer-is-floating-sel",
@ -1359,9 +1329,7 @@ register_layer_procs (Gimp *gimp)
/*
* gimp-layer-get-lock-alpha
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
layer_get_lock_alpha_invoker);
procedure = gimp_procedure_new (layer_get_lock_alpha_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-layer-get-lock-alpha",
"gimp-layer-get-lock-alpha",
@ -1389,9 +1357,7 @@ register_layer_procs (Gimp *gimp)
/*
* gimp-layer-set-lock-alpha
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
layer_set_lock_alpha_invoker);
procedure = gimp_procedure_new (layer_set_lock_alpha_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-layer-set-lock-alpha",
"gimp-layer-set-lock-alpha",
@ -1419,9 +1385,7 @@ register_layer_procs (Gimp *gimp)
/*
* gimp-layer-get-apply-mask
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
layer_get_apply_mask_invoker);
procedure = gimp_procedure_new (layer_get_apply_mask_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-layer-get-apply-mask",
"gimp-layer-get-apply-mask",
@ -1449,9 +1413,7 @@ register_layer_procs (Gimp *gimp)
/*
* gimp-layer-set-apply-mask
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
layer_set_apply_mask_invoker);
procedure = gimp_procedure_new (layer_set_apply_mask_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-layer-set-apply-mask",
"gimp-layer-set-apply-mask",
@ -1479,9 +1441,7 @@ register_layer_procs (Gimp *gimp)
/*
* gimp-layer-get-show-mask
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
layer_get_show_mask_invoker);
procedure = gimp_procedure_new (layer_get_show_mask_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-layer-get-show-mask",
"gimp-layer-get-show-mask",
@ -1509,9 +1469,7 @@ register_layer_procs (Gimp *gimp)
/*
* gimp-layer-set-show-mask
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
layer_set_show_mask_invoker);
procedure = gimp_procedure_new (layer_set_show_mask_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-layer-set-show-mask",
"gimp-layer-set-show-mask",
@ -1539,9 +1497,7 @@ register_layer_procs (Gimp *gimp)
/*
* gimp-layer-get-edit-mask
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
layer_get_edit_mask_invoker);
procedure = gimp_procedure_new (layer_get_edit_mask_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-layer-get-edit-mask",
"gimp-layer-get-edit-mask",
@ -1569,9 +1525,7 @@ register_layer_procs (Gimp *gimp)
/*
* gimp-layer-set-edit-mask
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
layer_set_edit_mask_invoker);
procedure = gimp_procedure_new (layer_set_edit_mask_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-layer-set-edit-mask",
"gimp-layer-set-edit-mask",
@ -1599,9 +1553,7 @@ register_layer_procs (Gimp *gimp)
/*
* gimp-layer-get-opacity
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
layer_get_opacity_invoker);
procedure = gimp_procedure_new (layer_get_opacity_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-layer-get-opacity",
"gimp-layer-get-opacity",
@ -1629,9 +1581,7 @@ register_layer_procs (Gimp *gimp)
/*
* gimp-layer-set-opacity
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
layer_set_opacity_invoker);
procedure = gimp_procedure_new (layer_set_opacity_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-layer-set-opacity",
"gimp-layer-set-opacity",
@ -1659,9 +1609,7 @@ register_layer_procs (Gimp *gimp)
/*
* gimp-layer-get-mode
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
layer_get_mode_invoker);
procedure = gimp_procedure_new (layer_get_mode_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-layer-get-mode",
"gimp-layer-get-mode",
@ -1690,9 +1638,7 @@ register_layer_procs (Gimp *gimp)
/*
* gimp-layer-set-mode
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
layer_set_mode_invoker);
procedure = gimp_procedure_new (layer_set_mode_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-layer-set-mode",
"gimp-layer-set-mode",

12
app/pdb/message_cmds.c
View File

@ -104,9 +104,7 @@ register_message_procs (Gimp *gimp)
/*
* gimp-message
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
message_invoker);
procedure = gimp_procedure_new (message_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-message",
"gimp-message",
@ -129,9 +127,7 @@ register_message_procs (Gimp *gimp)
/*
* gimp-message-get-handler
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 0, 1,
message_get_handler_invoker);
procedure = gimp_procedure_new (message_get_handler_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-message-get-handler",
"gimp-message-get-handler",
@ -154,9 +150,7 @@ register_message_procs (Gimp *gimp)
/*
* gimp-message-set-handler
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
message_set_handler_invoker);
procedure = gimp_procedure_new (message_set_handler_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-message-set-handler",
"gimp-message-set-handler",

12
app/pdb/misc_cmds.c
View File

@ -109,9 +109,7 @@ register_misc_procs (Gimp *gimp)
/*
* gimp-version
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 0, 1,
version_invoker);
procedure = gimp_procedure_new (version_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-version",
"gimp-version",
@ -134,9 +132,7 @@ register_misc_procs (Gimp *gimp)
/*
* gimp-getpid
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 0, 1,
getpid_invoker);
procedure = gimp_procedure_new (getpid_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-getpid",
"gimp-getpid",
@ -158,9 +154,7 @@ register_misc_procs (Gimp *gimp)
/*
* gimp-quit
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
quit_invoker);
procedure = gimp_procedure_new (quit_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-quit",
"gimp-quit",

60
app/pdb/paint_tools_cmds.c
View File

@ -697,9 +697,7 @@ register_paint_tools_procs (Gimp *gimp)
/*
* gimp-airbrush
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 4, 0,
airbrush_invoker);
procedure = gimp_procedure_new (airbrush_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-airbrush",
"gimp-airbrush",
@ -738,9 +736,7 @@ register_paint_tools_procs (Gimp *gimp)
/*
* gimp-airbrush-default
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 0,
airbrush_default_invoker);
procedure = gimp_procedure_new (airbrush_default_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-airbrush-default",
"gimp-airbrush-default",
@ -773,9 +769,7 @@ register_paint_tools_procs (Gimp *gimp)
/*
* gimp-clone
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 7, 0,
clone_invoker);
procedure = gimp_procedure_new (clone_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-clone",
"gimp-clone",
@ -833,9 +827,7 @@ register_paint_tools_procs (Gimp *gimp)
/*
* gimp-clone-default
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 0,
clone_default_invoker);
procedure = gimp_procedure_new (clone_default_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-clone-default",
"gimp-clone-default",
@ -868,9 +860,7 @@ register_paint_tools_procs (Gimp *gimp)
/*
* gimp-convolve
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 5, 0,
convolve_invoker);
procedure = gimp_procedure_new (convolve_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-convolve",
"gimp-convolve",
@ -916,9 +906,7 @@ register_paint_tools_procs (Gimp *gimp)
/*
* gimp-convolve-default
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 0,
convolve_default_invoker);
procedure = gimp_procedure_new (convolve_default_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-convolve-default",
"gimp-convolve-default",
@ -951,9 +939,7 @@ register_paint_tools_procs (Gimp *gimp)
/*
* gimp-dodgeburn
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 6, 0,
dodgeburn_invoker);
procedure = gimp_procedure_new (dodgeburn_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-dodgeburn",
"gimp-dodgeburn",
@ -1006,9 +992,7 @@ register_paint_tools_procs (Gimp *gimp)
/*
* gimp-dodgeburn-default
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 0,
dodgeburn_default_invoker);
procedure = gimp_procedure_new (dodgeburn_default_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-dodgeburn-default",
"gimp-dodgeburn-default",
@ -1041,9 +1025,7 @@ register_paint_tools_procs (Gimp *gimp)
/*
* gimp-eraser
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 5, 0,
eraser_invoker);
procedure = gimp_procedure_new (eraser_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-eraser",
"gimp-eraser",
@ -1090,9 +1072,7 @@ register_paint_tools_procs (Gimp *gimp)
/*
* gimp-eraser-default
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 0,
eraser_default_invoker);
procedure = gimp_procedure_new (eraser_default_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-eraser-default",
"gimp-eraser-default",
@ -1125,9 +1105,7 @@ register_paint_tools_procs (Gimp *gimp)
/*
* gimp-paintbrush
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 6, 0,
paintbrush_invoker);
procedure = gimp_procedure_new (paintbrush_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-paintbrush",
"gimp-paintbrush",
@ -1179,9 +1157,7 @@ register_paint_tools_procs (Gimp *gimp)
/*
* gimp-paintbrush-default
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 0,
paintbrush_default_invoker);
procedure = gimp_procedure_new (paintbrush_default_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-paintbrush-default",
"gimp-paintbrush-default",
@ -1214,9 +1190,7 @@ register_paint_tools_procs (Gimp *gimp)
/*
* gimp-pencil
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 0,
pencil_invoker);
procedure = gimp_procedure_new (pencil_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-pencil",
"gimp-pencil",
@ -1249,9 +1223,7 @@ register_paint_tools_procs (Gimp *gimp)
/*
* gimp-smudge
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 4, 0,
smudge_invoker);
procedure = gimp_procedure_new (smudge_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-smudge",
"gimp-smudge",
@ -1290,9 +1262,7 @@ register_paint_tools_procs (Gimp *gimp)
/*
* gimp-smudge-default
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 0,
smudge_default_invoker);
procedure = gimp_procedure_new (smudge_default_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-smudge-default",
"gimp-smudge-default",

56
app/pdb/palette_cmds.c
View File

@ -578,9 +578,7 @@ register_palette_procs (Gimp *gimp)
/*
* gimp-palette-new
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
palette_new_invoker);
procedure = gimp_procedure_new (palette_new_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-palette-new",
"gimp-palette-new",
@ -610,9 +608,7 @@ register_palette_procs (Gimp *gimp)
/*
* gimp-palette-duplicate
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
palette_duplicate_invoker);
procedure = gimp_procedure_new (palette_duplicate_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-palette-duplicate",
"gimp-palette-duplicate",
@ -642,9 +638,7 @@ register_palette_procs (Gimp *gimp)
/*
* gimp-palette-rename
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 1,
palette_rename_invoker);
procedure = gimp_procedure_new (palette_rename_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-palette-rename",
"gimp-palette-rename",
@ -681,9 +675,7 @@ register_palette_procs (Gimp *gimp)
/*
* gimp-palette-delete
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
palette_delete_invoker);
procedure = gimp_procedure_new (palette_delete_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-palette-delete",
"gimp-palette-delete",
@ -706,9 +698,7 @@ register_palette_procs (Gimp *gimp)
/*
* gimp-palette-is-editable
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
palette_is_editable_invoker);
procedure = gimp_procedure_new (palette_is_editable_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-palette-is-editable",
"gimp-palette-is-editable",
@ -737,9 +727,7 @@ register_palette_procs (Gimp *gimp)
/*
* gimp-palette-get-info
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
palette_get_info_invoker);
procedure = gimp_procedure_new (palette_get_info_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-palette-get-info",
"gimp-palette-get-info",
@ -768,9 +756,7 @@ register_palette_procs (Gimp *gimp)
/*
* gimp-palette-get-columns
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
palette_get_columns_invoker);
procedure = gimp_procedure_new (palette_get_columns_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-palette-get-columns",
"gimp-palette-get-columns",
@ -799,9 +785,7 @@ register_palette_procs (Gimp *gimp)
/*
* gimp-palette-set-columns
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
palette_set_columns_invoker);
procedure = gimp_procedure_new (palette_set_columns_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-palette-set-columns",
"gimp-palette-set-columns",
@ -830,9 +814,7 @@ register_palette_procs (Gimp *gimp)
/*
* gimp-palette-add-entry
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 1,
palette_add_entry_invoker);
procedure = gimp_procedure_new (palette_add_entry_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-palette-add-entry",
"gimp-palette-add-entry",
@ -874,9 +856,7 @@ register_palette_procs (Gimp *gimp)
/*
* gimp-palette-delete-entry
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
palette_delete_entry_invoker);
procedure = gimp_procedure_new (palette_delete_entry_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-palette-delete-entry",
"gimp-palette-delete-entry",
@ -905,9 +885,7 @@ register_palette_procs (Gimp *gimp)
/*
* gimp-palette-entry-get-color
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 1,
palette_entry_get_color_invoker);
procedure = gimp_procedure_new (palette_entry_get_color_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-palette-entry-get-color",
"gimp-palette-entry-get-color",
@ -942,9 +920,7 @@ register_palette_procs (Gimp *gimp)
/*
* gimp-palette-entry-set-color
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 0,
palette_entry_set_color_invoker);
procedure = gimp_procedure_new (palette_entry_set_color_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-palette-entry-set-color",
"gimp-palette-entry-set-color",
@ -979,9 +955,7 @@ register_palette_procs (Gimp *gimp)
/*
* gimp-palette-entry-get-name
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 1,
palette_entry_get_name_invoker);
procedure = gimp_procedure_new (palette_entry_get_name_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-palette-entry-get-name",
"gimp-palette-entry-get-name",
@ -1017,9 +991,7 @@ register_palette_procs (Gimp *gimp)
/*
* gimp-palette-entry-set-name
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 0,
palette_entry_set_name_invoker);
procedure = gimp_procedure_new (palette_entry_set_name_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-palette-entry-set-name",
"gimp-palette-entry-set-name",

12
app/pdb/palette_select_cmds.c
View File

@ -120,9 +120,7 @@ register_palette_select_procs (Gimp *gimp)
/*
* gimp-palettes-popup
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 0,
palettes_popup_invoker);
procedure = gimp_procedure_new (palettes_popup_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-palettes-popup",
"gimp-palettes-popup",
@ -159,9 +157,7 @@ register_palette_select_procs (Gimp *gimp)
/*
* gimp-palettes-close-popup
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
palettes_close_popup_invoker);
procedure = gimp_procedure_new (palettes_close_popup_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-palettes-close-popup",
"gimp-palettes-close-popup",
@ -184,9 +180,7 @@ register_palette_select_procs (Gimp *gimp)
/*
* gimp-palettes-set-popup
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
palettes_set_popup_invoker);
procedure = gimp_procedure_new (palettes_set_popup_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-palettes-set-popup",
"gimp-palettes-set-popup",

16
app/pdb/palettes_cmds.c
View File

@ -185,9 +185,7 @@ register_palettes_procs (Gimp *gimp)
/*
* gimp-palettes-refresh
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 0, 0,
palettes_refresh_invoker);
procedure = gimp_procedure_new (palettes_refresh_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-palettes-refresh",
"gimp-palettes-refresh",
@ -203,9 +201,7 @@ register_palettes_procs (Gimp *gimp)
/*
* gimp-palettes-get-list
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 2,
palettes_get_list_invoker);
procedure = gimp_procedure_new (palettes_get_list_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-palettes-get-list",
"gimp-palettes-get-list",
@ -239,9 +235,7 @@ register_palettes_procs (Gimp *gimp)
/*
* gimp-palettes-get-palette
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 0, 2,
palettes_get_palette_invoker);
procedure = gimp_procedure_new (palettes_get_palette_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-palettes-get-palette",
"gimp-palettes-get-palette",
@ -270,9 +264,7 @@ register_palettes_procs (Gimp *gimp)
/*
* gimp-palettes-get-palette-entry
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 3,
palettes_get_palette_entry_invoker);
procedure = gimp_procedure_new (palettes_get_palette_entry_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-palettes-get-palette-entry",
"gimp-palettes-get-palette-entry",

64
app/pdb/parasite_cmds.c
View File

@ -458,9 +458,7 @@ register_parasite_procs (Gimp *gimp)
/*
* gimp-parasite-find
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
parasite_find_invoker);
procedure = gimp_procedure_new (parasite_find_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-parasite-find",
"gimp-parasite-find",
@ -488,9 +486,7 @@ register_parasite_procs (Gimp *gimp)
/*
* gimp-parasite-attach
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
parasite_attach_invoker);
procedure = gimp_procedure_new (parasite_attach_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-parasite-attach",
"gimp-parasite-attach",
@ -511,9 +507,7 @@ register_parasite_procs (Gimp *gimp)
/*
* gimp-parasite-detach
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
parasite_detach_invoker);
procedure = gimp_procedure_new (parasite_detach_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-parasite-detach",
"gimp-parasite-detach",
@ -536,9 +530,7 @@ register_parasite_procs (Gimp *gimp)
/*
* gimp-parasite-list
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 0, 2,
parasite_list_invoker);
procedure = gimp_procedure_new (parasite_list_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-parasite-list",
"gimp-parasite-list",
@ -565,9 +557,7 @@ register_parasite_procs (Gimp *gimp)
/*
* gimp-image-parasite-find
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 1,
image_parasite_find_invoker);
procedure = gimp_procedure_new (image_parasite_find_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-parasite-find",
"gimp-image-parasite-find",
@ -601,9 +591,7 @@ register_parasite_procs (Gimp *gimp)
/*
* gimp-image-parasite-attach
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
image_parasite_attach_invoker);
procedure = gimp_procedure_new (image_parasite_attach_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-parasite-attach",
"gimp-image-parasite-attach",
@ -630,9 +618,7 @@ register_parasite_procs (Gimp *gimp)
/*
* gimp-image-parasite-detach
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
image_parasite_detach_invoker);
procedure = gimp_procedure_new (image_parasite_detach_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-parasite-detach",
"gimp-image-parasite-detach",
@ -661,9 +647,7 @@ register_parasite_procs (Gimp *gimp)
/*
* gimp-image-parasite-list
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 2,
image_parasite_list_invoker);
procedure = gimp_procedure_new (image_parasite_list_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-parasite-list",
"gimp-image-parasite-list",
@ -696,9 +680,7 @@ register_parasite_procs (Gimp *gimp)
/*
* gimp-drawable-parasite-find
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 1,
drawable_parasite_find_invoker);
procedure = gimp_procedure_new (drawable_parasite_find_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-parasite-find",
"gimp-drawable-parasite-find",
@ -732,9 +714,7 @@ register_parasite_procs (Gimp *gimp)
/*
* gimp-drawable-parasite-attach
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
drawable_parasite_attach_invoker);
procedure = gimp_procedure_new (drawable_parasite_attach_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-parasite-attach",
"gimp-drawable-parasite-attach",
@ -761,9 +741,7 @@ register_parasite_procs (Gimp *gimp)
/*
* gimp-drawable-parasite-detach
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
drawable_parasite_detach_invoker);
procedure = gimp_procedure_new (drawable_parasite_detach_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-parasite-detach",
"gimp-drawable-parasite-detach",
@ -792,9 +770,7 @@ register_parasite_procs (Gimp *gimp)
/*
* gimp-drawable-parasite-list
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 2,
drawable_parasite_list_invoker);
procedure = gimp_procedure_new (drawable_parasite_list_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-drawable-parasite-list",
"gimp-drawable-parasite-list",
@ -827,9 +803,7 @@ register_parasite_procs (Gimp *gimp)
/*
* gimp-vectors-parasite-find
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 1,
vectors_parasite_find_invoker);
procedure = gimp_procedure_new (vectors_parasite_find_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-parasite-find",
"gimp-vectors-parasite-find",
@ -863,9 +837,7 @@ register_parasite_procs (Gimp *gimp)
/*
* gimp-vectors-parasite-attach
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
vectors_parasite_attach_invoker);
procedure = gimp_procedure_new (vectors_parasite_attach_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-parasite-attach",
"gimp-vectors-parasite-attach",
@ -892,9 +864,7 @@ register_parasite_procs (Gimp *gimp)
/*
* gimp-vectors-parasite-detach
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
vectors_parasite_detach_invoker);
procedure = gimp_procedure_new (vectors_parasite_detach_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-parasite-detach",
"gimp-vectors-parasite-detach",
@ -923,9 +893,7 @@ register_parasite_procs (Gimp *gimp)
/*
* gimp-vectors-parasite-list
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 2,
vectors_parasite_list_invoker);
procedure = gimp_procedure_new (vectors_parasite_list_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-parasite-list",
"gimp-vectors-parasite-list",

64
app/pdb/paths_cmds.c
View File

@ -682,9 +682,7 @@ register_paths_procs (Gimp *gimp)
/*
* gimp-path-list
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 2,
path_list_invoker);
procedure = gimp_procedure_new (path_list_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-path-list",
"gimp-path-list",
@ -717,9 +715,7 @@ register_paths_procs (Gimp *gimp)
/*
* gimp-path-get-current
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
path_get_current_invoker);
procedure = gimp_procedure_new (path_get_current_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-path-get-current",
"gimp-path-get-current",
@ -748,9 +744,7 @@ register_paths_procs (Gimp *gimp)
/*
* gimp-path-set-current
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
path_set_current_invoker);
procedure = gimp_procedure_new (path_set_current_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-path-set-current",
"gimp-path-set-current",
@ -779,9 +773,7 @@ register_paths_procs (Gimp *gimp)
/*
* gimp-path-delete
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
path_delete_invoker);
procedure = gimp_procedure_new (path_delete_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-path-delete",
"gimp-path-delete",
@ -810,9 +802,7 @@ register_paths_procs (Gimp *gimp)
/*
* gimp-path-get-points
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 4,
path_get_points_invoker);
procedure = gimp_procedure_new (path_get_points_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-path-get-points",
"gimp-path-get-points",
@ -864,9 +854,7 @@ register_paths_procs (Gimp *gimp)
/*
* gimp-path-set-points
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 5, 0,
path_set_points_invoker);
procedure = gimp_procedure_new (path_set_points_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-path-set-points",
"gimp-path-set-points",
@ -912,9 +900,7 @@ register_paths_procs (Gimp *gimp)
/*
* gimp-path-stroke-current
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
path_stroke_current_invoker);
procedure = gimp_procedure_new (path_stroke_current_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-path-stroke-current",
"gimp-path-stroke-current",
@ -936,9 +922,7 @@ register_paths_procs (Gimp *gimp)
/*
* gimp-path-get-point-at-dist
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 3,
path_get_point_at_dist_invoker);
procedure = gimp_procedure_new (path_get_point_at_dist_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-path-get-point-at-dist",
"gimp-path-get-point-at-dist",
@ -984,9 +968,7 @@ register_paths_procs (Gimp *gimp)
/*
* gimp-path-get-tattoo
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 1,
path_get_tattoo_invoker);
procedure = gimp_procedure_new (path_get_tattoo_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-path-get-tattoo",
"gimp-path-get-tattoo",
@ -1021,9 +1003,7 @@ register_paths_procs (Gimp *gimp)
/*
* gimp-path-set-tattoo
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 0,
path_set_tattoo_invoker);
procedure = gimp_procedure_new (path_set_tattoo_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-path-set-tattoo",
"gimp-path-set-tattoo",
@ -1058,9 +1038,7 @@ register_paths_procs (Gimp *gimp)
/*
* gimp-get-path-by-tattoo
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 1,
get_path_by_tattoo_invoker);
procedure = gimp_procedure_new (get_path_by_tattoo_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-get-path-by-tattoo",
"gimp-get-path-by-tattoo",
@ -1095,9 +1073,7 @@ register_paths_procs (Gimp *gimp)
/*
* gimp-path-get-locked
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 1,
path_get_locked_invoker);
procedure = gimp_procedure_new (path_get_locked_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-path-get-locked",
"gimp-path-get-locked",
@ -1132,9 +1108,7 @@ register_paths_procs (Gimp *gimp)
/*
* gimp-path-set-locked
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 0,
path_set_locked_invoker);
procedure = gimp_procedure_new (path_set_locked_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-path-set-locked",
"gimp-path-set-locked",
@ -1169,9 +1143,7 @@ register_paths_procs (Gimp *gimp)
/*
* gimp-path-to-selection
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 7, 0,
path_to_selection_invoker);
procedure = gimp_procedure_new (path_to_selection_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-path-to-selection",
"gimp-path-to-selection",
@ -1231,9 +1203,7 @@ register_paths_procs (Gimp *gimp)
/*
* gimp-path-import
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 4, 0,
path_import_invoker);
procedure = gimp_procedure_new (path_import_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-path-import",
"gimp-path-import",
@ -1274,9 +1244,7 @@ register_paths_procs (Gimp *gimp)
/*
* gimp-path-import-string
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 5, 0,
path_import_string_invoker);
procedure = gimp_procedure_new (path_import_string_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-path-import-string",
"gimp-path-import-string",

8
app/pdb/pattern_cmds.c
View File

@ -139,9 +139,7 @@ register_pattern_procs (Gimp *gimp)
/*
* gimp-pattern-get-info
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 3,
pattern_get_info_invoker);
procedure = gimp_procedure_new (pattern_get_info_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-pattern-get-info",
"gimp-pattern-get-info",
@ -182,9 +180,7 @@ register_pattern_procs (Gimp *gimp)
/*
* gimp-pattern-get-pixels
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 5,
pattern_get_pixels_invoker);
procedure = gimp_procedure_new (pattern_get_pixels_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-pattern-get-pixels",
"gimp-pattern-get-pixels",

12
app/pdb/pattern_select_cmds.c
View File

@ -120,9 +120,7 @@ register_pattern_select_procs (Gimp *gimp)
/*
* gimp-patterns-popup
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 0,
patterns_popup_invoker);
procedure = gimp_procedure_new (patterns_popup_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-patterns-popup",
"gimp-patterns-popup",
@ -159,9 +157,7 @@ register_pattern_select_procs (Gimp *gimp)
/*
* gimp-patterns-close-popup
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
patterns_close_popup_invoker);
procedure = gimp_procedure_new (patterns_close_popup_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-patterns-close-popup",
"gimp-patterns-close-popup",
@ -184,9 +180,7 @@ register_pattern_select_procs (Gimp *gimp)
/*
* gimp-patterns-set-popup
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
patterns_set_popup_invoker);
procedure = gimp_procedure_new (patterns_set_popup_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-patterns-set-popup",
"gimp-patterns-set-popup",

16
app/pdb/patterns_cmds.c
View File

@ -188,9 +188,7 @@ register_patterns_procs (Gimp *gimp)
/*
* gimp-patterns-refresh
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 0, 0,
patterns_refresh_invoker);
procedure = gimp_procedure_new (patterns_refresh_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-patterns-refresh",
"gimp-patterns-refresh",
@ -206,9 +204,7 @@ register_patterns_procs (Gimp *gimp)
/*
* gimp-patterns-get-list
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 2,
patterns_get_list_invoker);
procedure = gimp_procedure_new (patterns_get_list_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-patterns-get-list",
"gimp-patterns-get-list",
@ -242,9 +238,7 @@ register_patterns_procs (Gimp *gimp)
/*
* gimp-patterns-get-pattern
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 0, 3,
patterns_get_pattern_invoker);
procedure = gimp_procedure_new (patterns_get_pattern_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-patterns-get-pattern",
"gimp-patterns-get-pattern",
@ -279,9 +273,7 @@ register_patterns_procs (Gimp *gimp)
/*
* gimp-patterns-get-pattern-data
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 6,
patterns_get_pattern_data_invoker);
procedure = gimp_procedure_new (patterns_get_pattern_data_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-patterns-get-pattern-data",
"gimp-patterns-get-pattern-data",

4
app/pdb/pdb-types.h
View File

@ -23,7 +23,9 @@
#include "core/core-types.h"
typedef struct _GimpProcedure GimpProcedure;
typedef struct _GimpProcedure GimpProcedure;
typedef struct _GimpPlugInProcedure GimpPlugInProcedure;
typedef struct _GimpTemporaryProcedure GimpTemporaryProcedure;
typedef enum

26
app/pdb/plug_in_cmds.c
View File

@ -34,9 +34,9 @@
#include "core/gimpparamspecs.h"
#include "core/gimp.h"
#include "gimppluginprocedure.h"
#include "plug-in/plug-in-def.h"
#include "plug-in/plug-in-params.h"
#include "plug-in/plug-in-proc-def.h"
#include "plug-in/plug-in.h"
#include "plug-in/plug-ins-query.h"
#include "plug-in/plug-ins.h"
@ -269,9 +269,7 @@ register_plug_in_procs (Gimp *gimp)
/*
* gimp-plugins-query
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 12,
plugins_query_invoker);
procedure = gimp_procedure_new (plugins_query_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-plugins-query",
"gimp-plugins-query",
@ -360,9 +358,7 @@ register_plug_in_procs (Gimp *gimp)
/*
* gimp-plugin-domain-register
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
plugin_domain_register_invoker);
procedure = gimp_procedure_new (plugin_domain_register_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-plugin-domain-register",
"gimp-plugin-domain-register",
@ -392,9 +388,7 @@ register_plug_in_procs (Gimp *gimp)
/*
* gimp-plugin-help-register
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
plugin_help_register_invoker);
procedure = gimp_procedure_new (plugin_help_register_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-plugin-help-register",
"gimp-plugin-help-register",
@ -424,9 +418,7 @@ register_plug_in_procs (Gimp *gimp)
/*
* gimp-plugin-menu-register
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
plugin_menu_register_invoker);
procedure = gimp_procedure_new (plugin_menu_register_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-plugin-menu-register",
"gimp-plugin-menu-register",
@ -456,9 +448,7 @@ register_plug_in_procs (Gimp *gimp)
/*
* gimp-plugin-menu-branch-register
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
plugin_menu_branch_register_invoker);
procedure = gimp_procedure_new (plugin_menu_branch_register_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-plugin-menu-branch-register",
"gimp-plugin-menu-branch-register",
@ -488,9 +478,7 @@ register_plug_in_procs (Gimp *gimp)
/*
* gimp-plugin-icon-register
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 4, 0,
plugin_icon_register_invoker);
procedure = gimp_procedure_new (plugin_icon_register_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-plugin-icon-register",
"gimp-plugin-icon-register",

36
app/pdb/procedural_db_cmds.c
View File

@ -421,9 +421,7 @@ register_procedural_db_procs (Gimp *gimp)
/*
* gimp-procedural-db-temp-name
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 0, 1,
procedural_db_temp_name_invoker);
procedure = gimp_procedure_new (procedural_db_temp_name_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-procedural-db-temp-name",
"gimp-procedural-db-temp-name",
@ -446,9 +444,7 @@ register_procedural_db_procs (Gimp *gimp)
/*
* gimp-procedural-db-dump
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
procedural_db_dump_invoker);
procedure = gimp_procedure_new (procedural_db_dump_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-procedural-db-dump",
"gimp-procedural-db-dump",
@ -471,9 +467,7 @@ register_procedural_db_procs (Gimp *gimp)
/*
* gimp-procedural-db-query
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 7, 2,
procedural_db_query_invoker);
procedure = gimp_procedure_new (procedural_db_query_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-procedural-db-query",
"gimp-procedural-db-query",
@ -549,9 +543,7 @@ register_procedural_db_procs (Gimp *gimp)
/*
* gimp-procedural-db-proc-info
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 8,
procedural_db_proc_info_invoker);
procedure = gimp_procedure_new (procedural_db_proc_info_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-procedural-db-proc-info",
"gimp-procedural-db-proc-info",
@ -628,9 +620,7 @@ register_procedural_db_procs (Gimp *gimp)
/*
* gimp-procedural-db-proc-arg
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 3,
procedural_db_proc_arg_invoker);
procedure = gimp_procedure_new (procedural_db_proc_arg_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-procedural-db-proc-arg",
"gimp-procedural-db-proc-arg",
@ -682,9 +672,7 @@ register_procedural_db_procs (Gimp *gimp)
/*
* gimp-procedural-db-proc-val
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 3,
procedural_db_proc_val_invoker);
procedure = gimp_procedure_new (procedural_db_proc_val_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-procedural-db-proc-val",
"gimp-procedural-db-proc-val",
@ -736,9 +724,7 @@ register_procedural_db_procs (Gimp *gimp)
/*
* gimp-procedural-db-get-data
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 2,
procedural_db_get_data_invoker);
procedure = gimp_procedure_new (procedural_db_get_data_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-procedural-db-get-data",
"gimp-procedural-db-get-data",
@ -772,9 +758,7 @@ register_procedural_db_procs (Gimp *gimp)
/*
* gimp-procedural-db-get-data-size
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
procedural_db_get_data_size_invoker);
procedure = gimp_procedure_new (procedural_db_get_data_size_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-procedural-db-get-data-size",
"gimp-procedural-db-get-data-size",
@ -803,9 +787,7 @@ register_procedural_db_procs (Gimp *gimp)
/*
* gimp-procedural-db-set-data
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 0,
procedural_db_set_data_invoker);
procedure = gimp_procedure_new (procedural_db_set_data_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-procedural-db-set-data",
"gimp-procedural-db-set-data",

32
app/pdb/progress_cmds.c
View File

@ -238,9 +238,7 @@ register_progress_procs (Gimp *gimp)
/*
* gimp-progress-init
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
progress_init_invoker);
procedure = gimp_procedure_new (progress_init_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-progress-init",
"gimp-progress-init",
@ -269,9 +267,7 @@ register_progress_procs (Gimp *gimp)
/*
* gimp-progress-update
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
progress_update_invoker);
procedure = gimp_procedure_new (progress_update_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-progress-update",
"gimp-progress-update",
@ -293,9 +289,7 @@ register_progress_procs (Gimp *gimp)
/*
* gimp-progress-pulse
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 0, 0,
progress_pulse_invoker);
procedure = gimp_procedure_new (progress_pulse_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-progress-pulse",
"gimp-progress-pulse",
@ -311,9 +305,7 @@ register_progress_procs (Gimp *gimp)
/*
* gimp-progress-set-text
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
progress_set_text_invoker);
procedure = gimp_procedure_new (progress_set_text_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-progress-set-text",
"gimp-progress-set-text",
@ -336,9 +328,7 @@ register_progress_procs (Gimp *gimp)
/*
* gimp-progress-get-window-handle
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 0, 1,
progress_get_window_handle_invoker);
procedure = gimp_procedure_new (progress_get_window_handle_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-progress-get-window-handle",
"gimp-progress-get-window-handle",
@ -360,9 +350,7 @@ register_progress_procs (Gimp *gimp)
/*
* gimp-progress-install
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
progress_install_invoker);
procedure = gimp_procedure_new (progress_install_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-progress-install",
"gimp-progress-install",
@ -385,9 +373,7 @@ register_progress_procs (Gimp *gimp)
/*
* gimp-progress-uninstall
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
progress_uninstall_invoker);
procedure = gimp_procedure_new (progress_uninstall_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-progress-uninstall",
"gimp-progress-uninstall",
@ -410,9 +396,7 @@ register_progress_procs (Gimp *gimp)
/*
* gimp-progress-cancel
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
progress_cancel_invoker);
procedure = gimp_procedure_new (progress_cancel_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-progress-cancel",
"gimp-progress-cancel",

68
app/pdb/selection_cmds.c
View File

@ -498,9 +498,7 @@ register_selection_procs (Gimp *gimp)
/*
* gimp-selection-bounds
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 5,
selection_bounds_invoker);
procedure = gimp_procedure_new (selection_bounds_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-selection-bounds",
"gimp-selection-bounds",
@ -552,9 +550,7 @@ register_selection_procs (Gimp *gimp)
/*
* gimp-selection-value
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 1,
selection_value_invoker);
procedure = gimp_procedure_new (selection_value_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-selection-value",
"gimp-selection-value",
@ -594,9 +590,7 @@ register_selection_procs (Gimp *gimp)
/*
* gimp-selection-is-empty
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
selection_is_empty_invoker);
procedure = gimp_procedure_new (selection_is_empty_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-selection-is-empty",
"gimp-selection-is-empty",
@ -624,9 +618,7 @@ register_selection_procs (Gimp *gimp)
/*
* gimp-selection-translate
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 0,
selection_translate_invoker);
procedure = gimp_procedure_new (selection_translate_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-selection-translate",
"gimp-selection-translate",
@ -660,9 +652,7 @@ register_selection_procs (Gimp *gimp)
/*
* gimp-selection-float
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 1,
selection_float_invoker);
procedure = gimp_procedure_new (selection_float_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-selection-float",
"gimp-selection-float",
@ -702,9 +692,7 @@ register_selection_procs (Gimp *gimp)
/*
* gimp-selection-invert
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
selection_invert_invoker);
procedure = gimp_procedure_new (selection_invert_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-selection-invert",
"gimp-selection-invert",
@ -726,9 +714,7 @@ register_selection_procs (Gimp *gimp)
/*
* gimp-selection-sharpen
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
selection_sharpen_invoker);
procedure = gimp_procedure_new (selection_sharpen_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-selection-sharpen",
"gimp-selection-sharpen",
@ -750,9 +736,7 @@ register_selection_procs (Gimp *gimp)
/*
* gimp-selection-all
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
selection_all_invoker);
procedure = gimp_procedure_new (selection_all_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-selection-all",
"gimp-selection-all",
@ -774,9 +758,7 @@ register_selection_procs (Gimp *gimp)
/*
* gimp-selection-none
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
selection_none_invoker);
procedure = gimp_procedure_new (selection_none_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-selection-none",
"gimp-selection-none",
@ -798,9 +780,7 @@ register_selection_procs (Gimp *gimp)
/*
* gimp-selection-feather
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
selection_feather_invoker);
procedure = gimp_procedure_new (selection_feather_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-selection-feather",
"gimp-selection-feather",
@ -828,9 +808,7 @@ register_selection_procs (Gimp *gimp)
/*
* gimp-selection-border
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
selection_border_invoker);
procedure = gimp_procedure_new (selection_border_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-selection-border",
"gimp-selection-border",
@ -858,9 +836,7 @@ register_selection_procs (Gimp *gimp)
/*
* gimp-selection-grow
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
selection_grow_invoker);
procedure = gimp_procedure_new (selection_grow_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-selection-grow",
"gimp-selection-grow",
@ -888,9 +864,7 @@ register_selection_procs (Gimp *gimp)
/*
* gimp-selection-shrink
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
selection_shrink_invoker);
procedure = gimp_procedure_new (selection_shrink_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-selection-shrink",
"gimp-selection-shrink",
@ -918,9 +892,7 @@ register_selection_procs (Gimp *gimp)
/*
* gimp-selection-layer-alpha
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
selection_layer_alpha_invoker);
procedure = gimp_procedure_new (selection_layer_alpha_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-selection-layer-alpha",
"gimp-selection-layer-alpha",
@ -942,9 +914,7 @@ register_selection_procs (Gimp *gimp)
/*
* gimp-selection-load
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
selection_load_invoker);
procedure = gimp_procedure_new (selection_load_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-selection-load",
"gimp-selection-load",
@ -966,9 +936,7 @@ register_selection_procs (Gimp *gimp)
/*
* gimp-selection-save
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
selection_save_invoker);
procedure = gimp_procedure_new (selection_save_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-selection-save",
"gimp-selection-save",
@ -996,9 +964,7 @@ register_selection_procs (Gimp *gimp)
/*
* gimp-selection-combine
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
selection_combine_invoker);
procedure = gimp_procedure_new (selection_combine_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-selection-combine",
"gimp-selection-combine",

20
app/pdb/selection_tools_cmds.c
View File

@ -260,9 +260,7 @@ register_selection_tools_procs (Gimp *gimp)
/*
* gimp-by-color-select
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 8, 0,
by_color_select_invoker);
procedure = gimp_procedure_new (by_color_select_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-by-color-select",
"gimp-by-color-select",
@ -327,9 +325,7 @@ register_selection_tools_procs (Gimp *gimp)
/*
* gimp-ellipse-select
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 9, 0,
ellipse_select_invoker);
procedure = gimp_procedure_new (ellipse_select_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-ellipse-select",
"gimp-ellipse-select",
@ -400,9 +396,7 @@ register_selection_tools_procs (Gimp *gimp)
/*
* gimp-free-select
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 7, 0,
free_select_invoker);
procedure = gimp_procedure_new (free_select_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-free-select",
"gimp-free-select",
@ -460,9 +454,7 @@ register_selection_tools_procs (Gimp *gimp)
/*
* gimp-fuzzy-select
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 9, 0,
fuzzy_select_invoker);
procedure = gimp_procedure_new (fuzzy_select_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-fuzzy-select",
"gimp-fuzzy-select",
@ -534,9 +526,7 @@ register_selection_tools_procs (Gimp *gimp)
/*
* gimp-rect-select
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 8, 0,
rect_select_invoker);
procedure = gimp_procedure_new (rect_select_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-rect-select",
"gimp-rect-select",

16
app/pdb/text_tool_cmds.c
View File

@ -280,9 +280,7 @@ register_text_tool_procs (Gimp *gimp)
/*
* gimp-text-fontname
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 10, 1,
text_fontname_invoker);
procedure = gimp_procedure_new (text_fontname_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-text-fontname",
"gimp-text-fontname",
@ -367,9 +365,7 @@ register_text_tool_procs (Gimp *gimp)
/*
* gimp-text-get-extents-fontname
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 4, 4,
text_get_extents_fontname_invoker);
procedure = gimp_procedure_new (text_get_extents_fontname_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-text-get-extents-fontname",
"gimp-text-get-extents-fontname",
@ -436,9 +432,7 @@ register_text_tool_procs (Gimp *gimp)
/*
* gimp-text
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 17, 1,
text_invoker);
procedure = gimp_procedure_new (text_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-text",
"gimp-text",
@ -572,9 +566,7 @@ register_text_tool_procs (Gimp *gimp)
/*
* gimp-text-get-extents
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 11, 4,
text_get_extents_invoker);
procedure = gimp_procedure_new (text_get_extents_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-text-get-extents",
"gimp-text-get-extents",

24
app/pdb/transform_tools_cmds.c
View File

@ -429,9 +429,7 @@ register_transform_tools_procs (Gimp *gimp)
/*
* gimp-flip
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 1,
flip_invoker);
procedure = gimp_procedure_new (flip_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-flip",
"gimp-flip",
@ -468,9 +466,7 @@ register_transform_tools_procs (Gimp *gimp)
/*
* gimp-perspective
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 10, 1,
perspective_invoker);
procedure = gimp_procedure_new (perspective_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-perspective",
"gimp-perspective",
@ -552,9 +548,7 @@ register_transform_tools_procs (Gimp *gimp)
/*
* gimp-rotate
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 1,
rotate_invoker);
procedure = gimp_procedure_new (rotate_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-rotate",
"gimp-rotate",
@ -594,9 +588,7 @@ register_transform_tools_procs (Gimp *gimp)
/*
* gimp-scale
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 6, 1,
scale_invoker);
procedure = gimp_procedure_new (scale_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-scale",
"gimp-scale",
@ -654,9 +646,7 @@ register_transform_tools_procs (Gimp *gimp)
/*
* gimp-shear
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 4, 1,
shear_invoker);
procedure = gimp_procedure_new (shear_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-shear",
"gimp-shear",
@ -705,9 +695,7 @@ register_transform_tools_procs (Gimp *gimp)
/*
* gimp-transform-2d
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 9, 1,
transform_2d_invoker);
procedure = gimp_procedure_new (transform_2d_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-transform-2d",
"gimp-transform-2d",

28
app/pdb/undo_cmds.c
View File

@ -225,9 +225,7 @@ register_undo_procs (Gimp *gimp)
/*
* gimp-image-undo-group-start
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
image_undo_group_start_invoker);
procedure = gimp_procedure_new (image_undo_group_start_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-undo-group-start",
"gimp-image-undo-group-start",
@ -249,9 +247,7 @@ register_undo_procs (Gimp *gimp)
/*
* gimp-image-undo-group-end
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 0,
image_undo_group_end_invoker);
procedure = gimp_procedure_new (image_undo_group_end_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-undo-group-end",
"gimp-image-undo-group-end",
@ -273,9 +269,7 @@ register_undo_procs (Gimp *gimp)
/*
* gimp-image-undo-is-enabled
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
image_undo_is_enabled_invoker);
procedure = gimp_procedure_new (image_undo_is_enabled_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-undo-is-enabled",
"gimp-image-undo-is-enabled",
@ -303,9 +297,7 @@ register_undo_procs (Gimp *gimp)
/*
* gimp-image-undo-disable
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
image_undo_disable_invoker);
procedure = gimp_procedure_new (image_undo_disable_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-undo-disable",
"gimp-image-undo-disable",
@ -333,9 +325,7 @@ register_undo_procs (Gimp *gimp)
/*
* gimp-image-undo-enable
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
image_undo_enable_invoker);
procedure = gimp_procedure_new (image_undo_enable_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-undo-enable",
"gimp-image-undo-enable",
@ -363,9 +353,7 @@ register_undo_procs (Gimp *gimp)
/*
* gimp-image-undo-freeze
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
image_undo_freeze_invoker);
procedure = gimp_procedure_new (image_undo_freeze_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-undo-freeze",
"gimp-image-undo-freeze",
@ -393,9 +381,7 @@ register_undo_procs (Gimp *gimp)
/*
* gimp-image-undo-thaw
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
image_undo_thaw_invoker);
procedure = gimp_procedure_new (image_undo_thaw_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-image-undo-thaw",
"gimp-image-undo-thaw",

48
app/pdb/unit_cmds.c
View File

@ -355,9 +355,7 @@ register_unit_procs (Gimp *gimp)
/*
* gimp-unit-get-number-of-units
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 0, 1,
unit_get_number_of_units_invoker);
procedure = gimp_procedure_new (unit_get_number_of_units_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-unit-get-number-of-units",
"gimp-unit-get-number-of-units",
@ -379,9 +377,7 @@ register_unit_procs (Gimp *gimp)
/*
* gimp-unit-get-number-of-built-in-units
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 0, 1,
unit_get_number_of_built_in_units_invoker);
procedure = gimp_procedure_new (unit_get_number_of_built_in_units_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-unit-get-number-of-built-in-units",
"gimp-unit-get-number-of-built-in-units",
@ -403,9 +399,7 @@ register_unit_procs (Gimp *gimp)
/*
* gimp-unit-new
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 7, 1,
unit_new_invoker);
procedure = gimp_procedure_new (unit_new_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-unit-new",
"gimp-unit-new",
@ -476,9 +470,7 @@ register_unit_procs (Gimp *gimp)
/*
* gimp-unit-get-deletion-flag
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
unit_get_deletion_flag_invoker);
procedure = gimp_procedure_new (unit_get_deletion_flag_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-unit-get-deletion-flag",
"gimp-unit-get-deletion-flag",
@ -508,9 +500,7 @@ register_unit_procs (Gimp *gimp)
/*
* gimp-unit-set-deletion-flag
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
unit_set_deletion_flag_invoker);
procedure = gimp_procedure_new (unit_set_deletion_flag_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-unit-set-deletion-flag",
"gimp-unit-set-deletion-flag",
@ -540,9 +530,7 @@ register_unit_procs (Gimp *gimp)
/*
* gimp-unit-get-identifier
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
unit_get_identifier_invoker);
procedure = gimp_procedure_new (unit_get_identifier_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-unit-get-identifier",
"gimp-unit-get-identifier",
@ -573,9 +561,7 @@ register_unit_procs (Gimp *gimp)
/*
* gimp-unit-get-factor
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
unit_get_factor_invoker);
procedure = gimp_procedure_new (unit_get_factor_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-unit-get-factor",
"gimp-unit-get-factor",
@ -605,9 +591,7 @@ register_unit_procs (Gimp *gimp)
/*
* gimp-unit-get-digits
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
unit_get_digits_invoker);
procedure = gimp_procedure_new (unit_get_digits_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-unit-get-digits",
"gimp-unit-get-digits",
@ -637,9 +621,7 @@ register_unit_procs (Gimp *gimp)
/*
* gimp-unit-get-symbol
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
unit_get_symbol_invoker);
procedure = gimp_procedure_new (unit_get_symbol_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-unit-get-symbol",
"gimp-unit-get-symbol",
@ -670,9 +652,7 @@ register_unit_procs (Gimp *gimp)
/*
* gimp-unit-get-abbreviation
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
unit_get_abbreviation_invoker);
procedure = gimp_procedure_new (unit_get_abbreviation_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-unit-get-abbreviation",
"gimp-unit-get-abbreviation",
@ -703,9 +683,7 @@ register_unit_procs (Gimp *gimp)
/*
* gimp-unit-get-singular
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
unit_get_singular_invoker);
procedure = gimp_procedure_new (unit_get_singular_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-unit-get-singular",
"gimp-unit-get-singular",
@ -736,9 +714,7 @@ register_unit_procs (Gimp *gimp)
/*
* gimp-unit-get-plural
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
unit_get_plural_invoker);
procedure = gimp_procedure_new (unit_get_plural_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-unit-get-plural",
"gimp-unit-get-plural",

92
app/pdb/vectors_cmds.c
View File

@ -835,9 +835,7 @@ register_vectors_procs (Gimp *gimp)
/*
* gimp-vectors-new
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 1,
vectors_new_invoker);
procedure = gimp_procedure_new (vectors_new_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-new",
"gimp-vectors-new",
@ -872,9 +870,7 @@ register_vectors_procs (Gimp *gimp)
/*
* gimp-vectors-get-image
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
vectors_get_image_invoker);
procedure = gimp_procedure_new (vectors_get_image_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-get-image",
"gimp-vectors-get-image",
@ -902,9 +898,7 @@ register_vectors_procs (Gimp *gimp)
/*
* gimp-vectors-get-name
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
vectors_get_name_invoker);
procedure = gimp_procedure_new (vectors_get_name_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-get-name",
"gimp-vectors-get-name",
@ -933,9 +927,7 @@ register_vectors_procs (Gimp *gimp)
/*
* gimp-vectors-set-name
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
vectors_set_name_invoker);
procedure = gimp_procedure_new (vectors_set_name_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-set-name",
"gimp-vectors-set-name",
@ -964,9 +956,7 @@ register_vectors_procs (Gimp *gimp)
/*
* gimp-vectors-get-visible
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
vectors_get_visible_invoker);
procedure = gimp_procedure_new (vectors_get_visible_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-get-visible",
"gimp-vectors-get-visible",
@ -994,9 +984,7 @@ register_vectors_procs (Gimp *gimp)
/*
* gimp-vectors-set-visible
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
vectors_set_visible_invoker);
procedure = gimp_procedure_new (vectors_set_visible_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-set-visible",
"gimp-vectors-set-visible",
@ -1024,9 +1012,7 @@ register_vectors_procs (Gimp *gimp)
/*
* gimp-vectors-get-linked
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
vectors_get_linked_invoker);
procedure = gimp_procedure_new (vectors_get_linked_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-get-linked",
"gimp-vectors-get-linked",
@ -1054,9 +1040,7 @@ register_vectors_procs (Gimp *gimp)
/*
* gimp-vectors-set-linked
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
vectors_set_linked_invoker);
procedure = gimp_procedure_new (vectors_set_linked_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-set-linked",
"gimp-vectors-set-linked",
@ -1084,9 +1068,7 @@ register_vectors_procs (Gimp *gimp)
/*
* gimp-vectors-get-tattoo
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 1,
vectors_get_tattoo_invoker);
procedure = gimp_procedure_new (vectors_get_tattoo_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-get-tattoo",
"gimp-vectors-get-tattoo",
@ -1114,9 +1096,7 @@ register_vectors_procs (Gimp *gimp)
/*
* gimp-vectors-set-tattoo
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
vectors_set_tattoo_invoker);
procedure = gimp_procedure_new (vectors_set_tattoo_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-set-tattoo",
"gimp-vectors-set-tattoo",
@ -1144,9 +1124,7 @@ register_vectors_procs (Gimp *gimp)
/*
* gimp-vectors-get-strokes
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 1, 2,
vectors_get_strokes_invoker);
procedure = gimp_procedure_new (vectors_get_strokes_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-get-strokes",
"gimp-vectors-get-strokes",
@ -1179,9 +1157,7 @@ register_vectors_procs (Gimp *gimp)
/*
* gimp-vectors-stroke-get-length
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 1,
vectors_stroke_get_length_invoker);
procedure = gimp_procedure_new (vectors_stroke_get_length_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-stroke-get-length",
"gimp-vectors-stroke-get-length",
@ -1221,9 +1197,7 @@ register_vectors_procs (Gimp *gimp)
/*
* gimp-vectors-stroke-get-point-at-dist
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 4, 4,
vectors_stroke_get_point_at_dist_invoker);
procedure = gimp_procedure_new (vectors_stroke_get_point_at_dist_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-stroke-get-point-at-dist",
"gimp-vectors-stroke-get-point-at-dist",
@ -1287,9 +1261,7 @@ register_vectors_procs (Gimp *gimp)
/*
* gimp-vectors-stroke-remove
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
vectors_stroke_remove_invoker);
procedure = gimp_procedure_new (vectors_stroke_remove_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-stroke-remove",
"gimp-vectors-stroke-remove",
@ -1317,9 +1289,7 @@ register_vectors_procs (Gimp *gimp)
/*
* gimp-vectors-stroke-close
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 2, 0,
vectors_stroke_close_invoker);
procedure = gimp_procedure_new (vectors_stroke_close_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-stroke-close",
"gimp-vectors-stroke-close",
@ -1347,9 +1317,7 @@ register_vectors_procs (Gimp *gimp)
/*
* gimp-vectors-stroke-translate
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 4, 0,
vectors_stroke_translate_invoker);
procedure = gimp_procedure_new (vectors_stroke_translate_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-stroke-translate",
"gimp-vectors-stroke-translate",
@ -1389,9 +1357,7 @@ register_vectors_procs (Gimp *gimp)
/*
* gimp-vectors-stroke-scale
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 4, 0,
vectors_stroke_scale_invoker);
procedure = gimp_procedure_new (vectors_stroke_scale_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-stroke-scale",
"gimp-vectors-stroke-scale",
@ -1431,9 +1397,7 @@ register_vectors_procs (Gimp *gimp)
/*
* gimp-vectors-stroke-interpolate
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 3,
vectors_stroke_interpolate_invoker);
procedure = gimp_procedure_new (vectors_stroke_interpolate_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-stroke-interpolate",
"gimp-vectors-stroke-interpolate",
@ -1484,9 +1448,7 @@ register_vectors_procs (Gimp *gimp)
/*
* gimp-vectors-bezier-stroke-new-moveto
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 1,
vectors_bezier_stroke_new_moveto_invoker);
procedure = gimp_procedure_new (vectors_bezier_stroke_new_moveto_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-bezier-stroke-new-moveto",
"gimp-vectors-bezier-stroke-new-moveto",
@ -1526,9 +1488,7 @@ register_vectors_procs (Gimp *gimp)
/*
* gimp-vectors-bezier-stroke-lineto
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 4, 0,
vectors_bezier_stroke_lineto_invoker);
procedure = gimp_procedure_new (vectors_bezier_stroke_lineto_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-bezier-stroke-lineto",
"gimp-vectors-bezier-stroke-lineto",
@ -1568,9 +1528,7 @@ register_vectors_procs (Gimp *gimp)
/*
* gimp-vectors-bezier-stroke-conicto
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 6, 0,
vectors_bezier_stroke_conicto_invoker);
procedure = gimp_procedure_new (vectors_bezier_stroke_conicto_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-bezier-stroke-conicto",
"gimp-vectors-bezier-stroke-conicto",
@ -1622,9 +1580,7 @@ register_vectors_procs (Gimp *gimp)
/*
* gimp-vectors-bezier-stroke-cubicto
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 8, 0,
vectors_bezier_stroke_cubicto_invoker);
procedure = gimp_procedure_new (vectors_bezier_stroke_cubicto_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-bezier-stroke-cubicto",
"gimp-vectors-bezier-stroke-cubicto",
@ -1688,9 +1644,7 @@ register_vectors_procs (Gimp *gimp)
/*
* gimp-vectors-bezier-stroke-new-ellipse
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 6, 1,
vectors_bezier_stroke_new_ellipse_invoker);
procedure = gimp_procedure_new (vectors_bezier_stroke_new_ellipse_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-vectors-bezier-stroke-new-ellipse",
"gimp-vectors-bezier-stroke-new-ellipse",

2
app/plug-in/Makefile.am
View File

@ -32,8 +32,6 @@ libappplug_in_a_SOURCES = \
plug-in-message.h \
plug-in-params.c \
plug-in-params.h \
plug-in-proc-def.c \
plug-in-proc-def.h \
plug-in-proc-frame.c \
plug-in-proc-frame.h \
plug-in-progress.c \

29
app/plug-in/gimpplugin-message.c
View File

@ -38,13 +38,12 @@
#include "pdb/gimp-pdb.h"
#include "pdb/gimp-pdb-compat.h"
#include "pdb/gimpprocedure.h"
#include "pdb/gimptemporaryprocedure.h"
#include "plug-in.h"
#include "plug-ins.h"
#include "plug-in-def.h"
#include "plug-in-params.h"
#include "plug-in-proc-def.h"
#include "plug-in-shm.h"
@ -570,7 +569,6 @@ plug_in_handle_proc_install (PlugIn *plug_in,
GimpPlugInProcedure *proc = NULL;
GimpProcedure *procedure = NULL;
gchar *canonical;
gchar *prog = NULL;
gboolean valid_utf8 = FALSE;
gint i;
@ -585,7 +583,7 @@ plug_in_handle_proc_install (PlugIn *plug_in,
proc_install->params[i].type == GIMP_PDB_FLOATARRAY ||
proc_install->params[i].type == GIMP_PDB_STRINGARRAY)
&&
proc_install->params[i-1].type != GIMP_PDB_INT32)
proc_install->params[i - 1].type != GIMP_PDB_INT32)
{
g_message ("Plug-In \"%s\"\n(%s)\n\n"
"attempted to install procedure \"%s\" "
@ -651,7 +649,6 @@ plug_in_handle_proc_install (PlugIn *plug_in,
case GIMP_PLUGIN:
case GIMP_EXTENSION:
plug_in_def = plug_in->plug_in_def;
prog = plug_in_def->prog;
proc = gimp_plug_in_procedure_find (plug_in_def->proc_defs, canonical);
@ -661,11 +658,13 @@ plug_in_handle_proc_install (PlugIn *plug_in,
proc);
g_object_unref (proc);
}
procedure = gimp_plug_in_procedure_new (proc_install->type,
plug_in->prog);
break;
case GIMP_TEMPORARY:
plug_in_def = NULL;
prog = "none";
proc = gimp_plug_in_procedure_find (plug_in->temp_proc_defs, canonical);
@ -675,19 +674,18 @@ plug_in_handle_proc_install (PlugIn *plug_in,
proc);
plug_ins_temp_proc_def_remove (plug_in->gimp, proc);
}
procedure = gimp_temporary_procedure_new (plug_in);
break;
}
proc = gimp_plug_in_procedure_new ();
proc = GIMP_PLUG_IN_PROCEDURE (procedure);
proc->prog = g_strdup (prog);
proc->mtime = time (NULL);
proc->installed_during_init = plug_in->init;
gimp_plug_in_procedure_set_image_types (proc, proc_install->image_types);
procedure = GIMP_PROCEDURE (proc);
gimp_procedure_set_strings (procedure,
canonical,
proc_install->name,
@ -700,13 +698,6 @@ plug_in_handle_proc_install (PlugIn *plug_in,
g_free (canonical);
gimp_procedure_initialize (procedure,
proc_install->type,
proc_install->nparams,
proc_install->nreturn_vals,
proc_install->type == GIMP_TEMPORARY ?
(gpointer) plug_in : (gpointer) prog);
for (i = 0; i < proc_install->nparams; i++)
{
GParamSpec *pspec =
@ -729,6 +720,8 @@ plug_in_handle_proc_install (PlugIn *plug_in,
gimp_procedure_add_return_value (procedure, pspec);
}
/* Sanity check menu path */
if (proc_install->menu_path)
{
if (proc_install->menu_path[0] == '<')
@ -761,6 +754,8 @@ plug_in_handle_proc_install (PlugIn *plug_in,
}
}
/* Install the procedure */
switch (proc_install->type)
{
case GIMP_PLUGIN:

13
app/plug-in/gimpplugin-progress.c
View File

@ -30,7 +30,7 @@
#include "core/gimpprogress.h"
#include "pdb/gimp-pdb.h"
#include "pdb/gimpprocedure.h"
#include "pdb/gimptemporaryprocedure.h"
#include "plug-in.h"
#include "plug-in-progress.h"
@ -205,12 +205,11 @@ plug_in_progress_install (PlugIn *plug_in,
procedure = gimp_pdb_lookup (plug_in->gimp, progress_callback);
if (! procedure ||
procedure->proc_type != GIMP_TEMPORARY ||
procedure->exec_method.temporary.plug_in != plug_in ||
procedure->num_args != 3 ||
! GIMP_IS_PARAM_SPEC_INT32 (procedure->args[0]) ||
! G_IS_PARAM_SPEC_STRING (procedure->args[1]) ||
if (! GIMP_IS_TEMPORARY_PROCEDURE (procedure) ||
GIMP_TEMPORARY_PROCEDURE (procedure)->plug_in != plug_in ||
procedure->num_args != 3 ||
! GIMP_IS_PARAM_SPEC_INT32 (procedure->args[0]) ||
! G_IS_PARAM_SPEC_STRING (procedure->args[1]) ||
! G_IS_PARAM_SPEC_DOUBLE (procedure->args[2]))
{
return FALSE;

3
app/plug-in/gimpplugin.c
View File

@ -76,7 +76,7 @@
#include "core/gimpinterpreterdb.h"
#include "core/gimpprogress.h"
#include "pdb/gimpprocedure.h"
#include "pdb/gimppluginprocedure.h"
#include "plug-in.h"
#include "plug-ins.h"
@ -84,7 +84,6 @@
#include "plug-in-def.h"
#include "plug-in-message.h"
#include "plug-in-params.h"
#include "plug-in-proc-def.h"
#include "plug-in-progress.h"
#include "plug-in-shm.h"

7
app/plug-in/gimppluginmanager-call.c
View File

@ -36,11 +36,10 @@
#include "core/gimpcontext.h"
#include "core/gimpprogress.h"
#include "pdb/gimpprocedure.h"
#include "pdb/gimptemporaryprocedure.h"
#include "plug-in.h"
#include "plug-in-params.h"
#include "plug-in-proc-def.h"
#include "plug-in-run.h"
#include "plug-in-shm.h"
@ -83,7 +82,7 @@ plug_in_run (Gimp *gimp,
}
plug_in = plug_in_new (gimp, context, progress, procedure,
procedure->exec_method.plug_in.filename);
GIMP_PLUG_IN_PROCEDURE (procedure)->prog);
if (plug_in)
{
@ -206,7 +205,7 @@ plug_in_temp_run (GimpProcedure *procedure,
GValueArray *return_vals = NULL;
PlugIn *plug_in;
plug_in = (PlugIn *) procedure->exec_method.temporary.plug_in;
plug_in = GIMP_TEMPORARY_PROCEDURE (procedure)->plug_in;
if (plug_in)
{

4
app/plug-in/gimppluginmanager-query.c
View File

@ -36,9 +36,7 @@
#include "core/gimp.h"
#include "pdb/gimpprocedure.h"
#include "plug-in-proc-def.h"
#include "pdb/gimppluginprocedure.h"
static int

7
app/plug-in/gimppluginmanager-run.c
View File

@ -36,11 +36,10 @@
#include "core/gimpcontext.h"
#include "core/gimpprogress.h"
#include "pdb/gimpprocedure.h"
#include "pdb/gimptemporaryprocedure.h"
#include "plug-in.h"
#include "plug-in-params.h"
#include "plug-in-proc-def.h"
#include "plug-in-run.h"
#include "plug-in-shm.h"
@ -83,7 +82,7 @@ plug_in_run (Gimp *gimp,
}
plug_in = plug_in_new (gimp, context, progress, procedure,
procedure->exec_method.plug_in.filename);
GIMP_PLUG_IN_PROCEDURE (procedure)->prog);
if (plug_in)
{
@ -206,7 +205,7 @@ plug_in_temp_run (GimpProcedure *procedure,
GValueArray *return_vals = NULL;
PlugIn *plug_in;
plug_in = (PlugIn *) procedure->exec_method.temporary.plug_in;
plug_in = GIMP_TEMPORARY_PROCEDURE (procedure)->plug_in;
if (plug_in)
{

11
app/plug-in/gimppluginmanager.c
View File

@ -39,14 +39,13 @@
#include "core/gimpimage.h"
#include "pdb/gimp-pdb.h"
#include "pdb/gimpprocedure.h"
#include "pdb/gimppluginprocedure.h"
#include "plug-in.h"
#include "plug-ins.h"
#include "plug-in-data.h"
#include "plug-in-def.h"
#include "plug-in-params.h"
#include "plug-in-proc-def.h"
#include "plug-in-progress.h"
#include "plug-in-rc.h"
#include "plug-in-run.h"
@ -870,11 +869,15 @@ plug_ins_add_to_db (Gimp *gimp,
{
proc = list->data;
if (proc->prog && (GIMP_PROCEDURE (proc)->proc_type != GIMP_INTERNAL))
if (GIMP_PROCEDURE (proc)->proc_type != GIMP_INTERNAL)
{
GIMP_PROCEDURE (proc)->exec_method.plug_in.filename = proc->prog;
gimp_pdb_register (gimp, GIMP_PROCEDURE (proc));
}
else
{
g_printerr ("%s: NOT adding %s (prog = %s) to PDB\n",
G_STRFUNC, GIMP_PROCEDURE (proc)->name, proc->prog);
}
}
for (list = gimp->plug_in_proc_defs; list; list = list->next)

79
app/plug-in/gimppluginprocedure.c
View File

@ -27,27 +27,28 @@
#include "libgimpbase/gimpbase.h"
#include "plug-in-types.h"
#include "pdb-types.h"
#include "core/gimp.h"
#include "pdb/gimpprocedure.h"
#include "plug-in/plug-in.h"
#include "plug-in/plug-ins.h"
#include "plug-in/plug-in-run.h"
#include "plug-in.h"
#include "plug-ins.h"
#include "plug-in-proc-def.h"
#include "plug-in-run.h"
#include "gimppluginprocedure.h"
#include "gimp-intl.h"
static void gimp_plug_in_procedure_finalize (GObject *object);
static void gimp_plug_in_procedure_finalize (GObject *object);
static GValueArray * gimp_plug_in_procedure_execute (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
GValueArray *args);
static GValueArray * gimp_plug_in_procedure_execute (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
GValueArray *args);
const gchar * gimp_plug_in_procedure_real_get_progname (const GimpPlugInProcedure *procedure);
G_DEFINE_TYPE (GimpPlugInProcedure, gimp_plug_in_procedure,
@ -65,11 +66,15 @@ gimp_plug_in_procedure_class_init (GimpPlugInProcedureClass *klass)
object_class->finalize = gimp_plug_in_procedure_finalize;
proc_class->execute = gimp_plug_in_procedure_execute;
klass->get_progname = gimp_plug_in_procedure_real_get_progname;
}
static void
gimp_plug_in_procedure_init (GimpPlugInProcedure *proc)
{
GIMP_PROCEDURE (proc)->proc_type = GIMP_PLUGIN;
proc->icon_data_length = -1;
}
@ -107,11 +112,11 @@ gimp_plug_in_procedure_finalize (GObject *object)
}
static GValueArray *
gimp_plug_in_procedure_execute (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
GValueArray *args)
gimp_plug_in_procedure_execute (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
GValueArray *args)
{
if (procedure->proc_type == GIMP_INTERNAL)
return GIMP_PROCEDURE_CLASS (parent_class)->execute (procedure, gimp,
@ -122,15 +127,32 @@ gimp_plug_in_procedure_execute (GimpProcedure *procedure,
args, TRUE, FALSE, -1);
}
const gchar *
gimp_plug_in_procedure_real_get_progname (const GimpPlugInProcedure *procedure)
{
return procedure->prog;
}
/* public functions */
GimpPlugInProcedure *
gimp_plug_in_procedure_new (void)
GimpProcedure *
gimp_plug_in_procedure_new (GimpPDBProcType proc_type,
const gchar *prog)
{
GimpPlugInProcedure *proc = g_object_new (GIMP_TYPE_PLUG_IN_PROCEDURE, NULL);
GimpPlugInProcedure *proc;
return proc;
g_return_val_if_fail (proc_type == GIMP_PLUGIN ||
proc_type == GIMP_EXTENSION, NULL);
g_return_val_if_fail (prog != NULL, NULL);
proc = g_object_new (GIMP_TYPE_PLUG_IN_PROCEDURE, NULL);
proc->prog = g_strdup (prog);
GIMP_PROCEDURE (proc)->proc_type = proc_type;
return GIMP_PROCEDURE (proc);
}
GimpPlugInProcedure *
@ -155,20 +177,7 @@ gimp_plug_in_procedure_get_progname (const GimpPlugInProcedure *proc)
{
g_return_val_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc), NULL);
switch (GIMP_PROCEDURE (proc)->proc_type)
{
case GIMP_PLUGIN:
case GIMP_EXTENSION:
return proc->prog;
case GIMP_TEMPORARY:
return ((PlugIn *) GIMP_PROCEDURE (proc)->exec_method.temporary.plug_in)->prog;
default:
break;
}
return NULL;
return GIMP_PLUG_IN_PROCEDURE_GET_CLASS (proc)->get_progname (proc);
}
gchar *

25
app/plug-in/gimppluginprocedure.h
View File

@ -25,7 +25,7 @@
#include <gdk-pixbuf/gdk-pixbuf.h>
#include "pdb/gimpprocedure.h"
#include "gimpprocedure.h"
#define GIMP_TYPE_PLUG_IN_PROCEDURE (gimp_plug_in_procedure_get_type ())
@ -69,31 +69,34 @@ struct _GimpPlugInProcedure
struct _GimpPlugInProcedureClass
{
GimpProcedureClass parent_class;
const gchar * (* get_progname) (const GimpPlugInProcedure *procedure);
};
GType gimp_plug_in_procedure_get_type (void) G_GNUC_CONST;
GType gimp_plug_in_procedure_get_type (void) G_GNUC_CONST;
GimpPlugInProcedure * gimp_plug_in_procedure_new (void);
GimpProcedure * gimp_plug_in_procedure_new (GimpPDBProcType proc_type,
const gchar *prog);
GimpPlugInProcedure * gimp_plug_in_procedure_find (GSList *list,
const gchar *proc_name);
GimpPlugInProcedure * gimp_plug_in_procedure_find (GSList *list,
const gchar *proc_name);
const gchar * gimp_plug_in_procedure_get_progname (const GimpPlugInProcedure *proc);
gchar * gimp_plug_in_procedure_get_label (const GimpPlugInProcedure *proc,
const gchar *locale_domain);
const gchar *locale_domain);
void gimp_plug_in_procedure_set_icon (GimpPlugInProcedure *proc,
GimpIconType type,
const guint8 *data,
gint data_length);
GimpIconType type,
const guint8 *data,
gint data_length);
const gchar * gimp_plug_in_procedure_get_stock_id (const GimpPlugInProcedure *proc);
GdkPixbuf * gimp_plug_in_procedure_get_pixbuf (const GimpPlugInProcedure *proc);
gchar * gimp_plug_in_procedure_get_help_id (const GimpPlugInProcedure *proc,
const gchar *help_domain);
const gchar *help_domain);
gboolean gimp_plug_in_procedure_get_sensitive (const GimpPlugInProcedure *proc,
GimpImageType image_type);
GimpImageType image_type);
void gimp_plug_in_procedure_set_image_types (GimpPlugInProcedure *proc,
const gchar *image_types);

114
app/plug-in/gimptemporaryprocedure.c Normal file
View File

@ -0,0 +1,114 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimptemporaryprocedure.c
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <glib-object.h>
#include "pdb-types.h"
#include "plug-in/plug-in.h"
#include "gimptemporaryprocedure.h"
#include "gimp-intl.h"
static void gimp_temporary_procedure_finalize (GObject *object);
static GValueArray * gimp_temporary_procedure_execute (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
GValueArray *args);
const gchar * gimp_temporary_procedure_get_progname (const GimpPlugInProcedure *procedure);
G_DEFINE_TYPE (GimpTemporaryProcedure, gimp_temporary_procedure,
GIMP_TYPE_PLUG_IN_PROCEDURE);
#define parent_class gimp_temporary_procedure_parent_class
static void
gimp_temporary_procedure_class_init (GimpTemporaryProcedureClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GimpProcedureClass *proc_class = GIMP_PROCEDURE_CLASS (klass);
GimpPlugInProcedureClass *plug_class = GIMP_PLUG_IN_PROCEDURE_CLASS (klass);
object_class->finalize = gimp_temporary_procedure_finalize;
proc_class->execute = gimp_temporary_procedure_execute;
plug_class->get_progname = gimp_temporary_procedure_get_progname;
}
static void
gimp_temporary_procedure_init (GimpTemporaryProcedure *proc)
{
GIMP_PROCEDURE (proc)->proc_type = GIMP_TEMPORARY;
}
static void
gimp_temporary_procedure_finalize (GObject *object)
{
/* GimpTemporaryProcedure *proc = GIMP_TEMPORARY_PROCEDURE (object); */
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static GValueArray *
gimp_temporary_procedure_execute (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
GValueArray *args)
{
return GIMP_PROCEDURE_CLASS (parent_class)->execute (procedure, gimp,
context, progress,
args);
}
const gchar *
gimp_temporary_procedure_get_progname (const GimpPlugInProcedure *procedure)
{
return GIMP_TEMPORARY_PROCEDURE (procedure)->plug_in->prog;
}
/* public functions */
GimpProcedure *
gimp_temporary_procedure_new (PlugIn *plug_in)
{
GimpTemporaryProcedure *proc;
g_return_val_if_fail (plug_in != NULL, NULL);
proc = g_object_new (GIMP_TYPE_TEMPORARY_PROCEDURE, NULL);
proc->plug_in = plug_in;
GIMP_PLUG_IN_PROCEDURE (proc)->prog = g_strdup ("none");
return GIMP_PROCEDURE (proc);
}

56
app/plug-in/gimptemporaryprocedure.h Normal file
View File

@ -0,0 +1,56 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimptemporaryprocedure.h
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_TEMPORARY_PROCEDURE_H__
#define __GIMP_TEMPORARY_PROCEDURE_H__
#include "gimppluginprocedure.h"
#define GIMP_TYPE_TEMPORARY_PROCEDURE (gimp_temporary_procedure_get_type ())
#define GIMP_TEMPORARY_PROCEDURE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_TEMPORARY_PROCEDURE, GimpTemporaryProcedure))
#define GIMP_TEMPORARY_PROCEDURE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_TEMPORARY_PROCEDURE, GimpTemporaryProcedureClass))
#define GIMP_IS_TEMPORARY_PROCEDURE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_TEMPORARY_PROCEDURE))
#define GIMP_IS_TEMPORARY_PROCEDURE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_TEMPORARY_PROCEDURE))
#define GIMP_TEMPORARY_PROCEDURE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_TEMPORARY_PROCEDURE, GimpTemporaryProcedureClass))
typedef struct _GimpTemporaryProcedureClass GimpTemporaryProcedureClass;
struct _GimpTemporaryProcedure
{
GimpPlugInProcedure parent_instance;
PlugIn *plug_in;
};
struct _GimpTemporaryProcedureClass
{
GimpPlugInProcedureClass parent_class;
};
GType gimp_temporary_procedure_get_type (void) G_GNUC_CONST;
GimpProcedure * gimp_temporary_procedure_new (PlugIn *plug_in);
#endif /* __GIMP_TEMPORARY_PROCEDURE_H__ */

4
app/plug-in/plug-in-def.c
View File

@ -24,9 +24,9 @@
#include "plug-in-types.h"
#include "plug-in.h"
#include "pdb/gimppluginprocedure.h"
#include "plug-in-def.h"
#include "plug-in-proc-def.h"
PlugInDef *

29
app/plug-in/plug-in-message.c
View File

@ -38,13 +38,12 @@
#include "pdb/gimp-pdb.h"
#include "pdb/gimp-pdb-compat.h"
#include "pdb/gimpprocedure.h"
#include "pdb/gimptemporaryprocedure.h"
#include "plug-in.h"
#include "plug-ins.h"
#include "plug-in-def.h"
#include "plug-in-params.h"
#include "plug-in-proc-def.h"
#include "plug-in-shm.h"
@ -570,7 +569,6 @@ plug_in_handle_proc_install (PlugIn *plug_in,
GimpPlugInProcedure *proc = NULL;
GimpProcedure *procedure = NULL;
gchar *canonical;
gchar *prog = NULL;
gboolean valid_utf8 = FALSE;
gint i;
@ -585,7 +583,7 @@ plug_in_handle_proc_install (PlugIn *plug_in,
proc_install->params[i].type == GIMP_PDB_FLOATARRAY ||
proc_install->params[i].type == GIMP_PDB_STRINGARRAY)
&&
proc_install->params[i-1].type != GIMP_PDB_INT32)
proc_install->params[i - 1].type != GIMP_PDB_INT32)
{
g_message ("Plug-In \"%s\"\n(%s)\n\n"
"attempted to install procedure \"%s\" "
@ -651,7 +649,6 @@ plug_in_handle_proc_install (PlugIn *plug_in,
case GIMP_PLUGIN:
case GIMP_EXTENSION:
plug_in_def = plug_in->plug_in_def;
prog = plug_in_def->prog;
proc = gimp_plug_in_procedure_find (plug_in_def->proc_defs, canonical);
@ -661,11 +658,13 @@ plug_in_handle_proc_install (PlugIn *plug_in,
proc);
g_object_unref (proc);
}
procedure = gimp_plug_in_procedure_new (proc_install->type,
plug_in->prog);
break;
case GIMP_TEMPORARY:
plug_in_def = NULL;
prog = "none";
proc = gimp_plug_in_procedure_find (plug_in->temp_proc_defs, canonical);
@ -675,19 +674,18 @@ plug_in_handle_proc_install (PlugIn *plug_in,
proc);
plug_ins_temp_proc_def_remove (plug_in->gimp, proc);
}
procedure = gimp_temporary_procedure_new (plug_in);
break;
}
proc = gimp_plug_in_procedure_new ();
proc = GIMP_PLUG_IN_PROCEDURE (procedure);
proc->prog = g_strdup (prog);
proc->mtime = time (NULL);
proc->installed_during_init = plug_in->init;
gimp_plug_in_procedure_set_image_types (proc, proc_install->image_types);
procedure = GIMP_PROCEDURE (proc);
gimp_procedure_set_strings (procedure,
canonical,
proc_install->name,
@ -700,13 +698,6 @@ plug_in_handle_proc_install (PlugIn *plug_in,
g_free (canonical);
gimp_procedure_initialize (procedure,
proc_install->type,
proc_install->nparams,
proc_install->nreturn_vals,
proc_install->type == GIMP_TEMPORARY ?
(gpointer) plug_in : (gpointer) prog);
for (i = 0; i < proc_install->nparams; i++)
{
GParamSpec *pspec =
@ -729,6 +720,8 @@ plug_in_handle_proc_install (PlugIn *plug_in,
gimp_procedure_add_return_value (procedure, pspec);
}
/* Sanity check menu path */
if (proc_install->menu_path)
{
if (proc_install->menu_path[0] == '<')
@ -761,6 +754,8 @@ plug_in_handle_proc_install (PlugIn *plug_in,
}
}
/* Install the procedure */
switch (proc_install->type)
{
case GIMP_PLUGIN:

530
app/plug-in/plug-in-proc-def.c
View File

@ -1,530 +0,0 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* plug-in-proc-def.c
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <string.h>
#include <glib-object.h>
#include <gdk-pixbuf/gdk-pixbuf.h>
#include "libgimpbase/gimpbase.h"
#include "plug-in-types.h"
#include "core/gimp.h"
#include "pdb/gimpprocedure.h"
#include "plug-in.h"
#include "plug-ins.h"
#include "plug-in-proc-def.h"
#include "plug-in-run.h"
#include "gimp-intl.h"
static void gimp_plug_in_procedure_finalize (GObject *object);
static GValueArray * gimp_plug_in_procedure_execute (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
GValueArray *args);
G_DEFINE_TYPE (GimpPlugInProcedure, gimp_plug_in_procedure,
GIMP_TYPE_PROCEDURE);
#define parent_class gimp_plug_in_procedure_parent_class
static void
gimp_plug_in_procedure_class_init (GimpPlugInProcedureClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GimpProcedureClass *proc_class = GIMP_PROCEDURE_CLASS (klass);
object_class->finalize = gimp_plug_in_procedure_finalize;
proc_class->execute = gimp_plug_in_procedure_execute;
}
static void
gimp_plug_in_procedure_init (GimpPlugInProcedure *proc)
{
proc->icon_data_length = -1;
}
static void
gimp_plug_in_procedure_finalize (GObject *object)
{
GimpPlugInProcedure *proc = GIMP_PLUG_IN_PROCEDURE (object);
g_free (proc->prog);
g_free (proc->menu_label);
g_list_foreach (proc->menu_paths, (GFunc) g_free, NULL);
g_list_free (proc->menu_paths);
g_free (proc->icon_data);
g_free (proc->image_types);
g_free (proc->extensions);
g_free (proc->prefixes);
g_free (proc->magics);
g_free (proc->mime_type);
g_slist_foreach (proc->extensions_list, (GFunc) g_free, NULL);
g_slist_free (proc->extensions_list);
g_slist_foreach (proc->prefixes_list, (GFunc) g_free, NULL);
g_slist_free (proc->prefixes_list);
g_slist_foreach (proc->magics_list, (GFunc) g_free, NULL);
g_slist_free (proc->magics_list);
g_free (proc->thumb_loader);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static GValueArray *
gimp_plug_in_procedure_execute (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
GValueArray *args)
{
if (procedure->proc_type == GIMP_INTERNAL)
return GIMP_PROCEDURE_CLASS (parent_class)->execute (procedure, gimp,
context, progress,
args);
return plug_in_run (gimp, context, progress, procedure,
args, TRUE, FALSE, -1);
}
/* public functions */
GimpPlugInProcedure *
gimp_plug_in_procedure_new (void)
{
GimpPlugInProcedure *proc = g_object_new (GIMP_TYPE_PLUG_IN_PROCEDURE, NULL);
return proc;
}
GimpPlugInProcedure *
gimp_plug_in_procedure_find (GSList *list,
const gchar *proc_name)
{
GSList *l;
for (l = list; l; l = g_slist_next (l))
{
GimpProcedure *proc = l->data;
if (! strcmp (proc_name, proc->name))
return GIMP_PLUG_IN_PROCEDURE (proc);
}
return NULL;
}
const gchar *
gimp_plug_in_procedure_get_progname (const GimpPlugInProcedure *proc)
{
g_return_val_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc), NULL);
switch (GIMP_PROCEDURE (proc)->proc_type)
{
case GIMP_PLUGIN:
case GIMP_EXTENSION:
return proc->prog;
case GIMP_TEMPORARY:
return ((PlugIn *) GIMP_PROCEDURE (proc)->exec_method.temporary.plug_in)->prog;
default:
break;
}
return NULL;
}
gchar *
gimp_plug_in_procedure_get_label (const GimpPlugInProcedure *proc,
const gchar *locale_domain)
{
const gchar *path;
gchar *stripped;
gchar *ellipses;
gchar *label;
g_return_val_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc), NULL);
if (proc->menu_label)
path = dgettext (locale_domain, proc->menu_label);
else if (proc->menu_paths)
path = dgettext (locale_domain, proc->menu_paths->data);
else
return NULL;
stripped = gimp_strip_uline (path);
if (proc->menu_label)
label = g_strdup (stripped);
else
label = g_path_get_basename (stripped);
g_free (stripped);
ellipses = strstr (label, "...");
if (ellipses && ellipses == (label + strlen (label) - 3))
*ellipses = '\0';
return label;
}
void
gimp_plug_in_procedure_set_icon (GimpPlugInProcedure *proc,
GimpIconType icon_type,
const guint8 *icon_data,
gint icon_data_length)
{
g_return_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc));
g_return_if_fail (icon_type == -1 || icon_data != NULL);
g_return_if_fail (icon_type == -1 || icon_data_length > 0);
if (proc->icon_data)
{
g_free (proc->icon_data);
proc->icon_data_length = -1;
proc->icon_data = NULL;
}
proc->icon_type = icon_type;
switch (proc->icon_type)
{
case GIMP_ICON_TYPE_STOCK_ID:
case GIMP_ICON_TYPE_IMAGE_FILE:
proc->icon_data_length = -1;
proc->icon_data = (guint8 *) g_strdup ((gchar *) icon_data);
break;
case GIMP_ICON_TYPE_INLINE_PIXBUF:
proc->icon_data_length = icon_data_length;
proc->icon_data = g_memdup (icon_data, icon_data_length);
break;
}
}
const gchar *
gimp_plug_in_procedure_get_stock_id (const GimpPlugInProcedure *proc)
{
g_return_val_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc), NULL);
switch (proc->icon_type)
{
case GIMP_ICON_TYPE_STOCK_ID:
return (gchar *) proc->icon_data;
default:
return NULL;
}
}
GdkPixbuf *
gimp_plug_in_procedure_get_pixbuf (const GimpPlugInProcedure *proc)
{
GdkPixbuf *pixbuf = NULL;
GError *error = NULL;
g_return_val_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc), NULL);
switch (proc->icon_type)
{
case GIMP_ICON_TYPE_INLINE_PIXBUF:
pixbuf = gdk_pixbuf_new_from_inline (proc->icon_data_length,
proc->icon_data, TRUE, &error);
break;
case GIMP_ICON_TYPE_IMAGE_FILE:
pixbuf = gdk_pixbuf_new_from_file ((gchar *) proc->icon_data,
&error);
break;
default:
break;
}
if (! pixbuf && error)
{
g_printerr (error->message);
g_clear_error (&error);
}
return pixbuf;
}
gchar *
gimp_plug_in_procedure_get_help_id (const GimpPlugInProcedure *proc,
const gchar *help_domain)
{
g_return_val_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc), NULL);
if (help_domain)
return g_strconcat (help_domain, "?", GIMP_PROCEDURE (proc)->name, NULL);
return g_strdup (GIMP_PROCEDURE (proc)->name);
}
gboolean
gimp_plug_in_procedure_get_sensitive (const GimpPlugInProcedure *proc,
GimpImageType image_type)
{
gboolean sensitive;
g_return_val_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc), FALSE);
switch (image_type)
{
case GIMP_RGB_IMAGE:
sensitive = proc->image_types_val & PLUG_IN_RGB_IMAGE;
break;
case GIMP_RGBA_IMAGE:
sensitive = proc->image_types_val & PLUG_IN_RGBA_IMAGE;
break;
case GIMP_GRAY_IMAGE:
sensitive = proc->image_types_val & PLUG_IN_GRAY_IMAGE;
break;
case GIMP_GRAYA_IMAGE:
sensitive = proc->image_types_val & PLUG_IN_GRAYA_IMAGE;
break;
case GIMP_INDEXED_IMAGE:
sensitive = proc->image_types_val & PLUG_IN_INDEXED_IMAGE;
break;
case GIMP_INDEXEDA_IMAGE:
sensitive = proc->image_types_val & PLUG_IN_INDEXEDA_IMAGE;
break;
default:
sensitive = FALSE;
break;
}
return sensitive ? TRUE : FALSE;
}
static PlugInImageType
image_types_parse (const gchar *image_types)
{
const gchar *type_spec = image_types;
PlugInImageType types = 0;
/* If the plug_in registers with image_type == NULL or "", return 0
* By doing so it won't be touched by plug_in_set_menu_sensitivity()
*/
if (! image_types)
return types;
while (*image_types)
{
while (*image_types &&
((*image_types == ' ') ||
(*image_types == '\t') ||
(*image_types == ',')))
image_types++;
if (*image_types)
{
if (strncmp (image_types, "RGBA", 4) == 0)
{
types |= PLUG_IN_RGBA_IMAGE;
image_types += 4;
}
else if (strncmp (image_types, "RGB*", 4) == 0)
{
types |= PLUG_IN_RGB_IMAGE | PLUG_IN_RGBA_IMAGE;
image_types += 4;
}
else if (strncmp (image_types, "RGB", 3) == 0)
{
types |= PLUG_IN_RGB_IMAGE;
image_types += 3;
}
else if (strncmp (image_types, "GRAYA", 5) == 0)
{
types |= PLUG_IN_GRAYA_IMAGE;
image_types += 5;
}
else if (strncmp (image_types, "GRAY*", 5) == 0)
{
types |= PLUG_IN_GRAY_IMAGE | PLUG_IN_GRAYA_IMAGE;
image_types += 5;
}
else if (strncmp (image_types, "GRAY", 4) == 0)
{
types |= PLUG_IN_GRAY_IMAGE;
image_types += 4;
}
else if (strncmp (image_types, "INDEXEDA", 8) == 0)
{
types |= PLUG_IN_INDEXEDA_IMAGE;
image_types += 8;
}
else if (strncmp (image_types, "INDEXED*", 8) == 0)
{
types |= PLUG_IN_INDEXED_IMAGE | PLUG_IN_INDEXEDA_IMAGE;
image_types += 8;
}
else if (strncmp (image_types, "INDEXED", 7) == 0)
{
types |= PLUG_IN_INDEXED_IMAGE;
image_types += 7;
}
else if (strncmp (image_types, "*", 1) == 0)
{
types |= PLUG_IN_RGB_IMAGE | PLUG_IN_RGBA_IMAGE
| PLUG_IN_GRAY_IMAGE | PLUG_IN_GRAYA_IMAGE
| PLUG_IN_INDEXED_IMAGE | PLUG_IN_INDEXEDA_IMAGE;
image_types += 1;
}
else
{
g_printerr ("image_type contains unrecognizable parts: '%s'\n",
type_spec);
while (*image_types &&
((*image_types != ' ') ||
(*image_types != '\t') ||
(*image_types != ',')))
image_types++;
}
}
}
return types;
}
void
gimp_plug_in_procedure_set_image_types (GimpPlugInProcedure *proc,
const gchar *image_types)
{
g_return_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc));
if (proc->image_types)
g_free (proc->image_types);
proc->image_types = g_strdup (image_types);
proc->image_types_val = image_types_parse (proc->image_types);
}
static GSList *
extensions_parse (gchar *extensions)
{
GSList *list = NULL;
/* EXTENSIONS can be NULL. Avoid calling strtok if it is. */
if (extensions)
{
gchar *extension;
gchar *next_token;
extensions = g_strdup (extensions);
next_token = extensions;
extension = strtok (next_token, " \t,");
while (extension)
{
list = g_slist_prepend (list, g_strdup (extension));
extension = strtok (NULL, " \t,");
}
g_free (extensions);
}
return g_slist_reverse (list);
}
void
gimp_plug_in_procedure_set_file_proc (GimpPlugInProcedure *proc,
const gchar *extensions,
const gchar *prefixes,
const gchar *magics)
{
g_return_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc));
proc->file_proc = TRUE;
if (proc->extensions != extensions)
{
if (proc->extensions)
g_free (proc->extensions);
proc->extensions = g_strdup (extensions);
}
proc->extensions_list = extensions_parse (proc->extensions);
if (proc->prefixes != prefixes)
{
if (proc->prefixes)
g_free (proc->prefixes);
proc->prefixes = g_strdup (prefixes);
}
proc->prefixes_list = extensions_parse (proc->prefixes);
if (proc->magics != magics)
{
if (proc->magics)
g_free (proc->magics);
proc->magics = g_strdup (magics);
}
proc->magics_list = extensions_parse (proc->magics);
}
void
gimp_plug_in_procedure_set_mime_type (GimpPlugInProcedure *proc,
const gchar *mime_type)
{
g_return_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc));
if (proc->mime_type)
g_free (proc->mime_type);
proc->mime_type = g_strdup (mime_type);
}
void
gimp_plug_in_procedure_set_thumb_loader (GimpPlugInProcedure *proc,
const gchar *thumb_loader)
{
g_return_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc));
if (proc->thumb_loader)
g_free (proc->thumb_loader);
proc->thumb_loader = g_strdup (thumb_loader);
}

110
app/plug-in/plug-in-proc-def.h
View File

@ -1,110 +0,0 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimppluginprocedure.h
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_PLUG_IN_PROCEDURE_H__
#define __GIMP_PLUG_IN_PROCEDURE_H__
#include <time.h> /* time_t */
#include <gdk-pixbuf/gdk-pixbuf.h>
#include "pdb/gimpprocedure.h"
#define GIMP_TYPE_PLUG_IN_PROCEDURE (gimp_plug_in_procedure_get_type ())
#define GIMP_PLUG_IN_PROCEDURE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_PLUG_IN_PROCEDURE, GimpPlugInProcedure))
#define GIMP_PLUG_IN_PROCEDURE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_PLUG_IN_PROCEDURE, GimpPlugInProcedureClass))
#define GIMP_IS_PLUG_IN_PROCEDURE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_PLUG_IN_PROCEDURE))
#define GIMP_IS_PLUG_IN_PROCEDURE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_PLUG_IN_PROCEDURE))
#define GIMP_PLUG_IN_PROCEDURE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_PLUG_IN_PROCEDURE, GimpPlugInProcedureClass))
typedef struct _GimpPlugInProcedureClass GimpPlugInProcedureClass;
struct _GimpPlugInProcedure
{
GimpProcedure parent_instance;
/* common members */
gchar *prog;
gchar *menu_label;
GList *menu_paths;
GimpIconType icon_type;
gint icon_data_length;
guint8 *icon_data;
gchar *image_types;
PlugInImageType image_types_val;
time_t mtime;
gboolean installed_during_init;
/* file proc specific members */
gboolean file_proc;
gchar *extensions;
gchar *prefixes;
gchar *magics;
gchar *mime_type;
GSList *extensions_list;
GSList *prefixes_list;
GSList *magics_list;
gchar *thumb_loader;
};
struct _GimpPlugInProcedureClass
{
GimpProcedureClass parent_class;
};
GType gimp_plug_in_procedure_get_type (void) G_GNUC_CONST;
GimpPlugInProcedure * gimp_plug_in_procedure_new (void);
GimpPlugInProcedure * gimp_plug_in_procedure_find (GSList *list,
const gchar *proc_name);
const gchar * gimp_plug_in_procedure_get_progname (const GimpPlugInProcedure *proc);
gchar * gimp_plug_in_procedure_get_label (const GimpPlugInProcedure *proc,
const gchar *locale_domain);
void gimp_plug_in_procedure_set_icon (GimpPlugInProcedure *proc,
GimpIconType type,
const guint8 *data,
gint data_length);
const gchar * gimp_plug_in_procedure_get_stock_id (const GimpPlugInProcedure *proc);
GdkPixbuf * gimp_plug_in_procedure_get_pixbuf (const GimpPlugInProcedure *proc);
gchar * gimp_plug_in_procedure_get_help_id (const GimpPlugInProcedure *proc,
const gchar *help_domain);
gboolean gimp_plug_in_procedure_get_sensitive (const GimpPlugInProcedure *proc,
GimpImageType image_type);
void gimp_plug_in_procedure_set_image_types (GimpPlugInProcedure *proc,
const gchar *image_types);
void gimp_plug_in_procedure_set_file_proc (GimpPlugInProcedure *proc,
const gchar *extensions,
const gchar *prefixes,
const gchar *magics);
void gimp_plug_in_procedure_set_mime_type (GimpPlugInProcedure *proc,
const gchar *mime_ype);
void gimp_plug_in_procedure_set_thumb_loader(GimpPlugInProcedure *proc,
const gchar *thumbnailer);
#endif /* __GIMP_PLUG_IN_PROCEDURE_H__ */

13
app/plug-in/plug-in-progress.c
View File

@ -30,7 +30,7 @@
#include "core/gimpprogress.h"
#include "pdb/gimp-pdb.h"
#include "pdb/gimpprocedure.h"
#include "pdb/gimptemporaryprocedure.h"
#include "plug-in.h"
#include "plug-in-progress.h"
@ -205,12 +205,11 @@ plug_in_progress_install (PlugIn *plug_in,
procedure = gimp_pdb_lookup (plug_in->gimp, progress_callback);
if (! procedure ||
procedure->proc_type != GIMP_TEMPORARY ||
procedure->exec_method.temporary.plug_in != plug_in ||
procedure->num_args != 3 ||
! GIMP_IS_PARAM_SPEC_INT32 (procedure->args[0]) ||
! G_IS_PARAM_SPEC_STRING (procedure->args[1]) ||
if (! GIMP_IS_TEMPORARY_PROCEDURE (procedure) ||
GIMP_TEMPORARY_PROCEDURE (procedure)->plug_in != plug_in ||
procedure->num_args != 3 ||
! GIMP_IS_PARAM_SPEC_INT32 (procedure->args[0]) ||
! G_IS_PARAM_SPEC_STRING (procedure->args[1]) ||
! G_IS_PARAM_SPEC_DOUBLE (procedure->args[2]))
{
return FALSE;

94
app/plug-in/plug-in-rc.c
View File

@ -31,12 +31,11 @@
#include "core/gimp.h"
#include "pdb/gimpprocedure.h"
#include "pdb/gimp-pdb-compat.h"
#include "pdb/gimppluginprocedure.h"
#include "plug-ins.h"
#include "plug-in-def.h"
#include "plug-in-proc-def.h"
#include "plug-in-rc.h"
#include "gimp-intl.h"
@ -47,27 +46,28 @@
* or the GTokenType they would have expected but didn't get.
*/
static GTokenType plug_in_def_deserialize (Gimp *gimp,
GScanner *scanner);
static GTokenType plug_in_procedure_deserialize (GScanner *scanner,
Gimp *gimp,
GimpPlugInProcedure *proc);
static GTokenType plug_in_menu_path_deserialize (GScanner *scanner,
GimpPlugInProcedure *proc);
static GTokenType plug_in_icon_deserialize (GScanner *scanner,
GimpPlugInProcedure *proc);
static GTokenType plug_in_file_proc_deserialize (GScanner *scanner,
GimpPlugInProcedure *proc);
static GTokenType plug_in_proc_arg_deserialize (GScanner *scanner,
Gimp *gimp,
GimpProcedure *procedure,
gboolean return_value);
static GTokenType plug_in_locale_def_deserialize (GScanner *scanner,
PlugInDef *plug_in_def);
static GTokenType plug_in_help_def_deserialize (GScanner *scanner,
PlugInDef *plug_in_def);
static GTokenType plug_in_has_init_deserialize (GScanner *scanner,
PlugInDef *plug_in_def);
static GTokenType plug_in_def_deserialize (Gimp *gimp,
GScanner *scanner);
static GTokenType plug_in_procedure_deserialize (GScanner *scanner,
Gimp *gimp,
const gchar *prog,
GimpPlugInProcedure **proc);
static GTokenType plug_in_menu_path_deserialize (GScanner *scanner,
GimpPlugInProcedure *proc);
static GTokenType plug_in_icon_deserialize (GScanner *scanner,
GimpPlugInProcedure *proc);
static GTokenType plug_in_file_proc_deserialize (GScanner *scanner,
GimpPlugInProcedure *proc);
static GTokenType plug_in_proc_arg_deserialize (GScanner *scanner,
Gimp *gimp,
GimpProcedure *procedure,
gboolean return_value);
static GTokenType plug_in_locale_def_deserialize (GScanner *scanner,
PlugInDef *plug_in_def);
static GTokenType plug_in_help_def_deserialize (GScanner *scanner,
PlugInDef *plug_in_def);
static GTokenType plug_in_has_init_deserialize (GScanner *scanner,
PlugInDef *plug_in_def);
enum
@ -227,18 +227,18 @@ plug_in_def_deserialize (Gimp *gimp,
{
gchar *name;
PlugInDef *plug_in_def;
GimpPlugInProcedure *proc;
GimpPlugInProcedure *proc = NULL;
GTokenType token;
if (! gimp_scanner_parse_string (scanner, &name))
return G_TOKEN_STRING;
plug_in_def = plug_in_def_new (name);
g_free (name);
if (! gimp_scanner_parse_int (scanner, (gint *) &plug_in_def->mtime))
{
plug_in_def_free (plug_in_def, TRUE);
g_free (name);
return G_TOKEN_INT;
}
@ -258,12 +258,11 @@ plug_in_def_deserialize (Gimp *gimp,
switch (GPOINTER_TO_INT (scanner->value.v_symbol))
{
case PROC_DEF:
proc = gimp_plug_in_procedure_new ();
token = plug_in_procedure_deserialize (scanner, gimp, proc);
token = plug_in_procedure_deserialize (scanner, gimp, name, &proc);
if (token == G_TOKEN_LEFT_PAREN)
plug_in_def_add_procedure (plug_in_def, proc);
else
else if (proc)
g_object_unref (proc);
break;
@ -293,6 +292,8 @@ plug_in_def_deserialize (Gimp *gimp,
}
}
g_free (name);
if (token == G_TOKEN_LEFT_PAREN)
{
token = G_TOKEN_RIGHT_PAREN;
@ -310,9 +311,10 @@ plug_in_def_deserialize (Gimp *gimp,
}
static GTokenType
plug_in_procedure_deserialize (GScanner *scanner,
Gimp *gimp,
GimpPlugInProcedure *proc)
plug_in_procedure_deserialize (GScanner *scanner,
Gimp *gimp,
const gchar *prog,
GimpPlugInProcedure **proc)
{
GimpProcedure *procedure;
GTokenType token;
@ -323,15 +325,21 @@ plug_in_procedure_deserialize (GScanner *scanner,
gint n_menu_paths;
gint i;
procedure = GIMP_PROCEDURE (proc);
if (! gimp_scanner_parse_string (scanner, &procedure->original_name))
if (! gimp_scanner_parse_string (scanner, &str))
return G_TOKEN_STRING;
procedure->name = gimp_canonicalize_identifier (procedure->original_name);
if (! gimp_scanner_parse_int (scanner, &proc_type))
return G_TOKEN_INT;
{
g_free (str);
return G_TOKEN_INT;
}
procedure = gimp_plug_in_procedure_new (proc_type, prog);
*proc = GIMP_PLUG_IN_PROCEDURE (procedure);
procedure->original_name = str;
procedure->name = gimp_canonicalize_identifier (procedure->original_name);
if (! gimp_scanner_parse_string (scanner, &procedure->blurb))
return G_TOKEN_STRING;
@ -343,7 +351,7 @@ plug_in_procedure_deserialize (GScanner *scanner,
return G_TOKEN_STRING;
if (! gimp_scanner_parse_string (scanner, &procedure->date))
return G_TOKEN_STRING;
if (! gimp_scanner_parse_string (scanner, &proc->menu_label))
if (! gimp_scanner_parse_string (scanner, &(*proc)->menu_label))
return G_TOKEN_STRING;
if (! gimp_scanner_parse_int (scanner, &n_menu_paths))
@ -351,23 +359,23 @@ plug_in_procedure_deserialize (GScanner *scanner,
for (i = 0; i < n_menu_paths; i++)
{
token = plug_in_menu_path_deserialize (scanner, proc);
token = plug_in_menu_path_deserialize (scanner, *proc);
if (token != G_TOKEN_LEFT_PAREN)
return token;
}
token = plug_in_icon_deserialize (scanner, proc);
token = plug_in_icon_deserialize (scanner, *proc);
if (token != G_TOKEN_LEFT_PAREN)
return token;
token = plug_in_file_proc_deserialize (scanner, proc);
token = plug_in_file_proc_deserialize (scanner, *proc);
if (token != G_TOKEN_LEFT_PAREN)
return token;
if (! gimp_scanner_parse_string (scanner, &str))
return G_TOKEN_STRING;
gimp_plug_in_procedure_set_image_types (proc, str);
gimp_plug_in_procedure_set_image_types (*proc, str);
g_free (str);
if (! gimp_scanner_parse_int (scanner, (gint *) &n_args))
@ -375,8 +383,6 @@ plug_in_procedure_deserialize (GScanner *scanner,
if (! gimp_scanner_parse_int (scanner, (gint *) &n_return_vals))
return G_TOKEN_INT;
gimp_procedure_initialize (procedure, proc_type, n_args, n_return_vals, NULL);
for (i = 0; i < n_args; i++)
{
token = plug_in_proc_arg_deserialize (scanner, gimp, procedure, FALSE);

7
app/plug-in/plug-in-run.c
View File

@ -36,11 +36,10 @@
#include "core/gimpcontext.h"
#include "core/gimpprogress.h"
#include "pdb/gimpprocedure.h"
#include "pdb/gimptemporaryprocedure.h"
#include "plug-in.h"
#include "plug-in-params.h"
#include "plug-in-proc-def.h"
#include "plug-in-run.h"
#include "plug-in-shm.h"
@ -83,7 +82,7 @@ plug_in_run (Gimp *gimp,
}
plug_in = plug_in_new (gimp, context, progress, procedure,
procedure->exec_method.plug_in.filename);
GIMP_PLUG_IN_PROCEDURE (procedure)->prog);
if (plug_in)
{
@ -206,7 +205,7 @@ plug_in_temp_run (GimpProcedure *procedure,
GValueArray *return_vals = NULL;
PlugIn *plug_in;
plug_in = (PlugIn *) procedure->exec_method.temporary.plug_in;
plug_in = GIMP_TEMPORARY_PROCEDURE (procedure)->plug_in;
if (plug_in)
{

12
app/plug-in/plug-in-types.h
View File

@ -25,13 +25,11 @@
#include "plug-in/plug-in-enums.h"
typedef struct _PlugIn PlugIn;
typedef struct _PlugInDef PlugInDef;
typedef struct _PlugInMenuBranch PlugInMenuBranch;
typedef struct _PlugInProcFrame PlugInProcFrame;
typedef struct _PlugInShm PlugInShm;
typedef struct _GimpPlugInProcedure GimpPlugInProcedure;
typedef struct _PlugIn PlugIn;
typedef struct _PlugInDef PlugInDef;
typedef struct _PlugInMenuBranch PlugInMenuBranch;
typedef struct _PlugInProcFrame PlugInProcFrame;
typedef struct _PlugInShm PlugInShm;
#endif /* __PLUG_IN_TYPES_H__ */

3
app/plug-in/plug-in.c
View File

@ -76,7 +76,7 @@
#include "core/gimpinterpreterdb.h"
#include "core/gimpprogress.h"
#include "pdb/gimpprocedure.h"
#include "pdb/gimppluginprocedure.h"
#include "plug-in.h"
#include "plug-ins.h"
@ -84,7 +84,6 @@
#include "plug-in-def.h"
#include "plug-in-message.h"
#include "plug-in-params.h"
#include "plug-in-proc-def.h"
#include "plug-in-progress.h"
#include "plug-in-shm.h"

4
app/plug-in/plug-ins-query.c
View File

@ -36,9 +36,7 @@
#include "core/gimp.h"
#include "pdb/gimpprocedure.h"
#include "plug-in-proc-def.h"
#include "pdb/gimppluginprocedure.h"
static int

11
app/plug-in/plug-ins.c
View File

@ -39,14 +39,13 @@
#include "core/gimpimage.h"
#include "pdb/gimp-pdb.h"
#include "pdb/gimpprocedure.h"
#include "pdb/gimppluginprocedure.h"
#include "plug-in.h"
#include "plug-ins.h"
#include "plug-in-data.h"
#include "plug-in-def.h"
#include "plug-in-params.h"
#include "plug-in-proc-def.h"
#include "plug-in-progress.h"
#include "plug-in-rc.h"
#include "plug-in-run.h"
@ -870,11 +869,15 @@ plug_ins_add_to_db (Gimp *gimp,
{
proc = list->data;
if (proc->prog && (GIMP_PROCEDURE (proc)->proc_type != GIMP_INTERNAL))
if (GIMP_PROCEDURE (proc)->proc_type != GIMP_INTERNAL)
{
GIMP_PROCEDURE (proc)->exec_method.plug_in.filename = proc->prog;
gimp_pdb_register (gimp, GIMP_PROCEDURE (proc));
}
else
{
g_printerr ("%s: NOT adding %s (prog = %s) to PDB\n",
G_STRFUNC, GIMP_PROCEDURE (proc)->name, proc->prog);
}
}
for (list = gimp->plug_in_proc_defs; list; list = list->next)

2
app/widgets/gimpfiledialog.c
View File

@ -37,10 +37,10 @@
#include "file/file-utils.h"
#include "plug-in/plug-in-proc-def.h"
#include "plug-in/plug-ins.h"
#include "pdb/gimp-pdb.h"
#include "pdb/gimppluginprocedure.h"
#include "gimpfiledialog.h"
#include "gimpfileprocview.h"

3
app/widgets/gimpfileprocview.c
View File

@ -30,9 +30,10 @@
#include "core/gimp.h"
#include "core/gimpmarshal.h"
#include "plug-in/plug-in-proc-def.h"
#include "plug-in/plug-ins.h"
#include "pdb/gimppluginprocedure.h"
#include "gimpfileprocview.h"
#include "gimp-intl.h"

2
app/widgets/gimppluginaction.c
View File

@ -27,7 +27,7 @@
#include "core/gimpmarshal.h"
#include "plug-in/plug-in-proc-def.h"
#include "pdb/gimppluginprocedure.h"
#include "gimppluginaction.h"

35
app/xcf/xcf.c
View File

@ -34,10 +34,9 @@
#include "core/gimpparamspecs.h"
#include "pdb/gimp-pdb.h"
#include "pdb/gimpprocedure.h"
#include "pdb/gimppluginprocedure.h"
#include "plug-in/plug-ins.h"
#include "plug-in/plug-in-proc-def.h"
#include "xcf.h"
#include "xcf-private.h"
@ -139,20 +138,19 @@ xcf_init (Gimp *gimp)
*/
/* gimp-xcf-save */
proc = gimp_plug_in_procedure_new ();
proc->prog = g_strdup ("gimp-xcf-save");
procedure = gimp_plug_in_procedure_new (GIMP_PLUGIN, "gimp-xcf-save");
procedure->proc_type = GIMP_INTERNAL;
procedure->marshal_func = xcf_save_invoker;
proc = GIMP_PLUG_IN_PROCEDURE (procedure);
proc->menu_label = g_strdup (N_("GIMP XCF image"));
gimp_plug_in_procedure_set_icon (proc, GIMP_ICON_TYPE_STOCK_ID,
(const guint8 *) "gimp-wilber",
strlen ("gimp-wilber") + 1);
gimp_plug_in_procedure_set_image_types (proc, "RGB*, GRAY*, INDEXED*");
proc->file_proc = TRUE;
proc->extensions = g_strdup ("xcf");
proc->prefixes = g_strdup ("");
proc->mime_type = g_strdup ("image/xcf");
gimp_plug_in_procedure_set_file_proc (proc, "xcf", "", NULL);
gimp_plug_in_procedure_set_mime_type (proc, "image/xcf");
procedure = GIMP_PROCEDURE (proc);
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 5, 0, xcf_save_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-xcf-save",
"gimp-xcf-save",
@ -206,21 +204,20 @@ xcf_init (Gimp *gimp)
plug_ins_add_internal (gimp, proc);
/* gimp-xcf-load */
proc = gimp_plug_in_procedure_new ();
proc->prog = g_strdup ("gimp-xcf-load");
procedure = gimp_plug_in_procedure_new (GIMP_PLUGIN, "gimp-xcf-load");
procedure->proc_type = GIMP_INTERNAL;
procedure->marshal_func = xcf_load_invoker;
proc = GIMP_PLUG_IN_PROCEDURE (procedure);
proc->menu_label = g_strdup (N_("GIMP XCF image"));
gimp_plug_in_procedure_set_icon (proc, GIMP_ICON_TYPE_STOCK_ID,
(const guint8 *) "gimp-wilber",
strlen ("gimp-wilber") + 1);
gimp_plug_in_procedure_set_image_types (proc, NULL);
proc->file_proc = TRUE;
proc->extensions = g_strdup ("xcf");
proc->prefixes = g_strdup ("");
proc->magics = g_strdup ("0,string,gimp\\040xcf\\040");
proc->mime_type = g_strdup ("image/xcf");
gimp_plug_in_procedure_set_file_proc (proc, "xcf", "",
"0,string,gimp\\040xcf\\040");
gimp_plug_in_procedure_set_mime_type (proc, "image/xcf");
procedure = GIMP_PROCEDURE (proc);
gimp_procedure_initialize (procedure, GIMP_INTERNAL, 3, 1, xcf_load_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-xcf-load",
"gimp-xcf-load",

4
tools/pdbgen/app.pl
View File

@ -527,9 +527,7 @@ sub generate {
/*
* gimp-$proc->{canonical_name}
*/
procedure = gimp_procedure_new ();
gimp_procedure_initialize (procedure, GIMP_INTERNAL, @{[scalar @inargs]}, @{[scalar @outargs]},
${name}_invoker);
procedure = gimp_procedure_new (${name}_invoker);
gimp_procedure_set_static_strings (procedure,
"gimp-$proc->{canonical_name}",
"gimp-$proc->{canonical_name}",

1
tools/pdbgen/pdb/fileops.pdb
View File

@ -653,7 +653,6 @@ CODE
"libgimpthumb/gimpthumb.h"
"core/gimp.h" "core/gimpimagefile.h"
"plug-in/plug-in.h" "plug-in/plug-ins.h"
"plug-in/plug-in-proc-def.h"
"file/file-utils.h");
@procs = qw(file_load file_load_layer file_load_thumbnail

2
tools/pdbgen/pdb/plug_in.pdb
View File

@ -278,7 +278,7 @@ CODE
"plug-in/plug-in.h" "plug-in/plug-ins.h"
"plug-in/plug-ins-query.h"
"plug-in/plug-in-def.h" "plug-in/plug-in-params.h"
"plug-in/plug-in-proc-def.h");
"gimppluginprocedure.h");
@procs = qw(plugins_query
plugin_domain_register plugin_help_register