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

app/pdb/pdb-types.h renamed struct Argument to GimpArgument and struct 

2006-03-31  Michael Natterer  <mitch@gimp.org>

	* app/pdb/pdb-types.h
	* app/pdb/gimpargument.h: renamed struct Argument to GimpArgument
	and struct ProcArg to GimpArgumentSpec.

	* app/batch.c
	* app/actions/plug-in-commands.c
	* app/actions/vectors-commands.c
	* app/core/gimppdbprogress.c
	* app/dialogs/about-dialog.c
	* app/file/file-open.c
	* app/file/file-save.c
	* app/pdb/gimpargument.c
	* app/pdb/gimpprocedure.[ch]
	* app/pdb/procedural-db-query.c
	* app/pdb/procedural_db.[ch]
	* app/plug-in/plug-in-message.c
	* app/plug-in/plug-in-params.[ch]
	* app/plug-in/plug-in-proc-frame.h
	* app/plug-in/plug-in-progress.c
	* app/plug-in/plug-in-rc.c
	* app/plug-in/plug-in-run.[ch]
	* app/plug-in/plug-ins.c
	* app/widgets/gimpbrushselect.c
	* app/widgets/gimpfontselect.c
	* app/widgets/gimpgradientselect.c
	* app/widgets/gimphelp.c
	* app/widgets/gimppaletteselect.c
	* app/widgets/gimppatternselect.c
	* app/widgets/gimppdbdialog.[ch]
	* app/xcf/xcf.c
	* tools/pdbgen/app.pl
	* tools/pdbgen/pdb/fileops.pdb
	* tools/pdbgen/pdb/procedural_db.pdb: changed accordingly.

	* app/pdb/*_cmds.c: regenerated.
This commit is contained in:
Michael Natterer 2006-03-31 20:16:22 +00:00 committed by Michael Natterer
parent 46a50b7e36
commit 03c28ec7fc
97 changed files with 1840 additions and 1793 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
ChangeLog
View File

@ -1,3 +1,41 @@
2006-03-31 Michael Natterer <mitch@gimp.org>
* app/pdb/pdb-types.h
* app/pdb/gimpargument.h: renamed struct Argument to GimpArgument
and struct ProcArg to GimpArgumentSpec.
* app/batch.c
* app/actions/plug-in-commands.c
* app/actions/vectors-commands.c
* app/core/gimppdbprogress.c
* app/dialogs/about-dialog.c
* app/file/file-open.c
* app/file/file-save.c
* app/pdb/gimpargument.c
* app/pdb/gimpprocedure.[ch]
* app/pdb/procedural-db-query.c
* app/pdb/procedural_db.[ch]
* app/plug-in/plug-in-message.c
* app/plug-in/plug-in-params.[ch]
* app/plug-in/plug-in-proc-frame.h
* app/plug-in/plug-in-progress.c
* app/plug-in/plug-in-rc.c
* app/plug-in/plug-in-run.[ch]
* app/plug-in/plug-ins.c
* app/widgets/gimpbrushselect.c
* app/widgets/gimpfontselect.c
* app/widgets/gimpgradientselect.c
* app/widgets/gimphelp.c
* app/widgets/gimppaletteselect.c
* app/widgets/gimppatternselect.c
* app/widgets/gimppdbdialog.[ch]
* app/xcf/xcf.c
* tools/pdbgen/app.pl
* tools/pdbgen/pdb/fileops.pdb
* tools/pdbgen/pdb/procedural_db.pdb: changed accordingly.
* app/pdb/*_cmds.c: regenerated.
2006-03-31 Michael Natterer <mitch@gimp.org>
* app/pdb/Makefile.am

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

@ -68,7 +68,7 @@ plug_in_run_cmd_callback (GtkAction *action,
{
Gimp *gimp;
GimpProcedure *procedure;
Argument *args;
GimpArgument *args;
gint n_args = 0;
GimpDisplay *display = NULL;

2
app/actions/vectors-commands.c
View File

@ -313,7 +313,7 @@ vectors_selection_to_vectors_cmd_callback (GtkAction *action,
{
GimpImage *image;
GimpProcedure *procedure;
Argument *args;
GimpArgument *args;
GimpDisplay *display;
return_if_no_image (image, data);

6
app/batch.c
View File

@ -131,9 +131,9 @@ batch_run_cmd (Gimp *gimp,
GimpRunMode run_mode,
const gchar *cmd)
{
Argument *args;
Argument *return_vals;
gint n_return_vals;
GimpArgument *args;
GimpArgument *return_vals;
gint n_return_vals;
args = gimp_procedure_get_arguments (procedure);

4
app/core/gimppdbprogress.c
View File

@ -245,8 +245,8 @@ gimp_pdb_progress_run_callback (GimpPdbProgress *progress,
if (progress->callback_name && ! progress->callback_busy)
{
Argument *return_vals;
gint n_return_vals;
GimpArgument *return_vals;
gint n_return_vals;
progress->callback_busy = TRUE;

10
app/dialogs/about-dialog.c
View File

@ -215,16 +215,16 @@ about_dialog_load_url (GtkAboutDialog *dialog,
const gchar *url,
gpointer data)
{
GimpContext *context = GIMP_CONTEXT (data);
Argument *return_vals;
gint nreturn_vals;
GimpContext *context = GIMP_CONTEXT (data);
GimpArgument *return_vals;
gint n_return_vals;
return_vals = procedural_db_run_proc (context->gimp, context, NULL,
PDB_URL_LOAD,
&nreturn_vals,
&n_return_vals,
GIMP_PDB_STRING, url,
GIMP_PDB_END);
gimp_arguments_destroy (return_vals, nreturn_vals, TRUE);
gimp_arguments_destroy (return_vals, n_return_vals, TRUE);
}

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

@ -87,10 +87,10 @@ file_open_image (Gimp *gimp,
const gchar **mime_type,
GError **error)
{
Argument *return_vals;
gint n_return_vals;
gchar *filename;
GimpImage *image = NULL;
GimpArgument *return_vals;
gint n_return_vals;
gchar *filename;
GimpImage *image = NULL;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
@ -215,7 +215,7 @@ file_open_thumbnail (Gimp *gimp,
if (procedure && procedure->num_args >= 2 && procedure->num_values >= 1)
{
GimpPDBStatusType status;
Argument *return_vals;
GimpArgument *return_vals;
gint n_return_vals;
gchar *filename;
GimpImage *image = NULL;

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

@ -79,7 +79,7 @@ file_save (GimpImage *image,
gboolean save_a_copy,
GError **error)
{
Argument *return_vals;
GimpArgument *return_vals;
gint n_return_vals;
GimpPDBStatusType status;
gchar *filename;

128
app/pdb/brush_cmds.c
View File

@ -647,15 +647,15 @@ register_brush_procs (Gimp *gimp)
}
static Argument *
static GimpArgument *
brush_new_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gchar *actual_name = NULL;
@ -700,15 +700,15 @@ static GimpProcedure brush_new_proc =
{ { brush_new_invoker } }
};
static Argument *
static GimpArgument *
brush_duplicate_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gchar *copy_name = NULL;
@ -758,15 +758,15 @@ static GimpProcedure brush_duplicate_proc =
{ { brush_duplicate_invoker } }
};
static Argument *
static GimpArgument *
brush_is_generated_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gboolean generated = FALSE;
@ -807,15 +807,15 @@ static GimpProcedure brush_is_generated_proc =
{ { brush_is_generated_invoker } }
};
static Argument *
static GimpArgument *
brush_rename_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gchar *new_name;
gchar *actual_name = NULL;
@ -861,12 +861,12 @@ static GimpProcedure brush_rename_proc =
{ { brush_rename_invoker } }
};
static Argument *
static GimpArgument *
brush_delete_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *name;
@ -915,15 +915,15 @@ static GimpProcedure brush_delete_proc =
{ { brush_delete_invoker } }
};
static Argument *
static GimpArgument *
brush_is_editable_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gboolean editable = FALSE;
@ -964,15 +964,15 @@ static GimpProcedure brush_is_editable_proc =
{ { brush_is_editable_invoker } }
};
static Argument *
static GimpArgument *
brush_get_info_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gint32 width = 0;
gint32 height = 0;
@ -1026,15 +1026,15 @@ static GimpProcedure brush_get_info_proc =
{ { brush_get_info_invoker } }
};
static Argument *
static GimpArgument *
brush_get_pixels_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gint32 width = 0;
gint32 height = 0;
@ -1105,15 +1105,15 @@ static GimpProcedure brush_get_pixels_proc =
{ { brush_get_pixels_invoker } }
};
static Argument *
static GimpArgument *
brush_get_spacing_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gint32 spacing = 0;
@ -1154,12 +1154,12 @@ static GimpProcedure brush_get_spacing_proc =
{ { brush_get_spacing_invoker } }
};
static Argument *
static GimpArgument *
brush_set_spacing_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *name;
@ -1198,15 +1198,15 @@ static GimpProcedure brush_set_spacing_proc =
{ { brush_set_spacing_invoker } }
};
static Argument *
static GimpArgument *
brush_get_shape_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gint32 shape = 0;
@ -1247,15 +1247,15 @@ static GimpProcedure brush_get_shape_proc =
{ { brush_get_shape_invoker } }
};
static Argument *
static GimpArgument *
brush_get_radius_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gdouble radius = 0.0;
@ -1296,15 +1296,15 @@ static GimpProcedure brush_get_radius_proc =
{ { brush_get_radius_invoker } }
};
static Argument *
static GimpArgument *
brush_get_spikes_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gint32 spikes = 0;
@ -1345,15 +1345,15 @@ static GimpProcedure brush_get_spikes_proc =
{ { brush_get_spikes_invoker } }
};
static Argument *
static GimpArgument *
brush_get_hardness_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gdouble hardness = 0.0;
@ -1394,15 +1394,15 @@ static GimpProcedure brush_get_hardness_proc =
{ { brush_get_hardness_invoker } }
};
static Argument *
static GimpArgument *
brush_get_aspect_ratio_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gdouble aspect_ratio = 0.0;
@ -1443,15 +1443,15 @@ static GimpProcedure brush_get_aspect_ratio_proc =
{ { brush_get_aspect_ratio_invoker } }
};
static Argument *
static GimpArgument *
brush_get_angle_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gdouble angle = 0.0;
@ -1492,15 +1492,15 @@ static GimpProcedure brush_get_angle_proc =
{ { brush_get_angle_invoker } }
};
static Argument *
static GimpArgument *
brush_set_shape_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gint32 shape_in;
gint32 shape_out = 0;
@ -1547,15 +1547,15 @@ static GimpProcedure brush_set_shape_proc =
{ { brush_set_shape_invoker } }
};
static Argument *
static GimpArgument *
brush_set_radius_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gdouble radius_in;
gdouble radius_out = 0.0;
@ -1602,15 +1602,15 @@ static GimpProcedure brush_set_radius_proc =
{ { brush_set_radius_invoker } }
};
static Argument *
static GimpArgument *
brush_set_spikes_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gint32 spikes_in;
gint32 spikes_out = 0;
@ -1657,15 +1657,15 @@ static GimpProcedure brush_set_spikes_proc =
{ { brush_set_spikes_invoker } }
};
static Argument *
static GimpArgument *
brush_set_hardness_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gdouble hardness_in;
gdouble hardness_out = 0.0;
@ -1712,15 +1712,15 @@ static GimpProcedure brush_set_hardness_proc =
{ { brush_set_hardness_invoker } }
};
static Argument *
static GimpArgument *
brush_set_aspect_ratio_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gdouble aspect_ratio_in;
gdouble aspect_ratio_out = 0.0;
@ -1767,15 +1767,15 @@ static GimpProcedure brush_set_aspect_ratio_proc =
{ { brush_set_aspect_ratio_invoker } }
};
static Argument *
static GimpArgument *
brush_set_angle_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gdouble angle_in;
gdouble angle_out = 0.0;

12
app/pdb/brush_select_cmds.c
View File

@ -153,12 +153,12 @@ register_brush_select_procs (Gimp *gimp)
}
static Argument *
static GimpArgument *
brushes_popup_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *brush_callback;
@ -207,12 +207,12 @@ static GimpProcedure brushes_popup_proc =
{ { brushes_popup_invoker } }
};
static Argument *
static GimpArgument *
brushes_close_popup_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *brush_callback;
@ -247,12 +247,12 @@ static GimpProcedure brushes_close_popup_proc =
{ { brushes_close_popup_invoker } }
};
static Argument *
static GimpArgument *
brushes_set_popup_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *brush_callback;

32
app/pdb/brushes_cmds.c
View File

@ -217,12 +217,12 @@ register_brushes_procs (Gimp *gimp)
}
static Argument *
static GimpArgument *
brushes_refresh_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gimp_data_factory_data_refresh (gimp->brush_factory);
return gimp_procedure_get_return_values (procedure, TRUE);
@ -244,15 +244,15 @@ static GimpProcedure brushes_refresh_proc =
{ { brushes_refresh_invoker } }
};
static Argument *
static GimpArgument *
brushes_get_list_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *filter;
gint32 num_brushes = 0;
gchar **brush_list = NULL;
@ -292,15 +292,15 @@ static GimpProcedure brushes_get_list_proc =
{ { brushes_get_list_invoker } }
};
static Argument *
static GimpArgument *
brushes_get_brush_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name = NULL;
gint32 width = 0;
gint32 height = 0;
@ -347,15 +347,15 @@ static GimpProcedure brushes_get_brush_proc =
{ { brushes_get_brush_invoker } }
};
static Argument *
static GimpArgument *
brushes_get_spacing_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gint32 spacing = 0;
GimpBrush *brush = gimp_context_get_brush (context);
@ -389,12 +389,12 @@ static GimpProcedure brushes_get_spacing_proc =
{ { brushes_get_spacing_invoker } }
};
static Argument *
static GimpArgument *
brushes_set_spacing_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gint32 spacing;
@ -425,15 +425,15 @@ static GimpProcedure brushes_set_spacing_proc =
{ { brushes_set_spacing_invoker } }
};
static Argument *
static GimpArgument *
brushes_get_brush_data_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gchar *actual_name = NULL;
gdouble opacity = 0.0;

40
app/pdb/buffer_cmds.c
View File

@ -207,15 +207,15 @@ register_buffer_procs (Gimp *gimp)
}
static Argument *
static GimpArgument *
buffers_get_list_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *filter;
gint32 num_buffers = 0;
gchar **buffer_list = NULL;
@ -255,15 +255,15 @@ static GimpProcedure buffers_get_list_proc =
{ { buffers_get_list_invoker } }
};
static Argument *
static GimpArgument *
buffer_rename_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *buffer_name;
gchar *new_name;
gchar *real_name = NULL;
@ -309,12 +309,12 @@ static GimpProcedure buffer_rename_proc =
{ { buffer_rename_invoker } }
};
static Argument *
static GimpArgument *
buffer_delete_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *buffer_name;
@ -351,15 +351,15 @@ static GimpProcedure buffer_delete_proc =
{ { buffer_delete_invoker } }
};
static Argument *
static GimpArgument *
buffer_get_width_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *buffer_name;
gint32 width = 0;
@ -400,15 +400,15 @@ static GimpProcedure buffer_get_width_proc =
{ { buffer_get_width_invoker } }
};
static Argument *
static GimpArgument *
buffer_get_height_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *buffer_name;
gint32 height = 0;
@ -449,15 +449,15 @@ static GimpProcedure buffer_get_height_proc =
{ { buffer_get_height_invoker } }
};
static Argument *
static GimpArgument *
buffer_get_bytes_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *buffer_name;
gint32 bytes = 0;
@ -498,15 +498,15 @@ static GimpProcedure buffer_get_bytes_proc =
{ { buffer_get_bytes_invoker } }
};
static Argument *
static GimpArgument *
buffer_get_image_type_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *buffer_name;
gint32 image_type = 0;

52
app/pdb/channel_cmds.c
View File

@ -339,15 +339,15 @@ register_channel_procs (Gimp *gimp)
}
static Argument *
static GimpArgument *
channel_new_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpImage *image;
gint32 width;
gint32 height;
@ -398,15 +398,15 @@ static GimpProcedure channel_new_proc =
{ { channel_new_invoker } }
};
static Argument *
static GimpArgument *
channel_new_from_component_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpImage *image;
gint32 component;
gchar *name;
@ -452,15 +452,15 @@ static GimpProcedure channel_new_from_component_proc =
{ { channel_new_from_component_invoker } }
};
static Argument *
static GimpArgument *
channel_copy_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpChannel *channel;
GimpChannel *channel_copy = NULL;
@ -499,12 +499,12 @@ static GimpProcedure channel_copy_proc =
{ { channel_copy_invoker } }
};
static Argument *
static GimpArgument *
channel_combine_masks_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpChannel *channel1;
@ -543,15 +543,15 @@ static GimpProcedure channel_combine_masks_proc =
{ { channel_combine_masks_invoker } }
};
static Argument *
static GimpArgument *
channel_get_show_masked_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpChannel *channel;
gboolean show_masked = FALSE;
@ -586,12 +586,12 @@ static GimpProcedure channel_get_show_masked_proc =
{ { channel_get_show_masked_invoker } }
};
static Argument *
static GimpArgument *
channel_set_show_masked_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpChannel *channel;
@ -624,15 +624,15 @@ static GimpProcedure channel_set_show_masked_proc =
{ { channel_set_show_masked_invoker } }
};
static Argument *
static GimpArgument *
channel_get_opacity_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpChannel *channel;
gdouble opacity = 0.0;
@ -667,12 +667,12 @@ static GimpProcedure channel_get_opacity_proc =
{ { channel_get_opacity_invoker } }
};
static Argument *
static GimpArgument *
channel_set_opacity_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpChannel *channel;
@ -705,15 +705,15 @@ static GimpProcedure channel_set_opacity_proc =
{ { channel_set_opacity_invoker } }
};
static Argument *
static GimpArgument *
channel_get_color_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpChannel *channel;
GimpRGB color = { 0.0, 0.0, 0.0, 1.0 };
@ -748,12 +748,12 @@ static GimpProcedure channel_get_color_proc =
{ { channel_get_color_invoker } }
};
static Argument *
static GimpArgument *
channel_set_color_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpChannel *channel;

66
app/pdb/color_cmds.c
View File

@ -583,12 +583,12 @@ register_color_procs (Gimp *gimp)
}
static Argument *
static GimpArgument *
brightness_contrast_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -655,12 +655,12 @@ static GimpProcedure brightness_contrast_proc =
{ { brightness_contrast_invoker } }
};
static Argument *
static GimpArgument *
levels_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -716,12 +716,12 @@ static GimpProcedure levels_proc =
{ { levels_invoker } }
};
static Argument *
static GimpArgument *
levels_auto_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -757,12 +757,12 @@ static GimpProcedure levels_auto_proc =
{ { levels_auto_invoker } }
};
static Argument *
static GimpArgument *
levels_stretch_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -798,12 +798,12 @@ static GimpProcedure levels_stretch_proc =
{ { levels_stretch_invoker } }
};
static Argument *
static GimpArgument *
posterize_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -866,12 +866,12 @@ static GimpProcedure posterize_proc =
{ { posterize_invoker } }
};
static Argument *
static GimpArgument *
desaturate_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -907,12 +907,12 @@ static GimpProcedure desaturate_proc =
{ { desaturate_invoker } }
};
static Argument *
static GimpArgument *
desaturate_full_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -950,12 +950,12 @@ static GimpProcedure desaturate_full_proc =
{ { desaturate_full_invoker } }
};
static Argument *
static GimpArgument *
equalize_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -993,12 +993,12 @@ static GimpProcedure equalize_proc =
{ { equalize_invoker } }
};
static Argument *
static GimpArgument *
invert_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -1034,12 +1034,12 @@ static GimpProcedure invert_proc =
{ { invert_invoker } }
};
static Argument *
static GimpArgument *
curves_spline_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -1136,12 +1136,12 @@ static GimpProcedure curves_spline_proc =
{ { curves_spline_invoker } }
};
static Argument *
static GimpArgument *
curves_explicit_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -1229,12 +1229,12 @@ static GimpProcedure curves_explicit_proc =
{ { curves_explicit_invoker } }
};
static Argument *
static GimpArgument *
color_balance_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -1310,12 +1310,12 @@ static GimpProcedure color_balance_proc =
{ { color_balance_invoker } }
};
static Argument *
static GimpArgument *
colorize_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -1385,15 +1385,15 @@ static GimpProcedure colorize_proc =
{ { colorize_invoker } }
};
static Argument *
static GimpArgument *
histogram_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gint32 channel;
gint32 start_range;
@ -1472,12 +1472,12 @@ static GimpProcedure histogram_proc =
{ { histogram_invoker } }
};
static Argument *
static GimpArgument *
hue_saturation_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -1550,12 +1550,12 @@ static GimpProcedure hue_saturation_proc =
{ { hue_saturation_invoker } }
};
static Argument *
static GimpArgument *
threshold_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;

116
app/pdb/context_cmds.c
View File

@ -368,12 +368,12 @@ register_context_procs (Gimp *gimp)
}
static Argument *
static GimpArgument *
context_push_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
if (gimp->current_plug_in && gimp->current_plug_in->open)
@ -399,12 +399,12 @@ static GimpProcedure context_push_proc =
{ { context_push_invoker } }
};
static Argument *
static GimpArgument *
context_pop_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
if (gimp->current_plug_in && gimp->current_plug_in->open)
@ -430,15 +430,15 @@ static GimpProcedure context_pop_proc =
{ { context_pop_invoker } }
};
static Argument *
static GimpArgument *
context_get_paint_method_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name = NULL;
GimpPaintInfo *paint_info = gimp_context_get_paint_info (context);
@ -472,12 +472,12 @@ static GimpProcedure context_get_paint_method_proc =
{ { context_get_paint_method_invoker } }
};
static Argument *
static GimpArgument *
context_set_paint_method_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *name;
@ -514,14 +514,14 @@ static GimpProcedure context_set_paint_method_proc =
{ { context_set_paint_method_invoker } }
};
static Argument *
static GimpArgument *
context_get_foreground_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
Argument *return_vals;
GimpArgument *return_vals;
GimpRGB foreground = { 0.0, 0.0, 0.0, 1.0 };
gimp_context_get_foreground (context, &foreground);
@ -548,12 +548,12 @@ static GimpProcedure context_get_foreground_proc =
{ { context_get_foreground_invoker } }
};
static Argument *
static GimpArgument *
context_set_foreground_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpRGB foreground;
@ -585,14 +585,14 @@ static GimpProcedure context_set_foreground_proc =
{ { context_set_foreground_invoker } }
};
static Argument *
static GimpArgument *
context_get_background_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
Argument *return_vals;
GimpArgument *return_vals;
GimpRGB background = { 0.0, 0.0, 0.0, 1.0 };
gimp_context_get_background (context, &background);
@ -619,12 +619,12 @@ static GimpProcedure context_get_background_proc =
{ { context_get_background_invoker } }
};
static Argument *
static GimpArgument *
context_set_background_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpRGB background;
@ -656,12 +656,12 @@ static GimpProcedure context_set_background_proc =
{ { context_set_background_invoker } }
};
static Argument *
static GimpArgument *
context_set_default_colors_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gimp_context_set_default_colors (context);
return gimp_procedure_get_return_values (procedure, TRUE);
@ -683,12 +683,12 @@ static GimpProcedure context_set_default_colors_proc =
{ { context_set_default_colors_invoker } }
};
static Argument *
static GimpArgument *
context_swap_colors_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gimp_context_swap_colors (context);
return gimp_procedure_get_return_values (procedure, TRUE);
@ -710,14 +710,14 @@ static GimpProcedure context_swap_colors_proc =
{ { context_swap_colors_invoker } }
};
static Argument *
static GimpArgument *
context_get_opacity_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
Argument *return_vals;
GimpArgument *return_vals;
gdouble opacity = 0.0;
opacity = gimp_context_get_opacity (context) * 100.0;
@ -744,12 +744,12 @@ static GimpProcedure context_get_opacity_proc =
{ { context_get_opacity_invoker } }
};
static Argument *
static GimpArgument *
context_set_opacity_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gdouble opacity;
@ -780,14 +780,14 @@ static GimpProcedure context_set_opacity_proc =
{ { context_set_opacity_invoker } }
};
static Argument *
static GimpArgument *
context_get_paint_mode_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
Argument *return_vals;
GimpArgument *return_vals;
gint32 paint_mode = 0;
paint_mode = gimp_context_get_paint_mode (context);
@ -814,12 +814,12 @@ static GimpProcedure context_get_paint_mode_proc =
{ { context_get_paint_mode_invoker } }
};
static Argument *
static GimpArgument *
context_set_paint_mode_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gint32 paint_mode;
@ -850,15 +850,15 @@ static GimpProcedure context_set_paint_mode_proc =
{ { context_set_paint_mode_invoker } }
};
static Argument *
static GimpArgument *
context_get_brush_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name = NULL;
GimpBrush *brush = gimp_context_get_brush (context);
@ -892,12 +892,12 @@ static GimpProcedure context_get_brush_proc =
{ { context_get_brush_invoker } }
};
static Argument *
static GimpArgument *
context_set_brush_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *name;
@ -934,15 +934,15 @@ static GimpProcedure context_set_brush_proc =
{ { context_set_brush_invoker } }
};
static Argument *
static GimpArgument *
context_get_pattern_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name = NULL;
GimpPattern *pattern = gimp_context_get_pattern (context);
@ -976,12 +976,12 @@ static GimpProcedure context_get_pattern_proc =
{ { context_get_pattern_invoker } }
};
static Argument *
static GimpArgument *
context_set_pattern_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *name;
@ -1018,15 +1018,15 @@ static GimpProcedure context_set_pattern_proc =
{ { context_set_pattern_invoker } }
};
static Argument *
static GimpArgument *
context_get_gradient_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name = NULL;
GimpGradient *gradient = gimp_context_get_gradient (context);
@ -1060,12 +1060,12 @@ static GimpProcedure context_get_gradient_proc =
{ { context_get_gradient_invoker } }
};
static Argument *
static GimpArgument *
context_set_gradient_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *name;
@ -1102,15 +1102,15 @@ static GimpProcedure context_set_gradient_proc =
{ { context_set_gradient_invoker } }
};
static Argument *
static GimpArgument *
context_get_palette_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name = NULL;
GimpPalette *palette = gimp_context_get_palette (context);
@ -1144,12 +1144,12 @@ static GimpProcedure context_get_palette_proc =
{ { context_get_palette_invoker } }
};
static Argument *
static GimpArgument *
context_set_palette_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *name;
@ -1186,15 +1186,15 @@ static GimpProcedure context_set_palette_proc =
{ { context_set_palette_invoker } }
};
static Argument *
static GimpArgument *
context_get_font_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name = NULL;
GimpFont *font = gimp_context_get_font (context);
@ -1228,12 +1228,12 @@ static GimpProcedure context_get_font_proc =
{ { context_get_font_invoker } }
};
static Argument *
static GimpArgument *
context_set_font_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *name;

12
app/pdb/convert_cmds.c
View File

@ -131,12 +131,12 @@ register_convert_procs (Gimp *gimp)
}
static Argument *
static GimpArgument *
image_convert_rgb_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpImage *image;
@ -170,12 +170,12 @@ static GimpProcedure image_convert_rgb_proc =
{ { image_convert_rgb_invoker } }
};
static Argument *
static GimpArgument *
image_convert_grayscale_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpImage *image;
@ -209,12 +209,12 @@ static GimpProcedure image_convert_grayscale_proc =
{ { image_convert_grayscale_invoker } }
};
static Argument *
static GimpArgument *
image_convert_indexed_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpImage *image;

24
app/pdb/display_cmds.c
View File

@ -125,15 +125,15 @@ register_display_procs (Gimp *gimp)
}
static Argument *
static GimpArgument *
display_new_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpImage *image;
GimpObject *display = NULL;
@ -177,12 +177,12 @@ static GimpProcedure display_new_proc =
{ { display_new_invoker } }
};
static Argument *
static GimpArgument *
display_delete_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpObject *display;
@ -213,15 +213,15 @@ static GimpProcedure display_delete_proc =
{ { display_delete_invoker } }
};
static Argument *
static GimpArgument *
display_get_window_handle_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpObject *display;
gint32 window = 0;
@ -256,12 +256,12 @@ static GimpProcedure display_get_window_handle_proc =
{ { display_get_window_handle_invoker } }
};
static Argument *
static GimpArgument *
displays_flush_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gimp_container_foreach (gimp->images, (GFunc) gimp_image_flush, NULL);
return gimp_procedure_get_return_values (procedure, TRUE);
@ -283,12 +283,12 @@ static GimpProcedure displays_flush_proc =
{ { displays_flush_invoker } }
};
static Argument *
static GimpArgument *
displays_reconnect_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpImage *old_image;

186
app/pdb/drawable_cmds.c
View File

@ -1091,12 +1091,12 @@ register_drawable_procs (Gimp *gimp)
}
static Argument *
static GimpArgument *
drawable_delete_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -1130,15 +1130,15 @@ static GimpProcedure drawable_delete_proc =
{ { drawable_delete_invoker } }
};
static Argument *
static GimpArgument *
drawable_is_layer_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gboolean layer = FALSE;
@ -1173,15 +1173,15 @@ static GimpProcedure drawable_is_layer_proc =
{ { drawable_is_layer_invoker } }
};
static Argument *
static GimpArgument *
drawable_is_layer_mask_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gboolean layer_mask = FALSE;
@ -1216,15 +1216,15 @@ static GimpProcedure drawable_is_layer_mask_proc =
{ { drawable_is_layer_mask_invoker } }
};
static Argument *
static GimpArgument *
drawable_is_channel_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gboolean channel = FALSE;
@ -1259,15 +1259,15 @@ static GimpProcedure drawable_is_channel_proc =
{ { drawable_is_channel_invoker } }
};
static Argument *
static GimpArgument *
drawable_type_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gint32 type = 0;
@ -1302,15 +1302,15 @@ static GimpProcedure drawable_type_proc =
{ { drawable_type_invoker } }
};
static Argument *
static GimpArgument *
drawable_type_with_alpha_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gint32 type_with_alpha = 0;
@ -1345,15 +1345,15 @@ static GimpProcedure drawable_type_with_alpha_proc =
{ { drawable_type_with_alpha_invoker } }
};
static Argument *
static GimpArgument *
drawable_has_alpha_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gboolean has_alpha = FALSE;
@ -1388,15 +1388,15 @@ static GimpProcedure drawable_has_alpha_proc =
{ { drawable_has_alpha_invoker } }
};
static Argument *
static GimpArgument *
drawable_is_rgb_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gboolean is_rgb = FALSE;
@ -1431,15 +1431,15 @@ static GimpProcedure drawable_is_rgb_proc =
{ { drawable_is_rgb_invoker } }
};
static Argument *
static GimpArgument *
drawable_is_gray_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gboolean is_gray = FALSE;
@ -1474,15 +1474,15 @@ static GimpProcedure drawable_is_gray_proc =
{ { drawable_is_gray_invoker } }
};
static Argument *
static GimpArgument *
drawable_is_indexed_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gboolean is_indexed = FALSE;
@ -1517,15 +1517,15 @@ static GimpProcedure drawable_is_indexed_proc =
{ { drawable_is_indexed_invoker } }
};
static Argument *
static GimpArgument *
drawable_bpp_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gint32 bpp = 0;
@ -1560,15 +1560,15 @@ static GimpProcedure drawable_bpp_proc =
{ { drawable_bpp_invoker } }
};
static Argument *
static GimpArgument *
drawable_width_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gint32 width = 0;
@ -1603,15 +1603,15 @@ static GimpProcedure drawable_width_proc =
{ { drawable_width_invoker } }
};
static Argument *
static GimpArgument *
drawable_height_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gint32 height = 0;
@ -1646,15 +1646,15 @@ static GimpProcedure drawable_height_proc =
{ { drawable_height_invoker } }
};
static Argument *
static GimpArgument *
drawable_offsets_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gint32 offset_x = 0;
gint32 offset_y = 0;
@ -1693,15 +1693,15 @@ static GimpProcedure drawable_offsets_proc =
{ { drawable_offsets_invoker } }
};
static Argument *
static GimpArgument *
drawable_get_image_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
GimpImage *image = NULL;
@ -1736,12 +1736,12 @@ static GimpProcedure drawable_get_image_proc =
{ { drawable_get_image_invoker } }
};
static Argument *
static GimpArgument *
drawable_set_image_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -1775,15 +1775,15 @@ static GimpProcedure drawable_set_image_proc =
{ { drawable_set_image_invoker } }
};
static Argument *
static GimpArgument *
drawable_get_name_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gchar *name = NULL;
@ -1818,12 +1818,12 @@ static GimpProcedure drawable_get_name_proc =
{ { drawable_get_name_invoker } }
};
static Argument *
static GimpArgument *
drawable_set_name_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -1856,15 +1856,15 @@ static GimpProcedure drawable_set_name_proc =
{ { drawable_set_name_invoker } }
};
static Argument *
static GimpArgument *
drawable_get_visible_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gboolean visible = FALSE;
@ -1899,12 +1899,12 @@ static GimpProcedure drawable_get_visible_proc =
{ { drawable_get_visible_invoker } }
};
static Argument *
static GimpArgument *
drawable_set_visible_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -1937,15 +1937,15 @@ static GimpProcedure drawable_set_visible_proc =
{ { drawable_set_visible_invoker } }
};
static Argument *
static GimpArgument *
drawable_get_linked_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gboolean linked = FALSE;
@ -1980,12 +1980,12 @@ static GimpProcedure drawable_get_linked_proc =
{ { drawable_get_linked_invoker } }
};
static Argument *
static GimpArgument *
drawable_set_linked_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -2018,15 +2018,15 @@ static GimpProcedure drawable_set_linked_proc =
{ { drawable_set_linked_invoker } }
};
static Argument *
static GimpArgument *
drawable_get_tattoo_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gint32 tattoo = 0;
@ -2061,12 +2061,12 @@ static GimpProcedure drawable_get_tattoo_proc =
{ { drawable_get_tattoo_invoker } }
};
static Argument *
static GimpArgument *
drawable_set_tattoo_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -2099,15 +2099,15 @@ static GimpProcedure drawable_set_tattoo_proc =
{ { drawable_set_tattoo_invoker } }
};
static Argument *
static GimpArgument *
drawable_mask_bounds_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gboolean non_empty = FALSE;
gint32 x1 = 0;
@ -2152,15 +2152,15 @@ static GimpProcedure drawable_mask_bounds_proc =
{ { drawable_mask_bounds_invoker } }
};
static Argument *
static GimpArgument *
drawable_mask_intersect_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gboolean non_empty = FALSE;
gint32 x = 0;
@ -2205,12 +2205,12 @@ static GimpProcedure drawable_mask_intersect_proc =
{ { drawable_mask_intersect_invoker } }
};
static Argument *
static GimpArgument *
drawable_merge_shadow_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -2258,12 +2258,12 @@ static GimpProcedure drawable_merge_shadow_proc =
{ { drawable_merge_shadow_invoker } }
};
static Argument *
static GimpArgument *
drawable_update_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -2302,15 +2302,15 @@ static GimpProcedure drawable_update_proc =
{ { drawable_update_invoker } }
};
static Argument *
static GimpArgument *
drawable_get_pixel_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gint32 x_coord;
gint32 y_coord;
@ -2377,12 +2377,12 @@ static GimpProcedure drawable_get_pixel_proc =
{ { drawable_get_pixel_invoker } }
};
static Argument *
static GimpArgument *
drawable_set_pixel_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -2443,12 +2443,12 @@ static GimpProcedure drawable_set_pixel_proc =
{ { drawable_set_pixel_invoker } }
};
static Argument *
static GimpArgument *
drawable_fill_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -2481,12 +2481,12 @@ static GimpProcedure drawable_fill_proc =
{ { drawable_fill_invoker } }
};
static Argument *
static GimpArgument *
drawable_offset_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -2529,15 +2529,15 @@ static GimpProcedure drawable_offset_proc =
{ { drawable_offset_invoker } }
};
static Argument *
static GimpArgument *
drawable_thumbnail_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gint32 width;
gint32 height;
@ -2620,15 +2620,15 @@ static GimpProcedure drawable_thumbnail_proc =
{ { drawable_thumbnail_invoker } }
};
static Argument *
static GimpArgument *
drawable_sub_thumbnail_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gint32 src_x;
gint32 src_y;
@ -2717,12 +2717,12 @@ static GimpProcedure drawable_sub_thumbnail_proc =
{ { drawable_sub_thumbnail_invoker } }
};
static Argument *
static GimpArgument *
drawable_foreground_extract_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;

96
app/pdb/drawable_transform_cmds.c
View File

@ -1378,15 +1378,15 @@ register_drawable_transform_procs (Gimp *gimp)
}
static Argument *
static GimpArgument *
drawable_transform_flip_simple_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gint32 flip_type;
gboolean auto_center;
@ -1439,15 +1439,15 @@ static GimpProcedure drawable_transform_flip_simple_proc =
{ { drawable_transform_flip_simple_invoker } }
};
static Argument *
static GimpArgument *
drawable_transform_flip_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gdouble x0;
gdouble y0;
@ -1525,15 +1525,15 @@ static GimpProcedure drawable_transform_flip_proc =
{ { drawable_transform_flip_invoker } }
};
static Argument *
static GimpArgument *
drawable_transform_flip_default_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gdouble x0;
gdouble y0;
@ -1609,15 +1609,15 @@ static GimpProcedure drawable_transform_flip_default_proc =
{ { drawable_transform_flip_default_invoker } }
};
static Argument *
static GimpArgument *
drawable_transform_perspective_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gdouble x0;
gdouble y0;
@ -1707,15 +1707,15 @@ static GimpProcedure drawable_transform_perspective_proc =
{ { drawable_transform_perspective_invoker } }
};
static Argument *
static GimpArgument *
drawable_transform_perspective_default_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gdouble x0;
gdouble y0;
@ -1803,15 +1803,15 @@ static GimpProcedure drawable_transform_perspective_default_proc =
{ { drawable_transform_perspective_default_invoker } }
};
static Argument *
static GimpArgument *
drawable_transform_rotate_simple_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gint32 rotate_type;
gboolean auto_center;
@ -1866,15 +1866,15 @@ static GimpProcedure drawable_transform_rotate_simple_proc =
{ { drawable_transform_rotate_simple_invoker } }
};
static Argument *
static GimpArgument *
drawable_transform_rotate_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gdouble angle;
gboolean auto_center;
@ -1955,15 +1955,15 @@ static GimpProcedure drawable_transform_rotate_proc =
{ { drawable_transform_rotate_invoker } }
};
static Argument *
static GimpArgument *
drawable_transform_rotate_default_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gdouble angle;
gboolean auto_center;
@ -2042,15 +2042,15 @@ static GimpProcedure drawable_transform_rotate_default_proc =
{ { drawable_transform_rotate_default_invoker } }
};
static Argument *
static GimpArgument *
drawable_transform_scale_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gdouble x0;
gdouble y0;
@ -2131,15 +2131,15 @@ static GimpProcedure drawable_transform_scale_proc =
{ { drawable_transform_scale_invoker } }
};
static Argument *
static GimpArgument *
drawable_transform_scale_default_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gdouble x0;
gdouble y0;
@ -2218,15 +2218,15 @@ static GimpProcedure drawable_transform_scale_default_proc =
{ { drawable_transform_scale_default_invoker } }
};
static Argument *
static GimpArgument *
drawable_transform_shear_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gint32 shear_type;
gdouble magnitude;
@ -2301,15 +2301,15 @@ static GimpProcedure drawable_transform_shear_proc =
{ { drawable_transform_shear_invoker } }
};
static Argument *
static GimpArgument *
drawable_transform_shear_default_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gint32 shear_type;
gdouble magnitude;
@ -2382,15 +2382,15 @@ static GimpProcedure drawable_transform_shear_default_proc =
{ { drawable_transform_shear_default_invoker } }
};
static Argument *
static GimpArgument *
drawable_transform_2d_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gdouble source_x;
gdouble source_y;
@ -2476,15 +2476,15 @@ static GimpProcedure drawable_transform_2d_proc =
{ { drawable_transform_2d_invoker } }
};
static Argument *
static GimpArgument *
drawable_transform_2d_default_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gdouble source_x;
gdouble source_y;
@ -2568,15 +2568,15 @@ static GimpProcedure drawable_transform_2d_default_proc =
{ { drawable_transform_2d_default_invoker } }
};
static Argument *
static GimpArgument *
drawable_transform_matrix_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gdouble coeff_0_0;
gdouble coeff_0_1;
@ -2670,15 +2670,15 @@ static GimpProcedure drawable_transform_matrix_proc =
{ { drawable_transform_matrix_invoker } }
};
static Argument *
static GimpArgument *
drawable_transform_matrix_default_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gdouble coeff_0_0;
gdouble coeff_0_1;

80
app/pdb/edit_cmds.c
View File

@ -555,15 +555,15 @@ register_edit_procs (Gimp *gimp)
}
static Argument *
static GimpArgument *
edit_cut_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gboolean non_empty = FALSE;
@ -605,15 +605,15 @@ static GimpProcedure edit_cut_proc =
{ { edit_cut_invoker } }
};
static Argument *
static GimpArgument *
edit_copy_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gboolean non_empty = FALSE;
@ -655,15 +655,15 @@ static GimpProcedure edit_copy_proc =
{ { edit_copy_invoker } }
};
static Argument *
static GimpArgument *
edit_copy_visible_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpImage *image;
gboolean non_empty = FALSE;
@ -698,15 +698,15 @@ static GimpProcedure edit_copy_visible_proc =
{ { edit_copy_visible_invoker } }
};
static Argument *
static GimpArgument *
edit_paste_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gboolean paste_into;
GimpLayer *floating_sel = NULL;
@ -753,15 +753,15 @@ static GimpProcedure edit_paste_proc =
{ { edit_paste_invoker } }
};
static Argument *
static GimpArgument *
edit_paste_as_new_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpImage *image = NULL;
if (gimp->global_buffer)
@ -798,15 +798,15 @@ static GimpProcedure edit_paste_as_new_proc =
{ { edit_paste_as_new_invoker } }
};
static Argument *
static GimpArgument *
edit_named_cut_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gchar *buffer_name;
gchar *real_name = NULL;
@ -856,15 +856,15 @@ static GimpProcedure edit_named_cut_proc =
{ { edit_named_cut_invoker } }
};
static Argument *
static GimpArgument *
edit_named_copy_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gchar *buffer_name;
gchar *real_name = NULL;
@ -914,15 +914,15 @@ static GimpProcedure edit_named_copy_proc =
{ { edit_named_copy_invoker } }
};
static Argument *
static GimpArgument *
edit_named_copy_visible_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpImage *image;
gchar *buffer_name;
gchar *real_name = NULL;
@ -970,15 +970,15 @@ static GimpProcedure edit_named_copy_visible_proc =
{ { edit_named_copy_visible_invoker } }
};
static Argument *
static GimpArgument *
edit_named_paste_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gchar *buffer_name;
gboolean paste_into;
@ -1029,15 +1029,15 @@ static GimpProcedure edit_named_paste_proc =
{ { edit_named_paste_invoker } }
};
static Argument *
static GimpArgument *
edit_named_paste_as_new_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *buffer_name;
GimpImage *image = NULL;
@ -1083,12 +1083,12 @@ static GimpProcedure edit_named_paste_as_new_proc =
{ { edit_named_paste_as_new_invoker } }
};
static Argument *
static GimpArgument *
edit_clear_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -1126,12 +1126,12 @@ static GimpProcedure edit_clear_proc =
{ { edit_clear_invoker } }
};
static Argument *
static GimpArgument *
edit_fill_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -1172,12 +1172,12 @@ static GimpProcedure edit_fill_proc =
{ { edit_fill_invoker } }
};
static Argument *
static GimpArgument *
edit_bucket_fill_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -1236,12 +1236,12 @@ static GimpProcedure edit_bucket_fill_proc =
{ { edit_bucket_fill_invoker } }
};
static Argument *
static GimpArgument *
edit_blend_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -1332,12 +1332,12 @@ static GimpProcedure edit_blend_proc =
{ { edit_blend_invoker } }
};
static Argument *
static GimpArgument *
edit_stroke_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;

58
app/pdb/fileops_cmds.c
View File

@ -463,15 +463,15 @@ done:
return success;
}
static Argument *
static GimpArgument *
file_load_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
Argument *new_args;
Argument *return_vals;
GimpArgument *new_args;
GimpArgument *return_vals;
PlugInProcDef *file_proc;
GimpProcedure *proc;
gchar *uri;
@ -529,15 +529,15 @@ static GimpProcedure file_load_proc =
{ { file_load_invoker } }
};
static Argument *
static GimpArgument *
file_load_layer_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gint32 run_mode;
GimpImage *image;
gchar *filename;
@ -590,15 +590,15 @@ static GimpProcedure file_load_layer_proc =
{ { file_load_layer_invoker } }
};
static Argument *
static GimpArgument *
file_load_thumbnail_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *filename;
gint32 width = 0;
gint32 height = 0;
@ -686,15 +686,15 @@ static GimpProcedure file_load_thumbnail_proc =
{ { file_load_thumbnail_invoker } }
};
static Argument *
static GimpArgument *
file_save_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
Argument *new_args;
Argument *return_vals;
GimpArgument *new_args;
GimpArgument *return_vals;
PlugInProcDef *file_proc;
GimpProcedure *proc;
gchar *uri;
@ -752,12 +752,12 @@ static GimpProcedure file_save_proc =
{ { file_save_invoker } }
};
static Argument *
static GimpArgument *
file_save_thumbnail_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpImage *image;
@ -815,15 +815,15 @@ static GimpProcedure file_save_thumbnail_proc =
{ { file_save_thumbnail_invoker } }
};
static Argument *
static GimpArgument *
temp_name_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *extension;
gchar *name = NULL;
@ -858,12 +858,12 @@ static GimpProcedure temp_name_proc =
{ { temp_name_invoker } }
};
static Argument *
static GimpArgument *
register_magic_load_handler_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *procedure_name;
@ -902,12 +902,12 @@ static GimpProcedure register_magic_load_handler_proc =
{ { register_magic_load_handler_invoker } }
};
static Argument *
static GimpArgument *
register_load_handler_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *procedure_name;
@ -944,12 +944,12 @@ static GimpProcedure register_load_handler_proc =
{ { register_load_handler_invoker } }
};
static Argument *
static GimpArgument *
register_save_handler_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *procedure_name;
@ -1022,12 +1022,12 @@ static GimpProcedure register_save_handler_proc =
{ { register_save_handler_invoker } }
};
static Argument *
static GimpArgument *
register_file_handler_mime_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *procedure_name;
@ -1067,12 +1067,12 @@ static GimpProcedure register_file_handler_mime_proc =
{ { register_file_handler_mime_invoker } }
};
static Argument *
static GimpArgument *
register_thumbnail_loader_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *load_proc;

24
app/pdb/floating_sel_cmds.c
View File

@ -153,12 +153,12 @@ register_floating_sel_procs (Gimp *gimp)
}
static Argument *
static GimpArgument *
floating_sel_remove_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpLayer *floating_sel;
@ -192,12 +192,12 @@ static GimpProcedure floating_sel_remove_proc =
{ { floating_sel_remove_invoker } }
};
static Argument *
static GimpArgument *
floating_sel_anchor_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpLayer *floating_sel;
@ -231,12 +231,12 @@ static GimpProcedure floating_sel_anchor_proc =
{ { floating_sel_anchor_invoker } }
};
static Argument *
static GimpArgument *
floating_sel_to_layer_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpLayer *floating_sel;
@ -270,12 +270,12 @@ static GimpProcedure floating_sel_to_layer_proc =
{ { floating_sel_to_layer_invoker } }
};
static Argument *
static GimpArgument *
floating_sel_attach_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpLayer *layer;
@ -311,12 +311,12 @@ static GimpProcedure floating_sel_attach_proc =
{ { floating_sel_attach_invoker } }
};
static Argument *
static GimpArgument *
floating_sel_rigor_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpLayer *floating_sel;
@ -352,12 +352,12 @@ static GimpProcedure floating_sel_rigor_proc =
{ { floating_sel_rigor_invoker } }
};
static Argument *
static GimpArgument *
floating_sel_relax_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpLayer *floating_sel;

12
app/pdb/font_select_cmds.c
View File

@ -108,12 +108,12 @@ register_font_select_procs (Gimp *gimp)
}
static Argument *
static GimpArgument *
fonts_popup_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *font_callback;
@ -153,12 +153,12 @@ static GimpProcedure fonts_popup_proc =
{ { fonts_popup_invoker } }
};
static Argument *
static GimpArgument *
fonts_close_popup_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *font_callback;
@ -192,12 +192,12 @@ static GimpProcedure fonts_close_popup_proc =
{ { fonts_close_popup_invoker } }
};
static Argument *
static GimpArgument *
fonts_set_popup_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *font_callback;

10
app/pdb/fonts_cmds.c
View File

@ -77,12 +77,12 @@ register_fonts_procs (Gimp *gimp)
}
static Argument *
static GimpArgument *
fonts_refresh_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gimp_fonts_load (gimp);
return gimp_procedure_get_return_values (procedure, TRUE);
@ -104,15 +104,15 @@ static GimpProcedure fonts_refresh_proc =
{ { fonts_refresh_invoker } }
};
static Argument *
static GimpArgument *
fonts_get_list_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *filter;
gint32 num_fonts = 0;
gchar **font_list = NULL;

4
app/pdb/gimp-pdb-query.c
View File

@ -404,7 +404,7 @@ procedural_db_print_entry (gpointer key,
fprintf (file, "( ");
for (i = 0; i < procedure->num_args; i++)
{
ProcArg *arg = &procedure->args[i];
GimpArgumentSpec *arg = &procedure->args[i];
fprintf (file, "( ");
@ -421,7 +421,7 @@ procedural_db_print_entry (gpointer key,
fprintf (file, "( ");
for (i = 0; i < procedure->num_values; i++)
{
ProcArg *arg = &procedure->values[i];
GimpArgumentSpec *arg = &procedure->values[i];
fprintf (file, "( ");

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

@ -235,17 +235,17 @@ procedural_db_lookup (Gimp *gimp,
return NULL;
}
Argument *
GimpArgument *
procedural_db_execute (Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const gchar *name,
Argument *args,
GimpArgument *args,
gint n_args,
gint *n_return_vals)
{
Argument *return_vals = NULL;
GList *list;
GimpArgument *return_vals = NULL;
GList *list;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
@ -299,7 +299,7 @@ procedural_db_execute (Gimp *gimp,
return return_vals;
}
Argument *
GimpArgument *
procedural_db_run_proc (Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
@ -308,9 +308,9 @@ procedural_db_run_proc (Gimp *gimp,
...)
{
GimpProcedure *procedure;
Argument *params;
Argument *return_vals;
va_list args;
GimpArgument *args;
GimpArgument *return_vals;
va_list va_args;
gint i;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
@ -335,24 +335,24 @@ procedural_db_run_proc (Gimp *gimp,
*n_return_vals = procedure->num_values + 1;
params = gimp_procedure_get_arguments (procedure);
args = gimp_procedure_get_arguments (procedure);
va_start (args, n_return_vals);
va_start (va_args, n_return_vals);
for (i = 0; i < procedure->num_args; i++)
{
GimpPDBArgType arg_type = va_arg (args, GimpPDBArgType);
GimpPDBArgType arg_type = va_arg (va_args, GimpPDBArgType);
GValue *value;
if (arg_type == GIMP_PDB_END)
break;
if (arg_type != params[i].type)
if (arg_type != args[i].type)
{
gchar *expected = procedural_db_type_name (procedure->args[i].type);
gchar *got = procedural_db_type_name (arg_type);
gimp_arguments_destroy (params, procedure->num_args, TRUE);
gimp_arguments_destroy (args, procedure->num_args, TRUE);
g_message (_("PDB calling error for procedure '%s':\n"
"Argument #%d type mismatch (expected %s, got %s)"),
@ -367,35 +367,35 @@ procedural_db_run_proc (Gimp *gimp,
return return_vals;
}
value = &params[i].value;
value = &args[i].value;
switch (arg_type)
{
case GIMP_PDB_INT32:
if (G_VALUE_HOLDS_INT (value))
g_value_set_int (value, va_arg (args, gint));
g_value_set_int (value, va_arg (va_args, gint));
else if (G_VALUE_HOLDS_ENUM (value))
g_value_set_enum (value, va_arg (args, gint));
g_value_set_enum (value, va_arg (va_args, gint));
else if (G_VALUE_HOLDS_BOOLEAN (value))
g_value_set_boolean (value, va_arg (args, gint) ? TRUE : FALSE);
g_value_set_boolean (value, va_arg (va_args, gint) ? TRUE : FALSE);
else
g_return_val_if_reached (NULL);
break;
case GIMP_PDB_INT16:
g_value_set_int (value, va_arg (args, gint));
g_value_set_int (value, va_arg (va_args, gint));
break;
case GIMP_PDB_INT8:
g_value_set_uint (value, va_arg (args, guint));
g_value_set_uint (value, va_arg (va_args, guint));
break;
case GIMP_PDB_FLOAT:
g_value_set_double (value, va_arg (args, gdouble));
g_value_set_double (value, va_arg (va_args, gdouble));
break;
case GIMP_PDB_STRING:
g_value_set_static_string (value, va_arg (args, gchar *));
g_value_set_static_string (value, va_arg (va_args, gchar *));
break;
case GIMP_PDB_INT32ARRAY:
@ -403,12 +403,12 @@ procedural_db_run_proc (Gimp *gimp,
case GIMP_PDB_INT8ARRAY:
case GIMP_PDB_FLOATARRAY:
case GIMP_PDB_STRINGARRAY:
g_value_set_pointer (value, va_arg (args, gpointer));
g_value_set_pointer (value, va_arg (va_args, gpointer));
break;
case GIMP_PDB_COLOR:
{
GimpRGB color = va_arg (args, GimpRGB);
GimpRGB color = va_arg (va_args, GimpRGB);
g_value_set_boxed (value, &color);
}
break;
@ -424,28 +424,28 @@ procedural_db_run_proc (Gimp *gimp,
case GIMP_PDB_DRAWABLE:
case GIMP_PDB_SELECTION:
case GIMP_PDB_VECTORS:
g_value_set_int (value, va_arg (args, gint));
g_value_set_int (value, va_arg (va_args, gint));
break;
case GIMP_PDB_PARASITE:
g_value_set_static_boxed (value, va_arg (args, gpointer));
g_value_set_static_boxed (value, va_arg (va_args, gpointer));
break;
case GIMP_PDB_STATUS:
g_value_set_enum (value, va_arg (args, gint));
g_value_set_enum (value, va_arg (va_args, gint));
case GIMP_PDB_END:
break;
}
}
va_end (args);
va_end (va_args);
return_vals = procedural_db_execute (gimp, context, progress, name,
params, procedure->num_args,
args, procedure->num_args,
n_return_vals);
gimp_arguments_destroy (params, procedure->num_args, FALSE);
gimp_arguments_destroy (args, procedure->num_args, FALSE);
return return_vals;
}

6
app/pdb/gimp-pdb.h
View File

@ -32,14 +32,14 @@ void procedural_db_unregister (Gimp *gimp,
GimpProcedure * procedural_db_lookup (Gimp *gimp,
const gchar *name);
Argument * procedural_db_execute (Gimp *gimp,
GimpArgument * procedural_db_execute (Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const gchar *name,
Argument *args,
GimpArgument *args,
gint n_args,
gint *n_return_vals);
Argument * procedural_db_run_proc (Gimp *gimp,
GimpArgument * procedural_db_run_proc (Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const gchar *name,

12
app/pdb/gimpargument.c
View File

@ -32,8 +32,8 @@
/* public functions */
void
gimp_argument_init (Argument *arg,
ProcArg *proc_arg)
gimp_argument_init (GimpArgument *arg,
GimpArgumentSpec *proc_arg)
{
g_return_if_fail (arg != NULL);
g_return_if_fail (proc_arg != NULL);
@ -43,7 +43,7 @@ gimp_argument_init (Argument *arg,
}
void
gimp_argument_init_compat (Argument *arg,
gimp_argument_init_compat (GimpArgument *arg,
GimpPDBArgType arg_type)
{
g_return_if_fail (arg != NULL);
@ -109,9 +109,9 @@ gimp_argument_init_compat (Argument *arg,
}
void
gimp_arguments_destroy (Argument *args,
gint n_args,
gboolean full_destroy)
gimp_arguments_destroy (GimpArgument *args,
gint n_args,
gboolean full_destroy)
{
gint i;

18
app/pdb/gimpargument.h
View File

@ -20,27 +20,27 @@
#define __GIMP_ARGUMENT_H__
struct _Argument
struct _GimpArgument
{
GimpPDBArgType type;
GValue value;
};
struct _ProcArg
struct _GimpArgumentSpec
{
GimpPDBArgType type;
GParamSpec *pspec;
};
void gimp_argument_init (Argument *arg,
ProcArg *proc_arg);
void gimp_argument_init_compat (Argument *arg,
GimpPDBArgType arg_type);
void gimp_argument_init (GimpArgument *arg,
GimpArgumentSpec *spec);
void gimp_argument_init_compat (GimpArgument *arg,
GimpPDBArgType arg_type);
void gimp_arguments_destroy (Argument *args,
gint n_args,
gboolean full_destroy);
void gimp_arguments_destroy (GimpArgument *args,
gint n_args,
gboolean full_destroy);
#endif /* __GIMP_ARGUMENT_H__ */

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

@ -404,7 +404,7 @@ procedural_db_print_entry (gpointer key,
fprintf (file, "( ");
for (i = 0; i < procedure->num_args; i++)
{
ProcArg *arg = &procedure->args[i];
GimpArgumentSpec *arg = &procedure->args[i];
fprintf (file, "( ");
@ -421,7 +421,7 @@ procedural_db_print_entry (gpointer key,
fprintf (file, "( ");
for (i = 0; i < procedure->num_values; i++)
{
ProcArg *arg = &procedure->values[i];
GimpArgumentSpec *arg = &procedure->values[i];
fprintf (file, "( ");

58
app/pdb/gimppdb.c
View File

@ -235,17 +235,17 @@ procedural_db_lookup (Gimp *gimp,
return NULL;
}
Argument *
GimpArgument *
procedural_db_execute (Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const gchar *name,
Argument *args,
GimpArgument *args,
gint n_args,
gint *n_return_vals)
{
Argument *return_vals = NULL;
GList *list;
GimpArgument *return_vals = NULL;
GList *list;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
@ -299,7 +299,7 @@ procedural_db_execute (Gimp *gimp,
return return_vals;
}
Argument *
GimpArgument *
procedural_db_run_proc (Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
@ -308,9 +308,9 @@ procedural_db_run_proc (Gimp *gimp,
...)
{
GimpProcedure *procedure;
Argument *params;
Argument *return_vals;
va_list args;
GimpArgument *args;
GimpArgument *return_vals;
va_list va_args;
gint i;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
@ -335,24 +335,24 @@ procedural_db_run_proc (Gimp *gimp,
*n_return_vals = procedure->num_values + 1;
params = gimp_procedure_get_arguments (procedure);
args = gimp_procedure_get_arguments (procedure);
va_start (args, n_return_vals);
va_start (va_args, n_return_vals);
for (i = 0; i < procedure->num_args; i++)
{
GimpPDBArgType arg_type = va_arg (args, GimpPDBArgType);
GimpPDBArgType arg_type = va_arg (va_args, GimpPDBArgType);
GValue *value;
if (arg_type == GIMP_PDB_END)
break;
if (arg_type != params[i].type)
if (arg_type != args[i].type)
{
gchar *expected = procedural_db_type_name (procedure->args[i].type);
gchar *got = procedural_db_type_name (arg_type);
gimp_arguments_destroy (params, procedure->num_args, TRUE);
gimp_arguments_destroy (args, procedure->num_args, TRUE);
g_message (_("PDB calling error for procedure '%s':\n"
"Argument #%d type mismatch (expected %s, got %s)"),
@ -367,35 +367,35 @@ procedural_db_run_proc (Gimp *gimp,
return return_vals;
}
value = &params[i].value;
value = &args[i].value;
switch (arg_type)
{
case GIMP_PDB_INT32:
if (G_VALUE_HOLDS_INT (value))
g_value_set_int (value, va_arg (args, gint));
g_value_set_int (value, va_arg (va_args, gint));
else if (G_VALUE_HOLDS_ENUM (value))
g_value_set_enum (value, va_arg (args, gint));
g_value_set_enum (value, va_arg (va_args, gint));
else if (G_VALUE_HOLDS_BOOLEAN (value))
g_value_set_boolean (value, va_arg (args, gint) ? TRUE : FALSE);
g_value_set_boolean (value, va_arg (va_args, gint) ? TRUE : FALSE);
else
g_return_val_if_reached (NULL);
break;
case GIMP_PDB_INT16:
g_value_set_int (value, va_arg (args, gint));
g_value_set_int (value, va_arg (va_args, gint));
break;
case GIMP_PDB_INT8:
g_value_set_uint (value, va_arg (args, guint));
g_value_set_uint (value, va_arg (va_args, guint));
break;
case GIMP_PDB_FLOAT:
g_value_set_double (value, va_arg (args, gdouble));
g_value_set_double (value, va_arg (va_args, gdouble));
break;
case GIMP_PDB_STRING:
g_value_set_static_string (value, va_arg (args, gchar *));
g_value_set_static_string (value, va_arg (va_args, gchar *));
break;
case GIMP_PDB_INT32ARRAY:
@ -403,12 +403,12 @@ procedural_db_run_proc (Gimp *gimp,
case GIMP_PDB_INT8ARRAY:
case GIMP_PDB_FLOATARRAY:
case GIMP_PDB_STRINGARRAY:
g_value_set_pointer (value, va_arg (args, gpointer));
g_value_set_pointer (value, va_arg (va_args, gpointer));
break;
case GIMP_PDB_COLOR:
{
GimpRGB color = va_arg (args, GimpRGB);
GimpRGB color = va_arg (va_args, GimpRGB);
g_value_set_boxed (value, &color);
}
break;
@ -424,28 +424,28 @@ procedural_db_run_proc (Gimp *gimp,
case GIMP_PDB_DRAWABLE:
case GIMP_PDB_SELECTION:
case GIMP_PDB_VECTORS:
g_value_set_int (value, va_arg (args, gint));
g_value_set_int (value, va_arg (va_args, gint));
break;
case GIMP_PDB_PARASITE:
g_value_set_static_boxed (value, va_arg (args, gpointer));
g_value_set_static_boxed (value, va_arg (va_args, gpointer));
break;
case GIMP_PDB_STATUS:
g_value_set_enum (value, va_arg (args, gint));
g_value_set_enum (value, va_arg (va_args, gint));
case GIMP_PDB_END:
break;
}
}
va_end (args);
va_end (va_args);
return_vals = procedural_db_execute (gimp, context, progress, name,
params, procedure->num_args,
args, procedure->num_args,
n_return_vals);
gimp_arguments_destroy (params, procedure->num_args, FALSE);
gimp_arguments_destroy (args, procedure->num_args, FALSE);
return return_vals;
}

6
app/pdb/gimppdb.h
View File

@ -32,14 +32,14 @@ void procedural_db_unregister (Gimp *gimp,
GimpProcedure * procedural_db_lookup (Gimp *gimp,
const gchar *name);
Argument * procedural_db_execute (Gimp *gimp,
GimpArgument * procedural_db_execute (Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const gchar *name,
Argument *args,
GimpArgument *args,
gint n_args,
gint *n_return_vals);
Argument * procedural_db_run_proc (Gimp *gimp,
GimpArgument * procedural_db_run_proc (Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const gchar *name,

30
app/pdb/gimpprocedure.c
View File

@ -105,10 +105,10 @@ gimp_procedure_init (GimpProcedure *procedure,
g_return_val_if_fail (n_return_values >= 0, procedure);
procedure->num_args = n_arguments;
procedure->args = g_new0 (ProcArg, n_arguments);
procedure->args = g_new0 (GimpArgumentSpec, n_arguments);
procedure->num_values = n_return_values;
procedure->values = g_new0 (ProcArg, n_return_values);
procedure->values = g_new0 (GimpArgumentSpec, n_return_values);
return procedure;
}
@ -194,17 +194,17 @@ gimp_procedure_take_strings (GimpProcedure *procedure,
procedure->static_strings = FALSE;
}
Argument *
GimpArgument *
gimp_procedure_execute (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args,
GimpArgument *args,
gint n_args,
gint *n_return_vals)
{
Argument *return_vals = NULL;
gint i;
GimpArgument *return_vals = NULL;
gint i;
g_return_val_if_fail (GIMP_IS_PROCEDURE (procedure), NULL);
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
@ -328,15 +328,15 @@ gimp_procedure_execute (GimpProcedure *procedure,
return return_vals;
}
Argument *
GimpArgument *
gimp_procedure_get_arguments (GimpProcedure *procedure)
{
Argument *args;
gint i;
GimpArgument *args;
gint i;
g_return_val_if_fail (GIMP_IS_PROCEDURE (procedure), NULL);
args = g_new0 (Argument, procedure->num_args);
args = g_new0 (GimpArgument, procedure->num_args);
for (i = 0; i < procedure->num_args; i++)
gimp_argument_init (&args[i], &procedure->args[i]);
@ -344,13 +344,13 @@ gimp_procedure_get_arguments (GimpProcedure *procedure)
return args;
}
Argument *
GimpArgument *
gimp_procedure_get_return_values (GimpProcedure *procedure,
gboolean success)
{
Argument *args;
gint n_args;
gint i;
GimpArgument *args;
gint n_args;
gint i;
g_return_val_if_fail (GIMP_IS_PROCEDURE (procedure) ||
success == FALSE, NULL);
@ -360,7 +360,7 @@ gimp_procedure_get_return_values (GimpProcedure *procedure,
else
n_args = 1;
args = g_new0 (Argument, n_args);
args = g_new0 (GimpArgument, n_args);
gimp_argument_init_compat (&args[0], GIMP_PDB_STATUS);

26
app/pdb/gimpprocedure.h
View File

@ -30,11 +30,11 @@ typedef struct _TempExec TempExec;
struct _IntExec
{
/* Function called to marshal arguments */
Argument * (* marshal_func) (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args);
GimpArgument * (* marshal_func) (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
GimpArgument *args);
};
struct _PlugInExec
@ -79,12 +79,12 @@ struct _GimpProcedure
GimpPDBProcType proc_type; /* Type of procedure */
/* Input arguments */
gint32 num_args; /* Number of procedure arguments */
ProcArg *args; /* Array of procedure arguments */
gint32 num_args; /* Number of procedure arguments */
GimpArgumentSpec *args; /* Array of procedure arguments */
/* Output values */
gint32 num_values; /* Number of return values */
ProcArg *values; /* Array of return values */
gint32 num_values;/* Number of return values */
GimpArgumentSpec *values; /* Array of return values */
/* Method of procedure execution */
union _ExecMethod
@ -150,15 +150,15 @@ void gimp_procedure_add_compat_value (GimpProcedure *procedure,
const gchar *name,
const gchar *desc);
Argument * gimp_procedure_get_arguments (GimpProcedure *procedure);
Argument * gimp_procedure_get_return_values (GimpProcedure *procedure,
GimpArgument * gimp_procedure_get_arguments (GimpProcedure *procedure);
GimpArgument * gimp_procedure_get_return_values (GimpProcedure *procedure,
gboolean success);
Argument * gimp_procedure_execute (GimpProcedure *procedure,
GimpArgument * gimp_procedure_execute (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args,
GimpArgument *args,
gint n_args,
gint *n_return_vals);

40
app/pdb/gimprc_cmds.c
View File

@ -172,15 +172,15 @@ register_gimprc_procs (Gimp *gimp)
}
static Argument *
static GimpArgument *
gimprc_query_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *token;
gchar *value = NULL;
@ -224,12 +224,12 @@ static GimpProcedure gimprc_query_proc =
{ { gimprc_query_invoker } }
};
static Argument *
static GimpArgument *
gimprc_set_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *token;
@ -268,14 +268,14 @@ static GimpProcedure gimprc_set_proc =
{ { gimprc_set_invoker } }
};
static Argument *
static GimpArgument *
get_default_comment_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
Argument *return_vals;
GimpArgument *return_vals;
gchar *comment = NULL;
comment = g_strdup (gimp->config->default_image->comment);
@ -302,14 +302,14 @@ static GimpProcedure get_default_comment_proc =
{ { get_default_comment_invoker } }
};
static Argument *
static GimpArgument *
get_monitor_resolution_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
Argument *return_vals;
GimpArgument *return_vals;
gdouble xres = 0.0;
gdouble yres = 0.0;
@ -340,14 +340,14 @@ static GimpProcedure get_monitor_resolution_proc =
{ { get_monitor_resolution_invoker } }
};
static Argument *
static GimpArgument *
get_theme_dir_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
Argument *return_vals;
GimpArgument *return_vals;
gchar *theme_dir = NULL;
theme_dir = g_strdup (gimp_get_theme_dir (gimp));
@ -374,14 +374,14 @@ static GimpProcedure get_theme_dir_proc =
{ { get_theme_dir_invoker } }
};
static Argument *
static GimpArgument *
get_color_configuration_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
Argument *return_vals;
GimpArgument *return_vals;
gchar *config = NULL;
config = gimp_config_serialize_to_string (GIMP_CONFIG (gimp->config->color_management), NULL);
@ -408,14 +408,14 @@ static GimpProcedure get_color_configuration_proc =
{ { get_color_configuration_invoker } }
};
static Argument *
static GimpArgument *
get_module_load_inhibit_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
Argument *return_vals;
GimpArgument *return_vals;
gchar *load_inhibit = NULL;
load_inhibit = g_strdup (gimp_module_db_get_load_inhibit (gimp->module_db));

154
app/pdb/gradient_cmds.c
View File

@ -1068,15 +1068,15 @@ gradient_get_range (Gimp *gimp,
return gradient;
}
static Argument *
static GimpArgument *
gradient_new_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gchar *actual_name = NULL;
@ -1121,15 +1121,15 @@ static GimpProcedure gradient_new_proc =
{ { gradient_new_invoker } }
};
static Argument *
static GimpArgument *
gradient_duplicate_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gchar *copy_name = NULL;
@ -1179,15 +1179,15 @@ static GimpProcedure gradient_duplicate_proc =
{ { gradient_duplicate_invoker } }
};
static Argument *
static GimpArgument *
gradient_is_editable_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gboolean editable = FALSE;
@ -1228,15 +1228,15 @@ static GimpProcedure gradient_is_editable_proc =
{ { gradient_is_editable_invoker } }
};
static Argument *
static GimpArgument *
gradient_rename_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gchar *new_name;
gchar *actual_name = NULL;
@ -1282,12 +1282,12 @@ static GimpProcedure gradient_rename_proc =
{ { gradient_rename_invoker } }
};
static Argument *
static GimpArgument *
gradient_delete_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *name;
@ -1336,15 +1336,15 @@ static GimpProcedure gradient_delete_proc =
{ { gradient_delete_invoker } }
};
static Argument *
static GimpArgument *
gradient_get_uniform_samples_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gint32 num_samples;
gboolean reverse;
@ -1416,15 +1416,15 @@ static GimpProcedure gradient_get_uniform_samples_proc =
{ { gradient_get_uniform_samples_invoker } }
};
static Argument *
static GimpArgument *
gradient_get_custom_samples_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gint32 num_samples;
gdouble *positions;
@ -1497,15 +1497,15 @@ static GimpProcedure gradient_get_custom_samples_proc =
{ { gradient_get_custom_samples_invoker } }
};
static Argument *
static GimpArgument *
gradient_segment_get_left_color_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gint32 segment;
GimpRGB color = { 0.0, 0.0, 0.0, 1.0 };
@ -1557,12 +1557,12 @@ static GimpProcedure gradient_segment_get_left_color_proc =
{ { gradient_segment_get_left_color_invoker } }
};
static Argument *
static GimpArgument *
gradient_segment_set_left_color_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *name;
@ -1610,15 +1610,15 @@ static GimpProcedure gradient_segment_set_left_color_proc =
{ { gradient_segment_set_left_color_invoker } }
};
static Argument *
static GimpArgument *
gradient_segment_get_right_color_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gint32 segment;
GimpRGB color = { 0.0, 0.0, 0.0, 1.0 };
@ -1670,12 +1670,12 @@ static GimpProcedure gradient_segment_get_right_color_proc =
{ { gradient_segment_get_right_color_invoker } }
};
static Argument *
static GimpArgument *
gradient_segment_set_right_color_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *name;
@ -1723,15 +1723,15 @@ static GimpProcedure gradient_segment_set_right_color_proc =
{ { gradient_segment_set_right_color_invoker } }
};
static Argument *
static GimpArgument *
gradient_segment_get_left_pos_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gint32 segment;
gdouble pos = 0.0;
@ -1778,15 +1778,15 @@ static GimpProcedure gradient_segment_get_left_pos_proc =
{ { gradient_segment_get_left_pos_invoker } }
};
static Argument *
static GimpArgument *
gradient_segment_set_left_pos_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gint32 segment;
gdouble pos;
@ -1835,15 +1835,15 @@ static GimpProcedure gradient_segment_set_left_pos_proc =
{ { gradient_segment_set_left_pos_invoker } }
};
static Argument *
static GimpArgument *
gradient_segment_get_middle_pos_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gint32 segment;
gdouble pos = 0.0;
@ -1890,15 +1890,15 @@ static GimpProcedure gradient_segment_get_middle_pos_proc =
{ { gradient_segment_get_middle_pos_invoker } }
};
static Argument *
static GimpArgument *
gradient_segment_set_middle_pos_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gint32 segment;
gdouble pos;
@ -1948,15 +1948,15 @@ static GimpProcedure gradient_segment_set_middle_pos_proc =
{ { gradient_segment_set_middle_pos_invoker } }
};
static Argument *
static GimpArgument *
gradient_segment_get_right_pos_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gint32 segment;
gdouble pos = 0.0;
@ -2003,15 +2003,15 @@ static GimpProcedure gradient_segment_get_right_pos_proc =
{ { gradient_segment_get_right_pos_invoker } }
};
static Argument *
static GimpArgument *
gradient_segment_set_right_pos_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gint32 segment;
gdouble pos;
@ -2061,15 +2061,15 @@ static GimpProcedure gradient_segment_set_right_pos_proc =
{ { gradient_segment_set_right_pos_invoker } }
};
static Argument *
static GimpArgument *
gradient_segment_get_blending_function_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gint32 segment;
gint32 blend_func = 0;
@ -2116,15 +2116,15 @@ static GimpProcedure gradient_segment_get_blending_function_proc =
{ { gradient_segment_get_blending_function_invoker } }
};
static Argument *
static GimpArgument *
gradient_segment_get_coloring_type_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gint32 segment;
gint32 coloring_type = 0;
@ -2171,12 +2171,12 @@ static GimpProcedure gradient_segment_get_coloring_type_proc =
{ { gradient_segment_get_coloring_type_invoker } }
};
static Argument *
static GimpArgument *
gradient_segment_range_set_blending_function_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *name;
@ -2227,12 +2227,12 @@ static GimpProcedure gradient_segment_range_set_blending_function_proc =
{ { gradient_segment_range_set_blending_function_invoker } }
};
static Argument *
static GimpArgument *
gradient_segment_range_set_coloring_type_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *name;
@ -2283,12 +2283,12 @@ static GimpProcedure gradient_segment_range_set_coloring_type_proc =
{ { gradient_segment_range_set_coloring_type_invoker } }
};
static Argument *
static GimpArgument *
gradient_segment_range_flip_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *name;
@ -2337,12 +2337,12 @@ static GimpProcedure gradient_segment_range_flip_proc =
{ { gradient_segment_range_flip_invoker } }
};
static Argument *
static GimpArgument *
gradient_segment_range_replicate_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *name;
@ -2394,12 +2394,12 @@ static GimpProcedure gradient_segment_range_replicate_proc =
{ { gradient_segment_range_replicate_invoker } }
};
static Argument *
static GimpArgument *
gradient_segment_range_split_midpoint_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *name;
@ -2448,12 +2448,12 @@ static GimpProcedure gradient_segment_range_split_midpoint_proc =
{ { gradient_segment_range_split_midpoint_invoker } }
};
static Argument *
static GimpArgument *
gradient_segment_range_split_uniform_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *name;
@ -2505,12 +2505,12 @@ static GimpProcedure gradient_segment_range_split_uniform_proc =
{ { gradient_segment_range_split_uniform_invoker } }
};
static Argument *
static GimpArgument *
gradient_segment_range_delete_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *name;
@ -2559,12 +2559,12 @@ static GimpProcedure gradient_segment_range_delete_proc =
{ { gradient_segment_range_delete_invoker } }
};
static Argument *
static GimpArgument *
gradient_segment_range_redistribute_handles_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *name;
@ -2612,12 +2612,12 @@ static GimpProcedure gradient_segment_range_redistribute_handles_proc =
{ { gradient_segment_range_redistribute_handles_invoker } }
};
static Argument *
static GimpArgument *
gradient_segment_range_blend_colors_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *name;
@ -2668,12 +2668,12 @@ static GimpProcedure gradient_segment_range_blend_colors_proc =
{ { gradient_segment_range_blend_colors_invoker } }
};
static Argument *
static GimpArgument *
gradient_segment_range_blend_opacity_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *name;
@ -2724,15 +2724,15 @@ static GimpProcedure gradient_segment_range_blend_opacity_proc =
{ { gradient_segment_range_blend_opacity_invoker } }
};
static Argument *
static GimpArgument *
gradient_segment_range_move_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gint32 start_segment;
gint32 end_segment;

12
app/pdb/gradient_select_cmds.c
View File

@ -117,12 +117,12 @@ register_gradient_select_procs (Gimp *gimp)
}
static Argument *
static GimpArgument *
gradients_popup_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *gradient_callback;
@ -168,12 +168,12 @@ static GimpProcedure gradients_popup_proc =
{ { gradients_popup_invoker } }
};
static Argument *
static GimpArgument *
gradients_close_popup_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *gradient_callback;
@ -208,12 +208,12 @@ static GimpProcedure gradients_close_popup_proc =
{ { gradients_close_popup_invoker } }
};
static Argument *
static GimpArgument *
gradients_set_popup_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *gradient_callback;

28
app/pdb/gradients_cmds.c
View File

@ -204,12 +204,12 @@ register_gradients_procs (Gimp *gimp)
}
static Argument *
static GimpArgument *
gradients_refresh_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gimp_data_factory_data_refresh (gimp->gradient_factory);
return gimp_procedure_get_return_values (procedure, TRUE);
@ -231,15 +231,15 @@ static GimpProcedure gradients_refresh_proc =
{ { gradients_refresh_invoker } }
};
static Argument *
static GimpArgument *
gradients_get_list_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *filter;
gint32 num_gradients = 0;
gchar **gradient_list = NULL;
@ -279,15 +279,15 @@ static GimpProcedure gradients_get_list_proc =
{ { gradients_get_list_invoker } }
};
static Argument *
static GimpArgument *
gradients_sample_uniform_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gint32 num_samples;
gboolean reverse;
gint32 array_length = 0;
@ -353,15 +353,15 @@ static GimpProcedure gradients_sample_uniform_proc =
{ { gradients_sample_uniform_invoker } }
};
static Argument *
static GimpArgument *
gradients_sample_custom_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gint32 num_samples;
gdouble *positions;
gboolean reverse;
@ -426,15 +426,15 @@ static GimpProcedure gradients_sample_custom_proc =
{ { gradients_sample_custom_invoker } }
};
static Argument *
static GimpArgument *
gradients_get_gradient_data_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gint32 sample_size;
gboolean reverse;

50
app/pdb/grid_cmds.c
View File

@ -284,15 +284,15 @@ register_grid_procs (Gimp *gimp)
}
static Argument *
static GimpArgument *
image_grid_get_spacing_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpImage *image;
gdouble xspacing = 0.0;
gdouble yspacing = 0.0;
@ -339,12 +339,12 @@ static GimpProcedure image_grid_get_spacing_proc =
{ { image_grid_get_spacing_invoker } }
};
static Argument *
static GimpArgument *
image_grid_set_spacing_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpImage *image;
@ -387,15 +387,15 @@ static GimpProcedure image_grid_set_spacing_proc =
{ { image_grid_set_spacing_invoker } }
};
static Argument *
static GimpArgument *
image_grid_get_offset_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpImage *image;
gdouble xoffset = 0.0;
gdouble yoffset = 0.0;
@ -442,12 +442,12 @@ static GimpProcedure image_grid_get_offset_proc =
{ { image_grid_get_offset_invoker } }
};
static Argument *
static GimpArgument *
image_grid_set_offset_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpImage *image;
@ -490,15 +490,15 @@ static GimpProcedure image_grid_set_offset_proc =
{ { image_grid_set_offset_invoker } }
};
static Argument *
static GimpArgument *
image_grid_get_foreground_color_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpImage *image;
GimpRGB fgcolor = { 0.0, 0.0, 0.0, 1.0 };
@ -538,12 +538,12 @@ static GimpProcedure image_grid_get_foreground_color_proc =
{ { image_grid_get_foreground_color_invoker } }
};
static Argument *
static GimpArgument *
image_grid_set_foreground_color_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpImage *image;
@ -581,15 +581,15 @@ static GimpProcedure image_grid_set_foreground_color_proc =
{ { image_grid_set_foreground_color_invoker } }
};
static Argument *
static GimpArgument *
image_grid_get_background_color_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpImage *image;
GimpRGB bgcolor = { 0.0, 0.0, 0.0, 1.0 };
@ -629,12 +629,12 @@ static GimpProcedure image_grid_get_background_color_proc =
{ { image_grid_get_background_color_invoker } }
};
static Argument *
static GimpArgument *
image_grid_set_background_color_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpImage *image;
@ -672,15 +672,15 @@ static GimpProcedure image_grid_set_background_color_proc =
{ { image_grid_set_background_color_invoker } }
};
static Argument *
static GimpArgument *
image_grid_get_style_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpImage *image;
gint32 style = 0;
@ -720,12 +720,12 @@ static GimpProcedure image_grid_get_style_proc =
{ { image_grid_get_style_invoker } }
};
static Argument *
static GimpArgument *
image_grid_set_style_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpImage *image;

34
app/pdb/guides_cmds.c
View File

@ -205,15 +205,15 @@ register_guides_procs (Gimp *gimp)
}
static Argument *
static GimpArgument *
image_add_hguide_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpImage *image;
gint32 yposition;
gint32 guide = 0;
@ -258,15 +258,15 @@ static GimpProcedure image_add_hguide_proc =
{ { image_add_hguide_invoker } }
};
static Argument *
static GimpArgument *
image_add_vguide_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpImage *image;
gint32 xposition;
gint32 guide = 0;
@ -311,12 +311,12 @@ static GimpProcedure image_add_vguide_proc =
{ { image_add_vguide_invoker } }
};
static Argument *
static GimpArgument *
image_delete_guide_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpImage *image;
@ -354,15 +354,15 @@ static GimpProcedure image_delete_guide_proc =
{ { image_delete_guide_invoker } }
};
static Argument *
static GimpArgument *
image_find_next_guide_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpImage *image;
gint32 guide;
gint32 next_guide = 0;
@ -402,15 +402,15 @@ static GimpProcedure image_find_next_guide_proc =
{ { image_find_next_guide_invoker } }
};
static Argument *
static GimpArgument *
image_get_guide_orientation_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpImage *image;
gint32 guide;
gint32 orientation = 0;
@ -452,15 +452,15 @@ static GimpProcedure image_get_guide_orientation_proc =
{ { image_get_guide_orientation_invoker } }
};
static Argument *
static GimpArgument *
image_get_guide_position_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpImage *image;
gint32 guide;
gint32 position = 0;

4
app/pdb/help_cmds.c
View File

@ -64,12 +64,12 @@ register_help_procs (Gimp *gimp)
}
static Argument *
static GimpArgument *
help_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *help_domain;

356
app/pdb/image_cmds.c
View File

File diff suppressed because it is too large Load Diff

134
app/pdb/layer_cmds.c
View File

@ -752,15 +752,15 @@ register_layer_procs (Gimp *gimp)
}
static Argument *
static GimpArgument *
layer_new_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpImage *image;
gint32 width;
gint32 height;
@ -811,15 +811,15 @@ static GimpProcedure layer_new_proc =
{ { layer_new_invoker } }
};
static Argument *
static GimpArgument *
layer_new_from_drawable_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
GimpImage *dest_image;
GimpLayer *layer_copy = NULL;
@ -872,15 +872,15 @@ static GimpProcedure layer_new_from_drawable_proc =
{ { layer_new_from_drawable_invoker } }
};
static Argument *
static GimpArgument *
layer_copy_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpLayer *layer;
gboolean add_alpha;
GimpLayer *layer_copy = NULL;
@ -921,12 +921,12 @@ static GimpProcedure layer_copy_proc =
{ { layer_copy_invoker } }
};
static Argument *
static GimpArgument *
layer_add_alpha_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpLayer *layer;
@ -957,12 +957,12 @@ static GimpProcedure layer_add_alpha_proc =
{ { layer_add_alpha_invoker } }
};
static Argument *
static GimpArgument *
layer_scale_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpLayer *layer;
@ -1004,12 +1004,12 @@ static GimpProcedure layer_scale_proc =
{ { layer_scale_invoker } }
};
static Argument *
static GimpArgument *
layer_resize_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpLayer *layer;
@ -1052,12 +1052,12 @@ static GimpProcedure layer_resize_proc =
{ { layer_resize_invoker } }
};
static Argument *
static GimpArgument *
layer_resize_to_image_size_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpLayer *layer;
@ -1091,12 +1091,12 @@ static GimpProcedure layer_resize_to_image_size_proc =
{ { layer_resize_to_image_size_invoker } }
};
static Argument *
static GimpArgument *
layer_translate_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpLayer *layer;
@ -1141,12 +1141,12 @@ static GimpProcedure layer_translate_proc =
{ { layer_translate_invoker } }
};
static Argument *
static GimpArgument *
layer_set_offsets_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpLayer *layer;
@ -1194,15 +1194,15 @@ static GimpProcedure layer_set_offsets_proc =
{ { layer_set_offsets_invoker } }
};
static Argument *
static GimpArgument *
layer_create_mask_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpLayer *layer;
gint32 mask_type;
GimpLayerMask *mask = NULL;
@ -1242,15 +1242,15 @@ static GimpProcedure layer_create_mask_proc =
{ { layer_create_mask_invoker } }
};
static Argument *
static GimpArgument *
layer_get_mask_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpLayer *layer;
GimpLayerMask *mask = NULL;
@ -1285,15 +1285,15 @@ static GimpProcedure layer_get_mask_proc =
{ { layer_get_mask_invoker } }
};
static Argument *
static GimpArgument *
layer_from_mask_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpLayerMask *mask;
GimpLayer *layer = NULL;
@ -1328,12 +1328,12 @@ static GimpProcedure layer_from_mask_proc =
{ { layer_from_mask_invoker } }
};
static Argument *
static GimpArgument *
layer_add_mask_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpLayer *layer;
@ -1369,12 +1369,12 @@ static GimpProcedure layer_add_mask_proc =
{ { layer_add_mask_invoker } }
};
static Argument *
static GimpArgument *
layer_remove_mask_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpLayer *layer;
@ -1410,15 +1410,15 @@ static GimpProcedure layer_remove_mask_proc =
{ { layer_remove_mask_invoker } }
};
static Argument *
static GimpArgument *
layer_is_floating_sel_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpLayer *layer;
gboolean is_floating_sel = FALSE;
@ -1453,15 +1453,15 @@ static GimpProcedure layer_is_floating_sel_proc =
{ { layer_is_floating_sel_invoker } }
};
static Argument *
static GimpArgument *
layer_get_lock_alpha_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpLayer *layer;
gboolean lock_alpha = FALSE;
@ -1496,12 +1496,12 @@ static GimpProcedure layer_get_lock_alpha_proc =
{ { layer_get_lock_alpha_invoker } }
};
static Argument *
static GimpArgument *
layer_set_lock_alpha_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpLayer *layer;
@ -1534,15 +1534,15 @@ static GimpProcedure layer_set_lock_alpha_proc =
{ { layer_set_lock_alpha_invoker } }
};
static Argument *
static GimpArgument *
layer_get_apply_mask_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpLayer *layer;
gboolean apply_mask = FALSE;
@ -1580,12 +1580,12 @@ static GimpProcedure layer_get_apply_mask_proc =
{ { layer_get_apply_mask_invoker } }
};
static Argument *
static GimpArgument *
layer_set_apply_mask_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpLayer *layer;
@ -1621,15 +1621,15 @@ static GimpProcedure layer_set_apply_mask_proc =
{ { layer_set_apply_mask_invoker } }
};
static Argument *
static GimpArgument *
layer_get_show_mask_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpLayer *layer;
gboolean show_mask = FALSE;
@ -1667,12 +1667,12 @@ static GimpProcedure layer_get_show_mask_proc =
{ { layer_get_show_mask_invoker } }
};
static Argument *
static GimpArgument *
layer_set_show_mask_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpLayer *layer;
@ -1708,15 +1708,15 @@ static GimpProcedure layer_set_show_mask_proc =
{ { layer_set_show_mask_invoker } }
};
static Argument *
static GimpArgument *
layer_get_edit_mask_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpLayer *layer;
gboolean edit_mask = FALSE;
@ -1754,12 +1754,12 @@ static GimpProcedure layer_get_edit_mask_proc =
{ { layer_get_edit_mask_invoker } }
};
static Argument *
static GimpArgument *
layer_set_edit_mask_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpLayer *layer;
@ -1795,15 +1795,15 @@ static GimpProcedure layer_set_edit_mask_proc =
{ { layer_set_edit_mask_invoker } }
};
static Argument *
static GimpArgument *
layer_get_opacity_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpLayer *layer;
gdouble opacity = 0.0;
@ -1838,12 +1838,12 @@ static GimpProcedure layer_get_opacity_proc =
{ { layer_get_opacity_invoker } }
};
static Argument *
static GimpArgument *
layer_set_opacity_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpLayer *layer;
@ -1876,15 +1876,15 @@ static GimpProcedure layer_set_opacity_proc =
{ { layer_set_opacity_invoker } }
};
static Argument *
static GimpArgument *
layer_get_mode_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpLayer *layer;
gint32 mode = 0;
@ -1919,12 +1919,12 @@ static GimpProcedure layer_get_mode_proc =
{ { layer_get_mode_invoker } }
};
static Argument *
static GimpArgument *
layer_set_mode_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpLayer *layer;

14
app/pdb/message_cmds.c
View File

@ -88,12 +88,12 @@ register_message_procs (Gimp *gimp)
}
static Argument *
static GimpArgument *
message_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *message;
@ -127,14 +127,14 @@ static GimpProcedure message_proc =
{ { message_invoker } }
};
static Argument *
static GimpArgument *
message_get_handler_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
Argument *return_vals;
GimpArgument *return_vals;
gint32 handler = 0;
handler = gimp->message_handler;
@ -161,12 +161,12 @@ static GimpProcedure message_get_handler_proc =
{ { message_get_handler_invoker } }
};
static Argument *
static GimpArgument *
message_set_handler_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gint32 handler;

16
app/pdb/misc_cmds.c
View File

@ -96,14 +96,14 @@ register_misc_procs (Gimp *gimp)
}
static Argument *
static GimpArgument *
version_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
Argument *return_vals;
GimpArgument *return_vals;
gchar *version = NULL;
version = g_strdup (GIMP_VERSION);
@ -130,14 +130,14 @@ static GimpProcedure version_proc =
{ { version_invoker } }
};
static Argument *
static GimpArgument *
getpid_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
Argument *return_vals;
GimpArgument *return_vals;
gint32 pid = 0;
pid = getpid ();
@ -164,12 +164,12 @@ static GimpProcedure getpid_proc =
{ { getpid_invoker } }
};
static Argument *
static GimpArgument *
quit_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gboolean force;

60
app/pdb/paint_tools_cmds.c
View File

@ -640,12 +640,12 @@ paint_tools_stroke (Gimp *gimp,
return retval;
}
static Argument *
static GimpArgument *
airbrush_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -697,12 +697,12 @@ static GimpProcedure airbrush_proc =
{ { airbrush_invoker } }
};
static Argument *
static GimpArgument *
airbrush_default_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -748,12 +748,12 @@ static GimpProcedure airbrush_default_proc =
{ { airbrush_default_invoker } }
};
static Argument *
static GimpArgument *
clone_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -815,12 +815,12 @@ static GimpProcedure clone_proc =
{ { clone_invoker } }
};
static Argument *
static GimpArgument *
clone_default_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -866,12 +866,12 @@ static GimpProcedure clone_default_proc =
{ { clone_default_invoker } }
};
static Argument *
static GimpArgument *
convolve_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -926,12 +926,12 @@ static GimpProcedure convolve_proc =
{ { convolve_invoker } }
};
static Argument *
static GimpArgument *
convolve_default_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -977,12 +977,12 @@ static GimpProcedure convolve_default_proc =
{ { convolve_default_invoker } }
};
static Argument *
static GimpArgument *
dodgeburn_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -1040,12 +1040,12 @@ static GimpProcedure dodgeburn_proc =
{ { dodgeburn_invoker } }
};
static Argument *
static GimpArgument *
dodgeburn_default_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -1091,12 +1091,12 @@ static GimpProcedure dodgeburn_default_proc =
{ { dodgeburn_default_invoker } }
};
static Argument *
static GimpArgument *
eraser_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -1151,12 +1151,12 @@ static GimpProcedure eraser_proc =
{ { eraser_invoker } }
};
static Argument *
static GimpArgument *
eraser_default_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -1202,12 +1202,12 @@ static GimpProcedure eraser_default_proc =
{ { eraser_default_invoker } }
};
static Argument *
static GimpArgument *
paintbrush_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -1267,12 +1267,12 @@ static GimpProcedure paintbrush_proc =
{ { paintbrush_invoker } }
};
static Argument *
static GimpArgument *
paintbrush_default_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -1318,12 +1318,12 @@ static GimpProcedure paintbrush_default_proc =
{ { paintbrush_default_invoker } }
};
static Argument *
static GimpArgument *
pencil_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -1369,12 +1369,12 @@ static GimpProcedure pencil_proc =
{ { pencil_invoker } }
};
static Argument *
static GimpArgument *
smudge_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -1426,12 +1426,12 @@ static GimpProcedure smudge_proc =
{ { smudge_invoker } }
};
static Argument *
static GimpArgument *
smudge_default_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;

74
app/pdb/palette_cmds.c
View File

@ -403,15 +403,15 @@ register_palette_procs (Gimp *gimp)
}
static Argument *
static GimpArgument *
palette_new_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gchar *actual_name = NULL;
@ -456,15 +456,15 @@ static GimpProcedure palette_new_proc =
{ { palette_new_invoker } }
};
static Argument *
static GimpArgument *
palette_duplicate_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gchar *copy_name = NULL;
@ -514,15 +514,15 @@ static GimpProcedure palette_duplicate_proc =
{ { palette_duplicate_invoker } }
};
static Argument *
static GimpArgument *
palette_rename_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gchar *new_name;
gchar *actual_name = NULL;
@ -568,12 +568,12 @@ static GimpProcedure palette_rename_proc =
{ { palette_rename_invoker } }
};
static Argument *
static GimpArgument *
palette_delete_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *name;
@ -622,15 +622,15 @@ static GimpProcedure palette_delete_proc =
{ { palette_delete_invoker } }
};
static Argument *
static GimpArgument *
palette_is_editable_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gboolean editable = FALSE;
@ -671,15 +671,15 @@ static GimpProcedure palette_is_editable_proc =
{ { palette_is_editable_invoker } }
};
static Argument *
static GimpArgument *
palette_get_info_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gint32 num_colors = 0;
@ -720,15 +720,15 @@ static GimpProcedure palette_get_info_proc =
{ { palette_get_info_invoker } }
};
static Argument *
static GimpArgument *
palette_get_columns_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gint32 num_columns = 0;
@ -769,12 +769,12 @@ static GimpProcedure palette_get_columns_proc =
{ { palette_get_columns_invoker } }
};
static Argument *
static GimpArgument *
palette_set_columns_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *name;
@ -813,15 +813,15 @@ static GimpProcedure palette_set_columns_proc =
{ { palette_set_columns_invoker } }
};
static Argument *
static GimpArgument *
palette_add_entry_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gchar *entry_name;
GimpRGB color;
@ -871,12 +871,12 @@ static GimpProcedure palette_add_entry_proc =
{ { palette_add_entry_invoker } }
};
static Argument *
static GimpArgument *
palette_delete_entry_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *name;
@ -924,15 +924,15 @@ static GimpProcedure palette_delete_entry_proc =
{ { palette_delete_entry_invoker } }
};
static Argument *
static GimpArgument *
palette_entry_get_color_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gint32 entry_num;
GimpRGB color = { 0.0, 0.0, 0.0, 1.0 };
@ -984,12 +984,12 @@ static GimpProcedure palette_entry_get_color_proc =
{ { palette_entry_get_color_invoker } }
};
static Argument *
static GimpArgument *
palette_entry_set_color_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *name;
@ -1041,15 +1041,15 @@ static GimpProcedure palette_entry_set_color_proc =
{ { palette_entry_set_color_invoker } }
};
static Argument *
static GimpArgument *
palette_entry_get_name_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gint32 entry_num;
gchar *entry_name = NULL;
@ -1101,12 +1101,12 @@ static GimpProcedure palette_entry_get_name_proc =
{ { palette_entry_get_name_invoker } }
};
static Argument *
static GimpArgument *
palette_entry_set_name_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *name;

12
app/pdb/palette_select_cmds.c
View File

@ -109,12 +109,12 @@ register_palette_select_procs (Gimp *gimp)
}
static Argument *
static GimpArgument *
palettes_popup_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *palette_callback;
@ -154,12 +154,12 @@ static GimpProcedure palettes_popup_proc =
{ { palettes_popup_invoker } }
};
static Argument *
static GimpArgument *
palettes_close_popup_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *palette_callback;
@ -194,12 +194,12 @@ static GimpProcedure palettes_close_popup_proc =
{ { palettes_close_popup_invoker } }
};
static Argument *
static GimpArgument *
palettes_set_popup_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *palette_callback;

22
app/pdb/palettes_cmds.c
View File

@ -148,12 +148,12 @@ register_palettes_procs (Gimp *gimp)
}
static Argument *
static GimpArgument *
palettes_refresh_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gimp_data_factory_data_refresh (gimp->palette_factory);
return gimp_procedure_get_return_values (procedure, TRUE);
@ -175,15 +175,15 @@ static GimpProcedure palettes_refresh_proc =
{ { palettes_refresh_invoker } }
};
static Argument *
static GimpArgument *
palettes_get_list_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *filter;
gint32 num_palettes = 0;
gchar **palette_list = NULL;
@ -223,15 +223,15 @@ static GimpProcedure palettes_get_list_proc =
{ { palettes_get_list_invoker } }
};
static Argument *
static GimpArgument *
palettes_get_palette_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name = NULL;
gint32 num_colors = 0;
@ -272,15 +272,15 @@ static GimpProcedure palettes_get_palette_proc =
{ { palettes_get_palette_invoker } }
};
static Argument *
static GimpArgument *
palettes_get_palette_entry_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gint32 entry_num;
gchar *actual_name = NULL;

80
app/pdb/parasite_cmds.c
View File

@ -412,15 +412,15 @@ register_parasite_procs (Gimp *gimp)
}
static Argument *
static GimpArgument *
parasite_find_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
GimpParasite *parasite = NULL;
@ -458,12 +458,12 @@ static GimpProcedure parasite_find_proc =
{ { parasite_find_invoker } }
};
static Argument *
static GimpArgument *
parasite_attach_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpParasite *parasite;
@ -494,12 +494,12 @@ static GimpProcedure parasite_attach_proc =
{ { parasite_attach_invoker } }
};
static Argument *
static GimpArgument *
parasite_detach_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *name;
@ -530,14 +530,14 @@ static GimpProcedure parasite_detach_proc =
{ { parasite_detach_invoker } }
};
static Argument *
static GimpArgument *
parasite_list_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
Argument *return_vals;
GimpArgument *return_vals;
gint32 num_parasites = 0;
gchar **parasites = NULL;
@ -567,15 +567,15 @@ static GimpProcedure parasite_list_proc =
{ { parasite_list_invoker } }
};
static Argument *
static GimpArgument *
image_parasite_find_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpImage *image;
gchar *name;
GimpParasite *parasite = NULL;
@ -615,12 +615,12 @@ static GimpProcedure image_parasite_find_proc =
{ { image_parasite_find_invoker } }
};
static Argument *
static GimpArgument *
image_parasite_attach_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpImage *image;
@ -653,12 +653,12 @@ static GimpProcedure image_parasite_attach_proc =
{ { image_parasite_attach_invoker } }
};
static Argument *
static GimpArgument *
image_parasite_detach_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpImage *image;
@ -691,15 +691,15 @@ static GimpProcedure image_parasite_detach_proc =
{ { image_parasite_detach_invoker } }
};
static Argument *
static GimpArgument *
image_parasite_list_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpImage *image;
gint32 num_parasites = 0;
gchar **parasites = NULL;
@ -738,15 +738,15 @@ static GimpProcedure image_parasite_list_proc =
{ { image_parasite_list_invoker } }
};
static Argument *
static GimpArgument *
drawable_parasite_find_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gchar *name;
GimpParasite *parasite = NULL;
@ -787,12 +787,12 @@ static GimpProcedure drawable_parasite_find_proc =
{ { drawable_parasite_find_invoker } }
};
static Argument *
static GimpArgument *
drawable_parasite_attach_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -825,12 +825,12 @@ static GimpProcedure drawable_parasite_attach_proc =
{ { drawable_parasite_attach_invoker } }
};
static Argument *
static GimpArgument *
drawable_parasite_detach_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -863,15 +863,15 @@ static GimpProcedure drawable_parasite_detach_proc =
{ { drawable_parasite_detach_invoker } }
};
static Argument *
static GimpArgument *
drawable_parasite_list_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gint32 num_parasites = 0;
gchar **parasites = NULL;
@ -910,15 +910,15 @@ static GimpProcedure drawable_parasite_list_proc =
{ { drawable_parasite_list_invoker } }
};
static Argument *
static GimpArgument *
vectors_parasite_find_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpVectors *vectors;
gchar *name;
GimpParasite *parasite = NULL;
@ -959,12 +959,12 @@ static GimpProcedure vectors_parasite_find_proc =
{ { vectors_parasite_find_invoker } }
};
static Argument *
static GimpArgument *
vectors_parasite_attach_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpVectors *vectors;
@ -997,12 +997,12 @@ static GimpProcedure vectors_parasite_attach_proc =
{ { vectors_parasite_attach_invoker } }
};
static Argument *
static GimpArgument *
vectors_parasite_detach_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpVectors *vectors;
@ -1035,15 +1035,15 @@ static GimpProcedure vectors_parasite_detach_proc =
{ { vectors_parasite_detach_invoker } }
};
static Argument *
static GimpArgument *
vectors_parasite_list_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpVectors *vectors;
gint32 num_parasites = 0;
gchar **parasites = NULL;

78
app/pdb/paths_cmds.c
View File

@ -572,15 +572,15 @@ register_paths_procs (Gimp *gimp)
}
static Argument *
static GimpArgument *
path_list_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpImage *image;
gint32 num_paths = 0;
gchar **path_list = NULL;
@ -619,15 +619,15 @@ static GimpProcedure path_list_proc =
{ { path_list_invoker } }
};
static Argument *
static GimpArgument *
path_get_current_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpImage *image;
gchar *name = NULL;
@ -667,12 +667,12 @@ static GimpProcedure path_get_current_proc =
{ { path_get_current_invoker } }
};
static Argument *
static GimpArgument *
path_set_current_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpImage *image;
@ -710,12 +710,12 @@ static GimpProcedure path_set_current_proc =
{ { path_set_current_invoker } }
};
static Argument *
static GimpArgument *
path_delete_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpImage *image;
@ -753,15 +753,15 @@ static GimpProcedure path_delete_proc =
{ { path_delete_invoker } }
};
static Argument *
static GimpArgument *
path_get_points_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpImage *image;
gchar *name;
gint32 path_type = 0;
@ -842,12 +842,12 @@ static GimpProcedure path_get_points_proc =
{ { path_get_points_invoker } }
};
static Argument *
static GimpArgument *
path_set_points_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpImage *image;
@ -923,12 +923,12 @@ static GimpProcedure path_set_points_proc =
{ { path_set_points_invoker } }
};
static Argument *
static GimpArgument *
path_stroke_current_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpImage *image;
@ -974,15 +974,15 @@ static GimpProcedure path_stroke_current_proc =
{ { path_stroke_current_invoker } }
};
static Argument *
static GimpArgument *
path_get_point_at_dist_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpImage *image;
gdouble distance;
gint32 x_point = 0;
@ -1073,15 +1073,15 @@ static GimpProcedure path_get_point_at_dist_proc =
{ { path_get_point_at_dist_invoker } }
};
static Argument *
static GimpArgument *
path_get_tattoo_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpImage *image;
gchar *name;
gint32 tattoo = 0;
@ -1123,12 +1123,12 @@ static GimpProcedure path_get_tattoo_proc =
{ { path_get_tattoo_invoker } }
};
static Argument *
static GimpArgument *
path_set_tattoo_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpImage *image;
@ -1168,15 +1168,15 @@ static GimpProcedure path_set_tattoo_proc =
{ { path_set_tattoo_invoker } }
};
static Argument *
static GimpArgument *
get_path_by_tattoo_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpImage *image;
gint32 tattoo;
gchar *name = NULL;
@ -1218,15 +1218,15 @@ static GimpProcedure get_path_by_tattoo_proc =
{ { get_path_by_tattoo_invoker } }
};
static Argument *
static GimpArgument *
path_get_locked_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpImage *image;
gchar *name;
gboolean locked = FALSE;
@ -1268,12 +1268,12 @@ static GimpProcedure path_get_locked_proc =
{ { path_get_locked_invoker } }
};
static Argument *
static GimpArgument *
path_set_locked_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpImage *image;
@ -1313,12 +1313,12 @@ static GimpProcedure path_set_locked_proc =
{ { path_set_locked_invoker } }
};
static Argument *
static GimpArgument *
path_to_selection_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpImage *image;
@ -1373,12 +1373,12 @@ static GimpProcedure path_to_selection_proc =
{ { path_to_selection_invoker } }
};
static Argument *
static GimpArgument *
path_import_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpImage *image;
@ -1415,12 +1415,12 @@ static GimpProcedure path_import_proc =
{ { path_import_invoker } }
};
static Argument *
static GimpArgument *
path_import_string_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpImage *image;

12
app/pdb/pattern_cmds.c
View File

@ -130,15 +130,15 @@ register_pattern_procs (Gimp *gimp)
}
static Argument *
static GimpArgument *
pattern_get_info_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gint32 width = 0;
gint32 height = 0;
@ -189,15 +189,15 @@ static GimpProcedure pattern_get_info_proc =
{ { pattern_get_info_invoker } }
};
static Argument *
static GimpArgument *
pattern_get_pixels_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gint32 width = 0;
gint32 height = 0;

12
app/pdb/pattern_select_cmds.c
View File

@ -109,12 +109,12 @@ register_pattern_select_procs (Gimp *gimp)
}
static Argument *
static GimpArgument *
patterns_popup_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *pattern_callback;
@ -154,12 +154,12 @@ static GimpProcedure patterns_popup_proc =
{ { patterns_popup_invoker } }
};
static Argument *
static GimpArgument *
patterns_close_popup_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *pattern_callback;
@ -194,12 +194,12 @@ static GimpProcedure patterns_close_popup_proc =
{ { patterns_close_popup_invoker } }
};
static Argument *
static GimpArgument *
patterns_set_popup_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *pattern_callback;

22
app/pdb/patterns_cmds.c
View File

@ -167,12 +167,12 @@ register_patterns_procs (Gimp *gimp)
}
static Argument *
static GimpArgument *
patterns_refresh_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gimp_data_factory_data_refresh (gimp->pattern_factory);
return gimp_procedure_get_return_values (procedure, TRUE);
@ -194,15 +194,15 @@ static GimpProcedure patterns_refresh_proc =
{ { patterns_refresh_invoker } }
};
static Argument *
static GimpArgument *
patterns_get_list_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *filter;
gint32 num_patterns = 0;
gchar **pattern_list = NULL;
@ -242,15 +242,15 @@ static GimpProcedure patterns_get_list_proc =
{ { patterns_get_list_invoker } }
};
static Argument *
static GimpArgument *
patterns_get_pattern_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name = NULL;
gint32 width = 0;
gint32 height = 0;
@ -294,15 +294,15 @@ static GimpProcedure patterns_get_pattern_proc =
{ { patterns_get_pattern_invoker } }
};
static Argument *
static GimpArgument *
patterns_get_pattern_data_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gchar *actual_name = NULL;
gint32 width = 0;

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

@ -23,9 +23,9 @@
#include "core/core-types.h"
typedef struct _Argument Argument;
typedef struct _ProcArg ProcArg;
typedef struct _GimpProcedure GimpProcedure;
typedef struct _GimpArgument GimpArgument;
typedef struct _GimpArgumentSpec GimpArgumentSpec;
typedef struct _GimpProcedure GimpProcedure;
typedef enum

26
app/pdb/plug_in_cmds.c
View File

@ -271,14 +271,14 @@ register_plug_in_procs (Gimp *gimp)
}
static Argument *
static GimpArgument *
plugins_query_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
Argument *return_vals;
GimpArgument *return_vals;
gchar *search_string;
gint32 num_plugins = 0;
gchar **menu_path = NULL;
@ -332,12 +332,12 @@ static GimpProcedure plugins_query_proc =
{ { plugins_query_invoker } }
};
static Argument *
static GimpArgument *
plugin_domain_register_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *domain_name;
@ -378,12 +378,12 @@ static GimpProcedure plugin_domain_register_proc =
{ { plugin_domain_register_invoker } }
};
static Argument *
static GimpArgument *
plugin_help_register_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *domain_name;
@ -424,12 +424,12 @@ static GimpProcedure plugin_help_register_proc =
{ { plugin_help_register_invoker } }
};
static Argument *
static GimpArgument *
plugin_menu_register_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *procedure_name;
@ -473,12 +473,12 @@ static GimpProcedure plugin_menu_register_proc =
{ { plugin_menu_register_invoker } }
};
static Argument *
static GimpArgument *
plugin_menu_branch_register_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *menu_path;
@ -525,12 +525,12 @@ static GimpProcedure plugin_menu_branch_register_proc =
{ { plugin_menu_branch_register_invoker } }
};
static Argument *
static GimpArgument *
plugin_icon_register_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *procedure_name;

4
app/pdb/procedural-db-query.c
View File

@ -404,7 +404,7 @@ procedural_db_print_entry (gpointer key,
fprintf (file, "( ");
for (i = 0; i < procedure->num_args; i++)
{
ProcArg *arg = &procedure->args[i];
GimpArgumentSpec *arg = &procedure->args[i];
fprintf (file, "( ");
@ -421,7 +421,7 @@ procedural_db_print_entry (gpointer key,
fprintf (file, "( ");
for (i = 0; i < procedure->num_values; i++)
{
ProcArg *arg = &procedure->values[i];
GimpArgumentSpec *arg = &procedure->values[i];
fprintf (file, "( ");

58
app/pdb/procedural_db.c
View File

@ -235,17 +235,17 @@ procedural_db_lookup (Gimp *gimp,
return NULL;
}
Argument *
GimpArgument *
procedural_db_execute (Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const gchar *name,
Argument *args,
GimpArgument *args,
gint n_args,
gint *n_return_vals)
{
Argument *return_vals = NULL;
GList *list;
GimpArgument *return_vals = NULL;
GList *list;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
@ -299,7 +299,7 @@ procedural_db_execute (Gimp *gimp,
return return_vals;
}
Argument *
GimpArgument *
procedural_db_run_proc (Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
@ -308,9 +308,9 @@ procedural_db_run_proc (Gimp *gimp,
...)
{
GimpProcedure *procedure;
Argument *params;
Argument *return_vals;
va_list args;
GimpArgument *args;
GimpArgument *return_vals;
va_list va_args;
gint i;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
@ -335,24 +335,24 @@ procedural_db_run_proc (Gimp *gimp,
*n_return_vals = procedure->num_values + 1;
params = gimp_procedure_get_arguments (procedure);
args = gimp_procedure_get_arguments (procedure);
va_start (args, n_return_vals);
va_start (va_args, n_return_vals);
for (i = 0; i < procedure->num_args; i++)
{
GimpPDBArgType arg_type = va_arg (args, GimpPDBArgType);
GimpPDBArgType arg_type = va_arg (va_args, GimpPDBArgType);
GValue *value;
if (arg_type == GIMP_PDB_END)
break;
if (arg_type != params[i].type)
if (arg_type != args[i].type)
{
gchar *expected = procedural_db_type_name (procedure->args[i].type);
gchar *got = procedural_db_type_name (arg_type);
gimp_arguments_destroy (params, procedure->num_args, TRUE);
gimp_arguments_destroy (args, procedure->num_args, TRUE);
g_message (_("PDB calling error for procedure '%s':\n"
"Argument #%d type mismatch (expected %s, got %s)"),
@ -367,35 +367,35 @@ procedural_db_run_proc (Gimp *gimp,
return return_vals;
}
value = &params[i].value;
value = &args[i].value;
switch (arg_type)
{
case GIMP_PDB_INT32:
if (G_VALUE_HOLDS_INT (value))
g_value_set_int (value, va_arg (args, gint));
g_value_set_int (value, va_arg (va_args, gint));
else if (G_VALUE_HOLDS_ENUM (value))
g_value_set_enum (value, va_arg (args, gint));
g_value_set_enum (value, va_arg (va_args, gint));
else if (G_VALUE_HOLDS_BOOLEAN (value))
g_value_set_boolean (value, va_arg (args, gint) ? TRUE : FALSE);
g_value_set_boolean (value, va_arg (va_args, gint) ? TRUE : FALSE);
else
g_return_val_if_reached (NULL);
break;
case GIMP_PDB_INT16:
g_value_set_int (value, va_arg (args, gint));
g_value_set_int (value, va_arg (va_args, gint));
break;
case GIMP_PDB_INT8:
g_value_set_uint (value, va_arg (args, guint));
g_value_set_uint (value, va_arg (va_args, guint));
break;
case GIMP_PDB_FLOAT:
g_value_set_double (value, va_arg (args, gdouble));
g_value_set_double (value, va_arg (va_args, gdouble));
break;
case GIMP_PDB_STRING:
g_value_set_static_string (value, va_arg (args, gchar *));
g_value_set_static_string (value, va_arg (va_args, gchar *));
break;
case GIMP_PDB_INT32ARRAY:
@ -403,12 +403,12 @@ procedural_db_run_proc (Gimp *gimp,
case GIMP_PDB_INT8ARRAY:
case GIMP_PDB_FLOATARRAY:
case GIMP_PDB_STRINGARRAY:
g_value_set_pointer (value, va_arg (args, gpointer));
g_value_set_pointer (value, va_arg (va_args, gpointer));
break;
case GIMP_PDB_COLOR:
{
GimpRGB color = va_arg (args, GimpRGB);
GimpRGB color = va_arg (va_args, GimpRGB);
g_value_set_boxed (value, &color);
}
break;
@ -424,28 +424,28 @@ procedural_db_run_proc (Gimp *gimp,
case GIMP_PDB_DRAWABLE:
case GIMP_PDB_SELECTION:
case GIMP_PDB_VECTORS:
g_value_set_int (value, va_arg (args, gint));
g_value_set_int (value, va_arg (va_args, gint));
break;
case GIMP_PDB_PARASITE:
g_value_set_static_boxed (value, va_arg (args, gpointer));
g_value_set_static_boxed (value, va_arg (va_args, gpointer));
break;
case GIMP_PDB_STATUS:
g_value_set_enum (value, va_arg (args, gint));
g_value_set_enum (value, va_arg (va_args, gint));
case GIMP_PDB_END:
break;
}
}
va_end (args);
va_end (va_args);
return_vals = procedural_db_execute (gimp, context, progress, name,
params, procedure->num_args,
args, procedure->num_args,
n_return_vals);
gimp_arguments_destroy (params, procedure->num_args, FALSE);
gimp_arguments_destroy (args, procedure->num_args, FALSE);
return return_vals;
}

6
app/pdb/procedural_db.h
View File

@ -32,14 +32,14 @@ void procedural_db_unregister (Gimp *gimp,
GimpProcedure * procedural_db_lookup (Gimp *gimp,
const gchar *name);
Argument * procedural_db_execute (Gimp *gimp,
GimpArgument * procedural_db_execute (Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const gchar *name,
Argument *args,
GimpArgument *args,
gint n_args,
gint *n_return_vals);
Argument * procedural_db_run_proc (Gimp *gimp,
GimpArgument * procedural_db_run_proc (Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const gchar *name,

54
app/pdb/procedural_db_cmds.c
View File

@ -400,14 +400,14 @@ register_procedural_db_procs (Gimp *gimp)
}
static Argument *
static GimpArgument *
procedural_db_temp_name_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
Argument *return_vals;
GimpArgument *return_vals;
gchar *temp_name = NULL;
static gint proc_number = 0;
@ -436,12 +436,12 @@ static GimpProcedure procedural_db_temp_name_proc =
{ { procedural_db_temp_name_invoker } }
};
static Argument *
static GimpArgument *
procedural_db_dump_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *filename;
@ -472,15 +472,15 @@ static GimpProcedure procedural_db_dump_proc =
{ { procedural_db_dump_invoker } }
};
static Argument *
static GimpArgument *
procedural_db_query_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *name;
gchar *blurb;
gchar *help;
@ -534,15 +534,15 @@ static GimpProcedure procedural_db_query_proc =
{ { procedural_db_query_invoker } }
};
static Argument *
static GimpArgument *
procedural_db_proc_info_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *procedure_name;
gchar *blurb = NULL;
gchar *help = NULL;
@ -604,15 +604,15 @@ static GimpProcedure procedural_db_proc_info_proc =
{ { procedural_db_proc_info_invoker } }
};
static Argument *
static GimpArgument *
procedural_db_proc_arg_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *procedure_name;
gint32 arg_num;
gint32 arg_type = 0;
@ -645,7 +645,7 @@ procedural_db_proc_arg_invoker (GimpProcedure *procedure,
if (proc && (arg_num >= 0 && arg_num < proc->num_args))
{
ProcArg *arg = &proc->args[arg_num];
GimpArgumentSpec *arg = &proc->args[arg_num];
arg_type = arg->type;
arg_name = g_strdup (g_param_spec_get_name (arg->pspec));
@ -683,15 +683,15 @@ static GimpProcedure procedural_db_proc_arg_proc =
{ { procedural_db_proc_arg_invoker } }
};
static Argument *
static GimpArgument *
procedural_db_proc_val_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *procedure_name;
gint32 val_num;
gint32 val_type = 0;
@ -724,7 +724,7 @@ procedural_db_proc_val_invoker (GimpProcedure *procedure,
if (proc && (val_num >= 0 && val_num < proc->num_values))
{
ProcArg *val = &proc->values[val_num];
GimpArgumentSpec *val = &proc->values[val_num];
val_type = val->type;
val_name = g_strdup (g_param_spec_get_name (val->pspec));
@ -762,15 +762,15 @@ static GimpProcedure procedural_db_proc_val_proc =
{ { procedural_db_proc_val_invoker } }
};
static Argument *
static GimpArgument *
procedural_db_get_data_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *identifier;
gint32 bytes = 0;
guint8 *data = NULL;
@ -821,15 +821,15 @@ static GimpProcedure procedural_db_get_data_proc =
{ { procedural_db_get_data_invoker } }
};
static Argument *
static GimpArgument *
procedural_db_get_data_size_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *identifier;
gint32 bytes = 0;
@ -875,12 +875,12 @@ static GimpProcedure procedural_db_get_data_size_proc =
{ { procedural_db_get_data_size_invoker } }
};
static Argument *
static GimpArgument *
procedural_db_set_data_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *identifier;

34
app/pdb/progress_cmds.c
View File

@ -158,12 +158,12 @@ register_progress_procs (Gimp *gimp)
}
static Argument *
static GimpArgument *
progress_init_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *message;
@ -202,12 +202,12 @@ static GimpProcedure progress_init_proc =
{ { progress_init_invoker } }
};
static Argument *
static GimpArgument *
progress_update_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gdouble percentage;
@ -244,12 +244,12 @@ static GimpProcedure progress_update_proc =
{ { progress_update_invoker } }
};
static Argument *
static GimpArgument *
progress_pulse_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
if (gimp->current_plug_in && gimp->current_plug_in->open)
@ -278,12 +278,12 @@ static GimpProcedure progress_pulse_proc =
{ { progress_pulse_invoker } }
};
static Argument *
static GimpArgument *
progress_set_text_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *message;
@ -320,15 +320,15 @@ static GimpProcedure progress_set_text_proc =
{ { progress_set_text_invoker } }
};
static Argument *
static GimpArgument *
progress_get_window_handle_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gint32 window = 0;
if (gimp->current_plug_in && gimp->current_plug_in->open)
@ -363,12 +363,12 @@ static GimpProcedure progress_get_window_handle_proc =
{ { progress_get_window_handle_invoker } }
};
static Argument *
static GimpArgument *
progress_install_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *progress_callback;
@ -403,12 +403,12 @@ static GimpProcedure progress_install_proc =
{ { progress_install_invoker } }
};
static Argument *
static GimpArgument *
progress_uninstall_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *progress_callback;
@ -443,12 +443,12 @@ static GimpProcedure progress_uninstall_proc =
{ { progress_uninstall_invoker } }
};
static Argument *
static GimpArgument *
progress_cancel_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
gchar *progress_callback;

78
app/pdb/selection_cmds.c
View File

@ -431,15 +431,15 @@ register_selection_procs (Gimp *gimp)
}
static Argument *
static GimpArgument *
selection_bounds_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpImage *image;
gboolean non_empty = FALSE;
gint32 x1 = 0;
@ -485,15 +485,15 @@ static GimpProcedure selection_bounds_proc =
{ { selection_bounds_invoker } }
};
static Argument *
static GimpArgument *
selection_value_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpImage *image;
gint32 x;
gint32 y;
@ -532,15 +532,15 @@ static GimpProcedure selection_value_proc =
{ { selection_value_invoker } }
};
static Argument *
static GimpArgument *
selection_is_empty_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpImage *image;
gboolean is_empty = FALSE;
@ -575,12 +575,12 @@ static GimpProcedure selection_is_empty_proc =
{ { selection_is_empty_invoker } }
};
static Argument *
static GimpArgument *
selection_translate_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpImage *image;
@ -616,15 +616,15 @@ static GimpProcedure selection_translate_proc =
{ { selection_translate_invoker } }
};
static Argument *
static GimpArgument *
selection_float_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gint32 offx;
gint32 offy;
@ -673,12 +673,12 @@ static GimpProcedure selection_float_proc =
{ { selection_float_invoker } }
};
static Argument *
static GimpArgument *
selection_invert_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpImage *image;
@ -709,12 +709,12 @@ static GimpProcedure selection_invert_proc =
{ { selection_invert_invoker } }
};
static Argument *
static GimpArgument *
selection_sharpen_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpImage *image;
@ -745,12 +745,12 @@ static GimpProcedure selection_sharpen_proc =
{ { selection_sharpen_invoker } }
};
static Argument *
static GimpArgument *
selection_all_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpImage *image;
@ -781,12 +781,12 @@ static GimpProcedure selection_all_proc =
{ { selection_all_invoker } }
};
static Argument *
static GimpArgument *
selection_none_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpImage *image;
@ -817,12 +817,12 @@ static GimpProcedure selection_none_proc =
{ { selection_none_invoker } }
};
static Argument *
static GimpArgument *
selection_feather_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpImage *image;
@ -856,12 +856,12 @@ static GimpProcedure selection_feather_proc =
{ { selection_feather_invoker } }
};
static Argument *
static GimpArgument *
selection_border_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpImage *image;
@ -895,12 +895,12 @@ static GimpProcedure selection_border_proc =
{ { selection_border_invoker } }
};
static Argument *
static GimpArgument *
selection_grow_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpImage *image;
@ -934,12 +934,12 @@ static GimpProcedure selection_grow_proc =
{ { selection_grow_invoker } }
};
static Argument *
static GimpArgument *
selection_shrink_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpImage *image;
@ -973,12 +973,12 @@ static GimpProcedure selection_shrink_proc =
{ { selection_shrink_invoker } }
};
static Argument *
static GimpArgument *
selection_layer_alpha_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpLayer *layer;
@ -1013,12 +1013,12 @@ static GimpProcedure selection_layer_alpha_proc =
{ { selection_layer_alpha_invoker } }
};
static Argument *
static GimpArgument *
selection_load_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpChannel *channel;
@ -1060,15 +1060,15 @@ static GimpProcedure selection_load_proc =
{ { selection_load_invoker } }
};
static Argument *
static GimpArgument *
selection_save_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpImage *image;
GimpChannel *channel = NULL;
@ -1106,12 +1106,12 @@ static GimpProcedure selection_save_proc =
{ { selection_save_invoker } }
};
static Argument *
static GimpArgument *
selection_combine_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpChannel *channel;

20
app/pdb/selection_tools_cmds.c
View File

@ -372,12 +372,12 @@ register_selection_tools_procs (Gimp *gimp)
}
static Argument *
static GimpArgument *
by_color_select_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -433,12 +433,12 @@ static GimpProcedure by_color_select_proc =
{ { by_color_select_invoker } }
};
static Argument *
static GimpArgument *
ellipse_select_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpImage *image;
@ -492,12 +492,12 @@ static GimpProcedure ellipse_select_proc =
{ { ellipse_select_invoker } }
};
static Argument *
static GimpArgument *
free_select_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpImage *image;
@ -548,12 +548,12 @@ static GimpProcedure free_select_proc =
{ { free_select_invoker } }
};
static Argument *
static GimpArgument *
fuzzy_select_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
@ -613,12 +613,12 @@ static GimpProcedure fuzzy_select_proc =
{ { fuzzy_select_invoker } }
};
static Argument *
static GimpArgument *
rect_select_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpImage *image;

24
app/pdb/text_tool_cmds.c
View File

@ -466,15 +466,15 @@ register_text_tool_procs (Gimp *gimp)
}
static Argument *
static GimpArgument *
text_fontname_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpImage *image;
GimpDrawable *drawable;
gdouble x;
@ -539,15 +539,15 @@ static GimpProcedure text_fontname_proc =
{ { text_fontname_invoker } }
};
static Argument *
static GimpArgument *
text_get_extents_fontname_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *text;
gdouble size;
gint32 size_type;
@ -602,15 +602,15 @@ static GimpProcedure text_get_extents_fontname_proc =
{ { text_get_extents_fontname_invoker } }
};
static Argument *
static GimpArgument *
text_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpImage *image;
GimpDrawable *drawable;
gdouble x;
@ -689,15 +689,15 @@ static GimpProcedure text_proc =
{ { text_invoker } }
};
static Argument *
static GimpArgument *
text_get_extents_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *text;
gdouble size;
gint32 size_type;

36
app/pdb/transform_tools_cmds.c
View File

@ -388,15 +388,15 @@ register_transform_tools_procs (Gimp *gimp)
}
static Argument *
static GimpArgument *
flip_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gint32 flip_type;
@ -441,15 +441,15 @@ static GimpProcedure flip_proc =
{ { flip_invoker } }
};
static Argument *
static GimpArgument *
perspective_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gboolean interpolation;
gdouble x0;
@ -535,15 +535,15 @@ static GimpProcedure perspective_proc =
{ { perspective_invoker } }
};
static Argument *
static GimpArgument *
rotate_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gboolean interpolation;
gdouble angle;
@ -611,15 +611,15 @@ static GimpProcedure rotate_proc =
{ { rotate_invoker } }
};
static Argument *
static GimpArgument *
scale_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gboolean interpolation;
gdouble x0;
@ -697,15 +697,15 @@ static GimpProcedure scale_proc =
{ { scale_invoker } }
};
static Argument *
static GimpArgument *
shear_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gboolean interpolation;
gint32 shear_type;
@ -776,15 +776,15 @@ static GimpProcedure shear_proc =
{ { shear_invoker } }
};
static Argument *
static GimpArgument *
transform_2d_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpDrawable *drawable;
gboolean interpolation;
gdouble source_x;

38
app/pdb/undo_cmds.c
View File

@ -175,12 +175,12 @@ register_undo_procs (Gimp *gimp)
}
static Argument *
static GimpArgument *
image_undo_group_start_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpImage *image;
@ -219,12 +219,12 @@ static GimpProcedure image_undo_group_start_proc =
{ { image_undo_group_start_invoker } }
};
static Argument *
static GimpArgument *
image_undo_group_end_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpImage *image;
@ -255,15 +255,15 @@ static GimpProcedure image_undo_group_end_proc =
{ { image_undo_group_end_invoker } }
};
static Argument *
static GimpArgument *
image_undo_is_enabled_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpImage *image;
gboolean enabled = FALSE;
@ -298,15 +298,15 @@ static GimpProcedure image_undo_is_enabled_proc =
{ { image_undo_is_enabled_invoker } }
};
static Argument *
static GimpArgument *
image_undo_disable_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpImage *image;
gboolean disabled = FALSE;
@ -341,15 +341,15 @@ static GimpProcedure image_undo_disable_proc =
{ { image_undo_disable_invoker } }
};
static Argument *
static GimpArgument *
image_undo_enable_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpImage *image;
gboolean enabled = FALSE;
@ -384,15 +384,15 @@ static GimpProcedure image_undo_enable_proc =
{ { image_undo_enable_invoker } }
};
static Argument *
static GimpArgument *
image_undo_freeze_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpImage *image;
gboolean frozen = FALSE;
@ -427,15 +427,15 @@ static GimpProcedure image_undo_freeze_proc =
{ { image_undo_freeze_invoker } }
};
static Argument *
static GimpArgument *
image_undo_thaw_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpImage *image;
gboolean thawed = FALSE;

70
app/pdb/unit_cmds.c
View File

@ -351,14 +351,14 @@ register_unit_procs (Gimp *gimp)
}
static Argument *
static GimpArgument *
unit_get_number_of_units_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
Argument *return_vals;
GimpArgument *return_vals;
gint32 num_units = 0;
num_units = _gimp_unit_get_number_of_units (gimp);
@ -385,14 +385,14 @@ static GimpProcedure unit_get_number_of_units_proc =
{ { unit_get_number_of_units_invoker } }
};
static Argument *
static GimpArgument *
unit_get_number_of_built_in_units_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
Argument *return_vals;
GimpArgument *return_vals;
gint32 num_units = 0;
num_units = _gimp_unit_get_number_of_built_in_units (gimp);
@ -419,15 +419,15 @@ static GimpProcedure unit_get_number_of_built_in_units_proc =
{ { unit_get_number_of_built_in_units_invoker } }
};
static Argument *
static GimpArgument *
unit_new_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
gchar *identifier;
gdouble factor;
gint32 digits;
@ -475,15 +475,15 @@ static GimpProcedure unit_new_proc =
{ { unit_new_invoker } }
};
static Argument *
static GimpArgument *
unit_get_deletion_flag_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpUnit unit_id;
gboolean deletion_flag = FALSE;
@ -518,12 +518,12 @@ static GimpProcedure unit_get_deletion_flag_proc =
{ { unit_get_deletion_flag_invoker } }
};
static Argument *
static GimpArgument *
unit_set_deletion_flag_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpUnit unit_id;
@ -556,15 +556,15 @@ static GimpProcedure unit_set_deletion_flag_proc =
{ { unit_set_deletion_flag_invoker } }
};
static Argument *
static GimpArgument *
unit_get_identifier_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpUnit unit_id;
gchar *identifier = NULL;
@ -599,15 +599,15 @@ static GimpProcedure unit_get_identifier_proc =
{ { unit_get_identifier_invoker } }
};
static Argument *
static GimpArgument *
unit_get_factor_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpUnit unit_id;
gdouble factor = 0.0;
@ -642,15 +642,15 @@ static GimpProcedure unit_get_factor_proc =
{ { unit_get_factor_invoker } }
};
static Argument *
static GimpArgument *
unit_get_digits_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpUnit unit_id;
gint32 digits = 0;
@ -685,15 +685,15 @@ static GimpProcedure unit_get_digits_proc =
{ { unit_get_digits_invoker } }
};
static Argument *
static GimpArgument *
unit_get_symbol_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpUnit unit_id;
gchar *symbol = NULL;
@ -728,15 +728,15 @@ static GimpProcedure unit_get_symbol_proc =
{ { unit_get_symbol_invoker } }
};
static Argument *
static GimpArgument *
unit_get_abbreviation_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpUnit unit_id;
gchar *abbreviation = NULL;
@ -771,15 +771,15 @@ static GimpProcedure unit_get_abbreviation_proc =
{ { unit_get_abbreviation_invoker } }
};
static Argument *
static GimpArgument *
unit_get_singular_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpUnit unit_id;
gchar *singular = NULL;
@ -814,15 +814,15 @@ static GimpProcedure unit_get_singular_proc =
{ { unit_get_singular_invoker } }
};
static Argument *
static GimpArgument *
unit_get_plural_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpUnit unit_id;
gchar *plural = NULL;

116
app/pdb/vectors_cmds.c
View File

@ -812,15 +812,15 @@ register_vectors_procs (Gimp *gimp)
}
static Argument *
static GimpArgument *
vectors_new_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpImage *image;
gchar *name;
GimpVectors *vectors = NULL;
@ -857,15 +857,15 @@ static GimpProcedure vectors_new_proc =
{ { vectors_new_invoker } }
};
static Argument *
static GimpArgument *
vectors_get_image_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpVectors *vectors;
GimpImage *image = NULL;
@ -900,15 +900,15 @@ static GimpProcedure vectors_get_image_proc =
{ { vectors_get_image_invoker } }
};
static Argument *
static GimpArgument *
vectors_get_name_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpVectors *vectors;
gchar *name = NULL;
@ -943,12 +943,12 @@ static GimpProcedure vectors_get_name_proc =
{ { vectors_get_name_invoker } }
};
static Argument *
static GimpArgument *
vectors_set_name_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpVectors *vectors;
@ -981,15 +981,15 @@ static GimpProcedure vectors_set_name_proc =
{ { vectors_set_name_invoker } }
};
static Argument *
static GimpArgument *
vectors_get_visible_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpVectors *vectors;
gboolean visible = FALSE;
@ -1024,12 +1024,12 @@ static GimpProcedure vectors_get_visible_proc =
{ { vectors_get_visible_invoker } }
};
static Argument *
static GimpArgument *
vectors_set_visible_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpVectors *vectors;
@ -1062,15 +1062,15 @@ static GimpProcedure vectors_set_visible_proc =
{ { vectors_set_visible_invoker } }
};
static Argument *
static GimpArgument *
vectors_get_linked_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpVectors *vectors;
gboolean linked = FALSE;
@ -1105,12 +1105,12 @@ static GimpProcedure vectors_get_linked_proc =
{ { vectors_get_linked_invoker } }
};
static Argument *
static GimpArgument *
vectors_set_linked_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpVectors *vectors;
@ -1143,15 +1143,15 @@ static GimpProcedure vectors_set_linked_proc =
{ { vectors_set_linked_invoker } }
};
static Argument *
static GimpArgument *
vectors_get_tattoo_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpVectors *vectors;
gint32 tattoo = 0;
@ -1186,12 +1186,12 @@ static GimpProcedure vectors_get_tattoo_proc =
{ { vectors_get_tattoo_invoker } }
};
static Argument *
static GimpArgument *
vectors_set_tattoo_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpVectors *vectors;
@ -1224,15 +1224,15 @@ static GimpProcedure vectors_set_tattoo_proc =
{ { vectors_set_tattoo_invoker } }
};
static Argument *
static GimpArgument *
vectors_get_strokes_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpVectors *vectors;
gint32 num_strokes = 0;
gint32 *stroke_ids = NULL;
@ -1287,15 +1287,15 @@ static GimpProcedure vectors_get_strokes_proc =
{ { vectors_get_strokes_invoker } }
};
static Argument *
static GimpArgument *
vectors_stroke_get_length_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpVectors *vectors;
gint32 stroke_id;
gdouble prescision;
@ -1339,15 +1339,15 @@ static GimpProcedure vectors_stroke_get_length_proc =
{ { vectors_stroke_get_length_invoker } }
};
static Argument *
static GimpArgument *
vectors_stroke_get_point_at_dist_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpVectors *vectors;
gint32 stroke_id;
gdouble dist;
@ -1408,12 +1408,12 @@ static GimpProcedure vectors_stroke_get_point_at_dist_proc =
{ { vectors_stroke_get_point_at_dist_invoker } }
};
static Argument *
static GimpArgument *
vectors_stroke_remove_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpVectors *vectors;
@ -1451,12 +1451,12 @@ static GimpProcedure vectors_stroke_remove_proc =
{ { vectors_stroke_remove_invoker } }
};
static Argument *
static GimpArgument *
vectors_stroke_close_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpVectors *vectors;
@ -1494,12 +1494,12 @@ static GimpProcedure vectors_stroke_close_proc =
{ { vectors_stroke_close_invoker } }
};
static Argument *
static GimpArgument *
vectors_stroke_translate_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpVectors *vectors;
@ -1541,12 +1541,12 @@ static GimpProcedure vectors_stroke_translate_proc =
{ { vectors_stroke_translate_invoker } }
};
static Argument *
static GimpArgument *
vectors_stroke_scale_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpVectors *vectors;
@ -1588,15 +1588,15 @@ static GimpProcedure vectors_stroke_scale_proc =
{ { vectors_stroke_scale_invoker } }
};
static Argument *
static GimpArgument *
vectors_stroke_interpolate_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpVectors *vectors;
gint32 stroke_id;
gdouble prescision;
@ -1667,15 +1667,15 @@ static GimpProcedure vectors_stroke_interpolate_proc =
{ { vectors_stroke_interpolate_invoker } }
};
static Argument *
static GimpArgument *
vectors_bezier_stroke_new_moveto_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpVectors *vectors;
gdouble x0;
gdouble y0;
@ -1722,12 +1722,12 @@ static GimpProcedure vectors_bezier_stroke_new_moveto_proc =
{ { vectors_bezier_stroke_new_moveto_invoker } }
};
static Argument *
static GimpArgument *
vectors_bezier_stroke_lineto_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpVectors *vectors;
@ -1776,12 +1776,12 @@ static GimpProcedure vectors_bezier_stroke_lineto_proc =
{ { vectors_bezier_stroke_lineto_invoker } }
};
static Argument *
static GimpArgument *
vectors_bezier_stroke_conicto_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpVectors *vectors;
@ -1838,12 +1838,12 @@ static GimpProcedure vectors_bezier_stroke_conicto_proc =
{ { vectors_bezier_stroke_conicto_invoker } }
};
static Argument *
static GimpArgument *
vectors_bezier_stroke_cubicto_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
GimpVectors *vectors;
@ -1908,15 +1908,15 @@ static GimpProcedure vectors_bezier_stroke_cubicto_proc =
{ { vectors_bezier_stroke_cubicto_invoker } }
};
static Argument *
static GimpArgument *
vectors_bezier_stroke_new_ellipse_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
gboolean success = TRUE;
Argument *return_vals;
GimpArgument *return_vals;
GimpVectors *vectors;
gdouble x0;
gdouble y0;

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

@ -36,6 +36,7 @@
#include "core/gimp.h"
#include "core/gimpdrawable.h"
#include "pdb/gimpargument.h"
#include "pdb/gimpprocedure.h"
#include "pdb/procedural_db.h"
@ -353,9 +354,9 @@ plug_in_handle_proc_run (PlugIn *plug_in,
gchar *canonical;
const gchar *proc_name = NULL;
GimpProcedure *procedure;
Argument *args = NULL;
GimpArgument *args = NULL;
gint n_args = 0;
Argument *return_vals = NULL;
GimpArgument *return_vals = NULL;
gint n_return_vals = 0;
canonical = gimp_canonicalize_identifier (proc_run->name);
@ -461,8 +462,8 @@ plug_in_handle_proc_run (PlugIn *plug_in,
return;
}
procedural_db_destroy_args (args, n_args, FALSE);
procedural_db_destroy_args (return_vals, n_return_vals, TRUE);
gimp_arguments_destroy (args, n_args, FALSE);
gimp_arguments_destroy (return_vals, n_return_vals, TRUE);
plug_in_params_destroy (proc_return.params, proc_return.nparams, FALSE);
}
else

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

@ -28,6 +28,7 @@
#include "core/gimppdbprogress.h"
#include "core/gimpprogress.h"
#include "pdb/gimpargument.h"
#include "pdb/gimpprocedure.h"
#include "pdb/procedural_db.h"

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

@ -38,8 +38,8 @@
#include "core/gimpcontext.h"
#include "core/gimpprogress.h"
#include "pdb/gimpargument.h"
#include "pdb/gimpprocedure.h"
#include "pdb/procedural_db.h"
#include "plug-in.h"
#include "plug-in-params.h"
@ -52,32 +52,32 @@
/* local function prototypes */
static Argument * plug_in_temp_run (GimpProcedure *procedure,
GimpContext *context,
GimpProgress *progress,
Argument *args,
gint n_args);
static Argument * plug_in_get_return_vals (PlugIn *plug_in,
PlugInProcFrame *proc_frame,
gint *n_return_vals);
static GimpArgument * plug_in_temp_run (GimpProcedure *procedure,
GimpContext *context,
GimpProgress *progress,
GimpArgument *args,
gint n_args);
static GimpArgument * plug_in_get_return_vals (PlugIn *plug_in,
PlugInProcFrame *proc_frame,
gint *n_return_vals);
/* public functions */
Argument *
GimpArgument *
plug_in_run (Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
GimpProcedure *procedure,
Argument *args,
GimpArgument *args,
gint n_args,
gboolean synchronous,
gboolean destroy_return_vals,
gint display_ID)
{
Argument *return_vals = NULL;
gint n_return_vals = 0;
PlugIn *plug_in;
GimpArgument *return_vals = NULL;
gint n_return_vals = 0;
PlugIn *plug_in;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
@ -193,7 +193,7 @@ plug_in_run (Gimp *gimp,
done:
if (return_vals && destroy_return_vals)
{
procedural_db_destroy_args (return_vals, procedure->num_values, TRUE);
gimp_arguments_destroy (return_vals, procedure->num_values, TRUE);
return_vals = NULL;
}
@ -211,7 +211,7 @@ plug_in_repeat (Gimp *gimp,
gboolean with_interface)
{
PlugInProcDef *proc_def;
Argument *args;
GimpArgument *args;
g_return_if_fail (GIMP_IS_GIMP (gimp));
g_return_if_fail (index >= 0);
@ -235,23 +235,23 @@ plug_in_repeat (Gimp *gimp,
args, 3 /* not proc_def->procedure->num_args */,
FALSE, TRUE, display_ID);
procedural_db_destroy_args (args, proc_def->procedure->num_args, TRUE);
gimp_arguments_destroy (args, proc_def->procedure->num_args, TRUE);
}
}
/* private functions */
static Argument *
static GimpArgument *
plug_in_temp_run (GimpProcedure *procedure,
GimpContext *context,
GimpProgress *progress,
Argument *args,
GimpArgument *args,
gint n_args)
{
Argument *return_vals = NULL;
gint n_return_vals = 0;
PlugIn *plug_in;
GimpArgument *return_vals = NULL;
gint n_return_vals = 0;
PlugIn *plug_in;
plug_in = (PlugIn *) procedure->exec_method.temporary.plug_in;
@ -299,12 +299,12 @@ plug_in_temp_run (GimpProcedure *procedure,
return return_vals;
}
static Argument *
static GimpArgument *
plug_in_get_return_vals (PlugIn *plug_in,
PlugInProcFrame *proc_frame,
gint *n_return_vals)
{
Argument *return_vals;
GimpArgument *return_vals;
g_return_val_if_fail (plug_in != NULL, NULL);
g_return_val_if_fail (proc_frame != NULL, NULL);
@ -326,8 +326,8 @@ plug_in_get_return_vals (PlugIn *plug_in,
/* Copy all of the arguments we can. */
memcpy (return_vals, proc_frame->return_vals,
sizeof (Argument) * MIN (proc_frame->n_return_vals,
*n_return_vals));
sizeof (GimpArgument) * MIN (proc_frame->n_return_vals,
*n_return_vals));
/* Free the old argument pointer. This will cause a memory leak
* only if there were more values returned than we need (which

34
app/plug-in/gimppluginmanager-call.h
View File

@ -24,27 +24,27 @@
/* Run a plug-in as if it were a procedure database procedure
*/
Argument * plug_in_run (Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
GimpProcedure *procedure,
Argument *args,
gint n_args,
gboolean synchronous,
gboolean destroy_return_vals,
gint display_ID);
GimpArgument * plug_in_run (Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
GimpProcedure *procedure,
GimpArgument *args,
gint n_args,
gboolean synchronous,
gboolean destroy_return_vals,
gint display_ID);
/* Run one of the last plug-ins from the plug-in history again with
* the same arguments. Extensions are exempt from this "privelege".
*/
void plug_in_repeat (Gimp *gimp,
gint index,
GimpContext *context,
GimpProgress *progress,
gint display_ID,
gint image_ID,
gint drawable_ID,
gboolean with_interface);
void plug_in_repeat (Gimp *gimp,
gint index,
GimpContext *context,
GimpProgress *progress,
gint display_ID,
gint image_ID,
gint drawable_ID,
gboolean with_interface);
#endif /* __PLUG_IN_RUN_H__ */

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

@ -38,8 +38,8 @@
#include "core/gimpcontext.h"
#include "core/gimpprogress.h"
#include "pdb/gimpargument.h"
#include "pdb/gimpprocedure.h"
#include "pdb/procedural_db.h"
#include "plug-in.h"
#include "plug-in-params.h"
@ -52,32 +52,32 @@
/* local function prototypes */
static Argument * plug_in_temp_run (GimpProcedure *procedure,
GimpContext *context,
GimpProgress *progress,
Argument *args,
gint n_args);
static Argument * plug_in_get_return_vals (PlugIn *plug_in,
PlugInProcFrame *proc_frame,
gint *n_return_vals);
static GimpArgument * plug_in_temp_run (GimpProcedure *procedure,
GimpContext *context,
GimpProgress *progress,
GimpArgument *args,
gint n_args);
static GimpArgument * plug_in_get_return_vals (PlugIn *plug_in,
PlugInProcFrame *proc_frame,
gint *n_return_vals);
/* public functions */
Argument *
GimpArgument *
plug_in_run (Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
GimpProcedure *procedure,
Argument *args,
GimpArgument *args,
gint n_args,
gboolean synchronous,
gboolean destroy_return_vals,
gint display_ID)
{
Argument *return_vals = NULL;
gint n_return_vals = 0;
PlugIn *plug_in;
GimpArgument *return_vals = NULL;
gint n_return_vals = 0;
PlugIn *plug_in;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
@ -193,7 +193,7 @@ plug_in_run (Gimp *gimp,
done:
if (return_vals && destroy_return_vals)
{
procedural_db_destroy_args (return_vals, procedure->num_values, TRUE);
gimp_arguments_destroy (return_vals, procedure->num_values, TRUE);
return_vals = NULL;
}
@ -211,7 +211,7 @@ plug_in_repeat (Gimp *gimp,
gboolean with_interface)
{
PlugInProcDef *proc_def;
Argument *args;
GimpArgument *args;
g_return_if_fail (GIMP_IS_GIMP (gimp));
g_return_if_fail (index >= 0);
@ -235,23 +235,23 @@ plug_in_repeat (Gimp *gimp,
args, 3 /* not proc_def->procedure->num_args */,
FALSE, TRUE, display_ID);
procedural_db_destroy_args (args, proc_def->procedure->num_args, TRUE);
gimp_arguments_destroy (args, proc_def->procedure->num_args, TRUE);
}
}
/* private functions */
static Argument *
static GimpArgument *
plug_in_temp_run (GimpProcedure *procedure,
GimpContext *context,
GimpProgress *progress,
Argument *args,
GimpArgument *args,
gint n_args)
{
Argument *return_vals = NULL;
gint n_return_vals = 0;
PlugIn *plug_in;
GimpArgument *return_vals = NULL;
gint n_return_vals = 0;
PlugIn *plug_in;
plug_in = (PlugIn *) procedure->exec_method.temporary.plug_in;
@ -299,12 +299,12 @@ plug_in_temp_run (GimpProcedure *procedure,
return return_vals;
}
static Argument *
static GimpArgument *
plug_in_get_return_vals (PlugIn *plug_in,
PlugInProcFrame *proc_frame,
gint *n_return_vals)
{
Argument *return_vals;
GimpArgument *return_vals;
g_return_val_if_fail (plug_in != NULL, NULL);
g_return_val_if_fail (proc_frame != NULL, NULL);
@ -326,8 +326,8 @@ plug_in_get_return_vals (PlugIn *plug_in,
/* Copy all of the arguments we can. */
memcpy (return_vals, proc_frame->return_vals,
sizeof (Argument) * MIN (proc_frame->n_return_vals,
*n_return_vals));
sizeof (GimpArgument) * MIN (proc_frame->n_return_vals,
*n_return_vals));
/* Free the old argument pointer. This will cause a memory leak
* only if there were more values returned than we need (which

34
app/plug-in/gimppluginmanager-run.h
View File

@ -24,27 +24,27 @@
/* Run a plug-in as if it were a procedure database procedure
*/
Argument * plug_in_run (Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
GimpProcedure *procedure,
Argument *args,
gint n_args,
gboolean synchronous,
gboolean destroy_return_vals,
gint display_ID);
GimpArgument * plug_in_run (Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
GimpProcedure *procedure,
GimpArgument *args,
gint n_args,
gboolean synchronous,
gboolean destroy_return_vals,
gint display_ID);
/* Run one of the last plug-ins from the plug-in history again with
* the same arguments. Extensions are exempt from this "privelege".
*/
void plug_in_repeat (Gimp *gimp,
gint index,
GimpContext *context,
GimpProgress *progress,
gint display_ID,
gint image_ID,
gint drawable_ID,
gboolean with_interface);
void plug_in_repeat (Gimp *gimp,
gint index,
GimpContext *context,
GimpProgress *progress,
gint display_ID,
gint image_ID,
gint drawable_ID,
gboolean with_interface);
#endif /* __PLUG_IN_RUN_H__ */

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

@ -38,6 +38,7 @@
#include "core/gimpdrawable.h"
#include "core/gimpimage.h"
#include "pdb/gimpargument.h"
#include "pdb/gimpprocedure.h"
#include "pdb/procedural_db.h"
@ -1059,8 +1060,8 @@ plug_ins_add_to_db (Gimp *gimp,
if (proc_def->file_proc)
{
Argument *return_vals;
gint n_return_vals;
GimpArgument *return_vals;
gint n_return_vals;
if (proc_def->image_types)
{
@ -1086,7 +1087,7 @@ plug_ins_add_to_db (Gimp *gimp,
GIMP_PDB_END);
}
procedural_db_destroy_args (return_vals, n_return_vals, TRUE);
gimp_arguments_destroy (return_vals, n_return_vals, TRUE);
}
}
}

2
app/plug-in/gimppluginprocframe.h
View File

@ -32,7 +32,7 @@ struct _PlugInProcFrame
GimpProcedure *procedure;
GMainLoop *main_loop;
Argument *return_vals;
GimpArgument *return_vals;
gint n_return_vals;
GimpProgress *progress;

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

@ -36,6 +36,7 @@
#include "core/gimp.h"
#include "core/gimpdrawable.h"
#include "pdb/gimpargument.h"
#include "pdb/gimpprocedure.h"
#include "pdb/procedural_db.h"
@ -353,9 +354,9 @@ plug_in_handle_proc_run (PlugIn *plug_in,
gchar *canonical;
const gchar *proc_name = NULL;
GimpProcedure *procedure;
Argument *args = NULL;
GimpArgument *args = NULL;
gint n_args = 0;
Argument *return_vals = NULL;
GimpArgument *return_vals = NULL;
gint n_return_vals = 0;
canonical = gimp_canonicalize_identifier (proc_run->name);
@ -461,8 +462,8 @@ plug_in_handle_proc_run (PlugIn *plug_in,
return;
}
procedural_db_destroy_args (args, n_args, FALSE);
procedural_db_destroy_args (return_vals, n_return_vals, TRUE);
gimp_arguments_destroy (args, n_args, FALSE);
gimp_arguments_destroy (return_vals, n_return_vals, TRUE);
plug_in_params_destroy (proc_return.params, proc_return.nparams, FALSE);
}
else

67
app/plug-in/plug-in-params.c
View File

@ -30,22 +30,23 @@
#include "core/gimpparamspecs.h"
#include "pdb/gimpargument.h"
#include "pdb/procedural_db.h"
#include "plug-in.h"
#include "plug-in-params.h"
Argument *
plug_in_params_to_args (ProcArg *proc_args,
gint n_proc_args,
GPParam *params,
gint n_params,
gboolean full_copy)
GimpArgument *
plug_in_params_to_args (GimpArgumentSpec *proc_args,
gint n_proc_args,
GPParam *params,
gint n_params,
gboolean full_copy)
{
Argument *args;
gint count;
gint i;
GimpArgument *args;
gint count;
gint i;
g_return_val_if_fail ((proc_args != NULL && n_proc_args > 0) ||
(proc_args == NULL && n_proc_args == 0), NULL);
@ -55,7 +56,7 @@ plug_in_params_to_args (ProcArg *proc_args,
if (! params)
return NULL;
args = g_new0 (Argument, n_params);
args = g_new0 (GimpArgument, n_params);
for (i = 0; i < n_params; i++)
{
@ -63,11 +64,11 @@ plug_in_params_to_args (ProcArg *proc_args,
if (i < n_proc_args && proc_args[i].type == params[i].type)
{
procedural_db_argument_init (&args[i], &proc_args[i]);
gimp_argument_init (&args[i], &proc_args[i]);
}
else
{
procedural_db_compat_arg_init (&args[i], params[i].type);
gimp_argument_init_compat (&args[i], params[i].type);
}
switch (args[i].type)
@ -238,13 +239,13 @@ plug_in_params_to_args (ProcArg *proc_args,
}
GPParam *
plug_in_args_to_params (Argument *args,
gint n_args,
gboolean full_copy)
plug_in_args_to_params (GimpArgument *args,
gint n_args,
gboolean full_copy)
{
GPParam *params;
gint count;
gint i;
GPParam *params;
gint count;
gint i;
g_return_val_if_fail ((args != NULL && n_args > 0) ||
(args == NULL && n_args == 0), NULL);
@ -545,16 +546,16 @@ plug_in_param_defs_check (const gchar *plug_in_name,
guint32 n_return_vals,
GError **error)
{
ProcArg *args;
ProcArg *return_args;
gboolean success;
gint i;
GimpArgumentSpec *args;
GimpArgumentSpec *return_args;
gboolean success;
gint i;
args = g_new0 (ProcArg, n_args);
args = g_new0 (GimpArgumentSpec, n_args);
for (i = 0; i < n_args; i++)
args[i].type = params[i].type;
return_args = g_new0 (ProcArg, n_return_vals);
return_args = g_new0 (GimpArgumentSpec, n_return_vals);
for (i = 0; i < n_return_vals; i++)
return_args[i].type = return_vals[i].type;
@ -575,15 +576,15 @@ plug_in_param_defs_check (const gchar *plug_in_name,
}
gboolean
plug_in_proc_args_check (const gchar *plug_in_name,
const gchar *plug_in_prog,
const gchar *procedure_name,
const gchar *menu_path,
ProcArg *args,
guint32 n_args,
ProcArg *return_vals,
guint32 n_return_vals,
GError **error)
plug_in_proc_args_check (const gchar *plug_in_name,
const gchar *plug_in_prog,
const gchar *procedure_name,
const gchar *menu_path,
GimpArgumentSpec *args,
guint32 n_args,
GimpArgumentSpec *return_vals,
guint32 n_return_vals,
GError **error)
{
gchar *prefix;
gchar *p;

58
app/plug-in/plug-in-params.h
View File

@ -20,37 +20,37 @@
#define __PLUG_IN_PARAMS_H__
Argument * plug_in_params_to_args (ProcArg *proc_args,
gint n_proc_args,
GPParam *params,
gint n_params,
gboolean full_copy);
GPParam * plug_in_args_to_params (Argument *args,
gint n_args,
gboolean full_copy);
GimpArgument * plug_in_params_to_args (GimpArgumentSpec *proc_args,
gint n_proc_args,
GPParam *params,
gint n_params,
gboolean full_copy);
GPParam * plug_in_args_to_params (GimpArgument *args,
gint n_args,
gboolean full_copy);
void plug_in_params_destroy (GPParam *params,
gint n_params,
gboolean full_destroy);
void plug_in_params_destroy (GPParam *params,
gint n_params,
gboolean full_destroy);
gboolean plug_in_param_defs_check (const gchar *plug_in_name,
const gchar *plug_in_prog,
const gchar *procedure_name,
const gchar *menu_path,
GPParamDef *params,
guint32 n_args,
GPParamDef *return_vals,
guint32 n_return_vals,
GError **error);
gboolean plug_in_proc_args_check (const gchar *plug_in_name,
const gchar *plug_in_prog,
const gchar *procedure_name,
const gchar *menu_path,
ProcArg *args,
guint32 n_args,
ProcArg *return_vals,
guint32 n_return_vals,
GError **error);
gboolean plug_in_param_defs_check (const gchar *plug_in_name,
const gchar *plug_in_prog,
const gchar *procedure_name,
const gchar *menu_path,
GPParamDef *params,
guint32 n_args,
GPParamDef *return_vals,
guint32 n_return_vals,
GError **error);
gboolean plug_in_proc_args_check (const gchar *plug_in_name,
const gchar *plug_in_prog,
const gchar *procedure_name,
const gchar *menu_path,
GimpArgumentSpec *args,
guint32 n_args,
GimpArgumentSpec *return_vals,
guint32 n_return_vals,
GError **error);
#endif /* __PLUG_IN_PARAMS_H__ */

2
app/plug-in/plug-in-proc-frame.h
View File

@ -32,7 +32,7 @@ struct _PlugInProcFrame
GimpProcedure *procedure;
GMainLoop *main_loop;
Argument *return_vals;
GimpArgument *return_vals;
gint n_return_vals;
GimpProgress *progress;

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

@ -28,6 +28,7 @@
#include "core/gimppdbprogress.h"
#include "core/gimpprogress.h"
#include "pdb/gimpargument.h"
#include "pdb/gimpprocedure.h"
#include "pdb/procedural_db.h"

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

@ -31,8 +31,8 @@
#include "core/gimp.h"
#include "pdb/gimpargument.h"
#include "pdb/gimpprocedure.h"
#include "pdb/procedural_db.h"
#include "plug-ins.h"
#include "plug-in-def.h"

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

@ -38,8 +38,8 @@
#include "core/gimpcontext.h"
#include "core/gimpprogress.h"
#include "pdb/gimpargument.h"
#include "pdb/gimpprocedure.h"
#include "pdb/procedural_db.h"
#include "plug-in.h"
#include "plug-in-params.h"
@ -52,32 +52,32 @@
/* local function prototypes */
static Argument * plug_in_temp_run (GimpProcedure *procedure,
GimpContext *context,
GimpProgress *progress,
Argument *args,
gint n_args);
static Argument * plug_in_get_return_vals (PlugIn *plug_in,
PlugInProcFrame *proc_frame,
gint *n_return_vals);
static GimpArgument * plug_in_temp_run (GimpProcedure *procedure,
GimpContext *context,
GimpProgress *progress,
GimpArgument *args,
gint n_args);
static GimpArgument * plug_in_get_return_vals (PlugIn *plug_in,
PlugInProcFrame *proc_frame,
gint *n_return_vals);
/* public functions */
Argument *
GimpArgument *
plug_in_run (Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
GimpProcedure *procedure,
Argument *args,
GimpArgument *args,
gint n_args,
gboolean synchronous,
gboolean destroy_return_vals,
gint display_ID)
{
Argument *return_vals = NULL;
gint n_return_vals = 0;
PlugIn *plug_in;
GimpArgument *return_vals = NULL;
gint n_return_vals = 0;
PlugIn *plug_in;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
@ -193,7 +193,7 @@ plug_in_run (Gimp *gimp,
done:
if (return_vals && destroy_return_vals)
{
procedural_db_destroy_args (return_vals, procedure->num_values, TRUE);
gimp_arguments_destroy (return_vals, procedure->num_values, TRUE);
return_vals = NULL;
}
@ -211,7 +211,7 @@ plug_in_repeat (Gimp *gimp,
gboolean with_interface)
{
PlugInProcDef *proc_def;
Argument *args;
GimpArgument *args;
g_return_if_fail (GIMP_IS_GIMP (gimp));
g_return_if_fail (index >= 0);
@ -235,23 +235,23 @@ plug_in_repeat (Gimp *gimp,
args, 3 /* not proc_def->procedure->num_args */,
FALSE, TRUE, display_ID);
procedural_db_destroy_args (args, proc_def->procedure->num_args, TRUE);
gimp_arguments_destroy (args, proc_def->procedure->num_args, TRUE);
}
}
/* private functions */
static Argument *
static GimpArgument *
plug_in_temp_run (GimpProcedure *procedure,
GimpContext *context,
GimpProgress *progress,
Argument *args,
GimpArgument *args,
gint n_args)
{
Argument *return_vals = NULL;
gint n_return_vals = 0;
PlugIn *plug_in;
GimpArgument *return_vals = NULL;
gint n_return_vals = 0;
PlugIn *plug_in;
plug_in = (PlugIn *) procedure->exec_method.temporary.plug_in;
@ -299,12 +299,12 @@ plug_in_temp_run (GimpProcedure *procedure,
return return_vals;
}
static Argument *
static GimpArgument *
plug_in_get_return_vals (PlugIn *plug_in,
PlugInProcFrame *proc_frame,
gint *n_return_vals)
{
Argument *return_vals;
GimpArgument *return_vals;
g_return_val_if_fail (plug_in != NULL, NULL);
g_return_val_if_fail (proc_frame != NULL, NULL);
@ -326,8 +326,8 @@ plug_in_get_return_vals (PlugIn *plug_in,
/* Copy all of the arguments we can. */
memcpy (return_vals, proc_frame->return_vals,
sizeof (Argument) * MIN (proc_frame->n_return_vals,
*n_return_vals));
sizeof (GimpArgument) * MIN (proc_frame->n_return_vals,
*n_return_vals));
/* Free the old argument pointer. This will cause a memory leak
* only if there were more values returned than we need (which

34
app/plug-in/plug-in-run.h
View File

@ -24,27 +24,27 @@
/* Run a plug-in as if it were a procedure database procedure
*/
Argument * plug_in_run (Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
GimpProcedure *procedure,
Argument *args,
gint n_args,
gboolean synchronous,
gboolean destroy_return_vals,
gint display_ID);
GimpArgument * plug_in_run (Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
GimpProcedure *procedure,
GimpArgument *args,
gint n_args,
gboolean synchronous,
gboolean destroy_return_vals,
gint display_ID);
/* Run one of the last plug-ins from the plug-in history again with
* the same arguments. Extensions are exempt from this "privelege".
*/
void plug_in_repeat (Gimp *gimp,
gint index,
GimpContext *context,
GimpProgress *progress,
gint display_ID,
gint image_ID,
gint drawable_ID,
gboolean with_interface);
void plug_in_repeat (Gimp *gimp,
gint index,
GimpContext *context,
GimpProgress *progress,
gint display_ID,
gint image_ID,
gint drawable_ID,
gboolean with_interface);
#endif /* __PLUG_IN_RUN_H__ */

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

@ -38,6 +38,7 @@
#include "core/gimpdrawable.h"
#include "core/gimpimage.h"
#include "pdb/gimpargument.h"
#include "pdb/gimpprocedure.h"
#include "pdb/procedural_db.h"
@ -1059,8 +1060,8 @@ plug_ins_add_to_db (Gimp *gimp,
if (proc_def->file_proc)
{
Argument *return_vals;
gint n_return_vals;
GimpArgument *return_vals;
gint n_return_vals;
if (proc_def->image_types)
{
@ -1086,7 +1087,7 @@ plug_ins_add_to_db (Gimp *gimp,
GIMP_PDB_END);
}
procedural_db_destroy_args (return_vals, n_return_vals, TRUE);
gimp_arguments_destroy (return_vals, n_return_vals, TRUE);
}
}
}

5
app/widgets/gimpbrushselect.c
View File

@ -60,7 +60,8 @@ static void gimp_brush_select_set_property (GObject *object,
const GValue *value,
GParamSpec *pspec);
static Argument * gimp_brush_select_run_callback (GimpPdbDialog *dialog,
static GimpArgument *
gimp_brush_select_run_callback (GimpPdbDialog *dialog,
GimpObject *object,
gboolean closing,
gint *n_return_vals);
@ -250,7 +251,7 @@ gimp_brush_select_set_property (GObject *object,
}
}
static Argument *
static GimpArgument *
gimp_brush_select_run_callback (GimpPdbDialog *dialog,
GimpObject *object,
gboolean closing,

16
app/widgets/gimpfontselect.c
View File

@ -39,14 +39,14 @@
#include "gimpfontview.h"
static GObject * gimp_font_select_constructor (GType type,
guint n_params,
GObjectConstructParam *params);
static GObject * gimp_font_select_constructor (GType type,
guint n_params,
GObjectConstructParam *params);
static Argument * gimp_font_select_run_callback (GimpPdbDialog *dialog,
GimpObject *object,
gboolean closing,
gint *n_return_vals);
static GimpArgument * gimp_font_select_run_callback (GimpPdbDialog *dialog,
GimpObject *object,
gboolean closing,
gint *n_return_vals);
G_DEFINE_TYPE (GimpFontSelect, gimp_font_select, GIMP_TYPE_PDB_DIALOG);
@ -99,7 +99,7 @@ gimp_font_select_constructor (GType type,
return object;
}
static Argument *
static GimpArgument *
gimp_font_select_run_callback (GimpPdbDialog *dialog,
GimpObject *object,
gboolean closing,

24
app/widgets/gimpgradientselect.c
View File

@ -45,18 +45,18 @@ enum
};
static GObject * gimp_gradient_select_constructor (GType type,
guint n_params,
GObjectConstructParam *params);
static void gimp_gradient_select_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec);
static GObject * gimp_gradient_select_constructor (GType type,
guint n_params,
GObjectConstructParam *params);
static void gimp_gradient_select_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec);
static Argument * gimp_gradient_select_run_callback (GimpPdbDialog *dialog,
GimpObject *object,
gboolean closing,
gint *n_return_vals);
static GimpArgument * gimp_gradient_select_run_callback (GimpPdbDialog *dialog,
GimpObject *object,
gboolean closing,
gint *n_return_vals);
G_DEFINE_TYPE (GimpGradientSelect, gimp_gradient_select,
@ -120,7 +120,7 @@ gimp_gradient_select_constructor (GType type,
return object;
}
static Argument *
static GimpArgument *
gimp_gradient_select_run_callback (GimpPdbDialog *dialog,
GimpObject *object,
gboolean closing,

21
app/widgets/gimphelp.c
View File

@ -36,6 +36,7 @@
#include "core/gimp.h"
#include "core/gimp-utils.h"
#include "pdb/gimpargument.h"
#include "pdb/gimpprocedure.h"
#include "pdb/procedural_db.h"
@ -178,7 +179,7 @@ gimp_help_browser (Gimp *gimp)
if (! procedure)
{
Argument *args = NULL;
GimpArgument *args = NULL;
procedure = procedural_db_lookup (gimp, "extension-gimp-help-browser");
@ -201,7 +202,7 @@ gimp_help_browser (Gimp *gimp)
plug_in_run (gimp, gimp_get_user_context (gimp), NULL,
procedure, args, 1, FALSE, TRUE, -1);
procedural_db_destroy_args (args, 1, TRUE);
gimp_arguments_destroy (args, procedure->num_args, TRUE);
}
/* Check if the help browser started properly */
@ -266,10 +267,10 @@ gimp_help_call (Gimp *gimp,
if (! procedure)
{
Argument *args = NULL;
gint n_domains = 0;
gchar **help_domains = NULL;
gchar **help_uris = NULL;
GimpArgument *args = NULL;
gint n_domains = 0;
gchar **help_domains = NULL;
gchar **help_uris = NULL;
procedure = procedural_db_lookup (gimp, "extension-gimp-help");
@ -289,7 +290,7 @@ gimp_help_call (Gimp *gimp,
plug_in_run (gimp, gimp_get_user_context (gimp), NULL,
procedure, args, 4, FALSE, TRUE, -1);
procedural_db_destroy_args (args, 4, TRUE);
gimp_arguments_destroy (args, procedure->num_args, TRUE);
}
/* Check if the help parser started properly */
@ -297,8 +298,8 @@ gimp_help_call (Gimp *gimp,
if (procedure)
{
Argument *return_vals;
gint n_return_vals;
GimpArgument *return_vals;
gint n_return_vals;
#ifdef GIMP_HELP_DEBUG
g_printerr ("Calling help via %s: %s %s %s\n",
@ -320,7 +321,7 @@ gimp_help_call (Gimp *gimp,
GIMP_PDB_STRING, help_id,
GIMP_PDB_END);
procedural_db_destroy_args (return_vals, n_return_vals, TRUE);
gimp_arguments_destroy (return_vals, n_return_vals, TRUE);
}
}

16
app/widgets/gimppaletteselect.c
View File

@ -38,14 +38,14 @@
#include "gimppaletteselect.h"
static GObject * gimp_palette_select_constructor (GType type,
guint n_params,
GObjectConstructParam *params);
static GObject * gimp_palette_select_constructor (GType type,
guint n_params,
GObjectConstructParam *params);
static Argument * gimp_palette_select_run_callback (GimpPdbDialog *dialog,
GimpObject *object,
gboolean closing,
gint *n_return_vals);
static GimpArgument * gimp_palette_select_run_callback (GimpPdbDialog *dialog,
GimpObject *object,
gboolean closing,
gint *n_return_vals);
G_DEFINE_TYPE (GimpPaletteSelect, gimp_palette_select, GIMP_TYPE_PDB_DIALOG);
@ -101,7 +101,7 @@ gimp_palette_select_constructor (GType type,
return object;
}
static Argument *
static GimpArgument *
gimp_palette_select_run_callback (GimpPdbDialog *dialog,
GimpObject *object,
gboolean closing,

16
app/widgets/gimppatternselect.c
View File

@ -40,14 +40,14 @@
#include "gimppatternselect.h"
static GObject * gimp_pattern_select_constructor (GType type,
guint n_params,
GObjectConstructParam *params);
static GObject * gimp_pattern_select_constructor (GType type,
guint n_params,
GObjectConstructParam *params);
static Argument * gimp_pattern_select_run_callback (GimpPdbDialog *dialog,
GimpObject *object,
gboolean closing,
gint *n_return_vals);
static GimpArgument * gimp_pattern_select_run_callback (GimpPdbDialog *dialog,
GimpObject *object,
gboolean closing,
gint *n_return_vals);
G_DEFINE_TYPE (GimpPatternSelect, gimp_pattern_select, GIMP_TYPE_PDB_DIALOG);
@ -101,7 +101,7 @@ gimp_pattern_select_constructor (GType type,
return object;
}
static Argument *
static GimpArgument *
gimp_pattern_select_run_callback (GimpPdbDialog *dialog,
GimpObject *object,
gboolean closing,

8
app/widgets/gimppdbdialog.c
View File

@ -31,7 +31,7 @@
#include "core/gimpcontext.h"
#include "pdb/gimpprocedure.h"
#include "pdb/gimpargument.h"
#include "pdb/procedural_db.h"
#include "gimpmenufactory.h"
@ -309,8 +309,8 @@ gimp_pdb_dialog_run_callback (GimpPdbDialog *dialog,
if (procedural_db_lookup (dialog->caller_context->gimp,
dialog->callback_name))
{
Argument *return_vals;
gint n_return_vals;
GimpArgument *return_vals;
gint n_return_vals;
return_vals = klass->run_callback (dialog, object, closing,
&n_return_vals);
@ -322,7 +322,7 @@ gimp_pdb_dialog_run_callback (GimpPdbDialog *dialog,
g_type_name (G_TYPE_FROM_INSTANCE (dialog)));
}
procedural_db_destroy_args (return_vals, n_return_vals, TRUE);
gimp_arguments_destroy (return_vals, n_return_vals, TRUE);
}
dialog->callback_busy = FALSE;

8
app/widgets/gimppdbdialog.h
View File

@ -66,10 +66,10 @@ struct _GimpPdbDialogClass
GList *dialogs;
Argument * (* run_callback) (GimpPdbDialog *dialog,
GimpObject *object,
gboolean closing,
gint *n_return_vals);
GimpArgument * (* run_callback) (GimpPdbDialog *dialog,
GimpObject *object,
gboolean closing,
gint *n_return_vals);
};

50
app/xcf/xcf.c
View File

@ -53,16 +53,16 @@ typedef GimpImage * GimpXcfLoaderFunc (Gimp *gimp,
XcfInfo *info);
static Argument * xcf_load_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args);
static Argument * xcf_save_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args);
static GimpArgument * xcf_load_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
GimpArgument *args);
static GimpArgument * xcf_save_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
GimpArgument *args);
static PlugInProcDef xcf_plug_in_load_proc =
@ -230,19 +230,19 @@ xcf_exit (Gimp *gimp)
g_return_if_fail (GIMP_IS_GIMP (gimp));
}
static Argument *
static GimpArgument *
xcf_load_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
XcfInfo info;
Argument *return_vals;
GimpImage *image = NULL;
const gchar *filename;
gboolean success = FALSE;
gchar id[14];
XcfInfo info;
GimpArgument *return_vals;
GimpImage *image = NULL;
const gchar *filename;
gboolean success = FALSE;
gchar id[14];
gimp_set_busy (gimp);
@ -318,18 +318,18 @@ xcf_load_invoker (GimpProcedure *procedure,
return return_vals;
}
static Argument *
static GimpArgument *
xcf_save_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
GimpArgument *args)
{
XcfInfo info;
Argument *return_vals;
GimpImage *image;
const gchar *filename;
gboolean success = FALSE;
XcfInfo info;
GimpArgument *return_vals;
GimpImage *image;
const gchar *filename;
gboolean success = FALSE;
gimp_set_busy (gimp);

6
tools/pdbgen/app.pl
View File

@ -551,12 +551,12 @@ CODE
}
}
$out->{code} .= "\nstatic Argument *\n";
$out->{code} .= "\nstatic GimpArgument *\n";
$out->{code} .= "${name}_invoker (GimpProcedure *procedure,\n";
$out->{code} .= ' ' x length($name) . " Gimp *gimp,\n";
$out->{code} .= ' ' x length($name) . " GimpContext *context,\n";
$out->{code} .= ' ' x length($name) . " GimpProgress *progress,\n";
$out->{code} .= ' ' x length($name) . " Argument *args)\n{\n";
$out->{code} .= ' ' x length($name) . " GimpArgument *args)\n{\n";
my $code = "";
@ -566,7 +566,7 @@ CODE
else {
my $invoker = "";
$invoker .= ' ' x 2 . "Argument *return_vals;\n" if scalar @outargs;
$invoker .= ' ' x 2 . "GimpArgument *return_vals;\n" if scalar @outargs;
$invoker .= &declare_args($proc, $out, 0, qw(inargs));
$invoker .= &declare_args($proc, $out, 1, qw(outargs));

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

@ -51,8 +51,8 @@ HELP
no_marshalling => 1,
code => <<'CODE'
{
Argument *new_args;
Argument *return_vals;
GimpArgument *new_args;
GimpArgument *return_vals;
PlugInProcDef *file_proc;
GimpProcedure *proc;
gchar *uri;
@ -178,8 +178,8 @@ HELP
no_marshalling => 1,
code => <<'CODE'
{
Argument *new_args;
Argument *return_vals;
GimpArgument *new_args;
GimpArgument *return_vals;
PlugInProcDef *file_proc;
GimpProcedure *proc;
gchar *uri;

4
tools/pdbgen/pdb/procedural_db.pdb
View File

@ -246,7 +246,7 @@ HELP
if (proc && (arg_num >= 0 && arg_num < proc->num_args))
{
ProcArg *arg = &proc->args[arg_num];
GimpArgumentSpec *arg = &proc->args[arg_num];
arg_type = arg->type;
arg_name = g_strdup (g_param_spec_get_name (arg->pspec));
@ -313,7 +313,7 @@ HELP
if (proc && (val_num >= 0 && val_num < proc->num_values))
{
ProcArg *val = &proc->values[val_num];
GimpArgumentSpec *val = &proc->values[val_num];
val_type = val->type;
val_name = g_strdup (g_param_spec_get_name (val->pspec));