From 8824a9bc8699b3d61e5e0749aaaab70ca2fe4a00 Mon Sep 17 00:00:00 2001 From: Sven Neumann Date: Wed, 12 Apr 2006 10:27:31 +0000 Subject: [PATCH] create code with spaces instead of tabs. 2006-04-12 Sven Neumann * tools/pdbgen/lib.pl: create code with spaces instead of tabs. * libgimp/gimp*_pdb.[ch]: regenerated. --- ChangeLog | 6 + libgimp/gimpbrush_pdb.c | 190 ++++---- libgimp/gimpbrush_pdb.h | 42 +- libgimp/gimpbrushes_pdb.c | 50 +- libgimp/gimpbrushes_pdb.h | 20 +- libgimp/gimpbrushselect_pdb.c | 54 +-- libgimp/gimpbrushselect_pdb.h | 18 +- libgimp/gimpbuffer_pdb.c | 48 +- libgimp/gimpbuffer_pdb.h | 4 +- libgimp/gimpchannel_pdb.c | 118 ++--- libgimp/gimpchannel_pdb.h | 30 +- libgimp/gimpcolor_pdb.c | 244 +++++----- libgimp/gimpcolor_pdb.h | 80 ++-- libgimp/gimpcontext_pdb.c | 116 ++--- libgimp/gimpconvert_pdb.c | 42 +- libgimp/gimpconvert_pdb.h | 12 +- libgimp/gimpdisplay_pdb.c | 32 +- libgimp/gimpdisplay_pdb.h | 2 +- libgimp/gimpdrawable_pdb.c | 376 +++++++-------- libgimp/gimpdrawable_pdb.h | 104 ++--- libgimp/gimpdrawabletransform_pdb.c | 632 ++++++++++++------------- libgimp/gimpdrawabletransform_pdb.h | 268 +++++------ libgimp/gimpedit_pdb.c | 204 ++++---- libgimp/gimpedit_pdb.h | 58 +-- libgimp/gimpfileops_pdb.c | 122 ++--- libgimp/gimpfileops_pdb.h | 34 +- libgimp/gimpfloatingsel_pdb.c | 48 +- libgimp/gimpfloatingsel_pdb.h | 6 +- libgimp/gimpfonts_pdb.c | 12 +- libgimp/gimpfonts_pdb.h | 2 +- libgimp/gimpfontselect_pdb.c | 30 +- libgimp/gimpfontselect_pdb.h | 6 +- libgimp/gimpgimprc_pdb.c | 38 +- libgimp/gimpgimprc_pdb.h | 4 +- libgimp/gimpgradient_pdb.c | 424 ++++++++--------- libgimp/gimpgradient_pdb.h | 138 +++--- libgimp/gimpgradients_pdb.c | 54 +-- libgimp/gimpgradients_pdb.h | 16 +- libgimp/gimpgradientselect_pdb.c | 34 +- libgimp/gimpgradientselect_pdb.h | 8 +- libgimp/gimpgrid_pdb.c | 100 ++-- libgimp/gimpgrid_pdb.h | 26 +- libgimp/gimpguides_pdb.c | 60 +-- libgimp/gimpguides_pdb.h | 12 +- libgimp/gimphelp_pdb.c | 10 +- libgimp/gimphelp_pdb.h | 2 +- libgimp/gimpimage_pdb.c | 692 ++++++++++++++-------------- libgimp/gimpimage_pdb.h | 152 +++--- libgimp/gimplayer_pdb.c | 274 +++++------ libgimp/gimplayer_pdb.h | 56 +-- libgimp/gimpmessage_pdb.c | 16 +- libgimp/gimpmisc_pdb.c | 8 +- libgimp/gimppainttools_pdb.c | 274 +++++------ libgimp/gimppainttools_pdb.h | 92 ++-- libgimp/gimppalette_pdb.c | 136 +++--- libgimp/gimppalette_pdb.h | 30 +- libgimp/gimppalettes_pdb.c | 30 +- libgimp/gimppalettes_pdb.h | 8 +- libgimp/gimppaletteselect_pdb.c | 30 +- libgimp/gimppaletteselect_pdb.h | 6 +- libgimp/gimpparasite_pdb.c | 144 +++--- libgimp/gimpparasite_pdb.h | 32 +- libgimp/gimppaths_pdb.c | 220 ++++----- libgimp/gimppaths_pdb.h | 68 +-- libgimp/gimppattern_pdb.c | 28 +- libgimp/gimppattern_pdb.h | 16 +- libgimp/gimppatterns_pdb.c | 34 +- libgimp/gimppatterns_pdb.h | 14 +- libgimp/gimppatternselect_pdb.c | 30 +- libgimp/gimppatternselect_pdb.h | 6 +- libgimp/gimpplugin_pdb.c | 58 +-- libgimp/gimpplugin_pdb.h | 14 +- libgimp/gimpproceduraldb_pdb.c | 128 ++--- libgimp/gimpproceduraldb_pdb.h | 56 +-- libgimp/gimpprogress_pdb.c | 48 +- libgimp/gimpprogress_pdb.h | 2 +- libgimp/gimpselection_pdb.c | 156 +++---- libgimp/gimpselection_pdb.h | 32 +- libgimp/gimpselectiontools_pdb.c | 174 +++---- libgimp/gimpselectiontools_pdb.h | 72 +-- libgimp/gimptexttool_pdb.c | 192 ++++---- libgimp/gimptexttool_pdb.h | 92 ++-- libgimp/gimptransformtools_pdb.c | 148 +++--- libgimp/gimptransformtools_pdb.h | 56 +-- libgimp/gimpundo_pdb.c | 42 +- libgimp/gimpunit_pdb.c | 96 ++-- libgimp/gimpunit_pdb.h | 14 +- libgimp/gimpvectors_pdb.c | 318 ++++++------- libgimp/gimpvectors_pdb.h | 96 ++-- tools/pdbgen/lib.pl | 11 +- 90 files changed, 4070 insertions(+), 4067 deletions(-) diff --git a/ChangeLog b/ChangeLog index 610e07b047..0f0647b617 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,9 @@ +2006-04-12 Sven Neumann + + * tools/pdbgen/lib.pl: create code with spaces instead of tabs. + + * libgimp/gimp*_pdb.[ch]: regenerated. + 2006-04-12 Sven Neumann * tools/gimp-remote.c diff --git a/libgimp/gimpbrush_pdb.c b/libgimp/gimpbrush_pdb.c index 8bf5a34f8b..d1a91fc5bd 100644 --- a/libgimp/gimpbrush_pdb.c +++ b/libgimp/gimpbrush_pdb.c @@ -47,9 +47,9 @@ gimp_brush_new (const gchar *name) gchar *actual_name = NULL; return_vals = gimp_run_procedure ("gimp-brush-new", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) actual_name = g_strdup (return_vals[1].data.d_string); @@ -79,9 +79,9 @@ gimp_brush_duplicate (const gchar *name) gchar *copy_name = NULL; return_vals = gimp_run_procedure ("gimp-brush-duplicate", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) copy_name = g_strdup (return_vals[1].data.d_string); @@ -111,9 +111,9 @@ gimp_brush_is_generated (const gchar *name) gboolean generated = FALSE; return_vals = gimp_run_procedure ("gimp-brush-is-generated", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) generated = return_vals[1].data.d_int32; @@ -138,17 +138,17 @@ gimp_brush_is_generated (const gchar *name) */ gchar * gimp_brush_rename (const gchar *name, - const gchar *new_name) + const gchar *new_name) { GimpParam *return_vals; gint nreturn_vals; gchar *actual_name = NULL; return_vals = gimp_run_procedure ("gimp-brush-rename", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_STRING, new_name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_STRING, new_name, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) actual_name = g_strdup (return_vals[1].data.d_string); @@ -178,9 +178,9 @@ gimp_brush_delete (const gchar *name) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-brush-delete", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -209,9 +209,9 @@ gimp_brush_is_editable (const gchar *name) gboolean editable = FALSE; return_vals = gimp_run_procedure ("gimp-brush-is-editable", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) editable = return_vals[1].data.d_int32; @@ -240,19 +240,19 @@ gimp_brush_is_editable (const gchar *name) */ gboolean gimp_brush_get_info (const gchar *name, - gint *width, - gint *height, - gint *mask_bpp, - gint *color_bpp) + gint *width, + gint *height, + gint *mask_bpp, + gint *color_bpp) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-brush-get-info", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_END); *width = 0; *height = 0; @@ -297,23 +297,23 @@ gimp_brush_get_info (const gchar *name, */ gboolean gimp_brush_get_pixels (const gchar *name, - gint *width, - gint *height, - gint *mask_bpp, - gint *num_mask_bytes, - guint8 **mask_bytes, - gint *color_bpp, - gint *num_color_bytes, - guint8 **color_bytes) + gint *width, + gint *height, + gint *mask_bpp, + gint *num_mask_bytes, + guint8 **mask_bytes, + gint *color_bpp, + gint *num_color_bytes, + guint8 **color_bytes) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-brush-get-pixels", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_END); *width = 0; *height = 0; @@ -364,16 +364,16 @@ gimp_brush_get_pixels (const gchar *name, */ gboolean gimp_brush_get_spacing (const gchar *name, - gint *spacing) + gint *spacing) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-brush-get-spacing", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_END); *spacing = 0; @@ -403,17 +403,17 @@ gimp_brush_get_spacing (const gchar *name, */ gboolean gimp_brush_set_spacing (const gchar *name, - gint spacing) + gint spacing) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-brush-set-spacing", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_INT32, spacing, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_INT32, spacing, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -447,9 +447,9 @@ gimp_brush_get_shape (const gchar *name) GimpBrushGeneratedShape shape = 0; return_vals = gimp_run_procedure ("gimp-brush-get-shape", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) shape = return_vals[1].data.d_int32; @@ -480,9 +480,9 @@ gimp_brush_get_radius (const gchar *name) gdouble radius = 0.0; return_vals = gimp_run_procedure ("gimp-brush-get-radius", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) radius = return_vals[1].data.d_float; @@ -513,9 +513,9 @@ gimp_brush_get_spikes (const gchar *name) gint spikes = 0; return_vals = gimp_run_procedure ("gimp-brush-get-spikes", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) spikes = return_vals[1].data.d_int32; @@ -547,9 +547,9 @@ gimp_brush_get_hardness (const gchar *name) gdouble hardness = 0.0; return_vals = gimp_run_procedure ("gimp-brush-get-hardness", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) hardness = return_vals[1].data.d_float; @@ -580,9 +580,9 @@ gimp_brush_get_aspect_ratio (const gchar *name) gdouble aspect_ratio = 0.0; return_vals = gimp_run_procedure ("gimp-brush-get-aspect-ratio", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) aspect_ratio = return_vals[1].data.d_float; @@ -613,9 +613,9 @@ gimp_brush_get_angle (const gchar *name) gdouble angle = 0.0; return_vals = gimp_run_procedure ("gimp-brush-get-angle", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) angle = return_vals[1].data.d_float; @@ -645,17 +645,17 @@ gimp_brush_get_angle (const gchar *name) */ GimpBrushGeneratedShape gimp_brush_set_shape (const gchar *name, - GimpBrushGeneratedShape shape_in) + GimpBrushGeneratedShape shape_in) { GimpParam *return_vals; gint nreturn_vals; GimpBrushGeneratedShape shape_out = 0; return_vals = gimp_run_procedure ("gimp-brush-set-shape", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_INT32, shape_in, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_INT32, shape_in, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) shape_out = return_vals[1].data.d_int32; @@ -681,17 +681,17 @@ gimp_brush_set_shape (const gchar *name, */ gdouble gimp_brush_set_radius (const gchar *name, - gdouble radius_in) + gdouble radius_in) { GimpParam *return_vals; gint nreturn_vals; gdouble radius_out = 0.0; return_vals = gimp_run_procedure ("gimp-brush-set-radius", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_FLOAT, radius_in, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_FLOAT, radius_in, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) radius_out = return_vals[1].data.d_float; @@ -717,17 +717,17 @@ gimp_brush_set_radius (const gchar *name, */ gint gimp_brush_set_spikes (const gchar *name, - gint spikes_in) + gint spikes_in) { GimpParam *return_vals; gint nreturn_vals; gint spikes_out = 0; return_vals = gimp_run_procedure ("gimp-brush-set-spikes", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_INT32, spikes_in, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_INT32, spikes_in, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) spikes_out = return_vals[1].data.d_int32; @@ -753,17 +753,17 @@ gimp_brush_set_spikes (const gchar *name, */ gdouble gimp_brush_set_hardness (const gchar *name, - gdouble hardness_in) + gdouble hardness_in) { GimpParam *return_vals; gint nreturn_vals; gdouble hardness_out = 0.0; return_vals = gimp_run_procedure ("gimp-brush-set-hardness", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_FLOAT, hardness_in, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_FLOAT, hardness_in, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) hardness_out = return_vals[1].data.d_float; @@ -789,17 +789,17 @@ gimp_brush_set_hardness (const gchar *name, */ gdouble gimp_brush_set_aspect_ratio (const gchar *name, - gdouble aspect_ratio_in) + gdouble aspect_ratio_in) { GimpParam *return_vals; gint nreturn_vals; gdouble aspect_ratio_out = 0.0; return_vals = gimp_run_procedure ("gimp-brush-set-aspect-ratio", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_FLOAT, aspect_ratio_in, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_FLOAT, aspect_ratio_in, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) aspect_ratio_out = return_vals[1].data.d_float; @@ -825,17 +825,17 @@ gimp_brush_set_aspect_ratio (const gchar *name, */ gdouble gimp_brush_set_angle (const gchar *name, - gdouble angle_in) + gdouble angle_in) { GimpParam *return_vals; gint nreturn_vals; gdouble angle_out = 0.0; return_vals = gimp_run_procedure ("gimp-brush-set-angle", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_FLOAT, angle_in, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_FLOAT, angle_in, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) angle_out = return_vals[1].data.d_float; diff --git a/libgimp/gimpbrush_pdb.h b/libgimp/gimpbrush_pdb.h index 78d2ea8279..a765df385e 100644 --- a/libgimp/gimpbrush_pdb.h +++ b/libgimp/gimpbrush_pdb.h @@ -33,27 +33,27 @@ gchar* gimp_brush_new (const gchar *n gchar* gimp_brush_duplicate (const gchar *name); gboolean gimp_brush_is_generated (const gchar *name); gchar* gimp_brush_rename (const gchar *name, - const gchar *new_name); + const gchar *new_name); gboolean gimp_brush_delete (const gchar *name); gboolean gimp_brush_is_editable (const gchar *name); gboolean gimp_brush_get_info (const gchar *name, - gint *width, - gint *height, - gint *mask_bpp, - gint *color_bpp); + gint *width, + gint *height, + gint *mask_bpp, + gint *color_bpp); gboolean gimp_brush_get_pixels (const gchar *name, - gint *width, - gint *height, - gint *mask_bpp, - gint *num_mask_bytes, - guint8 **mask_bytes, - gint *color_bpp, - gint *num_color_bytes, - guint8 **color_bytes); + gint *width, + gint *height, + gint *mask_bpp, + gint *num_mask_bytes, + guint8 **mask_bytes, + gint *color_bpp, + gint *num_color_bytes, + guint8 **color_bytes); gboolean gimp_brush_get_spacing (const gchar *name, - gint *spacing); + gint *spacing); gboolean gimp_brush_set_spacing (const gchar *name, - gint spacing); + gint spacing); GimpBrushGeneratedShape gimp_brush_get_shape (const gchar *name); gdouble gimp_brush_get_radius (const gchar *name); gint gimp_brush_get_spikes (const gchar *name); @@ -61,17 +61,17 @@ gdouble gimp_brush_get_hardness (const gchar *n gdouble gimp_brush_get_aspect_ratio (const gchar *name); gdouble gimp_brush_get_angle (const gchar *name); GimpBrushGeneratedShape gimp_brush_set_shape (const gchar *name, - GimpBrushGeneratedShape shape_in); + GimpBrushGeneratedShape shape_in); gdouble gimp_brush_set_radius (const gchar *name, - gdouble radius_in); + gdouble radius_in); gint gimp_brush_set_spikes (const gchar *name, - gint spikes_in); + gint spikes_in); gdouble gimp_brush_set_hardness (const gchar *name, - gdouble hardness_in); + gdouble hardness_in); gdouble gimp_brush_set_aspect_ratio (const gchar *name, - gdouble aspect_ratio_in); + gdouble aspect_ratio_in); gdouble gimp_brush_set_angle (const gchar *name, - gdouble angle_in); + gdouble angle_in); G_END_DECLS diff --git a/libgimp/gimpbrushes_pdb.c b/libgimp/gimpbrushes_pdb.c index b07929ea4f..a07d67e2a4 100644 --- a/libgimp/gimpbrushes_pdb.c +++ b/libgimp/gimpbrushes_pdb.c @@ -45,8 +45,8 @@ gimp_brushes_refresh (void) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-brushes-refresh", - &nreturn_vals, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -70,7 +70,7 @@ gimp_brushes_refresh (void) */ gchar ** gimp_brushes_get_list (const gchar *filter, - gint *num_brushes) + gint *num_brushes) { GimpParam *return_vals; gint nreturn_vals; @@ -78,9 +78,9 @@ gimp_brushes_get_list (const gchar *filter, gint i; return_vals = gimp_run_procedure ("gimp-brushes-get-list", - &nreturn_vals, - GIMP_PDB_STRING, filter, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, filter, + GIMP_PDB_END); *num_brushes = 0; @@ -109,16 +109,16 @@ gimp_brushes_get_list (const gchar *filter, */ gchar * gimp_brushes_get_brush (gint *width, - gint *height, - gint *spacing) + gint *height, + gint *spacing) { GimpParam *return_vals; gint nreturn_vals; gchar *name = NULL; return_vals = gimp_run_procedure ("gimp-brushes-get-brush", - &nreturn_vals, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) { @@ -148,8 +148,8 @@ gimp_brushes_get_spacing (void) gint spacing = 0; return_vals = gimp_run_procedure ("gimp-brushes-get-spacing", - &nreturn_vals, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) spacing = return_vals[1].data.d_int32; @@ -175,9 +175,9 @@ gimp_brushes_set_spacing (gint spacing) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-brushes-set-spacing", - &nreturn_vals, - GIMP_PDB_INT32, spacing, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_INT32, spacing, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -203,22 +203,22 @@ gimp_brushes_set_spacing (gint spacing) */ gchar * gimp_brushes_get_brush_data (const gchar *name, - gdouble *opacity, - gint *spacing, - GimpLayerModeEffects *paint_mode, - gint *width, - gint *height, - gint *length, - guint8 **mask_data) + gdouble *opacity, + gint *spacing, + GimpLayerModeEffects *paint_mode, + gint *width, + gint *height, + gint *length, + guint8 **mask_data) { GimpParam *return_vals; gint nreturn_vals; gchar *actual_name = NULL; return_vals = gimp_run_procedure ("gimp-brushes-get-brush-data", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_END); *length = 0; diff --git a/libgimp/gimpbrushes_pdb.h b/libgimp/gimpbrushes_pdb.h index 67521a091d..8ad01cf9f4 100644 --- a/libgimp/gimpbrushes_pdb.h +++ b/libgimp/gimpbrushes_pdb.h @@ -31,21 +31,21 @@ G_BEGIN_DECLS gboolean gimp_brushes_refresh (void); gchar** gimp_brushes_get_list (const gchar *filter, - gint *num_brushes); + gint *num_brushes); #ifndef GIMP_DISABLE_DEPRECATED gchar* gimp_brushes_get_brush (gint *width, - gint *height, - gint *spacing); + gint *height, + gint *spacing); gint gimp_brushes_get_spacing (void); gboolean gimp_brushes_set_spacing (gint spacing); gchar* gimp_brushes_get_brush_data (const gchar *name, - gdouble *opacity, - gint *spacing, - GimpLayerModeEffects *paint_mode, - gint *width, - gint *height, - gint *length, - guint8 **mask_data); + gdouble *opacity, + gint *spacing, + GimpLayerModeEffects *paint_mode, + gint *width, + gint *height, + gint *length, + guint8 **mask_data); #endif /* GIMP_DISABLE_DEPRECATED */ diff --git a/libgimp/gimpbrushselect_pdb.c b/libgimp/gimpbrushselect_pdb.c index af59ced7ea..3c0fac3b2b 100644 --- a/libgimp/gimpbrushselect_pdb.c +++ b/libgimp/gimpbrushselect_pdb.c @@ -42,25 +42,25 @@ */ gboolean gimp_brushes_popup (const gchar *brush_callback, - const gchar *popup_title, - const gchar *initial_brush, - gdouble opacity, - gint spacing, - GimpLayerModeEffects paint_mode) + const gchar *popup_title, + const gchar *initial_brush, + gdouble opacity, + gint spacing, + GimpLayerModeEffects paint_mode) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-brushes-popup", - &nreturn_vals, - GIMP_PDB_STRING, brush_callback, - GIMP_PDB_STRING, popup_title, - GIMP_PDB_STRING, initial_brush, - GIMP_PDB_FLOAT, opacity, - GIMP_PDB_INT32, spacing, - GIMP_PDB_INT32, paint_mode, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, brush_callback, + GIMP_PDB_STRING, popup_title, + GIMP_PDB_STRING, initial_brush, + GIMP_PDB_FLOAT, opacity, + GIMP_PDB_INT32, spacing, + GIMP_PDB_INT32, paint_mode, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -87,9 +87,9 @@ gimp_brushes_close_popup (const gchar *brush_callback) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-brushes-close-popup", - &nreturn_vals, - GIMP_PDB_STRING, brush_callback, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, brush_callback, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -114,23 +114,23 @@ gimp_brushes_close_popup (const gchar *brush_callback) */ gboolean gimp_brushes_set_popup (const gchar *brush_callback, - const gchar *brush_name, - gdouble opacity, - gint spacing, - GimpLayerModeEffects paint_mode) + const gchar *brush_name, + gdouble opacity, + gint spacing, + GimpLayerModeEffects paint_mode) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-brushes-set-popup", - &nreturn_vals, - GIMP_PDB_STRING, brush_callback, - GIMP_PDB_STRING, brush_name, - GIMP_PDB_FLOAT, opacity, - GIMP_PDB_INT32, spacing, - GIMP_PDB_INT32, paint_mode, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, brush_callback, + GIMP_PDB_STRING, brush_name, + GIMP_PDB_FLOAT, opacity, + GIMP_PDB_INT32, spacing, + GIMP_PDB_INT32, paint_mode, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; diff --git a/libgimp/gimpbrushselect_pdb.h b/libgimp/gimpbrushselect_pdb.h index 94114b942c..754fb280fc 100644 --- a/libgimp/gimpbrushselect_pdb.h +++ b/libgimp/gimpbrushselect_pdb.h @@ -30,17 +30,17 @@ G_BEGIN_DECLS gboolean gimp_brushes_popup (const gchar *brush_callback, - const gchar *popup_title, - const gchar *initial_brush, - gdouble opacity, - gint spacing, - GimpLayerModeEffects paint_mode); + const gchar *popup_title, + const gchar *initial_brush, + gdouble opacity, + gint spacing, + GimpLayerModeEffects paint_mode); gboolean gimp_brushes_close_popup (const gchar *brush_callback); gboolean gimp_brushes_set_popup (const gchar *brush_callback, - const gchar *brush_name, - gdouble opacity, - gint spacing, - GimpLayerModeEffects paint_mode); + const gchar *brush_name, + gdouble opacity, + gint spacing, + GimpLayerModeEffects paint_mode); G_END_DECLS diff --git a/libgimp/gimpbuffer_pdb.c b/libgimp/gimpbuffer_pdb.c index 2758155aee..b0c03fce1d 100644 --- a/libgimp/gimpbuffer_pdb.c +++ b/libgimp/gimpbuffer_pdb.c @@ -41,7 +41,7 @@ */ gchar ** gimp_buffers_get_list (const gchar *filter, - gint *num_buffers) + gint *num_buffers) { GimpParam *return_vals; gint nreturn_vals; @@ -49,9 +49,9 @@ gimp_buffers_get_list (const gchar *filter, gint i; return_vals = gimp_run_procedure ("gimp-buffers-get-list", - &nreturn_vals, - GIMP_PDB_STRING, filter, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, filter, + GIMP_PDB_END); *num_buffers = 0; @@ -83,17 +83,17 @@ gimp_buffers_get_list (const gchar *filter, */ gchar * gimp_buffer_rename (const gchar *buffer_name, - const gchar *new_name) + const gchar *new_name) { GimpParam *return_vals; gint nreturn_vals; gchar *real_name = NULL; return_vals = gimp_run_procedure ("gimp-buffer-rename", - &nreturn_vals, - GIMP_PDB_STRING, buffer_name, - GIMP_PDB_STRING, new_name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, buffer_name, + GIMP_PDB_STRING, new_name, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) real_name = g_strdup (return_vals[1].data.d_string); @@ -123,9 +123,9 @@ gimp_buffer_delete (const gchar *buffer_name) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-buffer-delete", - &nreturn_vals, - GIMP_PDB_STRING, buffer_name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, buffer_name, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -154,9 +154,9 @@ gimp_buffer_get_width (const gchar *buffer_name) gint width = 0; return_vals = gimp_run_procedure ("gimp-buffer-get-width", - &nreturn_vals, - GIMP_PDB_STRING, buffer_name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, buffer_name, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) width = return_vals[1].data.d_int32; @@ -186,9 +186,9 @@ gimp_buffer_get_height (const gchar *buffer_name) gint height = 0; return_vals = gimp_run_procedure ("gimp-buffer-get-height", - &nreturn_vals, - GIMP_PDB_STRING, buffer_name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, buffer_name, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) height = return_vals[1].data.d_int32; @@ -218,9 +218,9 @@ gimp_buffer_get_bytes (const gchar *buffer_name) gint bytes = 0; return_vals = gimp_run_procedure ("gimp-buffer-get-bytes", - &nreturn_vals, - GIMP_PDB_STRING, buffer_name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, buffer_name, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) bytes = return_vals[1].data.d_int32; @@ -250,9 +250,9 @@ gimp_buffer_get_image_type (const gchar *buffer_name) GimpImageBaseType image_type = 0; return_vals = gimp_run_procedure ("gimp-buffer-get-image-type", - &nreturn_vals, - GIMP_PDB_STRING, buffer_name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, buffer_name, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) image_type = return_vals[1].data.d_int32; diff --git a/libgimp/gimpbuffer_pdb.h b/libgimp/gimpbuffer_pdb.h index c094907515..ec900bc120 100644 --- a/libgimp/gimpbuffer_pdb.h +++ b/libgimp/gimpbuffer_pdb.h @@ -30,9 +30,9 @@ G_BEGIN_DECLS gchar** gimp_buffers_get_list (const gchar *filter, - gint *num_buffers); + gint *num_buffers); gchar* gimp_buffer_rename (const gchar *buffer_name, - const gchar *new_name); + const gchar *new_name); gboolean gimp_buffer_delete (const gchar *buffer_name); gint gimp_buffer_get_width (const gchar *buffer_name); gint gimp_buffer_get_height (const gchar *buffer_name); diff --git a/libgimp/gimpchannel_pdb.c b/libgimp/gimpchannel_pdb.c index e3e672f5bc..3090aafdef 100644 --- a/libgimp/gimpchannel_pdb.c +++ b/libgimp/gimpchannel_pdb.c @@ -48,25 +48,25 @@ */ gint32 _gimp_channel_new (gint32 image_ID, - gint width, - gint height, - const gchar *name, - gdouble opacity, - const GimpRGB *color) + gint width, + gint height, + const gchar *name, + gdouble opacity, + const GimpRGB *color) { GimpParam *return_vals; gint nreturn_vals; gint32 channel_ID = -1; return_vals = gimp_run_procedure ("gimp-channel-new", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_INT32, width, - GIMP_PDB_INT32, height, - GIMP_PDB_STRING, name, - GIMP_PDB_FLOAT, opacity, - GIMP_PDB_COLOR, color, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_INT32, width, + GIMP_PDB_INT32, height, + GIMP_PDB_STRING, name, + GIMP_PDB_FLOAT, opacity, + GIMP_PDB_COLOR, color, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) channel_ID = return_vals[1].data.d_channel; @@ -92,19 +92,19 @@ _gimp_channel_new (gint32 image_ID, */ gint32 gimp_channel_new_from_component (gint32 image_ID, - GimpChannelType component, - const gchar *name) + GimpChannelType component, + const gchar *name) { GimpParam *return_vals; gint nreturn_vals; gint32 channel_ID = -1; return_vals = gimp_run_procedure ("gimp-channel-new-from-component", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_INT32, component, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_INT32, component, + GIMP_PDB_STRING, name, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) channel_ID = return_vals[1].data.d_channel; @@ -132,9 +132,9 @@ gimp_channel_copy (gint32 channel_ID) gint32 channel_copy_ID = -1; return_vals = gimp_run_procedure ("gimp-channel-copy", - &nreturn_vals, - GIMP_PDB_CHANNEL, channel_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_CHANNEL, channel_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) channel_copy_ID = return_vals[1].data.d_channel; @@ -161,23 +161,23 @@ gimp_channel_copy (gint32 channel_ID) */ gboolean gimp_channel_combine_masks (gint32 channel1_ID, - gint32 channel2_ID, - GimpChannelOps operation, - gint offx, - gint offy) + gint32 channel2_ID, + GimpChannelOps operation, + gint offx, + gint offy) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-channel-combine-masks", - &nreturn_vals, - GIMP_PDB_CHANNEL, channel1_ID, - GIMP_PDB_CHANNEL, channel2_ID, - GIMP_PDB_INT32, operation, - GIMP_PDB_INT32, offx, - GIMP_PDB_INT32, offy, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_CHANNEL, channel1_ID, + GIMP_PDB_CHANNEL, channel2_ID, + GIMP_PDB_INT32, operation, + GIMP_PDB_INT32, offx, + GIMP_PDB_INT32, offy, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -206,9 +206,9 @@ gimp_channel_get_show_masked (gint32 channel_ID) gboolean show_masked = FALSE; return_vals = gimp_run_procedure ("gimp-channel-get-show-masked", - &nreturn_vals, - GIMP_PDB_CHANNEL, channel_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_CHANNEL, channel_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) show_masked = return_vals[1].data.d_int32; @@ -233,17 +233,17 @@ gimp_channel_get_show_masked (gint32 channel_ID) */ gboolean gimp_channel_set_show_masked (gint32 channel_ID, - gboolean show_masked) + gboolean show_masked) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-channel-set-show-masked", - &nreturn_vals, - GIMP_PDB_CHANNEL, channel_ID, - GIMP_PDB_INT32, show_masked, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_CHANNEL, channel_ID, + GIMP_PDB_INT32, show_masked, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -270,9 +270,9 @@ gimp_channel_get_opacity (gint32 channel_ID) gdouble opacity = 0.0; return_vals = gimp_run_procedure ("gimp-channel-get-opacity", - &nreturn_vals, - GIMP_PDB_CHANNEL, channel_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_CHANNEL, channel_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) opacity = return_vals[1].data.d_float; @@ -295,17 +295,17 @@ gimp_channel_get_opacity (gint32 channel_ID) */ gboolean gimp_channel_set_opacity (gint32 channel_ID, - gdouble opacity) + gdouble opacity) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-channel-set-opacity", - &nreturn_vals, - GIMP_PDB_CHANNEL, channel_ID, - GIMP_PDB_FLOAT, opacity, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_CHANNEL, channel_ID, + GIMP_PDB_FLOAT, opacity, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -327,16 +327,16 @@ gimp_channel_set_opacity (gint32 channel_ID, */ gboolean gimp_channel_get_color (gint32 channel_ID, - GimpRGB *color) + GimpRGB *color) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-channel-get-color", - &nreturn_vals, - GIMP_PDB_CHANNEL, channel_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_CHANNEL, channel_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -361,17 +361,17 @@ gimp_channel_get_color (gint32 channel_ID, */ gboolean gimp_channel_set_color (gint32 channel_ID, - const GimpRGB *color) + const GimpRGB *color) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-channel-set-color", - &nreturn_vals, - GIMP_PDB_CHANNEL, channel_ID, - GIMP_PDB_COLOR, color, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_CHANNEL, channel_ID, + GIMP_PDB_COLOR, color, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; diff --git a/libgimp/gimpchannel_pdb.h b/libgimp/gimpchannel_pdb.h index b4c14614d7..fe4d156964 100644 --- a/libgimp/gimpchannel_pdb.h +++ b/libgimp/gimpchannel_pdb.h @@ -30,30 +30,30 @@ G_BEGIN_DECLS gint32 _gimp_channel_new (gint32 image_ID, - gint width, - gint height, - const gchar *name, - gdouble opacity, - const GimpRGB *color) G_GNUC_INTERNAL; + gint width, + gint height, + const gchar *name, + gdouble opacity, + const GimpRGB *color) G_GNUC_INTERNAL; gint32 gimp_channel_new_from_component (gint32 image_ID, - GimpChannelType component, - const gchar *name); + GimpChannelType component, + const gchar *name); gint32 gimp_channel_copy (gint32 channel_ID); gboolean gimp_channel_combine_masks (gint32 channel1_ID, - gint32 channel2_ID, - GimpChannelOps operation, - gint offx, - gint offy); + gint32 channel2_ID, + GimpChannelOps operation, + gint offx, + gint offy); gboolean gimp_channel_get_show_masked (gint32 channel_ID); gboolean gimp_channel_set_show_masked (gint32 channel_ID, - gboolean show_masked); + gboolean show_masked); gdouble gimp_channel_get_opacity (gint32 channel_ID); gboolean gimp_channel_set_opacity (gint32 channel_ID, - gdouble opacity); + gdouble opacity); gboolean gimp_channel_get_color (gint32 channel_ID, - GimpRGB *color); + GimpRGB *color); gboolean gimp_channel_set_color (gint32 channel_ID, - const GimpRGB *color); + const GimpRGB *color); G_END_DECLS diff --git a/libgimp/gimpcolor_pdb.c b/libgimp/gimpcolor_pdb.c index 242bef1723..7b0d1b341b 100644 --- a/libgimp/gimpcolor_pdb.c +++ b/libgimp/gimpcolor_pdb.c @@ -41,19 +41,19 @@ */ gboolean gimp_brightness_contrast (gint32 drawable_ID, - gint brightness, - gint contrast) + gint brightness, + gint contrast) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-brightness-contrast", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, brightness, - GIMP_PDB_INT32, contrast, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, brightness, + GIMP_PDB_INT32, contrast, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -91,27 +91,27 @@ gimp_brightness_contrast (gint32 drawable_ID, */ gboolean gimp_levels (gint32 drawable_ID, - GimpHistogramChannel channel, - gint low_input, - gint high_input, - gdouble gamma, - gint low_output, - gint high_output) + GimpHistogramChannel channel, + gint low_input, + gint high_input, + gdouble gamma, + gint low_output, + gint high_output) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-levels", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, channel, - GIMP_PDB_INT32, low_input, - GIMP_PDB_INT32, high_input, - GIMP_PDB_FLOAT, gamma, - GIMP_PDB_INT32, low_output, - GIMP_PDB_INT32, high_output, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, channel, + GIMP_PDB_INT32, low_input, + GIMP_PDB_INT32, high_input, + GIMP_PDB_FLOAT, gamma, + GIMP_PDB_INT32, low_output, + GIMP_PDB_INT32, high_output, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -136,9 +136,9 @@ gimp_levels_auto (gint32 drawable_ID) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-levels-auto", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -169,9 +169,9 @@ gimp_levels_stretch (gint32 drawable_ID) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-levels-stretch", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -194,17 +194,17 @@ gimp_levels_stretch (gint32 drawable_ID) */ gboolean gimp_posterize (gint32 drawable_ID, - gint levels) + gint levels) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-posterize", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, levels, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, levels, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -232,9 +232,9 @@ gimp_desaturate (gint32 drawable_ID) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-desaturate", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -261,17 +261,17 @@ gimp_desaturate (gint32 drawable_ID) */ gboolean gimp_desaturate_full (gint32 drawable_ID, - GimpDesaturateMode desaturate_mode) + GimpDesaturateMode desaturate_mode) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-desaturate-full", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, desaturate_mode, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, desaturate_mode, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -300,17 +300,17 @@ gimp_desaturate_full (gint32 drawable_ID, */ gboolean gimp_equalize (gint32 drawable_ID, - gboolean mask_only) + gboolean mask_only) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-equalize", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, mask_only, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, mask_only, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -340,9 +340,9 @@ gimp_invert (gint32 drawable_ID) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-invert", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -372,21 +372,21 @@ gimp_invert (gint32 drawable_ID) */ gboolean gimp_curves_spline (gint32 drawable_ID, - GimpHistogramChannel channel, - gint num_points, - const guint8 *control_pts) + GimpHistogramChannel channel, + gint num_points, + const guint8 *control_pts) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-curves-spline", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, channel, - GIMP_PDB_INT32, num_points, - GIMP_PDB_INT8ARRAY, control_pts, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, channel, + GIMP_PDB_INT32, num_points, + GIMP_PDB_INT8ARRAY, control_pts, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -416,21 +416,21 @@ gimp_curves_spline (gint32 drawable_ID, */ gboolean gimp_curves_explicit (gint32 drawable_ID, - GimpHistogramChannel channel, - gint num_bytes, - const guint8 *curve) + GimpHistogramChannel channel, + gint num_bytes, + const guint8 *curve) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-curves-explicit", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, channel, - GIMP_PDB_INT32, num_bytes, - GIMP_PDB_INT8ARRAY, curve, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, channel, + GIMP_PDB_INT32, num_bytes, + GIMP_PDB_INT8ARRAY, curve, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -463,25 +463,25 @@ gimp_curves_explicit (gint32 drawable_ID, */ gboolean gimp_color_balance (gint32 drawable_ID, - GimpTransferMode transfer_mode, - gboolean preserve_lum, - gdouble cyan_red, - gdouble magenta_green, - gdouble yellow_blue) + GimpTransferMode transfer_mode, + gboolean preserve_lum, + gdouble cyan_red, + gdouble magenta_green, + gdouble yellow_blue) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-color-balance", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, transfer_mode, - GIMP_PDB_INT32, preserve_lum, - GIMP_PDB_FLOAT, cyan_red, - GIMP_PDB_FLOAT, magenta_green, - GIMP_PDB_FLOAT, yellow_blue, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, transfer_mode, + GIMP_PDB_INT32, preserve_lum, + GIMP_PDB_FLOAT, cyan_red, + GIMP_PDB_FLOAT, magenta_green, + GIMP_PDB_FLOAT, yellow_blue, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -510,21 +510,21 @@ gimp_color_balance (gint32 drawable_ID, */ gboolean gimp_colorize (gint32 drawable_ID, - gdouble hue, - gdouble saturation, - gdouble lightness) + gdouble hue, + gdouble saturation, + gdouble lightness) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-colorize", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_FLOAT, hue, - GIMP_PDB_FLOAT, saturation, - GIMP_PDB_FLOAT, lightness, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_FLOAT, hue, + GIMP_PDB_FLOAT, saturation, + GIMP_PDB_FLOAT, lightness, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -567,27 +567,27 @@ gimp_colorize (gint32 drawable_ID, */ gboolean gimp_histogram (gint32 drawable_ID, - GimpHistogramChannel channel, - gint start_range, - gint end_range, - gdouble *mean, - gdouble *std_dev, - gdouble *median, - gdouble *pixels, - gdouble *count, - gdouble *percentile) + GimpHistogramChannel channel, + gint start_range, + gint end_range, + gdouble *mean, + gdouble *std_dev, + gdouble *median, + gdouble *pixels, + gdouble *count, + gdouble *percentile) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-histogram", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, channel, - GIMP_PDB_INT32, start_range, - GIMP_PDB_INT32, end_range, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, channel, + GIMP_PDB_INT32, start_range, + GIMP_PDB_INT32, end_range, + GIMP_PDB_END); *mean = 0.0; *std_dev = 0.0; @@ -631,23 +631,23 @@ gimp_histogram (gint32 drawable_ID, */ gboolean gimp_hue_saturation (gint32 drawable_ID, - GimpHueRange hue_range, - gdouble hue_offset, - gdouble lightness, - gdouble saturation) + GimpHueRange hue_range, + gdouble hue_offset, + gdouble lightness, + gdouble saturation) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-hue-saturation", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, hue_range, - GIMP_PDB_FLOAT, hue_offset, - GIMP_PDB_FLOAT, lightness, - GIMP_PDB_FLOAT, saturation, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, hue_range, + GIMP_PDB_FLOAT, hue_offset, + GIMP_PDB_FLOAT, lightness, + GIMP_PDB_FLOAT, saturation, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -673,19 +673,19 @@ gimp_hue_saturation (gint32 drawable_ID, */ gboolean gimp_threshold (gint32 drawable_ID, - gint low_threshold, - gint high_threshold) + gint low_threshold, + gint high_threshold) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-threshold", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, low_threshold, - GIMP_PDB_INT32, high_threshold, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, low_threshold, + GIMP_PDB_INT32, high_threshold, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; diff --git a/libgimp/gimpcolor_pdb.h b/libgimp/gimpcolor_pdb.h index b658370d7c..f6aaee066b 100644 --- a/libgimp/gimpcolor_pdb.h +++ b/libgimp/gimpcolor_pdb.h @@ -30,63 +30,63 @@ G_BEGIN_DECLS gboolean gimp_brightness_contrast (gint32 drawable_ID, - gint brightness, - gint contrast); + gint brightness, + gint contrast); gboolean gimp_levels (gint32 drawable_ID, - GimpHistogramChannel channel, - gint low_input, - gint high_input, - gdouble gamma, - gint low_output, - gint high_output); + GimpHistogramChannel channel, + gint low_input, + gint high_input, + gdouble gamma, + gint low_output, + gint high_output); #ifndef GIMP_DISABLE_DEPRECATED gboolean gimp_levels_auto (gint32 drawable_ID); #endif /* GIMP_DISABLE_DEPRECATED */ gboolean gimp_levels_stretch (gint32 drawable_ID); gboolean gimp_posterize (gint32 drawable_ID, - gint levels); + gint levels); gboolean gimp_desaturate (gint32 drawable_ID); gboolean gimp_desaturate_full (gint32 drawable_ID, - GimpDesaturateMode desaturate_mode); + GimpDesaturateMode desaturate_mode); gboolean gimp_equalize (gint32 drawable_ID, - gboolean mask_only); + gboolean mask_only); gboolean gimp_invert (gint32 drawable_ID); gboolean gimp_curves_spline (gint32 drawable_ID, - GimpHistogramChannel channel, - gint num_points, - const guint8 *control_pts); + GimpHistogramChannel channel, + gint num_points, + const guint8 *control_pts); gboolean gimp_curves_explicit (gint32 drawable_ID, - GimpHistogramChannel channel, - gint num_bytes, - const guint8 *curve); + GimpHistogramChannel channel, + gint num_bytes, + const guint8 *curve); gboolean gimp_color_balance (gint32 drawable_ID, - GimpTransferMode transfer_mode, - gboolean preserve_lum, - gdouble cyan_red, - gdouble magenta_green, - gdouble yellow_blue); + GimpTransferMode transfer_mode, + gboolean preserve_lum, + gdouble cyan_red, + gdouble magenta_green, + gdouble yellow_blue); gboolean gimp_colorize (gint32 drawable_ID, - gdouble hue, - gdouble saturation, - gdouble lightness); + gdouble hue, + gdouble saturation, + gdouble lightness); gboolean gimp_histogram (gint32 drawable_ID, - GimpHistogramChannel channel, - gint start_range, - gint end_range, - gdouble *mean, - gdouble *std_dev, - gdouble *median, - gdouble *pixels, - gdouble *count, - gdouble *percentile); + GimpHistogramChannel channel, + gint start_range, + gint end_range, + gdouble *mean, + gdouble *std_dev, + gdouble *median, + gdouble *pixels, + gdouble *count, + gdouble *percentile); gboolean gimp_hue_saturation (gint32 drawable_ID, - GimpHueRange hue_range, - gdouble hue_offset, - gdouble lightness, - gdouble saturation); + GimpHueRange hue_range, + gdouble hue_offset, + gdouble lightness, + gdouble saturation); gboolean gimp_threshold (gint32 drawable_ID, - gint low_threshold, - gint high_threshold); + gint low_threshold, + gint high_threshold); G_END_DECLS diff --git a/libgimp/gimpcontext_pdb.c b/libgimp/gimpcontext_pdb.c index f7963afc80..e7793c421d 100644 --- a/libgimp/gimpcontext_pdb.c +++ b/libgimp/gimpcontext_pdb.c @@ -46,8 +46,8 @@ gimp_context_push (void) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-context-push", - &nreturn_vals, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -78,8 +78,8 @@ gimp_context_pop (void) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-context-pop", - &nreturn_vals, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -108,8 +108,8 @@ gimp_context_get_paint_method (void) gchar *name = NULL; return_vals = gimp_run_procedure ("gimp-context-get-paint-method", - &nreturn_vals, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) name = g_strdup (return_vals[1].data.d_string); @@ -144,9 +144,9 @@ gimp_context_set_paint_method (const gchar *name) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-context-set-paint-method", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -177,8 +177,8 @@ gimp_context_get_foreground (GimpRGB *foreground) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-context-get-foreground", - &nreturn_vals, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -212,9 +212,9 @@ gimp_context_set_foreground (const GimpRGB *foreground) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-context-set-foreground", - &nreturn_vals, - GIMP_PDB_COLOR, foreground, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_COLOR, foreground, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -245,8 +245,8 @@ gimp_context_get_background (GimpRGB *background) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-context-get-background", - &nreturn_vals, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -281,9 +281,9 @@ gimp_context_set_background (const GimpRGB *background) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-context-set-background", - &nreturn_vals, - GIMP_PDB_COLOR, background, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_COLOR, background, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -313,8 +313,8 @@ gimp_context_set_default_colors (void) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-context-set-default-colors", - &nreturn_vals, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -344,8 +344,8 @@ gimp_context_swap_colors (void) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-context-swap-colors", - &nreturn_vals, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -374,8 +374,8 @@ gimp_context_get_opacity (void) gdouble opacity = 0.0; return_vals = gimp_run_procedure ("gimp-context-get-opacity", - &nreturn_vals, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) opacity = return_vals[1].data.d_float; @@ -406,9 +406,9 @@ gimp_context_set_opacity (gdouble opacity) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-context-set-opacity", - &nreturn_vals, - GIMP_PDB_FLOAT, opacity, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_FLOAT, opacity, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -438,8 +438,8 @@ gimp_context_get_paint_mode (void) GimpLayerModeEffects paint_mode = 0; return_vals = gimp_run_procedure ("gimp-context-get-paint-mode", - &nreturn_vals, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) paint_mode = return_vals[1].data.d_int32; @@ -469,9 +469,9 @@ gimp_context_set_paint_mode (GimpLayerModeEffects paint_mode) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-context-set-paint-mode", - &nreturn_vals, - GIMP_PDB_INT32, paint_mode, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_INT32, paint_mode, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -501,8 +501,8 @@ gimp_context_get_brush (void) gchar *name = NULL; return_vals = gimp_run_procedure ("gimp-context-get-brush", - &nreturn_vals, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) name = g_strdup (return_vals[1].data.d_string); @@ -536,9 +536,9 @@ gimp_context_set_brush (const gchar *name) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-context-set-brush", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -568,8 +568,8 @@ gimp_context_get_pattern (void) gchar *name = NULL; return_vals = gimp_run_procedure ("gimp-context-get-pattern", - &nreturn_vals, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) name = g_strdup (return_vals[1].data.d_string); @@ -604,9 +604,9 @@ gimp_context_set_pattern (const gchar *name) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-context-set-pattern", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -634,8 +634,8 @@ gimp_context_get_gradient (void) gchar *name = NULL; return_vals = gimp_run_procedure ("gimp-context-get-gradient", - &nreturn_vals, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) name = g_strdup (return_vals[1].data.d_string); @@ -670,9 +670,9 @@ gimp_context_set_gradient (const gchar *name) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-context-set-gradient", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -700,8 +700,8 @@ gimp_context_get_palette (void) gchar *name = NULL; return_vals = gimp_run_procedure ("gimp-context-get-palette", - &nreturn_vals, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) name = g_strdup (return_vals[1].data.d_string); @@ -736,9 +736,9 @@ gimp_context_set_palette (const gchar *name) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-context-set-palette", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -766,8 +766,8 @@ gimp_context_get_font (void) gchar *name = NULL; return_vals = gimp_run_procedure ("gimp-context-get-font", - &nreturn_vals, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) name = g_strdup (return_vals[1].data.d_string); @@ -801,9 +801,9 @@ gimp_context_set_font (const gchar *name) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-context-set-font", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; diff --git a/libgimp/gimpconvert_pdb.c b/libgimp/gimpconvert_pdb.c index 7403634483..b8dd1d9665 100644 --- a/libgimp/gimpconvert_pdb.c +++ b/libgimp/gimpconvert_pdb.c @@ -46,9 +46,9 @@ gimp_image_convert_rgb (gint32 image_ID) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-convert-rgb", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -77,9 +77,9 @@ gimp_image_convert_grayscale (gint32 image_ID) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-convert-grayscale", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -118,27 +118,27 @@ gimp_image_convert_grayscale (gint32 image_ID) */ gboolean gimp_image_convert_indexed (gint32 image_ID, - GimpConvertDitherType dither_type, - GimpConvertPaletteType palette_type, - gint num_cols, - gboolean alpha_dither, - gboolean remove_unused, - const gchar *palette) + GimpConvertDitherType dither_type, + GimpConvertPaletteType palette_type, + gint num_cols, + gboolean alpha_dither, + gboolean remove_unused, + const gchar *palette) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-convert-indexed", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_INT32, dither_type, - GIMP_PDB_INT32, palette_type, - GIMP_PDB_INT32, num_cols, - GIMP_PDB_INT32, alpha_dither, - GIMP_PDB_INT32, remove_unused, - GIMP_PDB_STRING, palette, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_INT32, dither_type, + GIMP_PDB_INT32, palette_type, + GIMP_PDB_INT32, num_cols, + GIMP_PDB_INT32, alpha_dither, + GIMP_PDB_INT32, remove_unused, + GIMP_PDB_STRING, palette, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; diff --git a/libgimp/gimpconvert_pdb.h b/libgimp/gimpconvert_pdb.h index 6cec7ddaab..cd53efdb83 100644 --- a/libgimp/gimpconvert_pdb.h +++ b/libgimp/gimpconvert_pdb.h @@ -32,12 +32,12 @@ G_BEGIN_DECLS gboolean gimp_image_convert_rgb (gint32 image_ID); gboolean gimp_image_convert_grayscale (gint32 image_ID); gboolean gimp_image_convert_indexed (gint32 image_ID, - GimpConvertDitherType dither_type, - GimpConvertPaletteType palette_type, - gint num_cols, - gboolean alpha_dither, - gboolean remove_unused, - const gchar *palette); + GimpConvertDitherType dither_type, + GimpConvertPaletteType palette_type, + gint num_cols, + gboolean alpha_dither, + gboolean remove_unused, + const gchar *palette); G_END_DECLS diff --git a/libgimp/gimpdisplay_pdb.c b/libgimp/gimpdisplay_pdb.c index 001555e0c2..e627bce975 100644 --- a/libgimp/gimpdisplay_pdb.c +++ b/libgimp/gimpdisplay_pdb.c @@ -47,9 +47,9 @@ gimp_display_new (gint32 image_ID) gint32 display_ID = -1; return_vals = gimp_run_procedure ("gimp-display-new", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) display_ID = return_vals[1].data.d_display; @@ -79,9 +79,9 @@ gimp_display_delete (gint32 display_ID) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-display-delete", - &nreturn_vals, - GIMP_PDB_DISPLAY, display_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DISPLAY, display_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -114,9 +114,9 @@ gimp_display_get_window_handle (gint32 display_ID) gint window = 0; return_vals = gimp_run_procedure ("gimp-display-get-window-handle", - &nreturn_vals, - GIMP_PDB_DISPLAY, display_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DISPLAY, display_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) window = return_vals[1].data.d_int32; @@ -146,8 +146,8 @@ gimp_displays_flush (void) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-displays-flush", - &nreturn_vals, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -172,17 +172,17 @@ gimp_displays_flush (void) */ gboolean gimp_displays_reconnect (gint32 old_image_ID, - gint32 new_image_ID) + gint32 new_image_ID) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-displays-reconnect", - &nreturn_vals, - GIMP_PDB_IMAGE, old_image_ID, - GIMP_PDB_IMAGE, new_image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, old_image_ID, + GIMP_PDB_IMAGE, new_image_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; diff --git a/libgimp/gimpdisplay_pdb.h b/libgimp/gimpdisplay_pdb.h index 414471daae..633955ef31 100644 --- a/libgimp/gimpdisplay_pdb.h +++ b/libgimp/gimpdisplay_pdb.h @@ -34,7 +34,7 @@ gboolean gimp_display_delete (gint32 display_ID); gint gimp_display_get_window_handle (gint32 display_ID); gboolean gimp_displays_flush (void); gboolean gimp_displays_reconnect (gint32 old_image_ID, - gint32 new_image_ID); + gint32 new_image_ID); G_END_DECLS diff --git a/libgimp/gimpdrawable_pdb.c b/libgimp/gimpdrawable_pdb.c index e958ac1f22..cf33e35ca3 100644 --- a/libgimp/gimpdrawable_pdb.c +++ b/libgimp/gimpdrawable_pdb.c @@ -49,9 +49,9 @@ gimp_drawable_delete (gint32 drawable_ID) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-drawable-delete", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -78,9 +78,9 @@ gimp_drawable_is_layer (gint32 drawable_ID) gboolean layer = FALSE; return_vals = gimp_run_procedure ("gimp-drawable-is-layer", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) layer = return_vals[1].data.d_int32; @@ -109,9 +109,9 @@ gimp_drawable_is_layer_mask (gint32 drawable_ID) gboolean layer_mask = FALSE; return_vals = gimp_run_procedure ("gimp-drawable-is-layer-mask", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) layer_mask = return_vals[1].data.d_int32; @@ -139,9 +139,9 @@ gimp_drawable_is_channel (gint32 drawable_ID) gboolean channel = FALSE; return_vals = gimp_run_procedure ("gimp-drawable-is-channel", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) channel = return_vals[1].data.d_int32; @@ -169,9 +169,9 @@ gimp_drawable_type (gint32 drawable_ID) GimpImageType type = 0; return_vals = gimp_run_procedure ("gimp-drawable-type", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) type = return_vals[1].data.d_int32; @@ -202,9 +202,9 @@ gimp_drawable_type_with_alpha (gint32 drawable_ID) GimpImageType type_with_alpha = 0; return_vals = gimp_run_procedure ("gimp-drawable-type-with-alpha", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) type_with_alpha = return_vals[1].data.d_int32; @@ -234,9 +234,9 @@ gimp_drawable_has_alpha (gint32 drawable_ID) gboolean has_alpha = FALSE; return_vals = gimp_run_procedure ("gimp-drawable-has-alpha", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) has_alpha = return_vals[1].data.d_int32; @@ -265,9 +265,9 @@ gimp_drawable_is_rgb (gint32 drawable_ID) gboolean is_rgb = FALSE; return_vals = gimp_run_procedure ("gimp-drawable-is-rgb", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) is_rgb = return_vals[1].data.d_int32; @@ -296,9 +296,9 @@ gimp_drawable_is_gray (gint32 drawable_ID) gboolean is_gray = FALSE; return_vals = gimp_run_procedure ("gimp-drawable-is-gray", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) is_gray = return_vals[1].data.d_int32; @@ -327,9 +327,9 @@ gimp_drawable_is_indexed (gint32 drawable_ID) gboolean is_indexed = FALSE; return_vals = gimp_run_procedure ("gimp-drawable-is-indexed", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) is_indexed = return_vals[1].data.d_int32; @@ -358,9 +358,9 @@ gimp_drawable_bpp (gint32 drawable_ID) gint bpp = 0; return_vals = gimp_run_procedure ("gimp-drawable-bpp", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) bpp = return_vals[1].data.d_int32; @@ -388,9 +388,9 @@ gimp_drawable_width (gint32 drawable_ID) gint width = 0; return_vals = gimp_run_procedure ("gimp-drawable-width", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) width = return_vals[1].data.d_int32; @@ -418,9 +418,9 @@ gimp_drawable_height (gint32 drawable_ID) gint height = 0; return_vals = gimp_run_procedure ("gimp-drawable-height", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) height = return_vals[1].data.d_int32; @@ -446,17 +446,17 @@ gimp_drawable_height (gint32 drawable_ID) */ gboolean gimp_drawable_offsets (gint32 drawable_ID, - gint *offset_x, - gint *offset_y) + gint *offset_x, + gint *offset_y) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-drawable-offsets", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_END); *offset_x = 0; *offset_y = 0; @@ -492,9 +492,9 @@ gimp_drawable_get_image (gint32 drawable_ID) gint32 image_ID = -1; return_vals = gimp_run_procedure ("gimp-drawable-get-image", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) image_ID = return_vals[1].data.d_image; @@ -515,17 +515,17 @@ gimp_drawable_get_image (gint32 drawable_ID) */ gboolean gimp_drawable_set_image (gint32 drawable_ID, - gint32 image_ID) + gint32 image_ID) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-drawable-set-image", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -552,9 +552,9 @@ gimp_drawable_get_name (gint32 drawable_ID) gchar *name = NULL; return_vals = gimp_run_procedure ("gimp-drawable-get-name", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) name = g_strdup (return_vals[1].data.d_string); @@ -577,17 +577,17 @@ gimp_drawable_get_name (gint32 drawable_ID) */ gboolean gimp_drawable_set_name (gint32 drawable_ID, - const gchar *name) + const gchar *name) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-drawable-set-name", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_STRING, name, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -614,9 +614,9 @@ gimp_drawable_get_visible (gint32 drawable_ID) gboolean visible = FALSE; return_vals = gimp_run_procedure ("gimp-drawable-get-visible", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) visible = return_vals[1].data.d_int32; @@ -639,17 +639,17 @@ gimp_drawable_get_visible (gint32 drawable_ID) */ gboolean gimp_drawable_set_visible (gint32 drawable_ID, - gboolean visible) + gboolean visible) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-drawable-set-visible", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, visible, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, visible, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -676,9 +676,9 @@ gimp_drawable_get_linked (gint32 drawable_ID) gboolean linked = FALSE; return_vals = gimp_run_procedure ("gimp-drawable-get-linked", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) linked = return_vals[1].data.d_int32; @@ -701,17 +701,17 @@ gimp_drawable_get_linked (gint32 drawable_ID) */ gboolean gimp_drawable_set_linked (gint32 drawable_ID, - gboolean linked) + gboolean linked) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-drawable-set-linked", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, linked, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, linked, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -741,9 +741,9 @@ gimp_drawable_get_tattoo (gint32 drawable_ID) gint tattoo = 0; return_vals = gimp_run_procedure ("gimp-drawable-get-tattoo", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) tattoo = return_vals[1].data.d_tattoo; @@ -769,17 +769,17 @@ gimp_drawable_get_tattoo (gint32 drawable_ID) */ gboolean gimp_drawable_set_tattoo (gint32 drawable_ID, - gint tattoo) + gint tattoo) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-drawable-set-tattoo", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, tattoo, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, tattoo, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -816,19 +816,19 @@ gimp_drawable_set_tattoo (gint32 drawable_ID, */ gboolean gimp_drawable_mask_bounds (gint32 drawable_ID, - gint *x1, - gint *y1, - gint *x2, - gint *y2) + gint *x1, + gint *y1, + gint *x2, + gint *y2) { GimpParam *return_vals; gint nreturn_vals; gboolean non_empty = FALSE; return_vals = gimp_run_procedure ("gimp-drawable-mask-bounds", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) { @@ -867,19 +867,19 @@ gimp_drawable_mask_bounds (gint32 drawable_ID, */ gboolean gimp_drawable_mask_intersect (gint32 drawable_ID, - gint *x, - gint *y, - gint *width, - gint *height) + gint *x, + gint *y, + gint *width, + gint *height) { GimpParam *return_vals; gint nreturn_vals; gboolean non_empty = FALSE; return_vals = gimp_run_procedure ("gimp-drawable-mask-intersect", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) { @@ -911,17 +911,17 @@ gimp_drawable_mask_intersect (gint32 drawable_ID, */ gboolean gimp_drawable_merge_shadow (gint32 drawable_ID, - gboolean undo) + gboolean undo) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-drawable-merge-shadow", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, undo, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, undo, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -949,23 +949,23 @@ gimp_drawable_merge_shadow (gint32 drawable_ID, */ gboolean gimp_drawable_update (gint32 drawable_ID, - gint x, - gint y, - gint width, - gint height) + gint x, + gint y, + gint width, + gint height) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-drawable-update", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, x, - GIMP_PDB_INT32, y, - GIMP_PDB_INT32, width, - GIMP_PDB_INT32, height, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, x, + GIMP_PDB_INT32, y, + GIMP_PDB_INT32, width, + GIMP_PDB_INT32, height, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -991,20 +991,20 @@ gimp_drawable_update (gint32 drawable_ID, */ guint8 * gimp_drawable_get_pixel (gint32 drawable_ID, - gint x_coord, - gint y_coord, - gint *num_channels) + gint x_coord, + gint y_coord, + gint *num_channels) { GimpParam *return_vals; gint nreturn_vals; guint8 *pixel = NULL; return_vals = gimp_run_procedure ("gimp-drawable-get-pixel", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, x_coord, - GIMP_PDB_INT32, y_coord, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, x_coord, + GIMP_PDB_INT32, y_coord, + GIMP_PDB_END); *num_channels = 0; @@ -1041,23 +1041,23 @@ gimp_drawable_get_pixel (gint32 drawable_ID, */ gboolean gimp_drawable_set_pixel (gint32 drawable_ID, - gint x_coord, - gint y_coord, - gint num_channels, - const guint8 *pixel) + gint x_coord, + gint y_coord, + gint num_channels, + const guint8 *pixel) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-drawable-set-pixel", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, x_coord, - GIMP_PDB_INT32, y_coord, - GIMP_PDB_INT32, num_channels, - GIMP_PDB_INT8ARRAY, pixel, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, x_coord, + GIMP_PDB_INT32, y_coord, + GIMP_PDB_INT32, num_channels, + GIMP_PDB_INT8ARRAY, pixel, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -1088,17 +1088,17 @@ gimp_drawable_set_pixel (gint32 drawable_ID, */ gboolean gimp_drawable_fill (gint32 drawable_ID, - GimpFillType fill_type) + GimpFillType fill_type) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-drawable-fill", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, fill_type, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, fill_type, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -1129,23 +1129,23 @@ gimp_drawable_fill (gint32 drawable_ID, */ gboolean gimp_drawable_offset (gint32 drawable_ID, - gboolean wrap_around, - GimpOffsetType fill_type, - gint offset_x, - gint offset_y) + gboolean wrap_around, + GimpOffsetType fill_type, + gint offset_x, + gint offset_y) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-drawable-offset", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, wrap_around, - GIMP_PDB_INT32, fill_type, - GIMP_PDB_INT32, offset_x, - GIMP_PDB_INT32, offset_y, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, wrap_around, + GIMP_PDB_INT32, fill_type, + GIMP_PDB_INT32, offset_x, + GIMP_PDB_INT32, offset_y, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -1176,24 +1176,24 @@ gimp_drawable_offset (gint32 drawable_ID, */ gboolean _gimp_drawable_thumbnail (gint32 drawable_ID, - gint width, - gint height, - gint *actual_width, - gint *actual_height, - gint *bpp, - gint *thumbnail_data_count, - guint8 **thumbnail_data) + gint width, + gint height, + gint *actual_width, + gint *actual_height, + gint *bpp, + gint *thumbnail_data_count, + guint8 **thumbnail_data) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-drawable-thumbnail", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, width, - GIMP_PDB_INT32, height, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, width, + GIMP_PDB_INT32, height, + GIMP_PDB_END); *actual_width = 0; *actual_height = 0; @@ -1247,32 +1247,32 @@ _gimp_drawable_thumbnail (gint32 drawable_ID, */ gboolean _gimp_drawable_sub_thumbnail (gint32 drawable_ID, - gint src_x, - gint src_y, - gint src_width, - gint src_height, - gint dest_width, - gint dest_height, - gint *width, - gint *height, - gint *bpp, - gint *thumbnail_data_count, - guint8 **thumbnail_data) + gint src_x, + gint src_y, + gint src_width, + gint src_height, + gint dest_width, + gint dest_height, + gint *width, + gint *height, + gint *bpp, + gint *thumbnail_data_count, + guint8 **thumbnail_data) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-drawable-sub-thumbnail", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, src_x, - GIMP_PDB_INT32, src_y, - GIMP_PDB_INT32, src_width, - GIMP_PDB_INT32, src_height, - GIMP_PDB_INT32, dest_width, - GIMP_PDB_INT32, dest_height, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, src_x, + GIMP_PDB_INT32, src_y, + GIMP_PDB_INT32, src_width, + GIMP_PDB_INT32, src_height, + GIMP_PDB_INT32, dest_width, + GIMP_PDB_INT32, dest_height, + GIMP_PDB_END); *width = 0; *height = 0; @@ -1315,19 +1315,19 @@ _gimp_drawable_sub_thumbnail (gint32 drawable_ID, */ gboolean gimp_drawable_foreground_extract (gint32 drawable_ID, - GimpForegroundExtractMode mode, - gint32 mask_ID) + GimpForegroundExtractMode mode, + gint32 mask_ID) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-drawable-foreground-extract", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, mode, - GIMP_PDB_DRAWABLE, mask_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, mode, + GIMP_PDB_DRAWABLE, mask_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; diff --git a/libgimp/gimpdrawable_pdb.h b/libgimp/gimpdrawable_pdb.h index 6e11fa6078..d2c415ef9b 100644 --- a/libgimp/gimpdrawable_pdb.h +++ b/libgimp/gimpdrawable_pdb.h @@ -43,81 +43,81 @@ gint gimp_drawable_bpp (gint32 draw gint gimp_drawable_width (gint32 drawable_ID); gint gimp_drawable_height (gint32 drawable_ID); gboolean gimp_drawable_offsets (gint32 drawable_ID, - gint *offset_x, - gint *offset_y); + gint *offset_x, + gint *offset_y); gint32 gimp_drawable_get_image (gint32 drawable_ID); #ifndef GIMP_DISABLE_DEPRECATED gboolean gimp_drawable_set_image (gint32 drawable_ID, - gint32 image_ID); + gint32 image_ID); #endif /* GIMP_DISABLE_DEPRECATED */ gchar* gimp_drawable_get_name (gint32 drawable_ID); gboolean gimp_drawable_set_name (gint32 drawable_ID, - const gchar *name); + const gchar *name); gboolean gimp_drawable_get_visible (gint32 drawable_ID); gboolean gimp_drawable_set_visible (gint32 drawable_ID, - gboolean visible); + gboolean visible); gboolean gimp_drawable_get_linked (gint32 drawable_ID); gboolean gimp_drawable_set_linked (gint32 drawable_ID, - gboolean linked); + gboolean linked); gint gimp_drawable_get_tattoo (gint32 drawable_ID); gboolean gimp_drawable_set_tattoo (gint32 drawable_ID, - gint tattoo); + gint tattoo); gboolean gimp_drawable_mask_bounds (gint32 drawable_ID, - gint *x1, - gint *y1, - gint *x2, - gint *y2); + gint *x1, + gint *y1, + gint *x2, + gint *y2); gboolean gimp_drawable_mask_intersect (gint32 drawable_ID, - gint *x, - gint *y, - gint *width, - gint *height); + gint *x, + gint *y, + gint *width, + gint *height); gboolean gimp_drawable_merge_shadow (gint32 drawable_ID, - gboolean undo); + gboolean undo); gboolean gimp_drawable_update (gint32 drawable_ID, - gint x, - gint y, - gint width, - gint height); + gint x, + gint y, + gint width, + gint height); guint8* gimp_drawable_get_pixel (gint32 drawable_ID, - gint x_coord, - gint y_coord, - gint *num_channels); + gint x_coord, + gint y_coord, + gint *num_channels); gboolean gimp_drawable_set_pixel (gint32 drawable_ID, - gint x_coord, - gint y_coord, - gint num_channels, - const guint8 *pixel); + gint x_coord, + gint y_coord, + gint num_channels, + const guint8 *pixel); gboolean gimp_drawable_fill (gint32 drawable_ID, - GimpFillType fill_type); + GimpFillType fill_type); gboolean gimp_drawable_offset (gint32 drawable_ID, - gboolean wrap_around, - GimpOffsetType fill_type, - gint offset_x, - gint offset_y); + gboolean wrap_around, + GimpOffsetType fill_type, + gint offset_x, + gint offset_y); gboolean _gimp_drawable_thumbnail (gint32 drawable_ID, - gint width, - gint height, - gint *actual_width, - gint *actual_height, - gint *bpp, - gint *thumbnail_data_count, - guint8 **thumbnail_data) G_GNUC_INTERNAL; + gint width, + gint height, + gint *actual_width, + gint *actual_height, + gint *bpp, + gint *thumbnail_data_count, + guint8 **thumbnail_data) G_GNUC_INTERNAL; gboolean _gimp_drawable_sub_thumbnail (gint32 drawable_ID, - gint src_x, - gint src_y, - gint src_width, - gint src_height, - gint dest_width, - gint dest_height, - gint *width, - gint *height, - gint *bpp, - gint *thumbnail_data_count, - guint8 **thumbnail_data) G_GNUC_INTERNAL; + gint src_x, + gint src_y, + gint src_width, + gint src_height, + gint dest_width, + gint dest_height, + gint *width, + gint *height, + gint *bpp, + gint *thumbnail_data_count, + guint8 **thumbnail_data) G_GNUC_INTERNAL; gboolean gimp_drawable_foreground_extract (gint32 drawable_ID, - GimpForegroundExtractMode mode, - gint32 mask_ID); + GimpForegroundExtractMode mode, + gint32 mask_ID); G_END_DECLS diff --git a/libgimp/gimpdrawabletransform_pdb.c b/libgimp/gimpdrawabletransform_pdb.c index 949998135c..bc34c21c03 100644 --- a/libgimp/gimpdrawabletransform_pdb.c +++ b/libgimp/gimpdrawabletransform_pdb.c @@ -51,23 +51,23 @@ */ gint32 gimp_drawable_transform_flip_simple (gint32 drawable_ID, - GimpOrientationType flip_type, - gboolean auto_center, - gdouble axis, - gboolean clip_result) + GimpOrientationType flip_type, + gboolean auto_center, + gdouble axis, + gboolean clip_result) { GimpParam *return_vals; gint nreturn_vals; gint32 ret_drawable_ID = -1; return_vals = gimp_run_procedure ("gimp-drawable-transform-flip-simple", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, flip_type, - GIMP_PDB_INT32, auto_center, - GIMP_PDB_FLOAT, axis, - GIMP_PDB_INT32, clip_result, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, flip_type, + GIMP_PDB_INT32, auto_center, + GIMP_PDB_FLOAT, axis, + GIMP_PDB_INT32, clip_result, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) ret_drawable_ID = return_vals[1].data.d_drawable; @@ -109,33 +109,33 @@ gimp_drawable_transform_flip_simple (gint32 drawable_ID, */ gint32 gimp_drawable_transform_flip (gint32 drawable_ID, - gdouble x0, - gdouble y0, - gdouble x1, - gdouble y1, - GimpTransformDirection transform_direction, - GimpInterpolationType interpolation, - gboolean supersample, - gint recursion_level, - gboolean clip_result) + gdouble x0, + gdouble y0, + gdouble x1, + gdouble y1, + GimpTransformDirection transform_direction, + GimpInterpolationType interpolation, + gboolean supersample, + gint recursion_level, + gboolean clip_result) { GimpParam *return_vals; gint nreturn_vals; gint32 ret_drawable_ID = -1; return_vals = gimp_run_procedure ("gimp-drawable-transform-flip", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_FLOAT, x0, - GIMP_PDB_FLOAT, y0, - GIMP_PDB_FLOAT, x1, - GIMP_PDB_FLOAT, y1, - GIMP_PDB_INT32, transform_direction, - GIMP_PDB_INT32, interpolation, - GIMP_PDB_INT32, supersample, - GIMP_PDB_INT32, recursion_level, - GIMP_PDB_INT32, clip_result, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_FLOAT, x0, + GIMP_PDB_FLOAT, y0, + GIMP_PDB_FLOAT, x1, + GIMP_PDB_FLOAT, y1, + GIMP_PDB_INT32, transform_direction, + GIMP_PDB_INT32, interpolation, + GIMP_PDB_INT32, supersample, + GIMP_PDB_INT32, recursion_level, + GIMP_PDB_INT32, clip_result, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) ret_drawable_ID = return_vals[1].data.d_drawable; @@ -167,27 +167,27 @@ gimp_drawable_transform_flip (gint32 drawable_ID, */ gint32 gimp_drawable_transform_flip_default (gint32 drawable_ID, - gdouble x0, - gdouble y0, - gdouble x1, - gdouble y1, - gboolean interpolate, - gboolean clip_result) + gdouble x0, + gdouble y0, + gdouble x1, + gdouble y1, + gboolean interpolate, + gboolean clip_result) { GimpParam *return_vals; gint nreturn_vals; gint32 ret_drawable_ID = -1; return_vals = gimp_run_procedure ("gimp-drawable-transform-flip-default", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_FLOAT, x0, - GIMP_PDB_FLOAT, y0, - GIMP_PDB_FLOAT, x1, - GIMP_PDB_FLOAT, y1, - GIMP_PDB_INT32, interpolate, - GIMP_PDB_INT32, clip_result, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_FLOAT, x0, + GIMP_PDB_FLOAT, y0, + GIMP_PDB_FLOAT, x1, + GIMP_PDB_FLOAT, y1, + GIMP_PDB_INT32, interpolate, + GIMP_PDB_INT32, clip_result, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) ret_drawable_ID = return_vals[1].data.d_drawable; @@ -239,41 +239,41 @@ gimp_drawable_transform_flip_default (gint32 drawable_ID, */ gint32 gimp_drawable_transform_perspective (gint32 drawable_ID, - gdouble x0, - gdouble y0, - gdouble x1, - gdouble y1, - gdouble x2, - gdouble y2, - gdouble x3, - gdouble y3, - GimpTransformDirection transform_direction, - GimpInterpolationType interpolation, - gboolean supersample, - gint recursion_level, - gboolean clip_result) + gdouble x0, + gdouble y0, + gdouble x1, + gdouble y1, + gdouble x2, + gdouble y2, + gdouble x3, + gdouble y3, + GimpTransformDirection transform_direction, + GimpInterpolationType interpolation, + gboolean supersample, + gint recursion_level, + gboolean clip_result) { GimpParam *return_vals; gint nreturn_vals; gint32 ret_drawable_ID = -1; return_vals = gimp_run_procedure ("gimp-drawable-transform-perspective", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_FLOAT, x0, - GIMP_PDB_FLOAT, y0, - GIMP_PDB_FLOAT, x1, - GIMP_PDB_FLOAT, y1, - GIMP_PDB_FLOAT, x2, - GIMP_PDB_FLOAT, y2, - GIMP_PDB_FLOAT, x3, - GIMP_PDB_FLOAT, y3, - GIMP_PDB_INT32, transform_direction, - GIMP_PDB_INT32, interpolation, - GIMP_PDB_INT32, supersample, - GIMP_PDB_INT32, recursion_level, - GIMP_PDB_INT32, clip_result, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_FLOAT, x0, + GIMP_PDB_FLOAT, y0, + GIMP_PDB_FLOAT, x1, + GIMP_PDB_FLOAT, y1, + GIMP_PDB_FLOAT, x2, + GIMP_PDB_FLOAT, y2, + GIMP_PDB_FLOAT, x3, + GIMP_PDB_FLOAT, y3, + GIMP_PDB_INT32, transform_direction, + GIMP_PDB_INT32, interpolation, + GIMP_PDB_INT32, supersample, + GIMP_PDB_INT32, recursion_level, + GIMP_PDB_INT32, clip_result, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) ret_drawable_ID = return_vals[1].data.d_drawable; @@ -310,35 +310,35 @@ gimp_drawable_transform_perspective (gint32 drawable_ID, */ gint32 gimp_drawable_transform_perspective_default (gint32 drawable_ID, - gdouble x0, - gdouble y0, - gdouble x1, - gdouble y1, - gdouble x2, - gdouble y2, - gdouble x3, - gdouble y3, - gboolean interpolate, - gboolean clip_result) + gdouble x0, + gdouble y0, + gdouble x1, + gdouble y1, + gdouble x2, + gdouble y2, + gdouble x3, + gdouble y3, + gboolean interpolate, + gboolean clip_result) { GimpParam *return_vals; gint nreturn_vals; gint32 ret_drawable_ID = -1; return_vals = gimp_run_procedure ("gimp-drawable-transform-perspective-default", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_FLOAT, x0, - GIMP_PDB_FLOAT, y0, - GIMP_PDB_FLOAT, x1, - GIMP_PDB_FLOAT, y1, - GIMP_PDB_FLOAT, x2, - GIMP_PDB_FLOAT, y2, - GIMP_PDB_FLOAT, x3, - GIMP_PDB_FLOAT, y3, - GIMP_PDB_INT32, interpolate, - GIMP_PDB_INT32, clip_result, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_FLOAT, x0, + GIMP_PDB_FLOAT, y0, + GIMP_PDB_FLOAT, x1, + GIMP_PDB_FLOAT, y1, + GIMP_PDB_FLOAT, x2, + GIMP_PDB_FLOAT, y2, + GIMP_PDB_FLOAT, x3, + GIMP_PDB_FLOAT, y3, + GIMP_PDB_INT32, interpolate, + GIMP_PDB_INT32, clip_result, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) ret_drawable_ID = return_vals[1].data.d_drawable; @@ -374,25 +374,25 @@ gimp_drawable_transform_perspective_default (gint32 drawable_ID, */ gint32 gimp_drawable_transform_rotate_simple (gint32 drawable_ID, - GimpRotationType rotate_type, - gboolean auto_center, - gint center_x, - gint center_y, - gboolean clip_result) + GimpRotationType rotate_type, + gboolean auto_center, + gint center_x, + gint center_y, + gboolean clip_result) { GimpParam *return_vals; gint nreturn_vals; gint32 ret_drawable_ID = -1; return_vals = gimp_run_procedure ("gimp-drawable-transform-rotate-simple", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, rotate_type, - GIMP_PDB_INT32, auto_center, - GIMP_PDB_INT32, center_x, - GIMP_PDB_INT32, center_y, - GIMP_PDB_INT32, clip_result, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, rotate_type, + GIMP_PDB_INT32, auto_center, + GIMP_PDB_INT32, center_x, + GIMP_PDB_INT32, center_y, + GIMP_PDB_INT32, clip_result, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) ret_drawable_ID = return_vals[1].data.d_drawable; @@ -432,33 +432,33 @@ gimp_drawable_transform_rotate_simple (gint32 drawable_ID, */ gint32 gimp_drawable_transform_rotate (gint32 drawable_ID, - gdouble angle, - gboolean auto_center, - gint center_x, - gint center_y, - GimpTransformDirection transform_direction, - GimpInterpolationType interpolation, - gboolean supersample, - gint recursion_level, - gboolean clip_result) + gdouble angle, + gboolean auto_center, + gint center_x, + gint center_y, + GimpTransformDirection transform_direction, + GimpInterpolationType interpolation, + gboolean supersample, + gint recursion_level, + gboolean clip_result) { GimpParam *return_vals; gint nreturn_vals; gint32 ret_drawable_ID = -1; return_vals = gimp_run_procedure ("gimp-drawable-transform-rotate", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_FLOAT, angle, - GIMP_PDB_INT32, auto_center, - GIMP_PDB_INT32, center_x, - GIMP_PDB_INT32, center_y, - GIMP_PDB_INT32, transform_direction, - GIMP_PDB_INT32, interpolation, - GIMP_PDB_INT32, supersample, - GIMP_PDB_INT32, recursion_level, - GIMP_PDB_INT32, clip_result, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_FLOAT, angle, + GIMP_PDB_INT32, auto_center, + GIMP_PDB_INT32, center_x, + GIMP_PDB_INT32, center_y, + GIMP_PDB_INT32, transform_direction, + GIMP_PDB_INT32, interpolation, + GIMP_PDB_INT32, supersample, + GIMP_PDB_INT32, recursion_level, + GIMP_PDB_INT32, clip_result, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) ret_drawable_ID = return_vals[1].data.d_drawable; @@ -491,27 +491,27 @@ gimp_drawable_transform_rotate (gint32 drawable_ID, */ gint32 gimp_drawable_transform_rotate_default (gint32 drawable_ID, - gdouble angle, - gboolean auto_center, - gint center_x, - gint center_y, - gboolean interpolate, - gboolean clip_result) + gdouble angle, + gboolean auto_center, + gint center_x, + gint center_y, + gboolean interpolate, + gboolean clip_result) { GimpParam *return_vals; gint nreturn_vals; gint32 ret_drawable_ID = -1; return_vals = gimp_run_procedure ("gimp-drawable-transform-rotate-default", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_FLOAT, angle, - GIMP_PDB_INT32, auto_center, - GIMP_PDB_INT32, center_x, - GIMP_PDB_INT32, center_y, - GIMP_PDB_INT32, interpolate, - GIMP_PDB_INT32, clip_result, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_FLOAT, angle, + GIMP_PDB_INT32, auto_center, + GIMP_PDB_INT32, center_x, + GIMP_PDB_INT32, center_y, + GIMP_PDB_INT32, interpolate, + GIMP_PDB_INT32, clip_result, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) ret_drawable_ID = return_vals[1].data.d_drawable; @@ -550,33 +550,33 @@ gimp_drawable_transform_rotate_default (gint32 drawable_ID, */ gint32 gimp_drawable_transform_scale (gint32 drawable_ID, - gdouble x0, - gdouble y0, - gdouble x1, - gdouble y1, - GimpTransformDirection transform_direction, - GimpInterpolationType interpolation, - gboolean supersample, - gint recursion_level, - gboolean clip_result) + gdouble x0, + gdouble y0, + gdouble x1, + gdouble y1, + GimpTransformDirection transform_direction, + GimpInterpolationType interpolation, + gboolean supersample, + gint recursion_level, + gboolean clip_result) { GimpParam *return_vals; gint nreturn_vals; gint32 ret_drawable_ID = -1; return_vals = gimp_run_procedure ("gimp-drawable-transform-scale", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_FLOAT, x0, - GIMP_PDB_FLOAT, y0, - GIMP_PDB_FLOAT, x1, - GIMP_PDB_FLOAT, y1, - GIMP_PDB_INT32, transform_direction, - GIMP_PDB_INT32, interpolation, - GIMP_PDB_INT32, supersample, - GIMP_PDB_INT32, recursion_level, - GIMP_PDB_INT32, clip_result, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_FLOAT, x0, + GIMP_PDB_FLOAT, y0, + GIMP_PDB_FLOAT, x1, + GIMP_PDB_FLOAT, y1, + GIMP_PDB_INT32, transform_direction, + GIMP_PDB_INT32, interpolation, + GIMP_PDB_INT32, supersample, + GIMP_PDB_INT32, recursion_level, + GIMP_PDB_INT32, clip_result, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) ret_drawable_ID = return_vals[1].data.d_drawable; @@ -608,27 +608,27 @@ gimp_drawable_transform_scale (gint32 drawable_ID, */ gint32 gimp_drawable_transform_scale_default (gint32 drawable_ID, - gdouble x0, - gdouble y0, - gdouble x1, - gdouble y1, - gboolean interpolate, - gboolean clip_result) + gdouble x0, + gdouble y0, + gdouble x1, + gdouble y1, + gboolean interpolate, + gboolean clip_result) { GimpParam *return_vals; gint nreturn_vals; gint32 ret_drawable_ID = -1; return_vals = gimp_run_procedure ("gimp-drawable-transform-scale-default", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_FLOAT, x0, - GIMP_PDB_FLOAT, y0, - GIMP_PDB_FLOAT, x1, - GIMP_PDB_FLOAT, y1, - GIMP_PDB_INT32, interpolate, - GIMP_PDB_INT32, clip_result, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_FLOAT, x0, + GIMP_PDB_FLOAT, y0, + GIMP_PDB_FLOAT, x1, + GIMP_PDB_FLOAT, y1, + GIMP_PDB_INT32, interpolate, + GIMP_PDB_INT32, clip_result, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) ret_drawable_ID = return_vals[1].data.d_drawable; @@ -669,29 +669,29 @@ gimp_drawable_transform_scale_default (gint32 drawable_ID, */ gint32 gimp_drawable_transform_shear (gint32 drawable_ID, - GimpOrientationType shear_type, - gdouble magnitude, - GimpTransformDirection transform_direction, - GimpInterpolationType interpolation, - gboolean supersample, - gint recursion_level, - gboolean clip_result) + GimpOrientationType shear_type, + gdouble magnitude, + GimpTransformDirection transform_direction, + GimpInterpolationType interpolation, + gboolean supersample, + gint recursion_level, + gboolean clip_result) { GimpParam *return_vals; gint nreturn_vals; gint32 ret_drawable_ID = -1; return_vals = gimp_run_procedure ("gimp-drawable-transform-shear", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, shear_type, - GIMP_PDB_FLOAT, magnitude, - GIMP_PDB_INT32, transform_direction, - GIMP_PDB_INT32, interpolation, - GIMP_PDB_INT32, supersample, - GIMP_PDB_INT32, recursion_level, - GIMP_PDB_INT32, clip_result, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, shear_type, + GIMP_PDB_FLOAT, magnitude, + GIMP_PDB_INT32, transform_direction, + GIMP_PDB_INT32, interpolation, + GIMP_PDB_INT32, supersample, + GIMP_PDB_INT32, recursion_level, + GIMP_PDB_INT32, clip_result, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) ret_drawable_ID = return_vals[1].data.d_drawable; @@ -722,23 +722,23 @@ gimp_drawable_transform_shear (gint32 drawable_ID, */ gint32 gimp_drawable_transform_shear_default (gint32 drawable_ID, - GimpOrientationType shear_type, - gdouble magnitude, - gboolean interpolate, - gboolean clip_result) + GimpOrientationType shear_type, + gdouble magnitude, + gboolean interpolate, + gboolean clip_result) { GimpParam *return_vals; gint nreturn_vals; gint32 ret_drawable_ID = -1; return_vals = gimp_run_procedure ("gimp-drawable-transform-shear-default", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, shear_type, - GIMP_PDB_FLOAT, magnitude, - GIMP_PDB_INT32, interpolate, - GIMP_PDB_INT32, clip_result, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, shear_type, + GIMP_PDB_FLOAT, magnitude, + GIMP_PDB_INT32, interpolate, + GIMP_PDB_INT32, clip_result, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) ret_drawable_ID = return_vals[1].data.d_drawable; @@ -783,39 +783,39 @@ gimp_drawable_transform_shear_default (gint32 drawable_ID, */ gint32 gimp_drawable_transform_2d (gint32 drawable_ID, - gdouble source_x, - gdouble source_y, - gdouble scale_x, - gdouble scale_y, - gdouble angle, - gdouble dest_x, - gdouble dest_y, - GimpTransformDirection transform_direction, - GimpInterpolationType interpolation, - gboolean supersample, - gint recursion_level, - gboolean clip_result) + gdouble source_x, + gdouble source_y, + gdouble scale_x, + gdouble scale_y, + gdouble angle, + gdouble dest_x, + gdouble dest_y, + GimpTransformDirection transform_direction, + GimpInterpolationType interpolation, + gboolean supersample, + gint recursion_level, + gboolean clip_result) { GimpParam *return_vals; gint nreturn_vals; gint32 ret_drawable_ID = -1; return_vals = gimp_run_procedure ("gimp-drawable-transform-2d", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_FLOAT, source_x, - GIMP_PDB_FLOAT, source_y, - GIMP_PDB_FLOAT, scale_x, - GIMP_PDB_FLOAT, scale_y, - GIMP_PDB_FLOAT, angle, - GIMP_PDB_FLOAT, dest_x, - GIMP_PDB_FLOAT, dest_y, - GIMP_PDB_INT32, transform_direction, - GIMP_PDB_INT32, interpolation, - GIMP_PDB_INT32, supersample, - GIMP_PDB_INT32, recursion_level, - GIMP_PDB_INT32, clip_result, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_FLOAT, source_x, + GIMP_PDB_FLOAT, source_y, + GIMP_PDB_FLOAT, scale_x, + GIMP_PDB_FLOAT, scale_y, + GIMP_PDB_FLOAT, angle, + GIMP_PDB_FLOAT, dest_x, + GIMP_PDB_FLOAT, dest_y, + GIMP_PDB_INT32, transform_direction, + GIMP_PDB_INT32, interpolation, + GIMP_PDB_INT32, supersample, + GIMP_PDB_INT32, recursion_level, + GIMP_PDB_INT32, clip_result, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) ret_drawable_ID = return_vals[1].data.d_drawable; @@ -850,33 +850,33 @@ gimp_drawable_transform_2d (gint32 drawable_ID, */ gint32 gimp_drawable_transform_2d_default (gint32 drawable_ID, - gdouble source_x, - gdouble source_y, - gdouble scale_x, - gdouble scale_y, - gdouble angle, - gdouble dest_x, - gdouble dest_y, - gboolean interpolate, - gboolean clip_result) + gdouble source_x, + gdouble source_y, + gdouble scale_x, + gdouble scale_y, + gdouble angle, + gdouble dest_x, + gdouble dest_y, + gboolean interpolate, + gboolean clip_result) { GimpParam *return_vals; gint nreturn_vals; gint32 ret_drawable_ID = -1; return_vals = gimp_run_procedure ("gimp-drawable-transform-2d-default", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_FLOAT, source_x, - GIMP_PDB_FLOAT, source_y, - GIMP_PDB_FLOAT, scale_x, - GIMP_PDB_FLOAT, scale_y, - GIMP_PDB_FLOAT, angle, - GIMP_PDB_FLOAT, dest_x, - GIMP_PDB_FLOAT, dest_y, - GIMP_PDB_INT32, interpolate, - GIMP_PDB_INT32, clip_result, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_FLOAT, source_x, + GIMP_PDB_FLOAT, source_y, + GIMP_PDB_FLOAT, scale_x, + GIMP_PDB_FLOAT, scale_y, + GIMP_PDB_FLOAT, angle, + GIMP_PDB_FLOAT, dest_x, + GIMP_PDB_FLOAT, dest_y, + GIMP_PDB_INT32, interpolate, + GIMP_PDB_INT32, clip_result, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) ret_drawable_ID = return_vals[1].data.d_drawable; @@ -921,43 +921,43 @@ gimp_drawable_transform_2d_default (gint32 drawable_ID, */ gint32 gimp_drawable_transform_matrix (gint32 drawable_ID, - gdouble coeff_0_0, - gdouble coeff_0_1, - gdouble coeff_0_2, - gdouble coeff_1_0, - gdouble coeff_1_1, - gdouble coeff_1_2, - gdouble coeff_2_0, - gdouble coeff_2_1, - gdouble coeff_2_2, - GimpTransformDirection transform_direction, - GimpInterpolationType interpolation, - gboolean supersample, - gint recursion_level, - gboolean clip_result) + gdouble coeff_0_0, + gdouble coeff_0_1, + gdouble coeff_0_2, + gdouble coeff_1_0, + gdouble coeff_1_1, + gdouble coeff_1_2, + gdouble coeff_2_0, + gdouble coeff_2_1, + gdouble coeff_2_2, + GimpTransformDirection transform_direction, + GimpInterpolationType interpolation, + gboolean supersample, + gint recursion_level, + gboolean clip_result) { GimpParam *return_vals; gint nreturn_vals; gint32 ret_drawable_ID = -1; return_vals = gimp_run_procedure ("gimp-drawable-transform-matrix", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_FLOAT, coeff_0_0, - GIMP_PDB_FLOAT, coeff_0_1, - GIMP_PDB_FLOAT, coeff_0_2, - GIMP_PDB_FLOAT, coeff_1_0, - GIMP_PDB_FLOAT, coeff_1_1, - GIMP_PDB_FLOAT, coeff_1_2, - GIMP_PDB_FLOAT, coeff_2_0, - GIMP_PDB_FLOAT, coeff_2_1, - GIMP_PDB_FLOAT, coeff_2_2, - GIMP_PDB_INT32, transform_direction, - GIMP_PDB_INT32, interpolation, - GIMP_PDB_INT32, supersample, - GIMP_PDB_INT32, recursion_level, - GIMP_PDB_INT32, clip_result, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_FLOAT, coeff_0_0, + GIMP_PDB_FLOAT, coeff_0_1, + GIMP_PDB_FLOAT, coeff_0_2, + GIMP_PDB_FLOAT, coeff_1_0, + GIMP_PDB_FLOAT, coeff_1_1, + GIMP_PDB_FLOAT, coeff_1_2, + GIMP_PDB_FLOAT, coeff_2_0, + GIMP_PDB_FLOAT, coeff_2_1, + GIMP_PDB_FLOAT, coeff_2_2, + GIMP_PDB_INT32, transform_direction, + GIMP_PDB_INT32, interpolation, + GIMP_PDB_INT32, supersample, + GIMP_PDB_INT32, recursion_level, + GIMP_PDB_INT32, clip_result, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) ret_drawable_ID = return_vals[1].data.d_drawable; @@ -994,37 +994,37 @@ gimp_drawable_transform_matrix (gint32 drawable_ID, */ gint32 gimp_drawable_transform_matrix_default (gint32 drawable_ID, - gdouble coeff_0_0, - gdouble coeff_0_1, - gdouble coeff_0_2, - gdouble coeff_1_0, - gdouble coeff_1_1, - gdouble coeff_1_2, - gdouble coeff_2_0, - gdouble coeff_2_1, - gdouble coeff_2_2, - gboolean interpolate, - gboolean clip_result) + gdouble coeff_0_0, + gdouble coeff_0_1, + gdouble coeff_0_2, + gdouble coeff_1_0, + gdouble coeff_1_1, + gdouble coeff_1_2, + gdouble coeff_2_0, + gdouble coeff_2_1, + gdouble coeff_2_2, + gboolean interpolate, + gboolean clip_result) { GimpParam *return_vals; gint nreturn_vals; gint32 ret_drawable_ID = -1; return_vals = gimp_run_procedure ("gimp-drawable-transform-matrix-default", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_FLOAT, coeff_0_0, - GIMP_PDB_FLOAT, coeff_0_1, - GIMP_PDB_FLOAT, coeff_0_2, - GIMP_PDB_FLOAT, coeff_1_0, - GIMP_PDB_FLOAT, coeff_1_1, - GIMP_PDB_FLOAT, coeff_1_2, - GIMP_PDB_FLOAT, coeff_2_0, - GIMP_PDB_FLOAT, coeff_2_1, - GIMP_PDB_FLOAT, coeff_2_2, - GIMP_PDB_INT32, interpolate, - GIMP_PDB_INT32, clip_result, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_FLOAT, coeff_0_0, + GIMP_PDB_FLOAT, coeff_0_1, + GIMP_PDB_FLOAT, coeff_0_2, + GIMP_PDB_FLOAT, coeff_1_0, + GIMP_PDB_FLOAT, coeff_1_1, + GIMP_PDB_FLOAT, coeff_1_2, + GIMP_PDB_FLOAT, coeff_2_0, + GIMP_PDB_FLOAT, coeff_2_1, + GIMP_PDB_FLOAT, coeff_2_2, + GIMP_PDB_INT32, interpolate, + GIMP_PDB_INT32, clip_result, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) ret_drawable_ID = return_vals[1].data.d_drawable; diff --git a/libgimp/gimpdrawabletransform_pdb.h b/libgimp/gimpdrawabletransform_pdb.h index b71113fd15..c0d082e5dc 100644 --- a/libgimp/gimpdrawabletransform_pdb.h +++ b/libgimp/gimpdrawabletransform_pdb.h @@ -30,155 +30,155 @@ G_BEGIN_DECLS gint32 gimp_drawable_transform_flip_simple (gint32 drawable_ID, - GimpOrientationType flip_type, - gboolean auto_center, - gdouble axis, - gboolean clip_result); + GimpOrientationType flip_type, + gboolean auto_center, + gdouble axis, + gboolean clip_result); gint32 gimp_drawable_transform_flip (gint32 drawable_ID, - gdouble x0, - gdouble y0, - gdouble x1, - gdouble y1, - GimpTransformDirection transform_direction, - GimpInterpolationType interpolation, - gboolean supersample, - gint recursion_level, - gboolean clip_result); + gdouble x0, + gdouble y0, + gdouble x1, + gdouble y1, + GimpTransformDirection transform_direction, + GimpInterpolationType interpolation, + gboolean supersample, + gint recursion_level, + gboolean clip_result); gint32 gimp_drawable_transform_flip_default (gint32 drawable_ID, - gdouble x0, - gdouble y0, - gdouble x1, - gdouble y1, - gboolean interpolate, - gboolean clip_result); + gdouble x0, + gdouble y0, + gdouble x1, + gdouble y1, + gboolean interpolate, + gboolean clip_result); gint32 gimp_drawable_transform_perspective (gint32 drawable_ID, - gdouble x0, - gdouble y0, - gdouble x1, - gdouble y1, - gdouble x2, - gdouble y2, - gdouble x3, - gdouble y3, - GimpTransformDirection transform_direction, - GimpInterpolationType interpolation, - gboolean supersample, - gint recursion_level, - gboolean clip_result); + gdouble x0, + gdouble y0, + gdouble x1, + gdouble y1, + gdouble x2, + gdouble y2, + gdouble x3, + gdouble y3, + GimpTransformDirection transform_direction, + GimpInterpolationType interpolation, + gboolean supersample, + gint recursion_level, + gboolean clip_result); gint32 gimp_drawable_transform_perspective_default (gint32 drawable_ID, - gdouble x0, - gdouble y0, - gdouble x1, - gdouble y1, - gdouble x2, - gdouble y2, - gdouble x3, - gdouble y3, - gboolean interpolate, - gboolean clip_result); + gdouble x0, + gdouble y0, + gdouble x1, + gdouble y1, + gdouble x2, + gdouble y2, + gdouble x3, + gdouble y3, + gboolean interpolate, + gboolean clip_result); gint32 gimp_drawable_transform_rotate_simple (gint32 drawable_ID, - GimpRotationType rotate_type, - gboolean auto_center, - gint center_x, - gint center_y, - gboolean clip_result); + GimpRotationType rotate_type, + gboolean auto_center, + gint center_x, + gint center_y, + gboolean clip_result); gint32 gimp_drawable_transform_rotate (gint32 drawable_ID, - gdouble angle, - gboolean auto_center, - gint center_x, - gint center_y, - GimpTransformDirection transform_direction, - GimpInterpolationType interpolation, - gboolean supersample, - gint recursion_level, - gboolean clip_result); + gdouble angle, + gboolean auto_center, + gint center_x, + gint center_y, + GimpTransformDirection transform_direction, + GimpInterpolationType interpolation, + gboolean supersample, + gint recursion_level, + gboolean clip_result); gint32 gimp_drawable_transform_rotate_default (gint32 drawable_ID, - gdouble angle, - gboolean auto_center, - gint center_x, - gint center_y, - gboolean interpolate, - gboolean clip_result); + gdouble angle, + gboolean auto_center, + gint center_x, + gint center_y, + gboolean interpolate, + gboolean clip_result); gint32 gimp_drawable_transform_scale (gint32 drawable_ID, - gdouble x0, - gdouble y0, - gdouble x1, - gdouble y1, - GimpTransformDirection transform_direction, - GimpInterpolationType interpolation, - gboolean supersample, - gint recursion_level, - gboolean clip_result); + gdouble x0, + gdouble y0, + gdouble x1, + gdouble y1, + GimpTransformDirection transform_direction, + GimpInterpolationType interpolation, + gboolean supersample, + gint recursion_level, + gboolean clip_result); gint32 gimp_drawable_transform_scale_default (gint32 drawable_ID, - gdouble x0, - gdouble y0, - gdouble x1, - gdouble y1, - gboolean interpolate, - gboolean clip_result); + gdouble x0, + gdouble y0, + gdouble x1, + gdouble y1, + gboolean interpolate, + gboolean clip_result); gint32 gimp_drawable_transform_shear (gint32 drawable_ID, - GimpOrientationType shear_type, - gdouble magnitude, - GimpTransformDirection transform_direction, - GimpInterpolationType interpolation, - gboolean supersample, - gint recursion_level, - gboolean clip_result); + GimpOrientationType shear_type, + gdouble magnitude, + GimpTransformDirection transform_direction, + GimpInterpolationType interpolation, + gboolean supersample, + gint recursion_level, + gboolean clip_result); gint32 gimp_drawable_transform_shear_default (gint32 drawable_ID, - GimpOrientationType shear_type, - gdouble magnitude, - gboolean interpolate, - gboolean clip_result); + GimpOrientationType shear_type, + gdouble magnitude, + gboolean interpolate, + gboolean clip_result); gint32 gimp_drawable_transform_2d (gint32 drawable_ID, - gdouble source_x, - gdouble source_y, - gdouble scale_x, - gdouble scale_y, - gdouble angle, - gdouble dest_x, - gdouble dest_y, - GimpTransformDirection transform_direction, - GimpInterpolationType interpolation, - gboolean supersample, - gint recursion_level, - gboolean clip_result); + gdouble source_x, + gdouble source_y, + gdouble scale_x, + gdouble scale_y, + gdouble angle, + gdouble dest_x, + gdouble dest_y, + GimpTransformDirection transform_direction, + GimpInterpolationType interpolation, + gboolean supersample, + gint recursion_level, + gboolean clip_result); gint32 gimp_drawable_transform_2d_default (gint32 drawable_ID, - gdouble source_x, - gdouble source_y, - gdouble scale_x, - gdouble scale_y, - gdouble angle, - gdouble dest_x, - gdouble dest_y, - gboolean interpolate, - gboolean clip_result); + gdouble source_x, + gdouble source_y, + gdouble scale_x, + gdouble scale_y, + gdouble angle, + gdouble dest_x, + gdouble dest_y, + gboolean interpolate, + gboolean clip_result); gint32 gimp_drawable_transform_matrix (gint32 drawable_ID, - gdouble coeff_0_0, - gdouble coeff_0_1, - gdouble coeff_0_2, - gdouble coeff_1_0, - gdouble coeff_1_1, - gdouble coeff_1_2, - gdouble coeff_2_0, - gdouble coeff_2_1, - gdouble coeff_2_2, - GimpTransformDirection transform_direction, - GimpInterpolationType interpolation, - gboolean supersample, - gint recursion_level, - gboolean clip_result); + gdouble coeff_0_0, + gdouble coeff_0_1, + gdouble coeff_0_2, + gdouble coeff_1_0, + gdouble coeff_1_1, + gdouble coeff_1_2, + gdouble coeff_2_0, + gdouble coeff_2_1, + gdouble coeff_2_2, + GimpTransformDirection transform_direction, + GimpInterpolationType interpolation, + gboolean supersample, + gint recursion_level, + gboolean clip_result); gint32 gimp_drawable_transform_matrix_default (gint32 drawable_ID, - gdouble coeff_0_0, - gdouble coeff_0_1, - gdouble coeff_0_2, - gdouble coeff_1_0, - gdouble coeff_1_1, - gdouble coeff_1_2, - gdouble coeff_2_0, - gdouble coeff_2_1, - gdouble coeff_2_2, - gboolean interpolate, - gboolean clip_result); + gdouble coeff_0_0, + gdouble coeff_0_1, + gdouble coeff_0_2, + gdouble coeff_1_0, + gdouble coeff_1_1, + gdouble coeff_1_2, + gdouble coeff_2_0, + gdouble coeff_2_1, + gdouble coeff_2_2, + gboolean interpolate, + gboolean clip_result); G_END_DECLS diff --git a/libgimp/gimpedit_pdb.c b/libgimp/gimpedit_pdb.c index f22bbf5bb4..93de59d3a8 100644 --- a/libgimp/gimpedit_pdb.c +++ b/libgimp/gimpedit_pdb.c @@ -48,9 +48,9 @@ gimp_edit_cut (gint32 drawable_ID) gboolean non_empty = FALSE; return_vals = gimp_run_procedure ("gimp-edit-cut", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) non_empty = return_vals[1].data.d_int32; @@ -83,9 +83,9 @@ gimp_edit_copy (gint32 drawable_ID) gboolean non_empty = FALSE; return_vals = gimp_run_procedure ("gimp-edit-copy", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) non_empty = return_vals[1].data.d_int32; @@ -120,9 +120,9 @@ gimp_edit_copy_visible (gint32 image_ID) gboolean non_empty = FALSE; return_vals = gimp_run_procedure ("gimp-edit-copy-visible", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) non_empty = return_vals[1].data.d_int32; @@ -159,17 +159,17 @@ gimp_edit_copy_visible (gint32 image_ID) */ gint32 gimp_edit_paste (gint32 drawable_ID, - gboolean paste_into) + gboolean paste_into) { GimpParam *return_vals; gint nreturn_vals; gint32 floating_sel_ID = -1; return_vals = gimp_run_procedure ("gimp-edit-paste", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, paste_into, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, paste_into, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) floating_sel_ID = return_vals[1].data.d_layer; @@ -201,8 +201,8 @@ gimp_edit_paste_as_new (void) gint32 image_ID = -1; return_vals = gimp_run_procedure ("gimp-edit-paste-as-new", - &nreturn_vals, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) image_ID = return_vals[1].data.d_image; @@ -229,17 +229,17 @@ gimp_edit_paste_as_new (void) */ gchar * gimp_edit_named_cut (gint32 drawable_ID, - const gchar *buffer_name) + const gchar *buffer_name) { GimpParam *return_vals; gint nreturn_vals; gchar *real_name = NULL; return_vals = gimp_run_procedure ("gimp-edit-named-cut", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_STRING, buffer_name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_STRING, buffer_name, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) real_name = g_strdup (return_vals[1].data.d_string); @@ -267,17 +267,17 @@ gimp_edit_named_cut (gint32 drawable_ID, */ gchar * gimp_edit_named_copy (gint32 drawable_ID, - const gchar *buffer_name) + const gchar *buffer_name) { GimpParam *return_vals; gint nreturn_vals; gchar *real_name = NULL; return_vals = gimp_run_procedure ("gimp-edit-named-copy", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_STRING, buffer_name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_STRING, buffer_name, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) real_name = g_strdup (return_vals[1].data.d_string); @@ -305,17 +305,17 @@ gimp_edit_named_copy (gint32 drawable_ID, */ gchar * gimp_edit_named_copy_visible (gint32 image_ID, - const gchar *buffer_name) + const gchar *buffer_name) { GimpParam *return_vals; gint nreturn_vals; gchar *real_name = NULL; return_vals = gimp_run_procedure ("gimp-edit-named-copy-visible", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_STRING, buffer_name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_STRING, buffer_name, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) real_name = g_strdup (return_vals[1].data.d_string); @@ -342,19 +342,19 @@ gimp_edit_named_copy_visible (gint32 image_ID, */ gint32 gimp_edit_named_paste (gint32 drawable_ID, - const gchar *buffer_name, - gboolean paste_into) + const gchar *buffer_name, + gboolean paste_into) { GimpParam *return_vals; gint nreturn_vals; gint32 floating_sel_ID = -1; return_vals = gimp_run_procedure ("gimp-edit-named-paste", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_STRING, buffer_name, - GIMP_PDB_INT32, paste_into, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_STRING, buffer_name, + GIMP_PDB_INT32, paste_into, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) floating_sel_ID = return_vals[1].data.d_layer; @@ -385,9 +385,9 @@ gimp_edit_named_paste_as_new (const gchar *buffer_name) gint32 image_ID = -1; return_vals = gimp_run_procedure ("gimp-edit-named-paste-as-new", - &nreturn_vals, - GIMP_PDB_STRING, buffer_name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, buffer_name, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) image_ID = return_vals[1].data.d_image; @@ -419,9 +419,9 @@ gimp_edit_clear (gint32 drawable_ID) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-edit-clear", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -449,17 +449,17 @@ gimp_edit_clear (gint32 drawable_ID) */ gboolean gimp_edit_fill (gint32 drawable_ID, - GimpFillType fill_type) + GimpFillType fill_type) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-edit-fill", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, fill_type, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, fill_type, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -499,29 +499,29 @@ gimp_edit_fill (gint32 drawable_ID, */ gboolean gimp_edit_bucket_fill (gint32 drawable_ID, - GimpBucketFillMode fill_mode, - GimpLayerModeEffects paint_mode, - gdouble opacity, - gdouble threshold, - gboolean sample_merged, - gdouble x, - gdouble y) + GimpBucketFillMode fill_mode, + GimpLayerModeEffects paint_mode, + gdouble opacity, + gdouble threshold, + gboolean sample_merged, + gdouble x, + gdouble y) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-edit-bucket-fill", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, fill_mode, - GIMP_PDB_INT32, paint_mode, - GIMP_PDB_FLOAT, opacity, - GIMP_PDB_FLOAT, threshold, - GIMP_PDB_INT32, sample_merged, - GIMP_PDB_FLOAT, x, - GIMP_PDB_FLOAT, y, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, fill_mode, + GIMP_PDB_INT32, paint_mode, + GIMP_PDB_FLOAT, opacity, + GIMP_PDB_FLOAT, threshold, + GIMP_PDB_INT32, sample_merged, + GIMP_PDB_FLOAT, x, + GIMP_PDB_FLOAT, y, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -561,45 +561,45 @@ gimp_edit_bucket_fill (gint32 drawable_ID, */ gboolean gimp_edit_blend (gint32 drawable_ID, - GimpBlendMode blend_mode, - GimpLayerModeEffects paint_mode, - GimpGradientType gradient_type, - gdouble opacity, - gdouble offset, - GimpRepeatMode repeat, - gboolean reverse, - gboolean supersample, - gint max_depth, - gdouble threshold, - gboolean dither, - gdouble x1, - gdouble y1, - gdouble x2, - gdouble y2) + GimpBlendMode blend_mode, + GimpLayerModeEffects paint_mode, + GimpGradientType gradient_type, + gdouble opacity, + gdouble offset, + GimpRepeatMode repeat, + gboolean reverse, + gboolean supersample, + gint max_depth, + gdouble threshold, + gboolean dither, + gdouble x1, + gdouble y1, + gdouble x2, + gdouble y2) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-edit-blend", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, blend_mode, - GIMP_PDB_INT32, paint_mode, - GIMP_PDB_INT32, gradient_type, - GIMP_PDB_FLOAT, opacity, - GIMP_PDB_FLOAT, offset, - GIMP_PDB_INT32, repeat, - GIMP_PDB_INT32, reverse, - GIMP_PDB_INT32, supersample, - GIMP_PDB_INT32, max_depth, - GIMP_PDB_FLOAT, threshold, - GIMP_PDB_INT32, dither, - GIMP_PDB_FLOAT, x1, - GIMP_PDB_FLOAT, y1, - GIMP_PDB_FLOAT, x2, - GIMP_PDB_FLOAT, y2, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, blend_mode, + GIMP_PDB_INT32, paint_mode, + GIMP_PDB_INT32, gradient_type, + GIMP_PDB_FLOAT, opacity, + GIMP_PDB_FLOAT, offset, + GIMP_PDB_INT32, repeat, + GIMP_PDB_INT32, reverse, + GIMP_PDB_INT32, supersample, + GIMP_PDB_INT32, max_depth, + GIMP_PDB_FLOAT, threshold, + GIMP_PDB_INT32, dither, + GIMP_PDB_FLOAT, x1, + GIMP_PDB_FLOAT, y1, + GIMP_PDB_FLOAT, x2, + GIMP_PDB_FLOAT, y2, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -629,9 +629,9 @@ gimp_edit_stroke (gint32 drawable_ID) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-edit-stroke", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; diff --git a/libgimp/gimpedit_pdb.h b/libgimp/gimpedit_pdb.h index 0ea42cdd9a..6801670635 100644 --- a/libgimp/gimpedit_pdb.h +++ b/libgimp/gimpedit_pdb.h @@ -33,45 +33,45 @@ gboolean gimp_edit_cut (gint32 drawable_ID); gboolean gimp_edit_copy (gint32 drawable_ID); gboolean gimp_edit_copy_visible (gint32 image_ID); gint32 gimp_edit_paste (gint32 drawable_ID, - gboolean paste_into); + gboolean paste_into); gint32 gimp_edit_paste_as_new (void); gchar* gimp_edit_named_cut (gint32 drawable_ID, - const gchar *buffer_name); + const gchar *buffer_name); gchar* gimp_edit_named_copy (gint32 drawable_ID, - const gchar *buffer_name); + const gchar *buffer_name); gchar* gimp_edit_named_copy_visible (gint32 image_ID, - const gchar *buffer_name); + const gchar *buffer_name); gint32 gimp_edit_named_paste (gint32 drawable_ID, - const gchar *buffer_name, - gboolean paste_into); + const gchar *buffer_name, + gboolean paste_into); gint32 gimp_edit_named_paste_as_new (const gchar *buffer_name); gboolean gimp_edit_clear (gint32 drawable_ID); gboolean gimp_edit_fill (gint32 drawable_ID, - GimpFillType fill_type); + GimpFillType fill_type); gboolean gimp_edit_bucket_fill (gint32 drawable_ID, - GimpBucketFillMode fill_mode, - GimpLayerModeEffects paint_mode, - gdouble opacity, - gdouble threshold, - gboolean sample_merged, - gdouble x, - gdouble y); + GimpBucketFillMode fill_mode, + GimpLayerModeEffects paint_mode, + gdouble opacity, + gdouble threshold, + gboolean sample_merged, + gdouble x, + gdouble y); gboolean gimp_edit_blend (gint32 drawable_ID, - GimpBlendMode blend_mode, - GimpLayerModeEffects paint_mode, - GimpGradientType gradient_type, - gdouble opacity, - gdouble offset, - GimpRepeatMode repeat, - gboolean reverse, - gboolean supersample, - gint max_depth, - gdouble threshold, - gboolean dither, - gdouble x1, - gdouble y1, - gdouble x2, - gdouble y2); + GimpBlendMode blend_mode, + GimpLayerModeEffects paint_mode, + GimpGradientType gradient_type, + gdouble opacity, + gdouble offset, + GimpRepeatMode repeat, + gboolean reverse, + gboolean supersample, + gint max_depth, + gdouble threshold, + gboolean dither, + gdouble x1, + gdouble y1, + gdouble x2, + gdouble y2); gboolean gimp_edit_stroke (gint32 drawable_ID); diff --git a/libgimp/gimpfileops_pdb.c b/libgimp/gimpfileops_pdb.c index 8b138a1b18..cf2e72ee00 100644 --- a/libgimp/gimpfileops_pdb.c +++ b/libgimp/gimpfileops_pdb.c @@ -45,19 +45,19 @@ */ gint32 gimp_file_load (GimpRunMode run_mode, - const gchar *filename, - const gchar *raw_filename) + const gchar *filename, + const gchar *raw_filename) { GimpParam *return_vals; gint nreturn_vals; gint32 image_ID = -1; return_vals = gimp_run_procedure ("gimp-file-load", - &nreturn_vals, - GIMP_PDB_INT32, run_mode, - GIMP_PDB_STRING, filename, - GIMP_PDB_STRING, raw_filename, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_INT32, run_mode, + GIMP_PDB_STRING, filename, + GIMP_PDB_STRING, raw_filename, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) image_ID = return_vals[1].data.d_image; @@ -84,19 +84,19 @@ gimp_file_load (GimpRunMode run_mode, */ gint32 gimp_file_load_layer (GimpRunMode run_mode, - gint32 image_ID, - const gchar *filename) + gint32 image_ID, + const gchar *filename) { GimpParam *return_vals; gint nreturn_vals; gint32 layer_ID = -1; return_vals = gimp_run_procedure ("gimp-file-load-layer", - &nreturn_vals, - GIMP_PDB_INT32, run_mode, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_STRING, filename, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_INT32, run_mode, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_STRING, filename, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) layer_ID = return_vals[1].data.d_layer; @@ -127,23 +127,23 @@ gimp_file_load_layer (GimpRunMode run_mode, */ gboolean gimp_file_save (GimpRunMode run_mode, - gint32 image_ID, - gint32 drawable_ID, - const gchar *filename, - const gchar *raw_filename) + gint32 image_ID, + gint32 drawable_ID, + const gchar *filename, + const gchar *raw_filename) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-file-save", - &nreturn_vals, - GIMP_PDB_INT32, run_mode, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_STRING, filename, - GIMP_PDB_STRING, raw_filename, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_INT32, run_mode, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_STRING, filename, + GIMP_PDB_STRING, raw_filename, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -171,9 +171,9 @@ gimp_temp_name (const gchar *extension) gchar *name = NULL; return_vals = gimp_run_procedure ("gimp-temp-name", - &nreturn_vals, - GIMP_PDB_STRING, extension, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, extension, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) name = g_strdup (return_vals[1].data.d_string); @@ -199,21 +199,21 @@ gimp_temp_name (const gchar *extension) */ gboolean gimp_register_magic_load_handler (const gchar *procedure_name, - const gchar *extensions, - const gchar *prefixes, - const gchar *magics) + const gchar *extensions, + const gchar *prefixes, + const gchar *magics) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-register-magic-load-handler", - &nreturn_vals, - GIMP_PDB_STRING, procedure_name, - GIMP_PDB_STRING, extensions, - GIMP_PDB_STRING, prefixes, - GIMP_PDB_STRING, magics, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, procedure_name, + GIMP_PDB_STRING, extensions, + GIMP_PDB_STRING, prefixes, + GIMP_PDB_STRING, magics, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -237,19 +237,19 @@ gimp_register_magic_load_handler (const gchar *procedure_name, */ gboolean gimp_register_load_handler (const gchar *procedure_name, - const gchar *extensions, - const gchar *prefixes) + const gchar *extensions, + const gchar *prefixes) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-register-load-handler", - &nreturn_vals, - GIMP_PDB_STRING, procedure_name, - GIMP_PDB_STRING, extensions, - GIMP_PDB_STRING, prefixes, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, procedure_name, + GIMP_PDB_STRING, extensions, + GIMP_PDB_STRING, prefixes, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -273,19 +273,19 @@ gimp_register_load_handler (const gchar *procedure_name, */ gboolean gimp_register_save_handler (const gchar *procedure_name, - const gchar *extensions, - const gchar *prefixes) + const gchar *extensions, + const gchar *prefixes) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-register-save-handler", - &nreturn_vals, - GIMP_PDB_STRING, procedure_name, - GIMP_PDB_STRING, extensions, - GIMP_PDB_STRING, prefixes, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, procedure_name, + GIMP_PDB_STRING, extensions, + GIMP_PDB_STRING, prefixes, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -311,17 +311,17 @@ gimp_register_save_handler (const gchar *procedure_name, */ gboolean gimp_register_file_handler_mime (const gchar *procedure_name, - const gchar *mime_type) + const gchar *mime_type) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-register-file-handler-mime", - &nreturn_vals, - GIMP_PDB_STRING, procedure_name, - GIMP_PDB_STRING, mime_type, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, procedure_name, + GIMP_PDB_STRING, mime_type, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -350,17 +350,17 @@ gimp_register_file_handler_mime (const gchar *procedure_name, */ gboolean gimp_register_thumbnail_loader (const gchar *load_proc, - const gchar *thumb_proc) + const gchar *thumb_proc) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-register-thumbnail-loader", - &nreturn_vals, - GIMP_PDB_STRING, load_proc, - GIMP_PDB_STRING, thumb_proc, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, load_proc, + GIMP_PDB_STRING, thumb_proc, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; diff --git a/libgimp/gimpfileops_pdb.h b/libgimp/gimpfileops_pdb.h index 656f07f975..cd8a944156 100644 --- a/libgimp/gimpfileops_pdb.h +++ b/libgimp/gimpfileops_pdb.h @@ -30,31 +30,31 @@ G_BEGIN_DECLS gint32 gimp_file_load (GimpRunMode run_mode, - const gchar *filename, - const gchar *raw_filename); + const gchar *filename, + const gchar *raw_filename); gint32 gimp_file_load_layer (GimpRunMode run_mode, - gint32 image_ID, - const gchar *filename); + gint32 image_ID, + const gchar *filename); gboolean gimp_file_save (GimpRunMode run_mode, - gint32 image_ID, - gint32 drawable_ID, - const gchar *filename, - const gchar *raw_filename); + gint32 image_ID, + gint32 drawable_ID, + const gchar *filename, + const gchar *raw_filename); gchar* gimp_temp_name (const gchar *extension); gboolean gimp_register_magic_load_handler (const gchar *procedure_name, - const gchar *extensions, - const gchar *prefixes, - const gchar *magics); + const gchar *extensions, + const gchar *prefixes, + const gchar *magics); gboolean gimp_register_load_handler (const gchar *procedure_name, - const gchar *extensions, - const gchar *prefixes); + const gchar *extensions, + const gchar *prefixes); gboolean gimp_register_save_handler (const gchar *procedure_name, - const gchar *extensions, - const gchar *prefixes); + const gchar *extensions, + const gchar *prefixes); gboolean gimp_register_file_handler_mime (const gchar *procedure_name, - const gchar *mime_type); + const gchar *mime_type); gboolean gimp_register_thumbnail_loader (const gchar *load_proc, - const gchar *thumb_proc); + const gchar *thumb_proc); G_END_DECLS diff --git a/libgimp/gimpfloatingsel_pdb.c b/libgimp/gimpfloatingsel_pdb.c index 897df68d09..c34c12e077 100644 --- a/libgimp/gimpfloatingsel_pdb.c +++ b/libgimp/gimpfloatingsel_pdb.c @@ -45,9 +45,9 @@ gimp_floating_sel_remove (gint32 floating_sel_ID) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-floating-sel-remove", - &nreturn_vals, - GIMP_PDB_LAYER, floating_sel_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_LAYER, floating_sel_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -77,9 +77,9 @@ gimp_floating_sel_anchor (gint32 floating_sel_ID) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-floating-sel-anchor", - &nreturn_vals, - GIMP_PDB_LAYER, floating_sel_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_LAYER, floating_sel_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -113,9 +113,9 @@ gimp_floating_sel_to_layer (gint32 floating_sel_ID) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-floating-sel-to-layer", - &nreturn_vals, - GIMP_PDB_LAYER, floating_sel_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_LAYER, floating_sel_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -138,17 +138,17 @@ gimp_floating_sel_to_layer (gint32 floating_sel_ID) */ gboolean gimp_floating_sel_attach (gint32 layer_ID, - gint32 drawable_ID) + gint32 drawable_ID) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-floating-sel-attach", - &nreturn_vals, - GIMP_PDB_LAYER, layer_ID, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_LAYER, layer_ID, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -170,17 +170,17 @@ gimp_floating_sel_attach (gint32 layer_ID, */ gboolean gimp_floating_sel_rigor (gint32 floating_sel_ID, - gboolean undo) + gboolean undo) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-floating-sel-rigor", - &nreturn_vals, - GIMP_PDB_LAYER, floating_sel_ID, - GIMP_PDB_INT32, undo, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_LAYER, floating_sel_ID, + GIMP_PDB_INT32, undo, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -202,17 +202,17 @@ gimp_floating_sel_rigor (gint32 floating_sel_ID, */ gboolean gimp_floating_sel_relax (gint32 floating_sel_ID, - gboolean undo) + gboolean undo) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-floating-sel-relax", - &nreturn_vals, - GIMP_PDB_LAYER, floating_sel_ID, - GIMP_PDB_INT32, undo, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_LAYER, floating_sel_ID, + GIMP_PDB_INT32, undo, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; diff --git a/libgimp/gimpfloatingsel_pdb.h b/libgimp/gimpfloatingsel_pdb.h index 3a161a88a3..6d098dae1c 100644 --- a/libgimp/gimpfloatingsel_pdb.h +++ b/libgimp/gimpfloatingsel_pdb.h @@ -33,11 +33,11 @@ gboolean gimp_floating_sel_remove (gint32 floating_sel_ID); gboolean gimp_floating_sel_anchor (gint32 floating_sel_ID); gboolean gimp_floating_sel_to_layer (gint32 floating_sel_ID); gboolean gimp_floating_sel_attach (gint32 layer_ID, - gint32 drawable_ID); + gint32 drawable_ID); gboolean gimp_floating_sel_rigor (gint32 floating_sel_ID, - gboolean undo); + gboolean undo); gboolean gimp_floating_sel_relax (gint32 floating_sel_ID, - gboolean undo); + gboolean undo); G_END_DECLS diff --git a/libgimp/gimpfonts_pdb.c b/libgimp/gimpfonts_pdb.c index 17726ebc71..e4abe97f8f 100644 --- a/libgimp/gimpfonts_pdb.c +++ b/libgimp/gimpfonts_pdb.c @@ -43,8 +43,8 @@ gimp_fonts_refresh (void) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-fonts-refresh", - &nreturn_vals, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -67,7 +67,7 @@ gimp_fonts_refresh (void) */ gchar ** gimp_fonts_get_list (const gchar *filter, - gint *num_fonts) + gint *num_fonts) { GimpParam *return_vals; gint nreturn_vals; @@ -75,9 +75,9 @@ gimp_fonts_get_list (const gchar *filter, gint i; return_vals = gimp_run_procedure ("gimp-fonts-get-list", - &nreturn_vals, - GIMP_PDB_STRING, filter, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, filter, + GIMP_PDB_END); *num_fonts = 0; diff --git a/libgimp/gimpfonts_pdb.h b/libgimp/gimpfonts_pdb.h index 9568748560..c11786388c 100644 --- a/libgimp/gimpfonts_pdb.h +++ b/libgimp/gimpfonts_pdb.h @@ -31,7 +31,7 @@ G_BEGIN_DECLS gboolean gimp_fonts_refresh (void); gchar** gimp_fonts_get_list (const gchar *filter, - gint *num_fonts); + gint *num_fonts); G_END_DECLS diff --git a/libgimp/gimpfontselect_pdb.c b/libgimp/gimpfontselect_pdb.c index ebc50ca4ec..b64096957b 100644 --- a/libgimp/gimpfontselect_pdb.c +++ b/libgimp/gimpfontselect_pdb.c @@ -39,19 +39,19 @@ */ gboolean gimp_fonts_popup (const gchar *font_callback, - const gchar *popup_title, - const gchar *initial_font) + const gchar *popup_title, + const gchar *initial_font) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-fonts-popup", - &nreturn_vals, - GIMP_PDB_STRING, font_callback, - GIMP_PDB_STRING, popup_title, - GIMP_PDB_STRING, initial_font, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, font_callback, + GIMP_PDB_STRING, popup_title, + GIMP_PDB_STRING, initial_font, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -78,9 +78,9 @@ gimp_fonts_close_popup (const gchar *font_callback) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-fonts-close-popup", - &nreturn_vals, - GIMP_PDB_STRING, font_callback, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, font_callback, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -102,17 +102,17 @@ gimp_fonts_close_popup (const gchar *font_callback) */ gboolean gimp_fonts_set_popup (const gchar *font_callback, - const gchar *font_name) + const gchar *font_name) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-fonts-set-popup", - &nreturn_vals, - GIMP_PDB_STRING, font_callback, - GIMP_PDB_STRING, font_name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, font_callback, + GIMP_PDB_STRING, font_name, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; diff --git a/libgimp/gimpfontselect_pdb.h b/libgimp/gimpfontselect_pdb.h index aed1c49b23..d7bde4eb87 100644 --- a/libgimp/gimpfontselect_pdb.h +++ b/libgimp/gimpfontselect_pdb.h @@ -30,11 +30,11 @@ G_BEGIN_DECLS gboolean gimp_fonts_popup (const gchar *font_callback, - const gchar *popup_title, - const gchar *initial_font); + const gchar *popup_title, + const gchar *initial_font); gboolean gimp_fonts_close_popup (const gchar *font_callback); gboolean gimp_fonts_set_popup (const gchar *font_callback, - const gchar *font_name); + const gchar *font_name); G_END_DECLS diff --git a/libgimp/gimpgimprc_pdb.c b/libgimp/gimpgimprc_pdb.c index d6b4efa552..a9cf4fa233 100644 --- a/libgimp/gimpgimprc_pdb.c +++ b/libgimp/gimpgimprc_pdb.c @@ -51,9 +51,9 @@ gimp_gimprc_query (const gchar *token) gchar *value = NULL; return_vals = gimp_run_procedure ("gimp-gimprc-query", - &nreturn_vals, - GIMP_PDB_STRING, token, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, token, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) value = g_strdup (return_vals[1].data.d_string); @@ -80,17 +80,17 @@ gimp_gimprc_query (const gchar *token) */ gboolean gimp_gimprc_set (const gchar *token, - const gchar *value) + const gchar *value) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-gimprc-set", - &nreturn_vals, - GIMP_PDB_STRING, token, - GIMP_PDB_STRING, value, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, token, + GIMP_PDB_STRING, value, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -116,8 +116,8 @@ gimp_get_default_comment (void) gchar *comment = NULL; return_vals = gimp_run_procedure ("gimp-get-default-comment", - &nreturn_vals, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) comment = g_strdup (return_vals[1].data.d_string); @@ -143,15 +143,15 @@ gimp_get_default_comment (void) */ gboolean gimp_get_monitor_resolution (gdouble *xres, - gdouble *yres) + gdouble *yres) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-get-monitor-resolution", - &nreturn_vals, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_END); *xres = 0.0; *yres = 0.0; @@ -186,8 +186,8 @@ gimp_get_theme_dir (void) gchar *theme_dir = NULL; return_vals = gimp_run_procedure ("gimp-get-theme-dir", - &nreturn_vals, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) theme_dir = g_strdup (return_vals[1].data.d_string); @@ -217,8 +217,8 @@ _gimp_get_color_configuration (void) gchar *config = NULL; return_vals = gimp_run_procedure ("gimp-get-color-configuration", - &nreturn_vals, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) config = g_strdup (return_vals[1].data.d_string); @@ -245,8 +245,8 @@ gimp_get_module_load_inhibit (void) gchar *load_inhibit = NULL; return_vals = gimp_run_procedure ("gimp-get-module-load-inhibit", - &nreturn_vals, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) load_inhibit = g_strdup (return_vals[1].data.d_string); diff --git a/libgimp/gimpgimprc_pdb.h b/libgimp/gimpgimprc_pdb.h index 5256980ce6..2a9fa865a6 100644 --- a/libgimp/gimpgimprc_pdb.h +++ b/libgimp/gimpgimprc_pdb.h @@ -31,10 +31,10 @@ G_BEGIN_DECLS gchar* gimp_gimprc_query (const gchar *token); gboolean gimp_gimprc_set (const gchar *token, - const gchar *value); + const gchar *value); gchar* gimp_get_default_comment (void); gboolean gimp_get_monitor_resolution (gdouble *xres, - gdouble *yres); + gdouble *yres); gchar* gimp_get_theme_dir (void); gchar* _gimp_get_color_configuration (void) G_GNUC_INTERNAL; gchar* gimp_get_module_load_inhibit (void); diff --git a/libgimp/gimpgradient_pdb.c b/libgimp/gimpgradient_pdb.c index c0ce2a034b..91c0938301 100644 --- a/libgimp/gimpgradient_pdb.c +++ b/libgimp/gimpgradient_pdb.c @@ -47,9 +47,9 @@ gimp_gradient_new (const gchar *name) gchar *actual_name = NULL; return_vals = gimp_run_procedure ("gimp-gradient-new", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) actual_name = g_strdup (return_vals[1].data.d_string); @@ -79,9 +79,9 @@ gimp_gradient_duplicate (const gchar *name) gchar *copy_name = NULL; return_vals = gimp_run_procedure ("gimp-gradient-duplicate", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) copy_name = g_strdup (return_vals[1].data.d_string); @@ -111,9 +111,9 @@ gimp_gradient_is_editable (const gchar *name) gboolean editable = FALSE; return_vals = gimp_run_procedure ("gimp-gradient-is-editable", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) editable = return_vals[1].data.d_int32; @@ -138,17 +138,17 @@ gimp_gradient_is_editable (const gchar *name) */ gchar * gimp_gradient_rename (const gchar *name, - const gchar *new_name) + const gchar *new_name) { GimpParam *return_vals; gint nreturn_vals; gchar *actual_name = NULL; return_vals = gimp_run_procedure ("gimp-gradient-rename", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_STRING, new_name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_STRING, new_name, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) actual_name = g_strdup (return_vals[1].data.d_string); @@ -178,9 +178,9 @@ gimp_gradient_delete (const gchar *name) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-gradient-delete", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -213,21 +213,21 @@ gimp_gradient_delete (const gchar *name) */ gboolean gimp_gradient_get_uniform_samples (const gchar *name, - gint num_samples, - gboolean reverse, - gint *num_color_samples, - gdouble **color_samples) + gint num_samples, + gboolean reverse, + gint *num_color_samples, + gdouble **color_samples) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-gradient-get-uniform-samples", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_INT32, num_samples, - GIMP_PDB_INT32, reverse, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_INT32, num_samples, + GIMP_PDB_INT32, reverse, + GIMP_PDB_END); *num_color_samples = 0; *color_samples = NULL; @@ -271,23 +271,23 @@ gimp_gradient_get_uniform_samples (const gchar *name, */ gboolean gimp_gradient_get_custom_samples (const gchar *name, - gint num_samples, - const gdouble *positions, - gboolean reverse, - gint *num_color_samples, - gdouble **color_samples) + gint num_samples, + const gdouble *positions, + gboolean reverse, + gint *num_color_samples, + gdouble **color_samples) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-gradient-get-custom-samples", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_INT32, num_samples, - GIMP_PDB_FLOATARRAY, positions, - GIMP_PDB_INT32, reverse, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_INT32, num_samples, + GIMP_PDB_FLOATARRAY, positions, + GIMP_PDB_INT32, reverse, + GIMP_PDB_END); *num_color_samples = 0; *color_samples = NULL; @@ -325,19 +325,19 @@ gimp_gradient_get_custom_samples (const gchar *name, */ gboolean gimp_gradient_segment_get_left_color (const gchar *name, - gint segment, - GimpRGB *color, - gdouble *opacity) + gint segment, + GimpRGB *color, + gdouble *opacity) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-gradient-segment-get-left-color", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_INT32, segment, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_INT32, segment, + GIMP_PDB_END); *opacity = 0.0; @@ -372,21 +372,21 @@ gimp_gradient_segment_get_left_color (const gchar *name, */ gboolean gimp_gradient_segment_set_left_color (const gchar *name, - gint segment, - const GimpRGB *color, - gdouble opacity) + gint segment, + const GimpRGB *color, + gdouble opacity) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-gradient-segment-set-left-color", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_INT32, segment, - GIMP_PDB_COLOR, color, - GIMP_PDB_FLOAT, opacity, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_INT32, segment, + GIMP_PDB_COLOR, color, + GIMP_PDB_FLOAT, opacity, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -413,19 +413,19 @@ gimp_gradient_segment_set_left_color (const gchar *name, */ gboolean gimp_gradient_segment_get_right_color (const gchar *name, - gint segment, - GimpRGB *color, - gdouble *opacity) + gint segment, + GimpRGB *color, + gdouble *opacity) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-gradient-segment-get-right-color", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_INT32, segment, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_INT32, segment, + GIMP_PDB_END); *opacity = 0.0; @@ -460,21 +460,21 @@ gimp_gradient_segment_get_right_color (const gchar *name, */ gboolean gimp_gradient_segment_set_right_color (const gchar *name, - gint segment, - const GimpRGB *color, - gdouble opacity) + gint segment, + const GimpRGB *color, + gdouble opacity) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-gradient-segment-set-right-color", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_INT32, segment, - GIMP_PDB_COLOR, color, - GIMP_PDB_FLOAT, opacity, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_INT32, segment, + GIMP_PDB_COLOR, color, + GIMP_PDB_FLOAT, opacity, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -500,18 +500,18 @@ gimp_gradient_segment_set_right_color (const gchar *name, */ gboolean gimp_gradient_segment_get_left_pos (const gchar *name, - gint segment, - gdouble *pos) + gint segment, + gdouble *pos) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-gradient-segment-get-left-pos", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_INT32, segment, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_INT32, segment, + GIMP_PDB_END); *pos = 0.0; @@ -546,20 +546,20 @@ gimp_gradient_segment_get_left_pos (const gchar *name, */ gboolean gimp_gradient_segment_set_left_pos (const gchar *name, - gint segment, - gdouble pos, - gdouble *final_pos) + gint segment, + gdouble pos, + gdouble *final_pos) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-gradient-segment-set-left-pos", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_INT32, segment, - GIMP_PDB_FLOAT, pos, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_INT32, segment, + GIMP_PDB_FLOAT, pos, + GIMP_PDB_END); *final_pos = 0.0; @@ -590,18 +590,18 @@ gimp_gradient_segment_set_left_pos (const gchar *name, */ gboolean gimp_gradient_segment_get_middle_pos (const gchar *name, - gint segment, - gdouble *pos) + gint segment, + gdouble *pos) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-gradient-segment-get-middle-pos", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_INT32, segment, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_INT32, segment, + GIMP_PDB_END); *pos = 0.0; @@ -635,20 +635,20 @@ gimp_gradient_segment_get_middle_pos (const gchar *name, */ gboolean gimp_gradient_segment_set_middle_pos (const gchar *name, - gint segment, - gdouble pos, - gdouble *final_pos) + gint segment, + gdouble pos, + gdouble *final_pos) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-gradient-segment-set-middle-pos", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_INT32, segment, - GIMP_PDB_FLOAT, pos, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_INT32, segment, + GIMP_PDB_FLOAT, pos, + GIMP_PDB_END); *final_pos = 0.0; @@ -679,18 +679,18 @@ gimp_gradient_segment_set_middle_pos (const gchar *name, */ gboolean gimp_gradient_segment_get_right_pos (const gchar *name, - gint segment, - gdouble *pos) + gint segment, + gdouble *pos) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-gradient-segment-get-right-pos", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_INT32, segment, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_INT32, segment, + GIMP_PDB_END); *pos = 0.0; @@ -725,20 +725,20 @@ gimp_gradient_segment_get_right_pos (const gchar *name, */ gboolean gimp_gradient_segment_set_right_pos (const gchar *name, - gint segment, - gdouble pos, - gdouble *final_pos) + gint segment, + gdouble pos, + gdouble *final_pos) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-gradient-segment-set-right-pos", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_INT32, segment, - GIMP_PDB_FLOAT, pos, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_INT32, segment, + GIMP_PDB_FLOAT, pos, + GIMP_PDB_END); *final_pos = 0.0; @@ -769,18 +769,18 @@ gimp_gradient_segment_set_right_pos (const gchar *name, */ gboolean gimp_gradient_segment_get_blending_function (const gchar *name, - gint segment, - GimpGradientSegmentType *blend_func) + gint segment, + GimpGradientSegmentType *blend_func) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-gradient-segment-get-blending-function", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_INT32, segment, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_INT32, segment, + GIMP_PDB_END); *blend_func = 0; @@ -811,18 +811,18 @@ gimp_gradient_segment_get_blending_function (const gchar *name, */ gboolean gimp_gradient_segment_get_coloring_type (const gchar *name, - gint segment, - GimpGradientSegmentColor *coloring_type) + gint segment, + GimpGradientSegmentColor *coloring_type) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-gradient-segment-get-coloring-type", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_INT32, segment, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_INT32, segment, + GIMP_PDB_END); *coloring_type = 0; @@ -854,21 +854,21 @@ gimp_gradient_segment_get_coloring_type (const gchar *name, */ gboolean gimp_gradient_segment_range_set_blending_function (const gchar *name, - gint start_segment, - gint end_segment, - GimpGradientSegmentType blending_function) + gint start_segment, + gint end_segment, + GimpGradientSegmentType blending_function) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-gradient-segment-range-set-blending-function", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_INT32, start_segment, - GIMP_PDB_INT32, end_segment, - GIMP_PDB_INT32, blending_function, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_INT32, start_segment, + GIMP_PDB_INT32, end_segment, + GIMP_PDB_INT32, blending_function, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -895,21 +895,21 @@ gimp_gradient_segment_range_set_blending_function (const gchar *name */ gboolean gimp_gradient_segment_range_set_coloring_type (const gchar *name, - gint start_segment, - gint end_segment, - GimpGradientSegmentColor coloring_type) + gint start_segment, + gint end_segment, + GimpGradientSegmentColor coloring_type) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-gradient-segment-range-set-coloring-type", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_INT32, start_segment, - GIMP_PDB_INT32, end_segment, - GIMP_PDB_INT32, coloring_type, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_INT32, start_segment, + GIMP_PDB_INT32, end_segment, + GIMP_PDB_INT32, coloring_type, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -934,19 +934,19 @@ gimp_gradient_segment_range_set_coloring_type (const gchar *name, */ gboolean gimp_gradient_segment_range_flip (const gchar *name, - gint start_segment, - gint end_segment) + gint start_segment, + gint end_segment) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-gradient-segment-range-flip", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_INT32, start_segment, - GIMP_PDB_INT32, end_segment, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_INT32, start_segment, + GIMP_PDB_INT32, end_segment, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -974,21 +974,21 @@ gimp_gradient_segment_range_flip (const gchar *name, */ gboolean gimp_gradient_segment_range_replicate (const gchar *name, - gint start_segment, - gint end_segment, - gint replicate_times) + gint start_segment, + gint end_segment, + gint replicate_times) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-gradient-segment-range-replicate", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_INT32, start_segment, - GIMP_PDB_INT32, end_segment, - GIMP_PDB_INT32, replicate_times, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_INT32, start_segment, + GIMP_PDB_INT32, end_segment, + GIMP_PDB_INT32, replicate_times, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -1014,19 +1014,19 @@ gimp_gradient_segment_range_replicate (const gchar *name, */ gboolean gimp_gradient_segment_range_split_midpoint (const gchar *name, - gint start_segment, - gint end_segment) + gint start_segment, + gint end_segment) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-gradient-segment-range-split-midpoint", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_INT32, start_segment, - GIMP_PDB_INT32, end_segment, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_INT32, start_segment, + GIMP_PDB_INT32, end_segment, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -1053,21 +1053,21 @@ gimp_gradient_segment_range_split_midpoint (const gchar *name, */ gboolean gimp_gradient_segment_range_split_uniform (const gchar *name, - gint start_segment, - gint end_segment, - gint split_parts) + gint start_segment, + gint end_segment, + gint split_parts) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-gradient-segment-range-split-uniform", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_INT32, start_segment, - GIMP_PDB_INT32, end_segment, - GIMP_PDB_INT32, split_parts, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_INT32, start_segment, + GIMP_PDB_INT32, end_segment, + GIMP_PDB_INT32, split_parts, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -1092,19 +1092,19 @@ gimp_gradient_segment_range_split_uniform (const gchar *name, */ gboolean gimp_gradient_segment_range_delete (const gchar *name, - gint start_segment, - gint end_segment) + gint start_segment, + gint end_segment) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-gradient-segment-range-delete", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_INT32, start_segment, - GIMP_PDB_INT32, end_segment, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_INT32, start_segment, + GIMP_PDB_INT32, end_segment, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -1130,19 +1130,19 @@ gimp_gradient_segment_range_delete (const gchar *name, */ gboolean gimp_gradient_segment_range_redistribute_handles (const gchar *name, - gint start_segment, - gint end_segment) + gint start_segment, + gint end_segment) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-gradient-segment-range-redistribute-handles", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_INT32, start_segment, - GIMP_PDB_INT32, end_segment, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_INT32, start_segment, + GIMP_PDB_INT32, end_segment, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -1169,19 +1169,19 @@ gimp_gradient_segment_range_redistribute_handles (const gchar *name, */ gboolean gimp_gradient_segment_range_blend_colors (const gchar *name, - gint start_segment, - gint end_segment) + gint start_segment, + gint end_segment) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-gradient-segment-range-blend-colors", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_INT32, start_segment, - GIMP_PDB_INT32, end_segment, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_INT32, start_segment, + GIMP_PDB_INT32, end_segment, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -1208,19 +1208,19 @@ gimp_gradient_segment_range_blend_colors (const gchar *name, */ gboolean gimp_gradient_segment_range_blend_opacity (const gchar *name, - gint start_segment, - gint end_segment) + gint start_segment, + gint end_segment) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-gradient-segment-range-blend-opacity", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_INT32, start_segment, - GIMP_PDB_INT32, end_segment, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_INT32, start_segment, + GIMP_PDB_INT32, end_segment, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -1249,23 +1249,23 @@ gimp_gradient_segment_range_blend_opacity (const gchar *name, */ gdouble gimp_gradient_segment_range_move (const gchar *name, - gint start_segment, - gint end_segment, - gdouble delta, - gboolean control_compress) + gint start_segment, + gint end_segment, + gdouble delta, + gboolean control_compress) { GimpParam *return_vals; gint nreturn_vals; gdouble final_delta = 0.0; return_vals = gimp_run_procedure ("gimp-gradient-segment-range-move", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_INT32, start_segment, - GIMP_PDB_INT32, end_segment, - GIMP_PDB_FLOAT, delta, - GIMP_PDB_INT32, control_compress, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_INT32, start_segment, + GIMP_PDB_INT32, end_segment, + GIMP_PDB_FLOAT, delta, + GIMP_PDB_INT32, control_compress, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) final_delta = return_vals[1].data.d_float; diff --git a/libgimp/gimpgradient_pdb.h b/libgimp/gimpgradient_pdb.h index 85688306e2..b686c6b809 100644 --- a/libgimp/gimpgradient_pdb.h +++ b/libgimp/gimpgradient_pdb.h @@ -33,101 +33,101 @@ gchar* gimp_gradient_new (const gchar gchar* gimp_gradient_duplicate (const gchar *name); gboolean gimp_gradient_is_editable (const gchar *name); gchar* gimp_gradient_rename (const gchar *name, - const gchar *new_name); + const gchar *new_name); gboolean gimp_gradient_delete (const gchar *name); gboolean gimp_gradient_get_uniform_samples (const gchar *name, - gint num_samples, - gboolean reverse, - gint *num_color_samples, - gdouble **color_samples); + gint num_samples, + gboolean reverse, + gint *num_color_samples, + gdouble **color_samples); gboolean gimp_gradient_get_custom_samples (const gchar *name, - gint num_samples, - const gdouble *positions, - gboolean reverse, - gint *num_color_samples, - gdouble **color_samples); + gint num_samples, + const gdouble *positions, + gboolean reverse, + gint *num_color_samples, + gdouble **color_samples); gboolean gimp_gradient_segment_get_left_color (const gchar *name, - gint segment, - GimpRGB *color, - gdouble *opacity); + gint segment, + GimpRGB *color, + gdouble *opacity); gboolean gimp_gradient_segment_set_left_color (const gchar *name, - gint segment, - const GimpRGB *color, - gdouble opacity); + gint segment, + const GimpRGB *color, + gdouble opacity); gboolean gimp_gradient_segment_get_right_color (const gchar *name, - gint segment, - GimpRGB *color, - gdouble *opacity); + gint segment, + GimpRGB *color, + gdouble *opacity); gboolean gimp_gradient_segment_set_right_color (const gchar *name, - gint segment, - const GimpRGB *color, - gdouble opacity); + gint segment, + const GimpRGB *color, + gdouble opacity); gboolean gimp_gradient_segment_get_left_pos (const gchar *name, - gint segment, - gdouble *pos); + gint segment, + gdouble *pos); gboolean gimp_gradient_segment_set_left_pos (const gchar *name, - gint segment, - gdouble pos, - gdouble *final_pos); + gint segment, + gdouble pos, + gdouble *final_pos); gboolean gimp_gradient_segment_get_middle_pos (const gchar *name, - gint segment, - gdouble *pos); + gint segment, + gdouble *pos); gboolean gimp_gradient_segment_set_middle_pos (const gchar *name, - gint segment, - gdouble pos, - gdouble *final_pos); + gint segment, + gdouble pos, + gdouble *final_pos); gboolean gimp_gradient_segment_get_right_pos (const gchar *name, - gint segment, - gdouble *pos); + gint segment, + gdouble *pos); gboolean gimp_gradient_segment_set_right_pos (const gchar *name, - gint segment, - gdouble pos, - gdouble *final_pos); + gint segment, + gdouble pos, + gdouble *final_pos); gboolean gimp_gradient_segment_get_blending_function (const gchar *name, - gint segment, - GimpGradientSegmentType *blend_func); + gint segment, + GimpGradientSegmentType *blend_func); gboolean gimp_gradient_segment_get_coloring_type (const gchar *name, - gint segment, - GimpGradientSegmentColor *coloring_type); + gint segment, + GimpGradientSegmentColor *coloring_type); gboolean gimp_gradient_segment_range_set_blending_function (const gchar *name, - gint start_segment, - gint end_segment, - GimpGradientSegmentType blending_function); + gint start_segment, + gint end_segment, + GimpGradientSegmentType blending_function); gboolean gimp_gradient_segment_range_set_coloring_type (const gchar *name, - gint start_segment, - gint end_segment, - GimpGradientSegmentColor coloring_type); + gint start_segment, + gint end_segment, + GimpGradientSegmentColor coloring_type); gboolean gimp_gradient_segment_range_flip (const gchar *name, - gint start_segment, - gint end_segment); + gint start_segment, + gint end_segment); gboolean gimp_gradient_segment_range_replicate (const gchar *name, - gint start_segment, - gint end_segment, - gint replicate_times); + gint start_segment, + gint end_segment, + gint replicate_times); gboolean gimp_gradient_segment_range_split_midpoint (const gchar *name, - gint start_segment, - gint end_segment); + gint start_segment, + gint end_segment); gboolean gimp_gradient_segment_range_split_uniform (const gchar *name, - gint start_segment, - gint end_segment, - gint split_parts); + gint start_segment, + gint end_segment, + gint split_parts); gboolean gimp_gradient_segment_range_delete (const gchar *name, - gint start_segment, - gint end_segment); + gint start_segment, + gint end_segment); gboolean gimp_gradient_segment_range_redistribute_handles (const gchar *name, - gint start_segment, - gint end_segment); + gint start_segment, + gint end_segment); gboolean gimp_gradient_segment_range_blend_colors (const gchar *name, - gint start_segment, - gint end_segment); + gint start_segment, + gint end_segment); gboolean gimp_gradient_segment_range_blend_opacity (const gchar *name, - gint start_segment, - gint end_segment); + gint start_segment, + gint end_segment); gdouble gimp_gradient_segment_range_move (const gchar *name, - gint start_segment, - gint end_segment, - gdouble delta, - gboolean control_compress); + gint start_segment, + gint end_segment, + gdouble delta, + gboolean control_compress); G_END_DECLS diff --git a/libgimp/gimpgradients_pdb.c b/libgimp/gimpgradients_pdb.c index 7d89f1a2a7..23788b0b1b 100644 --- a/libgimp/gimpgradients_pdb.c +++ b/libgimp/gimpgradients_pdb.c @@ -45,8 +45,8 @@ gimp_gradients_refresh (void) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-gradients-refresh", - &nreturn_vals, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -70,7 +70,7 @@ gimp_gradients_refresh (void) */ gchar ** gimp_gradients_get_list (const gchar *filter, - gint *num_gradients) + gint *num_gradients) { GimpParam *return_vals; gint nreturn_vals; @@ -78,9 +78,9 @@ gimp_gradients_get_list (const gchar *filter, gint i; return_vals = gimp_run_procedure ("gimp-gradients-get-list", - &nreturn_vals, - GIMP_PDB_STRING, filter, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, filter, + GIMP_PDB_END); *num_gradients = 0; @@ -109,7 +109,7 @@ gimp_gradients_get_list (const gchar *filter, */ gdouble * gimp_gradients_sample_uniform (gint num_samples, - gboolean reverse) + gboolean reverse) { GimpParam *return_vals; gint nreturn_vals; @@ -117,10 +117,10 @@ gimp_gradients_sample_uniform (gint num_samples, gint num_color_samples; return_vals = gimp_run_procedure ("gimp-gradients-sample-uniform", - &nreturn_vals, - GIMP_PDB_INT32, num_samples, - GIMP_PDB_INT32, reverse, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_INT32, num_samples, + GIMP_PDB_INT32, reverse, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) { @@ -148,8 +148,8 @@ gimp_gradients_sample_uniform (gint num_samples, */ gdouble * gimp_gradients_sample_custom (gint num_samples, - const gdouble *positions, - gboolean reverse) + const gdouble *positions, + gboolean reverse) { GimpParam *return_vals; gint nreturn_vals; @@ -157,11 +157,11 @@ gimp_gradients_sample_custom (gint num_samples, gint num_color_samples; return_vals = gimp_run_procedure ("gimp-gradients-sample-custom", - &nreturn_vals, - GIMP_PDB_INT32, num_samples, - GIMP_PDB_FLOATARRAY, positions, - GIMP_PDB_INT32, reverse, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_INT32, num_samples, + GIMP_PDB_FLOATARRAY, positions, + GIMP_PDB_INT32, reverse, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) { @@ -191,21 +191,21 @@ gimp_gradients_sample_custom (gint num_samples, */ gchar * gimp_gradients_get_gradient_data (const gchar *name, - gint sample_size, - gboolean reverse, - gint *width, - gdouble **grad_data) + gint sample_size, + gboolean reverse, + gint *width, + gdouble **grad_data) { GimpParam *return_vals; gint nreturn_vals; gchar *actual_name = NULL; return_vals = gimp_run_procedure ("gimp-gradients-get-gradient-data", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_INT32, sample_size, - GIMP_PDB_INT32, reverse, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_INT32, sample_size, + GIMP_PDB_INT32, reverse, + GIMP_PDB_END); *width = 0; diff --git a/libgimp/gimpgradients_pdb.h b/libgimp/gimpgradients_pdb.h index fccabee056..87321a6379 100644 --- a/libgimp/gimpgradients_pdb.h +++ b/libgimp/gimpgradients_pdb.h @@ -31,18 +31,18 @@ G_BEGIN_DECLS gboolean gimp_gradients_refresh (void); gchar** gimp_gradients_get_list (const gchar *filter, - gint *num_gradients); + gint *num_gradients); #ifndef GIMP_DISABLE_DEPRECATED gdouble* gimp_gradients_sample_uniform (gint num_samples, - gboolean reverse); + gboolean reverse); gdouble* gimp_gradients_sample_custom (gint num_samples, - const gdouble *positions, - gboolean reverse); + const gdouble *positions, + gboolean reverse); gchar* gimp_gradients_get_gradient_data (const gchar *name, - gint sample_size, - gboolean reverse, - gint *width, - gdouble **grad_data); + gint sample_size, + gboolean reverse, + gint *width, + gdouble **grad_data); #endif /* GIMP_DISABLE_DEPRECATED */ diff --git a/libgimp/gimpgradientselect_pdb.c b/libgimp/gimpgradientselect_pdb.c index 3d07c756d3..0174d5f04a 100644 --- a/libgimp/gimpgradientselect_pdb.c +++ b/libgimp/gimpgradientselect_pdb.c @@ -40,21 +40,21 @@ */ gboolean gimp_gradients_popup (const gchar *gradient_callback, - const gchar *popup_title, - const gchar *initial_gradient, - gint sample_size) + const gchar *popup_title, + const gchar *initial_gradient, + gint sample_size) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-gradients-popup", - &nreturn_vals, - GIMP_PDB_STRING, gradient_callback, - GIMP_PDB_STRING, popup_title, - GIMP_PDB_STRING, initial_gradient, - GIMP_PDB_INT32, sample_size, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, gradient_callback, + GIMP_PDB_STRING, popup_title, + GIMP_PDB_STRING, initial_gradient, + GIMP_PDB_INT32, sample_size, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -81,9 +81,9 @@ gimp_gradients_close_popup (const gchar *gradient_callback) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-gradients-close-popup", - &nreturn_vals, - GIMP_PDB_STRING, gradient_callback, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, gradient_callback, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -105,17 +105,17 @@ gimp_gradients_close_popup (const gchar *gradient_callback) */ gboolean gimp_gradients_set_popup (const gchar *gradient_callback, - const gchar *gradient_name) + const gchar *gradient_name) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-gradients-set-popup", - &nreturn_vals, - GIMP_PDB_STRING, gradient_callback, - GIMP_PDB_STRING, gradient_name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, gradient_callback, + GIMP_PDB_STRING, gradient_name, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; diff --git a/libgimp/gimpgradientselect_pdb.h b/libgimp/gimpgradientselect_pdb.h index ae19a6a980..337a52c84e 100644 --- a/libgimp/gimpgradientselect_pdb.h +++ b/libgimp/gimpgradientselect_pdb.h @@ -30,12 +30,12 @@ G_BEGIN_DECLS gboolean gimp_gradients_popup (const gchar *gradient_callback, - const gchar *popup_title, - const gchar *initial_gradient, - gint sample_size); + const gchar *popup_title, + const gchar *initial_gradient, + gint sample_size); gboolean gimp_gradients_close_popup (const gchar *gradient_callback); gboolean gimp_gradients_set_popup (const gchar *gradient_callback, - const gchar *gradient_name); + const gchar *gradient_name); G_END_DECLS diff --git a/libgimp/gimpgrid_pdb.c b/libgimp/gimpgrid_pdb.c index 501471327e..15e3a98385 100644 --- a/libgimp/gimpgrid_pdb.c +++ b/libgimp/gimpgrid_pdb.c @@ -42,17 +42,17 @@ */ gboolean gimp_image_grid_get_spacing (gint32 image_ID, - gdouble *xspacing, - gdouble *yspacing) + gdouble *xspacing, + gdouble *yspacing) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-grid-get-spacing", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); *xspacing = 0.0; *yspacing = 0.0; @@ -87,19 +87,19 @@ gimp_image_grid_get_spacing (gint32 image_ID, */ gboolean gimp_image_grid_set_spacing (gint32 image_ID, - gdouble xspacing, - gdouble yspacing) + gdouble xspacing, + gdouble yspacing) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-grid-set-spacing", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_FLOAT, xspacing, - GIMP_PDB_FLOAT, yspacing, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_FLOAT, xspacing, + GIMP_PDB_FLOAT, yspacing, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -125,17 +125,17 @@ gimp_image_grid_set_spacing (gint32 image_ID, */ gboolean gimp_image_grid_get_offset (gint32 image_ID, - gdouble *xoffset, - gdouble *yoffset) + gdouble *xoffset, + gdouble *yoffset) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-grid-get-offset", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); *xoffset = 0.0; *yoffset = 0.0; @@ -170,19 +170,19 @@ gimp_image_grid_get_offset (gint32 image_ID, */ gboolean gimp_image_grid_set_offset (gint32 image_ID, - gdouble xoffset, - gdouble yoffset) + gdouble xoffset, + gdouble yoffset) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-grid-set-offset", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_FLOAT, xoffset, - GIMP_PDB_FLOAT, yoffset, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_FLOAT, xoffset, + GIMP_PDB_FLOAT, yoffset, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -206,16 +206,16 @@ gimp_image_grid_set_offset (gint32 image_ID, */ gboolean gimp_image_grid_get_foreground_color (gint32 image_ID, - GimpRGB *fgcolor) + GimpRGB *fgcolor) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-grid-get-foreground-color", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -242,17 +242,17 @@ gimp_image_grid_get_foreground_color (gint32 image_ID, */ gboolean gimp_image_grid_set_foreground_color (gint32 image_ID, - const GimpRGB *fgcolor) + const GimpRGB *fgcolor) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-grid-set-foreground-color", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_COLOR, fgcolor, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_COLOR, fgcolor, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -276,16 +276,16 @@ gimp_image_grid_set_foreground_color (gint32 image_ID, */ gboolean gimp_image_grid_get_background_color (gint32 image_ID, - GimpRGB *bgcolor) + GimpRGB *bgcolor) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-grid-get-background-color", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -312,17 +312,17 @@ gimp_image_grid_get_background_color (gint32 image_ID, */ gboolean gimp_image_grid_set_background_color (gint32 image_ID, - const GimpRGB *bgcolor) + const GimpRGB *bgcolor) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-grid-set-background-color", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_COLOR, bgcolor, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_COLOR, bgcolor, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -351,9 +351,9 @@ gimp_image_grid_get_style (gint32 image_ID) GimpGridStyle style = 0; return_vals = gimp_run_procedure ("gimp-image-grid-get-style", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) style = return_vals[1].data.d_int32; @@ -379,17 +379,17 @@ gimp_image_grid_get_style (gint32 image_ID) */ gboolean gimp_image_grid_set_style (gint32 image_ID, - GimpGridStyle style) + GimpGridStyle style) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-grid-set-style", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_INT32, style, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_INT32, style, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; diff --git a/libgimp/gimpgrid_pdb.h b/libgimp/gimpgrid_pdb.h index e068ff14ef..0bce86e4f0 100644 --- a/libgimp/gimpgrid_pdb.h +++ b/libgimp/gimpgrid_pdb.h @@ -30,28 +30,28 @@ G_BEGIN_DECLS gboolean gimp_image_grid_get_spacing (gint32 image_ID, - gdouble *xspacing, - gdouble *yspacing); + gdouble *xspacing, + gdouble *yspacing); gboolean gimp_image_grid_set_spacing (gint32 image_ID, - gdouble xspacing, - gdouble yspacing); + gdouble xspacing, + gdouble yspacing); gboolean gimp_image_grid_get_offset (gint32 image_ID, - gdouble *xoffset, - gdouble *yoffset); + gdouble *xoffset, + gdouble *yoffset); gboolean gimp_image_grid_set_offset (gint32 image_ID, - gdouble xoffset, - gdouble yoffset); + gdouble xoffset, + gdouble yoffset); gboolean gimp_image_grid_get_foreground_color (gint32 image_ID, - GimpRGB *fgcolor); + GimpRGB *fgcolor); gboolean gimp_image_grid_set_foreground_color (gint32 image_ID, - const GimpRGB *fgcolor); + const GimpRGB *fgcolor); gboolean gimp_image_grid_get_background_color (gint32 image_ID, - GimpRGB *bgcolor); + GimpRGB *bgcolor); gboolean gimp_image_grid_set_background_color (gint32 image_ID, - const GimpRGB *bgcolor); + const GimpRGB *bgcolor); GimpGridStyle gimp_image_grid_get_style (gint32 image_ID); gboolean gimp_image_grid_set_style (gint32 image_ID, - GimpGridStyle style); + GimpGridStyle style); G_END_DECLS diff --git a/libgimp/gimpguides_pdb.c b/libgimp/gimpguides_pdb.c index c4d2e76825..46846f4a8c 100644 --- a/libgimp/gimpguides_pdb.c +++ b/libgimp/gimpguides_pdb.c @@ -40,17 +40,17 @@ */ gint32 gimp_image_add_hguide (gint32 image_ID, - gint yposition) + gint yposition) { GimpParam *return_vals; gint nreturn_vals; gint32 guide_ID = -1; return_vals = gimp_run_procedure ("gimp-image-add-hguide", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_INT32, yposition, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_INT32, yposition, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) guide_ID = return_vals[1].data.d_int32; @@ -75,17 +75,17 @@ gimp_image_add_hguide (gint32 image_ID, */ gint32 gimp_image_add_vguide (gint32 image_ID, - gint xposition) + gint xposition) { GimpParam *return_vals; gint nreturn_vals; gint32 guide_ID = -1; return_vals = gimp_run_procedure ("gimp-image-add-vguide", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_INT32, xposition, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_INT32, xposition, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) guide_ID = return_vals[1].data.d_int32; @@ -109,17 +109,17 @@ gimp_image_add_vguide (gint32 image_ID, */ gboolean gimp_image_delete_guide (gint32 image_ID, - gint32 guide_ID) + gint32 guide_ID) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-delete-guide", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_INT32, guide_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_INT32, guide_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -145,17 +145,17 @@ gimp_image_delete_guide (gint32 image_ID, */ gint32 gimp_image_find_next_guide (gint32 image_ID, - gint32 guide_ID) + gint32 guide_ID) { GimpParam *return_vals; gint nreturn_vals; gint32 next_guide_ID = -1; return_vals = gimp_run_procedure ("gimp-image-find-next-guide", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_INT32, guide_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_INT32, guide_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) next_guide_ID = return_vals[1].data.d_int32; @@ -179,17 +179,17 @@ gimp_image_find_next_guide (gint32 image_ID, */ GimpOrientationType gimp_image_get_guide_orientation (gint32 image_ID, - gint32 guide_ID) + gint32 guide_ID) { GimpParam *return_vals; gint nreturn_vals; GimpOrientationType orientation = GIMP_ORIENTATION_UNKNOWN; return_vals = gimp_run_procedure ("gimp-image-get-guide-orientation", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_INT32, guide_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_INT32, guide_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) orientation = return_vals[1].data.d_int32; @@ -213,17 +213,17 @@ gimp_image_get_guide_orientation (gint32 image_ID, */ gint gimp_image_get_guide_position (gint32 image_ID, - gint32 guide_ID) + gint32 guide_ID) { GimpParam *return_vals; gint nreturn_vals; gint position = -1; return_vals = gimp_run_procedure ("gimp-image-get-guide-position", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_INT32, guide_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_INT32, guide_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) position = return_vals[1].data.d_int32; diff --git a/libgimp/gimpguides_pdb.h b/libgimp/gimpguides_pdb.h index 76366dff5d..2cec4fd710 100644 --- a/libgimp/gimpguides_pdb.h +++ b/libgimp/gimpguides_pdb.h @@ -30,17 +30,17 @@ G_BEGIN_DECLS gint32 gimp_image_add_hguide (gint32 image_ID, - gint yposition); + gint yposition); gint32 gimp_image_add_vguide (gint32 image_ID, - gint xposition); + gint xposition); gboolean gimp_image_delete_guide (gint32 image_ID, - gint32 guide_ID); + gint32 guide_ID); gint32 gimp_image_find_next_guide (gint32 image_ID, - gint32 guide_ID); + gint32 guide_ID); GimpOrientationType gimp_image_get_guide_orientation (gint32 image_ID, - gint32 guide_ID); + gint32 guide_ID); gint gimp_image_get_guide_position (gint32 image_ID, - gint32 guide_ID); + gint32 guide_ID); G_END_DECLS diff --git a/libgimp/gimphelp_pdb.c b/libgimp/gimphelp_pdb.c index 936466e5be..2d26dd6130 100644 --- a/libgimp/gimphelp_pdb.c +++ b/libgimp/gimphelp_pdb.c @@ -43,17 +43,17 @@ */ gboolean gimp_help (const gchar *help_domain, - const gchar *help_id) + const gchar *help_id) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-help", - &nreturn_vals, - GIMP_PDB_STRING, help_domain, - GIMP_PDB_STRING, help_id, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, help_domain, + GIMP_PDB_STRING, help_id, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; diff --git a/libgimp/gimphelp_pdb.h b/libgimp/gimphelp_pdb.h index ea571a190f..903657a0f9 100644 --- a/libgimp/gimphelp_pdb.h +++ b/libgimp/gimphelp_pdb.h @@ -30,7 +30,7 @@ G_BEGIN_DECLS gboolean gimp_help (const gchar *help_domain, - const gchar *help_id); + const gchar *help_id); G_END_DECLS diff --git a/libgimp/gimpimage_pdb.c b/libgimp/gimpimage_pdb.c index f7e5714c3b..02f1d0cb09 100644 --- a/libgimp/gimpimage_pdb.c +++ b/libgimp/gimpimage_pdb.c @@ -46,8 +46,8 @@ gimp_image_list (gint *num_images) gint *image_ids = NULL; return_vals = gimp_run_procedure ("gimp-image-list", - &nreturn_vals, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_END); *num_images = 0; @@ -83,19 +83,19 @@ gimp_image_list (gint *num_images) */ gint32 gimp_image_new (gint width, - gint height, - GimpImageBaseType type) + gint height, + GimpImageBaseType type) { GimpParam *return_vals; gint nreturn_vals; gint32 image_ID = -1; return_vals = gimp_run_procedure ("gimp-image-new", - &nreturn_vals, - GIMP_PDB_INT32, width, - GIMP_PDB_INT32, height, - GIMP_PDB_INT32, type, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_INT32, width, + GIMP_PDB_INT32, height, + GIMP_PDB_INT32, type, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) image_ID = return_vals[1].data.d_image; @@ -124,9 +124,9 @@ gimp_image_duplicate (gint32 image_ID) gint32 new_image_ID = -1; return_vals = gimp_run_procedure ("gimp-image-duplicate", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) new_image_ID = return_vals[1].data.d_image; @@ -159,9 +159,9 @@ gimp_image_delete (gint32 image_ID) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-delete", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -189,9 +189,9 @@ gimp_image_base_type (gint32 image_ID) GimpImageBaseType base_type = 0; return_vals = gimp_run_procedure ("gimp-image-base-type", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) base_type = return_vals[1].data.d_int32; @@ -220,9 +220,9 @@ gimp_image_width (gint32 image_ID) gint width = 0; return_vals = gimp_run_procedure ("gimp-image-width", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) width = return_vals[1].data.d_int32; @@ -251,9 +251,9 @@ gimp_image_height (gint32 image_ID) gint height = 0; return_vals = gimp_run_procedure ("gimp-image-height", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) height = return_vals[1].data.d_int32; @@ -283,9 +283,9 @@ gimp_image_free_shadow (gint32 image_ID) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-free-shadow", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -317,23 +317,23 @@ gimp_image_free_shadow (gint32 image_ID) */ gboolean gimp_image_resize (gint32 image_ID, - gint new_width, - gint new_height, - gint offx, - gint offy) + gint new_width, + gint new_height, + gint offx, + gint offy) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-resize", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_INT32, new_width, - GIMP_PDB_INT32, new_height, - GIMP_PDB_INT32, offx, - GIMP_PDB_INT32, offy, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_INT32, new_width, + GIMP_PDB_INT32, new_height, + GIMP_PDB_INT32, offx, + GIMP_PDB_INT32, offy, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -365,9 +365,9 @@ gimp_image_resize_to_layers (gint32 image_ID) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-resize-to-layers", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -397,19 +397,19 @@ gimp_image_resize_to_layers (gint32 image_ID) */ gboolean gimp_image_scale (gint32 image_ID, - gint new_width, - gint new_height) + gint new_width, + gint new_height) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-scale", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_INT32, new_width, - GIMP_PDB_INT32, new_height, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_INT32, new_width, + GIMP_PDB_INT32, new_height, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -439,23 +439,23 @@ gimp_image_scale (gint32 image_ID, */ gboolean gimp_image_crop (gint32 image_ID, - gint new_width, - gint new_height, - gint offx, - gint offy) + gint new_width, + gint new_height, + gint offx, + gint offy) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-crop", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_INT32, new_width, - GIMP_PDB_INT32, new_height, - GIMP_PDB_INT32, offx, - GIMP_PDB_INT32, offy, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_INT32, new_width, + GIMP_PDB_INT32, new_height, + GIMP_PDB_INT32, offx, + GIMP_PDB_INT32, offy, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -477,17 +477,17 @@ gimp_image_crop (gint32 image_ID, */ gboolean gimp_image_flip (gint32 image_ID, - GimpOrientationType flip_type) + GimpOrientationType flip_type) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-flip", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_INT32, flip_type, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_INT32, flip_type, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -509,17 +509,17 @@ gimp_image_flip (gint32 image_ID, */ gboolean gimp_image_rotate (gint32 image_ID, - GimpRotationType rotate_type) + GimpRotationType rotate_type) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-rotate", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_INT32, rotate_type, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_INT32, rotate_type, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -542,16 +542,16 @@ gimp_image_rotate (gint32 image_ID, */ gint * gimp_image_get_layers (gint32 image_ID, - gint *num_layers) + gint *num_layers) { GimpParam *return_vals; gint nreturn_vals; gint *layer_ids = NULL; return_vals = gimp_run_procedure ("gimp-image-get-layers", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); *num_layers = 0; @@ -583,16 +583,16 @@ gimp_image_get_layers (gint32 image_ID, */ gint * gimp_image_get_channels (gint32 image_ID, - gint *num_channels) + gint *num_channels) { GimpParam *return_vals; gint nreturn_vals; gint *channel_ids = NULL; return_vals = gimp_run_procedure ("gimp-image-get-channels", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); *num_channels = 0; @@ -625,16 +625,16 @@ gimp_image_get_channels (gint32 image_ID, */ gint * gimp_image_get_vectors (gint32 image_ID, - gint *num_vectors) + gint *num_vectors) { GimpParam *return_vals; gint nreturn_vals; gint *vector_ids = NULL; return_vals = gimp_run_procedure ("gimp-image-get-vectors", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); *num_vectors = 0; @@ -674,9 +674,9 @@ gimp_image_get_active_drawable (gint32 image_ID) gint32 drawable_ID = -1; return_vals = gimp_run_procedure ("gimp-image-get-active-drawable", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) drawable_ID = return_vals[1].data.d_drawable; @@ -707,9 +707,9 @@ gimp_image_unset_active_channel (gint32 image_ID) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-unset-active-channel", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -737,9 +737,9 @@ gimp_image_get_floating_sel (gint32 image_ID) gint32 floating_sel_ID = -1; return_vals = gimp_run_procedure ("gimp-image-get-floating-sel", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) floating_sel_ID = return_vals[1].data.d_layer; @@ -769,9 +769,9 @@ gimp_image_floating_sel_attached_to (gint32 image_ID) gint32 drawable_ID = -1; return_vals = gimp_run_procedure ("gimp-image-floating-sel-attached-to", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) drawable_ID = return_vals[1].data.d_drawable; @@ -810,28 +810,28 @@ gimp_image_floating_sel_attached_to (gint32 image_ID) */ gboolean gimp_image_pick_color (gint32 image_ID, - gint32 drawable_ID, - gdouble x, - gdouble y, - gboolean sample_merged, - gboolean sample_average, - gdouble average_radius, - GimpRGB *color) + gint32 drawable_ID, + gdouble x, + gdouble y, + gboolean sample_merged, + gboolean sample_average, + gdouble average_radius, + GimpRGB *color) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-pick-color", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_FLOAT, x, - GIMP_PDB_FLOAT, y, - GIMP_PDB_INT32, sample_merged, - GIMP_PDB_INT32, sample_average, - GIMP_PDB_FLOAT, average_radius, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_FLOAT, x, + GIMP_PDB_FLOAT, y, + GIMP_PDB_INT32, sample_merged, + GIMP_PDB_INT32, sample_average, + GIMP_PDB_FLOAT, average_radius, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -861,19 +861,19 @@ gimp_image_pick_color (gint32 image_ID, */ gint32 gimp_image_pick_correlate_layer (gint32 image_ID, - gint x, - gint y) + gint x, + gint y) { GimpParam *return_vals; gint nreturn_vals; gint32 layer_ID = -1; return_vals = gimp_run_procedure ("gimp-image-pick-correlate-layer", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_INT32, x, - GIMP_PDB_INT32, y, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_INT32, x, + GIMP_PDB_INT32, y, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) layer_ID = return_vals[1].data.d_layer; @@ -901,19 +901,19 @@ gimp_image_pick_correlate_layer (gint32 image_ID, */ gboolean gimp_image_add_layer (gint32 image_ID, - gint32 layer_ID, - gint position) + gint32 layer_ID, + gint position) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-add-layer", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_LAYER, layer_ID, - GIMP_PDB_INT32, position, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_LAYER, layer_ID, + GIMP_PDB_INT32, position, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -939,17 +939,17 @@ gimp_image_add_layer (gint32 image_ID, */ gboolean gimp_image_remove_layer (gint32 image_ID, - gint32 layer_ID) + gint32 layer_ID) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-remove-layer", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_LAYER, layer_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_LAYER, layer_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -973,17 +973,17 @@ gimp_image_remove_layer (gint32 image_ID, */ gboolean gimp_image_raise_layer (gint32 image_ID, - gint32 layer_ID) + gint32 layer_ID) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-raise-layer", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_LAYER, layer_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_LAYER, layer_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -1007,17 +1007,17 @@ gimp_image_raise_layer (gint32 image_ID, */ gboolean gimp_image_lower_layer (gint32 image_ID, - gint32 layer_ID) + gint32 layer_ID) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-lower-layer", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_LAYER, layer_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_LAYER, layer_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -1041,17 +1041,17 @@ gimp_image_lower_layer (gint32 image_ID, */ gboolean gimp_image_raise_layer_to_top (gint32 image_ID, - gint32 layer_ID) + gint32 layer_ID) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-raise-layer-to-top", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_LAYER, layer_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_LAYER, layer_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -1076,17 +1076,17 @@ gimp_image_raise_layer_to_top (gint32 image_ID, */ gboolean gimp_image_lower_layer_to_bottom (gint32 image_ID, - gint32 layer_ID) + gint32 layer_ID) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-lower-layer-to-bottom", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_LAYER, layer_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_LAYER, layer_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -1111,19 +1111,19 @@ gimp_image_lower_layer_to_bottom (gint32 image_ID, */ gboolean gimp_image_add_channel (gint32 image_ID, - gint32 channel_ID, - gint position) + gint32 channel_ID, + gint position) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-add-channel", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_CHANNEL, channel_ID, - GIMP_PDB_INT32, position, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_CHANNEL, channel_ID, + GIMP_PDB_INT32, position, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -1146,17 +1146,17 @@ gimp_image_add_channel (gint32 image_ID, */ gboolean gimp_image_remove_channel (gint32 image_ID, - gint32 channel_ID) + gint32 channel_ID) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-remove-channel", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_CHANNEL, channel_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_CHANNEL, channel_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -1180,17 +1180,17 @@ gimp_image_remove_channel (gint32 image_ID, */ gboolean gimp_image_raise_channel (gint32 image_ID, - gint32 channel_ID) + gint32 channel_ID) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-raise-channel", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_CHANNEL, channel_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_CHANNEL, channel_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -1214,17 +1214,17 @@ gimp_image_raise_channel (gint32 image_ID, */ gboolean gimp_image_lower_channel (gint32 image_ID, - gint32 channel_ID) + gint32 channel_ID) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-lower-channel", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_CHANNEL, channel_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_CHANNEL, channel_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -1249,19 +1249,19 @@ gimp_image_lower_channel (gint32 image_ID, */ gboolean gimp_image_add_vectors (gint32 image_ID, - gint32 vectors_ID, - gint position) + gint32 vectors_ID, + gint position) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-add-vectors", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_VECTORS, vectors_ID, - GIMP_PDB_INT32, position, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_VECTORS, vectors_ID, + GIMP_PDB_INT32, position, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -1286,17 +1286,17 @@ gimp_image_add_vectors (gint32 image_ID, */ gboolean gimp_image_remove_vectors (gint32 image_ID, - gint32 vectors_ID) + gint32 vectors_ID) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-remove-vectors", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_VECTORS, vectors_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_VECTORS, vectors_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -1322,17 +1322,17 @@ gimp_image_remove_vectors (gint32 image_ID, */ gboolean gimp_image_raise_vectors (gint32 image_ID, - gint32 vectors_ID) + gint32 vectors_ID) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-raise-vectors", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_VECTORS, vectors_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_VECTORS, vectors_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -1358,17 +1358,17 @@ gimp_image_raise_vectors (gint32 image_ID, */ gboolean gimp_image_lower_vectors (gint32 image_ID, - gint32 vectors_ID) + gint32 vectors_ID) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-lower-vectors", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_VECTORS, vectors_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_VECTORS, vectors_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -1395,17 +1395,17 @@ gimp_image_lower_vectors (gint32 image_ID, */ gboolean gimp_image_raise_vectors_to_top (gint32 image_ID, - gint32 vectors_ID) + gint32 vectors_ID) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-raise-vectors-to-top", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_VECTORS, vectors_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_VECTORS, vectors_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -1432,17 +1432,17 @@ gimp_image_raise_vectors_to_top (gint32 image_ID, */ gboolean gimp_image_lower_vectors_to_bottom (gint32 image_ID, - gint32 vectors_ID) + gint32 vectors_ID) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-lower-vectors-to-bottom", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_VECTORS, vectors_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_VECTORS, vectors_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -1472,9 +1472,9 @@ gimp_image_flatten (gint32 image_ID) gint32 layer_ID = -1; return_vals = gimp_run_procedure ("gimp-image-flatten", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) layer_ID = return_vals[1].data.d_layer; @@ -1502,17 +1502,17 @@ gimp_image_flatten (gint32 image_ID) */ gint32 gimp_image_merge_visible_layers (gint32 image_ID, - GimpMergeType merge_type) + GimpMergeType merge_type) { GimpParam *return_vals; gint nreturn_vals; gint32 layer_ID = -1; return_vals = gimp_run_procedure ("gimp-image-merge-visible-layers", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_INT32, merge_type, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_INT32, merge_type, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) layer_ID = return_vals[1].data.d_layer; @@ -1542,19 +1542,19 @@ gimp_image_merge_visible_layers (gint32 image_ID, */ gint32 gimp_image_merge_down (gint32 image_ID, - gint32 merge_layer_ID, - GimpMergeType merge_type) + gint32 merge_layer_ID, + GimpMergeType merge_type) { GimpParam *return_vals; gint nreturn_vals; gint32 layer_ID = -1; return_vals = gimp_run_procedure ("gimp-image-merge-down", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_LAYER, merge_layer_ID, - GIMP_PDB_INT32, merge_type, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_LAYER, merge_layer_ID, + GIMP_PDB_INT32, merge_type, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) layer_ID = return_vals[1].data.d_layer; @@ -1581,16 +1581,16 @@ gimp_image_merge_down (gint32 image_ID, */ guint8 * _gimp_image_get_colormap (gint32 image_ID, - gint *num_bytes) + gint *num_bytes) { GimpParam *return_vals; gint nreturn_vals; guint8 *colormap = NULL; return_vals = gimp_run_procedure ("gimp-image-get-colormap", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); *num_bytes = 0; @@ -1625,19 +1625,19 @@ _gimp_image_get_colormap (gint32 image_ID, */ gboolean _gimp_image_set_colormap (gint32 image_ID, - gint num_bytes, - const guint8 *colormap) + gint num_bytes, + const guint8 *colormap) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-set-colormap", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_INT32, num_bytes, - GIMP_PDB_INT8ARRAY, colormap, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_INT32, num_bytes, + GIMP_PDB_INT8ARRAY, colormap, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -1669,9 +1669,9 @@ gimp_image_clean_all (gint32 image_ID) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-clean-all", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -1701,9 +1701,9 @@ gimp_image_is_dirty (gint32 image_ID) gboolean dirty = FALSE; return_vals = gimp_run_procedure ("gimp-image-is-dirty", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) dirty = return_vals[1].data.d_int32; @@ -1735,24 +1735,24 @@ gimp_image_is_dirty (gint32 image_ID) */ gboolean _gimp_image_thumbnail (gint32 image_ID, - gint width, - gint height, - gint *actual_width, - gint *actual_height, - gint *bpp, - gint *thumbnail_data_count, - guint8 **thumbnail_data) + gint width, + gint height, + gint *actual_width, + gint *actual_height, + gint *bpp, + gint *thumbnail_data_count, + guint8 **thumbnail_data) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-thumbnail", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_INT32, width, - GIMP_PDB_INT32, height, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_INT32, width, + GIMP_PDB_INT32, height, + GIMP_PDB_END); *actual_width = 0; *actual_height = 0; @@ -1798,9 +1798,9 @@ gimp_image_get_active_layer (gint32 image_ID) gint32 active_layer_ID = -1; return_vals = gimp_run_procedure ("gimp-image-get-active-layer", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) active_layer_ID = return_vals[1].data.d_layer; @@ -1826,17 +1826,17 @@ gimp_image_get_active_layer (gint32 image_ID) */ gboolean gimp_image_set_active_layer (gint32 image_ID, - gint32 active_layer_ID) + gint32 active_layer_ID) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-set-active-layer", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_LAYER, active_layer_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_LAYER, active_layer_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -1864,9 +1864,9 @@ gimp_image_get_active_channel (gint32 image_ID) gint32 active_channel_ID = -1; return_vals = gimp_run_procedure ("gimp-image-get-active-channel", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) active_channel_ID = return_vals[1].data.d_channel; @@ -1892,17 +1892,17 @@ gimp_image_get_active_channel (gint32 image_ID) */ gboolean gimp_image_set_active_channel (gint32 image_ID, - gint32 active_channel_ID) + gint32 active_channel_ID) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-set-active-channel", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_CHANNEL, active_channel_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_CHANNEL, active_channel_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -1929,9 +1929,9 @@ gimp_image_get_active_vectors (gint32 image_ID) gint32 active_vectors_ID = -1; return_vals = gimp_run_procedure ("gimp-image-get-active-vectors", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) active_vectors_ID = return_vals[1].data.d_vectors; @@ -1954,17 +1954,17 @@ gimp_image_get_active_vectors (gint32 image_ID) */ gboolean gimp_image_set_active_vectors (gint32 image_ID, - gint32 active_vectors_ID) + gint32 active_vectors_ID) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-set-active-vectors", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_VECTORS, active_vectors_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_VECTORS, active_vectors_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -1992,9 +1992,9 @@ gimp_image_get_selection (gint32 image_ID) gint32 selection_ID = -1; return_vals = gimp_run_procedure ("gimp-image-get-selection", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) selection_ID = return_vals[1].data.d_selection; @@ -2020,17 +2020,17 @@ gimp_image_get_selection (gint32 image_ID) */ gboolean gimp_image_get_component_active (gint32 image_ID, - GimpChannelType component) + GimpChannelType component) { GimpParam *return_vals; gint nreturn_vals; gboolean active = FALSE; return_vals = gimp_run_procedure ("gimp-image-get-component-active", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_INT32, component, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_INT32, component, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) active = return_vals[1].data.d_int32; @@ -2057,19 +2057,19 @@ gimp_image_get_component_active (gint32 image_ID, */ gboolean gimp_image_set_component_active (gint32 image_ID, - GimpChannelType component, - gboolean active) + GimpChannelType component, + gboolean active) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-set-component-active", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_INT32, component, - GIMP_PDB_INT32, active, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_INT32, component, + GIMP_PDB_INT32, active, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -2095,17 +2095,17 @@ gimp_image_set_component_active (gint32 image_ID, */ gboolean gimp_image_get_component_visible (gint32 image_ID, - GimpChannelType component) + GimpChannelType component) { GimpParam *return_vals; gint nreturn_vals; gboolean visible = FALSE; return_vals = gimp_run_procedure ("gimp-image-get-component-visible", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_INT32, component, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_INT32, component, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) visible = return_vals[1].data.d_int32; @@ -2132,19 +2132,19 @@ gimp_image_get_component_visible (gint32 image_ID, */ gboolean gimp_image_set_component_visible (gint32 image_ID, - GimpChannelType component, - gboolean visible) + GimpChannelType component, + gboolean visible) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-set-component-visible", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_INT32, component, - GIMP_PDB_INT32, visible, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_INT32, component, + GIMP_PDB_INT32, visible, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -2173,9 +2173,9 @@ gimp_image_get_filename (gint32 image_ID) gchar *filename = NULL; return_vals = gimp_run_procedure ("gimp-image-get-filename", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) filename = g_strdup (return_vals[1].data.d_string); @@ -2199,17 +2199,17 @@ gimp_image_get_filename (gint32 image_ID) */ gboolean gimp_image_set_filename (gint32 image_ID, - const gchar *filename) + const gchar *filename) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-set-filename", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_STRING, filename, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_STRING, filename, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -2236,9 +2236,9 @@ gimp_image_get_name (gint32 image_ID) gchar *name = NULL; return_vals = gimp_run_procedure ("gimp-image-get-name", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) name = g_strdup (return_vals[1].data.d_string); @@ -2263,17 +2263,17 @@ gimp_image_get_name (gint32 image_ID) */ gboolean gimp_image_get_resolution (gint32 image_ID, - gdouble *xresolution, - gdouble *yresolution) + gdouble *xresolution, + gdouble *yresolution) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-get-resolution", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); *xresolution = 0.0; *yresolution = 0.0; @@ -2307,19 +2307,19 @@ gimp_image_get_resolution (gint32 image_ID, */ gboolean gimp_image_set_resolution (gint32 image_ID, - gdouble xresolution, - gdouble yresolution) + gdouble xresolution, + gdouble yresolution) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-set-resolution", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_FLOAT, xresolution, - GIMP_PDB_FLOAT, yresolution, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_FLOAT, xresolution, + GIMP_PDB_FLOAT, yresolution, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -2349,9 +2349,9 @@ gimp_image_get_unit (gint32 image_ID) GimpUnit unit = 0; return_vals = gimp_run_procedure ("gimp-image-get-unit", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) unit = return_vals[1].data.d_unit; @@ -2377,17 +2377,17 @@ gimp_image_get_unit (gint32 image_ID) */ gboolean gimp_image_set_unit (gint32 image_ID, - GimpUnit unit) + GimpUnit unit) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-set-unit", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_INT32, unit, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_INT32, unit, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -2416,9 +2416,9 @@ gimp_image_get_tattoo_state (gint32 image_ID) gint tattoo_state = 0; return_vals = gimp_run_procedure ("gimp-image-get-tattoo-state", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) tattoo_state = return_vals[1].data.d_tattoo; @@ -2452,17 +2452,17 @@ gimp_image_get_tattoo_state (gint32 image_ID) */ gboolean gimp_image_set_tattoo_state (gint32 image_ID, - gint tattoo_state) + gint tattoo_state) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-set-tattoo-state", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_INT32, tattoo_state, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_INT32, tattoo_state, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -2485,17 +2485,17 @@ gimp_image_set_tattoo_state (gint32 image_ID, */ gint32 gimp_image_get_layer_by_tattoo (gint32 image_ID, - gint tattoo) + gint tattoo) { GimpParam *return_vals; gint nreturn_vals; gint32 layer_ID = -1; return_vals = gimp_run_procedure ("gimp-image-get-layer-by-tattoo", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_INT32, tattoo, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_INT32, tattoo, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) layer_ID = return_vals[1].data.d_layer; @@ -2519,17 +2519,17 @@ gimp_image_get_layer_by_tattoo (gint32 image_ID, */ gint32 gimp_image_get_channel_by_tattoo (gint32 image_ID, - gint tattoo) + gint tattoo) { GimpParam *return_vals; gint nreturn_vals; gint32 channel_ID = -1; return_vals = gimp_run_procedure ("gimp-image-get-channel-by-tattoo", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_INT32, tattoo, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_INT32, tattoo, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) channel_ID = return_vals[1].data.d_channel; diff --git a/libgimp/gimpimage_pdb.h b/libgimp/gimpimage_pdb.h index 8e352dfbf8..3dd9b5abc5 100644 --- a/libgimp/gimpimage_pdb.h +++ b/libgimp/gimpimage_pdb.h @@ -31,8 +31,8 @@ G_BEGIN_DECLS gint* gimp_image_list (gint *num_images); gint32 gimp_image_new (gint width, - gint height, - GimpImageBaseType type); + gint height, + GimpImageBaseType type); gint32 gimp_image_duplicate (gint32 image_ID); gboolean gimp_image_delete (gint32 image_ID); GimpImageBaseType gimp_image_base_type (gint32 image_ID); @@ -40,140 +40,140 @@ gint gimp_image_width (gint32 ima gint gimp_image_height (gint32 image_ID); gboolean gimp_image_free_shadow (gint32 image_ID); gboolean gimp_image_resize (gint32 image_ID, - gint new_width, - gint new_height, - gint offx, - gint offy); + gint new_width, + gint new_height, + gint offx, + gint offy); gboolean gimp_image_resize_to_layers (gint32 image_ID); gboolean gimp_image_scale (gint32 image_ID, - gint new_width, - gint new_height); + gint new_width, + gint new_height); gboolean gimp_image_crop (gint32 image_ID, - gint new_width, - gint new_height, - gint offx, - gint offy); + gint new_width, + gint new_height, + gint offx, + gint offy); gboolean gimp_image_flip (gint32 image_ID, - GimpOrientationType flip_type); + GimpOrientationType flip_type); gboolean gimp_image_rotate (gint32 image_ID, - GimpRotationType rotate_type); + GimpRotationType rotate_type); gint* gimp_image_get_layers (gint32 image_ID, - gint *num_layers); + gint *num_layers); gint* gimp_image_get_channels (gint32 image_ID, - gint *num_channels); + gint *num_channels); gint* gimp_image_get_vectors (gint32 image_ID, - gint *num_vectors); + gint *num_vectors); gint32 gimp_image_get_active_drawable (gint32 image_ID); gboolean gimp_image_unset_active_channel (gint32 image_ID); gint32 gimp_image_get_floating_sel (gint32 image_ID); gint32 gimp_image_floating_sel_attached_to (gint32 image_ID); gboolean gimp_image_pick_color (gint32 image_ID, - gint32 drawable_ID, - gdouble x, - gdouble y, - gboolean sample_merged, - gboolean sample_average, - gdouble average_radius, - GimpRGB *color); + gint32 drawable_ID, + gdouble x, + gdouble y, + gboolean sample_merged, + gboolean sample_average, + gdouble average_radius, + GimpRGB *color); gint32 gimp_image_pick_correlate_layer (gint32 image_ID, - gint x, - gint y); + gint x, + gint y); gboolean gimp_image_add_layer (gint32 image_ID, - gint32 layer_ID, - gint position); + gint32 layer_ID, + gint position); gboolean gimp_image_remove_layer (gint32 image_ID, - gint32 layer_ID); + gint32 layer_ID); gboolean gimp_image_raise_layer (gint32 image_ID, - gint32 layer_ID); + gint32 layer_ID); gboolean gimp_image_lower_layer (gint32 image_ID, - gint32 layer_ID); + gint32 layer_ID); gboolean gimp_image_raise_layer_to_top (gint32 image_ID, - gint32 layer_ID); + gint32 layer_ID); gboolean gimp_image_lower_layer_to_bottom (gint32 image_ID, - gint32 layer_ID); + gint32 layer_ID); gboolean gimp_image_add_channel (gint32 image_ID, - gint32 channel_ID, - gint position); + gint32 channel_ID, + gint position); gboolean gimp_image_remove_channel (gint32 image_ID, - gint32 channel_ID); + gint32 channel_ID); gboolean gimp_image_raise_channel (gint32 image_ID, - gint32 channel_ID); + gint32 channel_ID); gboolean gimp_image_lower_channel (gint32 image_ID, - gint32 channel_ID); + gint32 channel_ID); gboolean gimp_image_add_vectors (gint32 image_ID, - gint32 vectors_ID, - gint position); + gint32 vectors_ID, + gint position); gboolean gimp_image_remove_vectors (gint32 image_ID, - gint32 vectors_ID); + gint32 vectors_ID); gboolean gimp_image_raise_vectors (gint32 image_ID, - gint32 vectors_ID); + gint32 vectors_ID); gboolean gimp_image_lower_vectors (gint32 image_ID, - gint32 vectors_ID); + gint32 vectors_ID); gboolean gimp_image_raise_vectors_to_top (gint32 image_ID, - gint32 vectors_ID); + gint32 vectors_ID); gboolean gimp_image_lower_vectors_to_bottom (gint32 image_ID, - gint32 vectors_ID); + gint32 vectors_ID); gint32 gimp_image_flatten (gint32 image_ID); gint32 gimp_image_merge_visible_layers (gint32 image_ID, - GimpMergeType merge_type); + GimpMergeType merge_type); gint32 gimp_image_merge_down (gint32 image_ID, - gint32 merge_layer_ID, - GimpMergeType merge_type); + gint32 merge_layer_ID, + GimpMergeType merge_type); guint8* _gimp_image_get_colormap (gint32 image_ID, - gint *num_bytes) G_GNUC_INTERNAL; + gint *num_bytes) G_GNUC_INTERNAL; gboolean _gimp_image_set_colormap (gint32 image_ID, - gint num_bytes, - const guint8 *colormap) G_GNUC_INTERNAL; + gint num_bytes, + const guint8 *colormap) G_GNUC_INTERNAL; gboolean gimp_image_clean_all (gint32 image_ID); gboolean gimp_image_is_dirty (gint32 image_ID); gboolean _gimp_image_thumbnail (gint32 image_ID, - gint width, - gint height, - gint *actual_width, - gint *actual_height, - gint *bpp, - gint *thumbnail_data_count, - guint8 **thumbnail_data) G_GNUC_INTERNAL; + gint width, + gint height, + gint *actual_width, + gint *actual_height, + gint *bpp, + gint *thumbnail_data_count, + guint8 **thumbnail_data) G_GNUC_INTERNAL; gint32 gimp_image_get_active_layer (gint32 image_ID); gboolean gimp_image_set_active_layer (gint32 image_ID, - gint32 active_layer_ID); + gint32 active_layer_ID); gint32 gimp_image_get_active_channel (gint32 image_ID); gboolean gimp_image_set_active_channel (gint32 image_ID, - gint32 active_channel_ID); + gint32 active_channel_ID); gint32 gimp_image_get_active_vectors (gint32 image_ID); gboolean gimp_image_set_active_vectors (gint32 image_ID, - gint32 active_vectors_ID); + gint32 active_vectors_ID); gint32 gimp_image_get_selection (gint32 image_ID); gboolean gimp_image_get_component_active (gint32 image_ID, - GimpChannelType component); + GimpChannelType component); gboolean gimp_image_set_component_active (gint32 image_ID, - GimpChannelType component, - gboolean active); + GimpChannelType component, + gboolean active); gboolean gimp_image_get_component_visible (gint32 image_ID, - GimpChannelType component); + GimpChannelType component); gboolean gimp_image_set_component_visible (gint32 image_ID, - GimpChannelType component, - gboolean visible); + GimpChannelType component, + gboolean visible); gchar* gimp_image_get_filename (gint32 image_ID); gboolean gimp_image_set_filename (gint32 image_ID, - const gchar *filename); + const gchar *filename); gchar* gimp_image_get_name (gint32 image_ID); gboolean gimp_image_get_resolution (gint32 image_ID, - gdouble *xresolution, - gdouble *yresolution); + gdouble *xresolution, + gdouble *yresolution); gboolean gimp_image_set_resolution (gint32 image_ID, - gdouble xresolution, - gdouble yresolution); + gdouble xresolution, + gdouble yresolution); GimpUnit gimp_image_get_unit (gint32 image_ID); gboolean gimp_image_set_unit (gint32 image_ID, - GimpUnit unit); + GimpUnit unit); gint gimp_image_get_tattoo_state (gint32 image_ID); gboolean gimp_image_set_tattoo_state (gint32 image_ID, - gint tattoo_state); + gint tattoo_state); gint32 gimp_image_get_layer_by_tattoo (gint32 image_ID, - gint tattoo); + gint tattoo); gint32 gimp_image_get_channel_by_tattoo (gint32 image_ID, - gint tattoo); + gint tattoo); G_END_DECLS diff --git a/libgimp/gimplayer_pdb.c b/libgimp/gimplayer_pdb.c index dcdcc35668..097ba11bae 100644 --- a/libgimp/gimplayer_pdb.c +++ b/libgimp/gimplayer_pdb.c @@ -48,27 +48,27 @@ */ gint32 _gimp_layer_new (gint32 image_ID, - gint width, - gint height, - GimpImageType type, - const gchar *name, - gdouble opacity, - GimpLayerModeEffects mode) + gint width, + gint height, + GimpImageType type, + const gchar *name, + gdouble opacity, + GimpLayerModeEffects mode) { GimpParam *return_vals; gint nreturn_vals; gint32 layer_ID = -1; return_vals = gimp_run_procedure ("gimp-layer-new", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_INT32, width, - GIMP_PDB_INT32, height, - GIMP_PDB_INT32, type, - GIMP_PDB_STRING, name, - GIMP_PDB_FLOAT, opacity, - GIMP_PDB_INT32, mode, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_INT32, width, + GIMP_PDB_INT32, height, + GIMP_PDB_INT32, type, + GIMP_PDB_STRING, name, + GIMP_PDB_FLOAT, opacity, + GIMP_PDB_INT32, mode, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) layer_ID = return_vals[1].data.d_layer; @@ -95,17 +95,17 @@ _gimp_layer_new (gint32 image_ID, */ gint32 gimp_layer_new_from_drawable (gint32 drawable_ID, - gint32 dest_image_ID) + gint32 dest_image_ID) { GimpParam *return_vals; gint nreturn_vals; gint32 layer_copy_ID = -1; return_vals = gimp_run_procedure ("gimp-layer-new-from-drawable", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_IMAGE, dest_image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_IMAGE, dest_image_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) layer_copy_ID = return_vals[1].data.d_layer; @@ -133,17 +133,17 @@ gimp_layer_new_from_drawable (gint32 drawable_ID, */ gint32 _gimp_layer_copy (gint32 layer_ID, - gboolean add_alpha) + gboolean add_alpha) { GimpParam *return_vals; gint nreturn_vals; gint32 layer_copy_ID = -1; return_vals = gimp_run_procedure ("gimp-layer-copy", - &nreturn_vals, - GIMP_PDB_LAYER, layer_ID, - GIMP_PDB_INT32, add_alpha, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_LAYER, layer_ID, + GIMP_PDB_INT32, add_alpha, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) layer_copy_ID = return_vals[1].data.d_layer; @@ -176,9 +176,9 @@ gimp_layer_add_alpha (gint32 layer_ID) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-layer-add-alpha", - &nreturn_vals, - GIMP_PDB_LAYER, layer_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_LAYER, layer_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -206,21 +206,21 @@ gimp_layer_add_alpha (gint32 layer_ID) */ gboolean gimp_layer_scale (gint32 layer_ID, - gint new_width, - gint new_height, - gboolean local_origin) + gint new_width, + gint new_height, + gboolean local_origin) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-layer-scale", - &nreturn_vals, - GIMP_PDB_LAYER, layer_ID, - GIMP_PDB_INT32, new_width, - GIMP_PDB_INT32, new_height, - GIMP_PDB_INT32, local_origin, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_LAYER, layer_ID, + GIMP_PDB_INT32, new_width, + GIMP_PDB_INT32, new_height, + GIMP_PDB_INT32, local_origin, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -248,23 +248,23 @@ gimp_layer_scale (gint32 layer_ID, */ gboolean gimp_layer_resize (gint32 layer_ID, - gint new_width, - gint new_height, - gint offx, - gint offy) + gint new_width, + gint new_height, + gint offx, + gint offy) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-layer-resize", - &nreturn_vals, - GIMP_PDB_LAYER, layer_ID, - GIMP_PDB_INT32, new_width, - GIMP_PDB_INT32, new_height, - GIMP_PDB_INT32, offx, - GIMP_PDB_INT32, offy, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_LAYER, layer_ID, + GIMP_PDB_INT32, new_width, + GIMP_PDB_INT32, new_height, + GIMP_PDB_INT32, offx, + GIMP_PDB_INT32, offy, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -292,9 +292,9 @@ gimp_layer_resize_to_image_size (gint32 layer_ID) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-layer-resize-to-image-size", - &nreturn_vals, - GIMP_PDB_LAYER, layer_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_LAYER, layer_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -322,19 +322,19 @@ gimp_layer_resize_to_image_size (gint32 layer_ID) */ gboolean gimp_layer_translate (gint32 layer_ID, - gint offx, - gint offy) + gint offx, + gint offy) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-layer-translate", - &nreturn_vals, - GIMP_PDB_LAYER, layer_ID, - GIMP_PDB_INT32, offx, - GIMP_PDB_INT32, offy, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_LAYER, layer_ID, + GIMP_PDB_INT32, offx, + GIMP_PDB_INT32, offy, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -359,19 +359,19 @@ gimp_layer_translate (gint32 layer_ID, */ gboolean gimp_layer_set_offsets (gint32 layer_ID, - gint offx, - gint offy) + gint offx, + gint offy) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-layer-set-offsets", - &nreturn_vals, - GIMP_PDB_LAYER, layer_ID, - GIMP_PDB_INT32, offx, - GIMP_PDB_INT32, offy, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_LAYER, layer_ID, + GIMP_PDB_INT32, offx, + GIMP_PDB_INT32, offy, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -402,17 +402,17 @@ gimp_layer_set_offsets (gint32 layer_ID, */ gint32 gimp_layer_create_mask (gint32 layer_ID, - GimpAddMaskType mask_type) + GimpAddMaskType mask_type) { GimpParam *return_vals; gint nreturn_vals; gint32 mask_ID = -1; return_vals = gimp_run_procedure ("gimp-layer-create-mask", - &nreturn_vals, - GIMP_PDB_LAYER, layer_ID, - GIMP_PDB_INT32, mask_type, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_LAYER, layer_ID, + GIMP_PDB_INT32, mask_type, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) mask_ID = return_vals[1].data.d_layer_mask; @@ -441,9 +441,9 @@ gimp_layer_get_mask (gint32 layer_ID) gint32 mask_ID = -1; return_vals = gimp_run_procedure ("gimp-layer-get-mask", - &nreturn_vals, - GIMP_PDB_LAYER, layer_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_LAYER, layer_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) mask_ID = return_vals[1].data.d_layer_mask; @@ -474,9 +474,9 @@ gimp_layer_from_mask (gint32 mask_ID) gint32 layer_ID = -1; return_vals = gimp_run_procedure ("gimp-layer-from-mask", - &nreturn_vals, - GIMP_PDB_CHANNEL, mask_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_CHANNEL, mask_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) layer_ID = return_vals[1].data.d_layer; @@ -504,17 +504,17 @@ gimp_layer_from_mask (gint32 mask_ID) */ gboolean gimp_layer_add_mask (gint32 layer_ID, - gint32 mask_ID) + gint32 mask_ID) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-layer-add-mask", - &nreturn_vals, - GIMP_PDB_LAYER, layer_ID, - GIMP_PDB_CHANNEL, mask_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_LAYER, layer_ID, + GIMP_PDB_CHANNEL, mask_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -537,17 +537,17 @@ gimp_layer_add_mask (gint32 layer_ID, */ gboolean gimp_layer_remove_mask (gint32 layer_ID, - GimpMaskApplyMode mode) + GimpMaskApplyMode mode) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-layer-remove-mask", - &nreturn_vals, - GIMP_PDB_LAYER, layer_ID, - GIMP_PDB_INT32, mode, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_LAYER, layer_ID, + GIMP_PDB_INT32, mode, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -576,9 +576,9 @@ gimp_layer_is_floating_sel (gint32 layer_ID) gboolean is_floating_sel = FALSE; return_vals = gimp_run_procedure ("gimp-layer-is-floating-sel", - &nreturn_vals, - GIMP_PDB_LAYER, layer_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_LAYER, layer_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) is_floating_sel = return_vals[1].data.d_int32; @@ -607,9 +607,9 @@ gimp_layer_get_lock_alpha (gint32 layer_ID) gboolean lock_alpha = FALSE; return_vals = gimp_run_procedure ("gimp-layer-get-lock-alpha", - &nreturn_vals, - GIMP_PDB_LAYER, layer_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_LAYER, layer_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) lock_alpha = return_vals[1].data.d_int32; @@ -633,17 +633,17 @@ gimp_layer_get_lock_alpha (gint32 layer_ID) */ gboolean gimp_layer_set_lock_alpha (gint32 layer_ID, - gboolean lock_alpha) + gboolean lock_alpha) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-layer-set-lock-alpha", - &nreturn_vals, - GIMP_PDB_LAYER, layer_ID, - GIMP_PDB_INT32, lock_alpha, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_LAYER, layer_ID, + GIMP_PDB_INT32, lock_alpha, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -672,9 +672,9 @@ gimp_layer_get_apply_mask (gint32 layer_ID) gboolean apply_mask = FALSE; return_vals = gimp_run_procedure ("gimp-layer-get-apply-mask", - &nreturn_vals, - GIMP_PDB_LAYER, layer_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_LAYER, layer_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) apply_mask = return_vals[1].data.d_int32; @@ -700,17 +700,17 @@ gimp_layer_get_apply_mask (gint32 layer_ID) */ gboolean gimp_layer_set_apply_mask (gint32 layer_ID, - gboolean apply_mask) + gboolean apply_mask) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-layer-set-apply-mask", - &nreturn_vals, - GIMP_PDB_LAYER, layer_ID, - GIMP_PDB_INT32, apply_mask, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_LAYER, layer_ID, + GIMP_PDB_INT32, apply_mask, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -740,9 +740,9 @@ gimp_layer_get_show_mask (gint32 layer_ID) gboolean show_mask = FALSE; return_vals = gimp_run_procedure ("gimp-layer-get-show-mask", - &nreturn_vals, - GIMP_PDB_LAYER, layer_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_LAYER, layer_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) show_mask = return_vals[1].data.d_int32; @@ -768,17 +768,17 @@ gimp_layer_get_show_mask (gint32 layer_ID) */ gboolean gimp_layer_set_show_mask (gint32 layer_ID, - gboolean show_mask) + gboolean show_mask) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-layer-set-show-mask", - &nreturn_vals, - GIMP_PDB_LAYER, layer_ID, - GIMP_PDB_INT32, show_mask, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_LAYER, layer_ID, + GIMP_PDB_INT32, show_mask, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -807,9 +807,9 @@ gimp_layer_get_edit_mask (gint32 layer_ID) gboolean edit_mask = FALSE; return_vals = gimp_run_procedure ("gimp-layer-get-edit-mask", - &nreturn_vals, - GIMP_PDB_LAYER, layer_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_LAYER, layer_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) edit_mask = return_vals[1].data.d_int32; @@ -835,17 +835,17 @@ gimp_layer_get_edit_mask (gint32 layer_ID) */ gboolean gimp_layer_set_edit_mask (gint32 layer_ID, - gboolean edit_mask) + gboolean edit_mask) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-layer-set-edit-mask", - &nreturn_vals, - GIMP_PDB_LAYER, layer_ID, - GIMP_PDB_INT32, edit_mask, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_LAYER, layer_ID, + GIMP_PDB_INT32, edit_mask, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -872,9 +872,9 @@ gimp_layer_get_opacity (gint32 layer_ID) gdouble opacity = 0.0; return_vals = gimp_run_procedure ("gimp-layer-get-opacity", - &nreturn_vals, - GIMP_PDB_LAYER, layer_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_LAYER, layer_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) opacity = return_vals[1].data.d_float; @@ -897,17 +897,17 @@ gimp_layer_get_opacity (gint32 layer_ID) */ gboolean gimp_layer_set_opacity (gint32 layer_ID, - gdouble opacity) + gdouble opacity) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-layer-set-opacity", - &nreturn_vals, - GIMP_PDB_LAYER, layer_ID, - GIMP_PDB_FLOAT, opacity, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_LAYER, layer_ID, + GIMP_PDB_FLOAT, opacity, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -934,9 +934,9 @@ gimp_layer_get_mode (gint32 layer_ID) GimpLayerModeEffects mode = 0; return_vals = gimp_run_procedure ("gimp-layer-get-mode", - &nreturn_vals, - GIMP_PDB_LAYER, layer_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_LAYER, layer_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) mode = return_vals[1].data.d_int32; @@ -959,17 +959,17 @@ gimp_layer_get_mode (gint32 layer_ID) */ gboolean gimp_layer_set_mode (gint32 layer_ID, - GimpLayerModeEffects mode) + GimpLayerModeEffects mode) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-layer-set-mode", - &nreturn_vals, - GIMP_PDB_LAYER, layer_ID, - GIMP_PDB_INT32, mode, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_LAYER, layer_ID, + GIMP_PDB_INT32, mode, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; diff --git a/libgimp/gimplayer_pdb.h b/libgimp/gimplayer_pdb.h index c914c03826..4b60da8566 100644 --- a/libgimp/gimplayer_pdb.h +++ b/libgimp/gimplayer_pdb.h @@ -30,60 +30,60 @@ G_BEGIN_DECLS gint32 _gimp_layer_new (gint32 image_ID, - gint width, - gint height, - GimpImageType type, - const gchar *name, - gdouble opacity, - GimpLayerModeEffects mode) G_GNUC_INTERNAL; + gint width, + gint height, + GimpImageType type, + const gchar *name, + gdouble opacity, + GimpLayerModeEffects mode) G_GNUC_INTERNAL; gint32 gimp_layer_new_from_drawable (gint32 drawable_ID, - gint32 dest_image_ID); + gint32 dest_image_ID); gint32 _gimp_layer_copy (gint32 layer_ID, - gboolean add_alpha) G_GNUC_INTERNAL; + gboolean add_alpha) G_GNUC_INTERNAL; gboolean gimp_layer_add_alpha (gint32 layer_ID); gboolean gimp_layer_scale (gint32 layer_ID, - gint new_width, - gint new_height, - gboolean local_origin); + gint new_width, + gint new_height, + gboolean local_origin); gboolean gimp_layer_resize (gint32 layer_ID, - gint new_width, - gint new_height, - gint offx, - gint offy); + gint new_width, + gint new_height, + gint offx, + gint offy); gboolean gimp_layer_resize_to_image_size (gint32 layer_ID); gboolean gimp_layer_translate (gint32 layer_ID, - gint offx, - gint offy); + gint offx, + gint offy); gboolean gimp_layer_set_offsets (gint32 layer_ID, - gint offx, - gint offy); + gint offx, + gint offy); gint32 gimp_layer_create_mask (gint32 layer_ID, - GimpAddMaskType mask_type); + GimpAddMaskType mask_type); gint32 gimp_layer_get_mask (gint32 layer_ID); gint32 gimp_layer_from_mask (gint32 mask_ID); gboolean gimp_layer_add_mask (gint32 layer_ID, - gint32 mask_ID); + gint32 mask_ID); gboolean gimp_layer_remove_mask (gint32 layer_ID, - GimpMaskApplyMode mode); + GimpMaskApplyMode mode); gboolean gimp_layer_is_floating_sel (gint32 layer_ID); gboolean gimp_layer_get_lock_alpha (gint32 layer_ID); gboolean gimp_layer_set_lock_alpha (gint32 layer_ID, - gboolean lock_alpha); + gboolean lock_alpha); gboolean gimp_layer_get_apply_mask (gint32 layer_ID); gboolean gimp_layer_set_apply_mask (gint32 layer_ID, - gboolean apply_mask); + gboolean apply_mask); gboolean gimp_layer_get_show_mask (gint32 layer_ID); gboolean gimp_layer_set_show_mask (gint32 layer_ID, - gboolean show_mask); + gboolean show_mask); gboolean gimp_layer_get_edit_mask (gint32 layer_ID); gboolean gimp_layer_set_edit_mask (gint32 layer_ID, - gboolean edit_mask); + gboolean edit_mask); gdouble gimp_layer_get_opacity (gint32 layer_ID); gboolean gimp_layer_set_opacity (gint32 layer_ID, - gdouble opacity); + gdouble opacity); GimpLayerModeEffects gimp_layer_get_mode (gint32 layer_ID); gboolean gimp_layer_set_mode (gint32 layer_ID, - GimpLayerModeEffects mode); + GimpLayerModeEffects mode); G_END_DECLS diff --git a/libgimp/gimpmessage_pdb.c b/libgimp/gimpmessage_pdb.c index 829bb840b0..1316f7e83e 100644 --- a/libgimp/gimpmessage_pdb.c +++ b/libgimp/gimpmessage_pdb.c @@ -44,9 +44,9 @@ gimp_message (const gchar *message) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-message", - &nreturn_vals, - GIMP_PDB_STRING, message, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, message, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -74,8 +74,8 @@ gimp_message_get_handler (void) GimpMessageHandlerType handler = 0; return_vals = gimp_run_procedure ("gimp-message-get-handler", - &nreturn_vals, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) handler = return_vals[1].data.d_int32; @@ -105,9 +105,9 @@ gimp_message_set_handler (GimpMessageHandlerType handler) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-message-set-handler", - &nreturn_vals, - GIMP_PDB_INT32, handler, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_INT32, handler, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; diff --git a/libgimp/gimpmisc_pdb.c b/libgimp/gimpmisc_pdb.c index 8e36403114..04f9829d29 100644 --- a/libgimp/gimpmisc_pdb.c +++ b/libgimp/gimpmisc_pdb.c @@ -43,8 +43,8 @@ gimp_version (void) gchar *version = NULL; return_vals = gimp_run_procedure ("gimp-version", - &nreturn_vals, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) version = g_strdup (return_vals[1].data.d_string); @@ -73,8 +73,8 @@ gimp_getpid (void) gint pid = 0; return_vals = gimp_run_procedure ("gimp-getpid", - &nreturn_vals, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) pid = return_vals[1].data.d_int32; diff --git a/libgimp/gimppainttools_pdb.c b/libgimp/gimppainttools_pdb.c index d57ee515eb..2f7e851cbe 100644 --- a/libgimp/gimppainttools_pdb.c +++ b/libgimp/gimppainttools_pdb.c @@ -44,21 +44,21 @@ */ gboolean gimp_airbrush (gint32 drawable_ID, - gdouble pressure, - gint num_strokes, - const gdouble *strokes) + gdouble pressure, + gint num_strokes, + const gdouble *strokes) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-airbrush", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_FLOAT, pressure, - GIMP_PDB_INT32, num_strokes, - GIMP_PDB_FLOATARRAY, strokes, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_FLOAT, pressure, + GIMP_PDB_INT32, num_strokes, + GIMP_PDB_FLOATARRAY, strokes, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -85,19 +85,19 @@ gimp_airbrush (gint32 drawable_ID, */ gboolean gimp_airbrush_default (gint32 drawable_ID, - gint num_strokes, - const gdouble *strokes) + gint num_strokes, + const gdouble *strokes) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-airbrush-default", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, num_strokes, - GIMP_PDB_FLOATARRAY, strokes, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, num_strokes, + GIMP_PDB_FLOATARRAY, strokes, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -135,27 +135,27 @@ gimp_airbrush_default (gint32 drawable_ID, */ gboolean gimp_clone (gint32 drawable_ID, - gint32 src_drawable_ID, - GimpCloneType clone_type, - gdouble src_x, - gdouble src_y, - gint num_strokes, - const gdouble *strokes) + gint32 src_drawable_ID, + GimpCloneType clone_type, + gdouble src_x, + gdouble src_y, + gint num_strokes, + const gdouble *strokes) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-clone", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_DRAWABLE, src_drawable_ID, - GIMP_PDB_INT32, clone_type, - GIMP_PDB_FLOAT, src_x, - GIMP_PDB_FLOAT, src_y, - GIMP_PDB_INT32, num_strokes, - GIMP_PDB_FLOATARRAY, strokes, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_DRAWABLE, src_drawable_ID, + GIMP_PDB_INT32, clone_type, + GIMP_PDB_FLOAT, src_x, + GIMP_PDB_FLOAT, src_y, + GIMP_PDB_INT32, num_strokes, + GIMP_PDB_FLOATARRAY, strokes, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -183,19 +183,19 @@ gimp_clone (gint32 drawable_ID, */ gboolean gimp_clone_default (gint32 drawable_ID, - gint num_strokes, - const gdouble *strokes) + gint num_strokes, + const gdouble *strokes) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-clone-default", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, num_strokes, - GIMP_PDB_FLOATARRAY, strokes, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, num_strokes, + GIMP_PDB_FLOATARRAY, strokes, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -223,23 +223,23 @@ gimp_clone_default (gint32 drawable_ID, */ gboolean gimp_convolve (gint32 drawable_ID, - gdouble pressure, - GimpConvolveType convolve_type, - gint num_strokes, - const gdouble *strokes) + gdouble pressure, + GimpConvolveType convolve_type, + gint num_strokes, + const gdouble *strokes) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-convolve", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_FLOAT, pressure, - GIMP_PDB_INT32, convolve_type, - GIMP_PDB_INT32, num_strokes, - GIMP_PDB_FLOATARRAY, strokes, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_FLOAT, pressure, + GIMP_PDB_INT32, convolve_type, + GIMP_PDB_INT32, num_strokes, + GIMP_PDB_FLOATARRAY, strokes, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -266,19 +266,19 @@ gimp_convolve (gint32 drawable_ID, */ gboolean gimp_convolve_default (gint32 drawable_ID, - gint num_strokes, - const gdouble *strokes) + gint num_strokes, + const gdouble *strokes) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-convolve-default", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, num_strokes, - GIMP_PDB_FLOATARRAY, strokes, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, num_strokes, + GIMP_PDB_FLOATARRAY, strokes, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -304,25 +304,25 @@ gimp_convolve_default (gint32 drawable_ID, */ gboolean gimp_dodgeburn (gint32 drawable_ID, - gdouble exposure, - GimpDodgeBurnType dodgeburn_type, - GimpTransferMode dodgeburn_mode, - gint num_strokes, - const gdouble *strokes) + gdouble exposure, + GimpDodgeBurnType dodgeburn_type, + GimpTransferMode dodgeburn_mode, + gint num_strokes, + const gdouble *strokes) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-dodgeburn", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_FLOAT, exposure, - GIMP_PDB_INT32, dodgeburn_type, - GIMP_PDB_INT32, dodgeburn_mode, - GIMP_PDB_INT32, num_strokes, - GIMP_PDB_FLOATARRAY, strokes, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_FLOAT, exposure, + GIMP_PDB_INT32, dodgeburn_type, + GIMP_PDB_INT32, dodgeburn_mode, + GIMP_PDB_INT32, num_strokes, + GIMP_PDB_FLOATARRAY, strokes, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -348,19 +348,19 @@ gimp_dodgeburn (gint32 drawable_ID, */ gboolean gimp_dodgeburn_default (gint32 drawable_ID, - gint num_strokes, - const gdouble *strokes) + gint num_strokes, + const gdouble *strokes) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-dodgeburn-default", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, num_strokes, - GIMP_PDB_FLOATARRAY, strokes, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, num_strokes, + GIMP_PDB_FLOATARRAY, strokes, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -389,23 +389,23 @@ gimp_dodgeburn_default (gint32 drawable_ID, */ gboolean gimp_eraser (gint32 drawable_ID, - gint num_strokes, - const gdouble *strokes, - GimpBrushApplicationMode hardness, - GimpPaintApplicationMode method) + gint num_strokes, + const gdouble *strokes, + GimpBrushApplicationMode hardness, + GimpPaintApplicationMode method) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-eraser", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, num_strokes, - GIMP_PDB_FLOATARRAY, strokes, - GIMP_PDB_INT32, hardness, - GIMP_PDB_INT32, method, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, num_strokes, + GIMP_PDB_FLOATARRAY, strokes, + GIMP_PDB_INT32, hardness, + GIMP_PDB_INT32, method, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -432,19 +432,19 @@ gimp_eraser (gint32 drawable_ID, */ gboolean gimp_eraser_default (gint32 drawable_ID, - gint num_strokes, - const gdouble *strokes) + gint num_strokes, + const gdouble *strokes) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-eraser-default", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, num_strokes, - GIMP_PDB_FLOATARRAY, strokes, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, num_strokes, + GIMP_PDB_FLOATARRAY, strokes, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -480,25 +480,25 @@ gimp_eraser_default (gint32 drawable_ID, */ gboolean gimp_paintbrush (gint32 drawable_ID, - gdouble fade_out, - gint num_strokes, - const gdouble *strokes, - GimpPaintApplicationMode method, - gdouble gradient_length) + gdouble fade_out, + gint num_strokes, + const gdouble *strokes, + GimpPaintApplicationMode method, + gdouble gradient_length) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-paintbrush", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_FLOAT, fade_out, - GIMP_PDB_INT32, num_strokes, - GIMP_PDB_FLOATARRAY, strokes, - GIMP_PDB_INT32, method, - GIMP_PDB_FLOAT, gradient_length, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_FLOAT, fade_out, + GIMP_PDB_INT32, num_strokes, + GIMP_PDB_FLOATARRAY, strokes, + GIMP_PDB_INT32, method, + GIMP_PDB_FLOAT, gradient_length, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -534,19 +534,19 @@ gimp_paintbrush (gint32 drawable_ID, */ gboolean gimp_paintbrush_default (gint32 drawable_ID, - gint num_strokes, - const gdouble *strokes) + gint num_strokes, + const gdouble *strokes) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-paintbrush-default", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, num_strokes, - GIMP_PDB_FLOATARRAY, strokes, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, num_strokes, + GIMP_PDB_FLOATARRAY, strokes, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -574,19 +574,19 @@ gimp_paintbrush_default (gint32 drawable_ID, */ gboolean gimp_pencil (gint32 drawable_ID, - gint num_strokes, - const gdouble *strokes) + gint num_strokes, + const gdouble *strokes) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-pencil", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, num_strokes, - GIMP_PDB_FLOATARRAY, strokes, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, num_strokes, + GIMP_PDB_FLOATARRAY, strokes, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -612,21 +612,21 @@ gimp_pencil (gint32 drawable_ID, */ gboolean gimp_smudge (gint32 drawable_ID, - gdouble pressure, - gint num_strokes, - const gdouble *strokes) + gdouble pressure, + gint num_strokes, + const gdouble *strokes) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-smudge", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_FLOAT, pressure, - GIMP_PDB_INT32, num_strokes, - GIMP_PDB_FLOATARRAY, strokes, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_FLOAT, pressure, + GIMP_PDB_INT32, num_strokes, + GIMP_PDB_FLOATARRAY, strokes, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -652,19 +652,19 @@ gimp_smudge (gint32 drawable_ID, */ gboolean gimp_smudge_default (gint32 drawable_ID, - gint num_strokes, - const gdouble *strokes) + gint num_strokes, + const gdouble *strokes) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-smudge-default", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, num_strokes, - GIMP_PDB_FLOATARRAY, strokes, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, num_strokes, + GIMP_PDB_FLOATARRAY, strokes, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; diff --git a/libgimp/gimppainttools_pdb.h b/libgimp/gimppainttools_pdb.h index 62a8508490..25a120ae3a 100644 --- a/libgimp/gimppainttools_pdb.h +++ b/libgimp/gimppainttools_pdb.h @@ -30,66 +30,66 @@ G_BEGIN_DECLS gboolean gimp_airbrush (gint32 drawable_ID, - gdouble pressure, - gint num_strokes, - const gdouble *strokes); + gdouble pressure, + gint num_strokes, + const gdouble *strokes); gboolean gimp_airbrush_default (gint32 drawable_ID, - gint num_strokes, - const gdouble *strokes); + gint num_strokes, + const gdouble *strokes); gboolean gimp_clone (gint32 drawable_ID, - gint32 src_drawable_ID, - GimpCloneType clone_type, - gdouble src_x, - gdouble src_y, - gint num_strokes, - const gdouble *strokes); + gint32 src_drawable_ID, + GimpCloneType clone_type, + gdouble src_x, + gdouble src_y, + gint num_strokes, + const gdouble *strokes); gboolean gimp_clone_default (gint32 drawable_ID, - gint num_strokes, - const gdouble *strokes); + gint num_strokes, + const gdouble *strokes); gboolean gimp_convolve (gint32 drawable_ID, - gdouble pressure, - GimpConvolveType convolve_type, - gint num_strokes, - const gdouble *strokes); + gdouble pressure, + GimpConvolveType convolve_type, + gint num_strokes, + const gdouble *strokes); gboolean gimp_convolve_default (gint32 drawable_ID, - gint num_strokes, - const gdouble *strokes); + gint num_strokes, + const gdouble *strokes); gboolean gimp_dodgeburn (gint32 drawable_ID, - gdouble exposure, - GimpDodgeBurnType dodgeburn_type, - GimpTransferMode dodgeburn_mode, - gint num_strokes, - const gdouble *strokes); + gdouble exposure, + GimpDodgeBurnType dodgeburn_type, + GimpTransferMode dodgeburn_mode, + gint num_strokes, + const gdouble *strokes); gboolean gimp_dodgeburn_default (gint32 drawable_ID, - gint num_strokes, - const gdouble *strokes); + gint num_strokes, + const gdouble *strokes); gboolean gimp_eraser (gint32 drawable_ID, - gint num_strokes, - const gdouble *strokes, - GimpBrushApplicationMode hardness, - GimpPaintApplicationMode method); + gint num_strokes, + const gdouble *strokes, + GimpBrushApplicationMode hardness, + GimpPaintApplicationMode method); gboolean gimp_eraser_default (gint32 drawable_ID, - gint num_strokes, - const gdouble *strokes); + gint num_strokes, + const gdouble *strokes); gboolean gimp_paintbrush (gint32 drawable_ID, - gdouble fade_out, - gint num_strokes, - const gdouble *strokes, - GimpPaintApplicationMode method, - gdouble gradient_length); + gdouble fade_out, + gint num_strokes, + const gdouble *strokes, + GimpPaintApplicationMode method, + gdouble gradient_length); gboolean gimp_paintbrush_default (gint32 drawable_ID, - gint num_strokes, - const gdouble *strokes); + gint num_strokes, + const gdouble *strokes); gboolean gimp_pencil (gint32 drawable_ID, - gint num_strokes, - const gdouble *strokes); + gint num_strokes, + const gdouble *strokes); gboolean gimp_smudge (gint32 drawable_ID, - gdouble pressure, - gint num_strokes, - const gdouble *strokes); + gdouble pressure, + gint num_strokes, + const gdouble *strokes); gboolean gimp_smudge_default (gint32 drawable_ID, - gint num_strokes, - const gdouble *strokes); + gint num_strokes, + const gdouble *strokes); G_END_DECLS diff --git a/libgimp/gimppalette_pdb.c b/libgimp/gimppalette_pdb.c index 6d099a7738..6db4f71ff4 100644 --- a/libgimp/gimppalette_pdb.c +++ b/libgimp/gimppalette_pdb.c @@ -45,9 +45,9 @@ gimp_palette_new (const gchar *name) gchar *actual_name = NULL; return_vals = gimp_run_procedure ("gimp-palette-new", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) actual_name = g_strdup (return_vals[1].data.d_string); @@ -77,9 +77,9 @@ gimp_palette_duplicate (const gchar *name) gchar *copy_name = NULL; return_vals = gimp_run_procedure ("gimp-palette-duplicate", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) copy_name = g_strdup (return_vals[1].data.d_string); @@ -104,17 +104,17 @@ gimp_palette_duplicate (const gchar *name) */ gchar * gimp_palette_rename (const gchar *name, - const gchar *new_name) + const gchar *new_name) { GimpParam *return_vals; gint nreturn_vals; gchar *actual_name = NULL; return_vals = gimp_run_procedure ("gimp-palette-rename", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_STRING, new_name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_STRING, new_name, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) actual_name = g_strdup (return_vals[1].data.d_string); @@ -144,9 +144,9 @@ gimp_palette_delete (const gchar *name) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-palette-delete", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -175,9 +175,9 @@ gimp_palette_is_editable (const gchar *name) gboolean editable = FALSE; return_vals = gimp_run_procedure ("gimp-palette-is-editable", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) editable = return_vals[1].data.d_int32; @@ -203,16 +203,16 @@ gimp_palette_is_editable (const gchar *name) */ gboolean gimp_palette_get_info (const gchar *name, - gint *num_colors) + gint *num_colors) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-palette-get-info", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_END); *num_colors = 0; @@ -247,9 +247,9 @@ gimp_palette_get_columns (const gchar *name) gint num_columns = 0; return_vals = gimp_run_procedure ("gimp-palette-get-columns", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) num_columns = return_vals[1].data.d_int32; @@ -276,17 +276,17 @@ gimp_palette_get_columns (const gchar *name) */ gboolean gimp_palette_set_columns (const gchar *name, - gint columns) + gint columns) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-palette-set-columns", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_INT32, columns, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_INT32, columns, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -313,20 +313,20 @@ gimp_palette_set_columns (const gchar *name, */ gboolean gimp_palette_add_entry (const gchar *name, - const gchar *entry_name, - const GimpRGB *color, - gint *entry_num) + const gchar *entry_name, + const GimpRGB *color, + gint *entry_num) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-palette-add-entry", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_STRING, entry_name, - GIMP_PDB_COLOR, color, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_STRING, entry_name, + GIMP_PDB_COLOR, color, + GIMP_PDB_END); *entry_num = 0; @@ -356,17 +356,17 @@ gimp_palette_add_entry (const gchar *name, */ gboolean gimp_palette_delete_entry (const gchar *name, - gint entry_num) + gint entry_num) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-palette-delete-entry", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_INT32, entry_num, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_INT32, entry_num, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -393,18 +393,18 @@ gimp_palette_delete_entry (const gchar *name, */ gboolean gimp_palette_entry_get_color (const gchar *name, - gint entry_num, - GimpRGB *color) + gint entry_num, + GimpRGB *color) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-palette-entry-get-color", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_INT32, entry_num, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_INT32, entry_num, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -434,19 +434,19 @@ gimp_palette_entry_get_color (const gchar *name, */ gboolean gimp_palette_entry_set_color (const gchar *name, - gint entry_num, - const GimpRGB *color) + gint entry_num, + const GimpRGB *color) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-palette-entry-set-color", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_INT32, entry_num, - GIMP_PDB_COLOR, color, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_INT32, entry_num, + GIMP_PDB_COLOR, color, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -473,18 +473,18 @@ gimp_palette_entry_set_color (const gchar *name, */ gboolean gimp_palette_entry_get_name (const gchar *name, - gint entry_num, - gchar **entry_name) + gint entry_num, + gchar **entry_name) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-palette-entry-get-name", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_INT32, entry_num, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_INT32, entry_num, + GIMP_PDB_END); *entry_name = NULL; @@ -516,19 +516,19 @@ gimp_palette_entry_get_name (const gchar *name, */ gboolean gimp_palette_entry_set_name (const gchar *name, - gint entry_num, - const gchar *entry_name) + gint entry_num, + const gchar *entry_name) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-palette-entry-set-name", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_INT32, entry_num, - GIMP_PDB_STRING, entry_name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_INT32, entry_num, + GIMP_PDB_STRING, entry_name, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; diff --git a/libgimp/gimppalette_pdb.h b/libgimp/gimppalette_pdb.h index 8fa46bf20b..6071af45ca 100644 --- a/libgimp/gimppalette_pdb.h +++ b/libgimp/gimppalette_pdb.h @@ -32,32 +32,32 @@ G_BEGIN_DECLS gchar* gimp_palette_new (const gchar *name); gchar* gimp_palette_duplicate (const gchar *name); gchar* gimp_palette_rename (const gchar *name, - const gchar *new_name); + const gchar *new_name); gboolean gimp_palette_delete (const gchar *name); gboolean gimp_palette_is_editable (const gchar *name); gboolean gimp_palette_get_info (const gchar *name, - gint *num_colors); + gint *num_colors); gint gimp_palette_get_columns (const gchar *name); gboolean gimp_palette_set_columns (const gchar *name, - gint columns); + gint columns); gboolean gimp_palette_add_entry (const gchar *name, - const gchar *entry_name, - const GimpRGB *color, - gint *entry_num); + const gchar *entry_name, + const GimpRGB *color, + gint *entry_num); gboolean gimp_palette_delete_entry (const gchar *name, - gint entry_num); + gint entry_num); gboolean gimp_palette_entry_get_color (const gchar *name, - gint entry_num, - GimpRGB *color); + gint entry_num, + GimpRGB *color); gboolean gimp_palette_entry_set_color (const gchar *name, - gint entry_num, - const GimpRGB *color); + gint entry_num, + const GimpRGB *color); gboolean gimp_palette_entry_get_name (const gchar *name, - gint entry_num, - gchar **entry_name); + gint entry_num, + gchar **entry_name); gboolean gimp_palette_entry_set_name (const gchar *name, - gint entry_num, - const gchar *entry_name); + gint entry_num, + const gchar *entry_name); G_END_DECLS diff --git a/libgimp/gimppalettes_pdb.c b/libgimp/gimppalettes_pdb.c index cf0a077739..2f134f545e 100644 --- a/libgimp/gimppalettes_pdb.c +++ b/libgimp/gimppalettes_pdb.c @@ -43,8 +43,8 @@ gimp_palettes_refresh (void) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-palettes-refresh", - &nreturn_vals, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -68,7 +68,7 @@ gimp_palettes_refresh (void) */ gchar ** gimp_palettes_get_list (const gchar *filter, - gint *num_palettes) + gint *num_palettes) { GimpParam *return_vals; gint nreturn_vals; @@ -76,9 +76,9 @@ gimp_palettes_get_list (const gchar *filter, gint i; return_vals = gimp_run_procedure ("gimp-palettes-get-list", - &nreturn_vals, - GIMP_PDB_STRING, filter, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, filter, + GIMP_PDB_END); *num_palettes = 0; @@ -112,8 +112,8 @@ gimp_palettes_get_palette (gint *num_colors) gchar *name = NULL; return_vals = gimp_run_procedure ("gimp-palettes-get-palette", - &nreturn_vals, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) { @@ -140,19 +140,19 @@ gimp_palettes_get_palette (gint *num_colors) */ gchar * gimp_palettes_get_palette_entry (const gchar *name, - gint entry_num, - gint *num_colors, - GimpRGB *color) + gint entry_num, + gint *num_colors, + GimpRGB *color) { GimpParam *return_vals; gint nreturn_vals; gchar *actual_name = NULL; return_vals = gimp_run_procedure ("gimp-palettes-get-palette-entry", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_INT32, entry_num, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_INT32, entry_num, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) { diff --git a/libgimp/gimppalettes_pdb.h b/libgimp/gimppalettes_pdb.h index 414b436e0a..4974fd21ac 100644 --- a/libgimp/gimppalettes_pdb.h +++ b/libgimp/gimppalettes_pdb.h @@ -31,13 +31,13 @@ G_BEGIN_DECLS gboolean gimp_palettes_refresh (void); gchar** gimp_palettes_get_list (const gchar *filter, - gint *num_palettes); + gint *num_palettes); #ifndef GIMP_DISABLE_DEPRECATED gchar* gimp_palettes_get_palette (gint *num_colors); gchar* gimp_palettes_get_palette_entry (const gchar *name, - gint entry_num, - gint *num_colors, - GimpRGB *color); + gint entry_num, + gint *num_colors, + GimpRGB *color); #endif /* GIMP_DISABLE_DEPRECATED */ diff --git a/libgimp/gimppaletteselect_pdb.c b/libgimp/gimppaletteselect_pdb.c index 2351339d04..3269f3fe1c 100644 --- a/libgimp/gimppaletteselect_pdb.c +++ b/libgimp/gimppaletteselect_pdb.c @@ -39,19 +39,19 @@ */ gboolean gimp_palettes_popup (const gchar *palette_callback, - const gchar *popup_title, - const gchar *initial_palette) + const gchar *popup_title, + const gchar *initial_palette) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-palettes-popup", - &nreturn_vals, - GIMP_PDB_STRING, palette_callback, - GIMP_PDB_STRING, popup_title, - GIMP_PDB_STRING, initial_palette, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, palette_callback, + GIMP_PDB_STRING, popup_title, + GIMP_PDB_STRING, initial_palette, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -78,9 +78,9 @@ gimp_palettes_close_popup (const gchar *palette_callback) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-palettes-close-popup", - &nreturn_vals, - GIMP_PDB_STRING, palette_callback, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, palette_callback, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -102,17 +102,17 @@ gimp_palettes_close_popup (const gchar *palette_callback) */ gboolean gimp_palettes_set_popup (const gchar *palette_callback, - const gchar *palette_name) + const gchar *palette_name) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-palettes-set-popup", - &nreturn_vals, - GIMP_PDB_STRING, palette_callback, - GIMP_PDB_STRING, palette_name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, palette_callback, + GIMP_PDB_STRING, palette_name, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; diff --git a/libgimp/gimppaletteselect_pdb.h b/libgimp/gimppaletteselect_pdb.h index ef0a5cb1fa..09bd141a8e 100644 --- a/libgimp/gimppaletteselect_pdb.h +++ b/libgimp/gimppaletteselect_pdb.h @@ -30,11 +30,11 @@ G_BEGIN_DECLS gboolean gimp_palettes_popup (const gchar *palette_callback, - const gchar *popup_title, - const gchar *initial_palette); + const gchar *popup_title, + const gchar *initial_palette); gboolean gimp_palettes_close_popup (const gchar *palette_callback); gboolean gimp_palettes_set_popup (const gchar *palette_callback, - const gchar *palette_name); + const gchar *palette_name); G_END_DECLS diff --git a/libgimp/gimpparasite_pdb.c b/libgimp/gimpparasite_pdb.c index 9e5c5a5731..2160b784d4 100644 --- a/libgimp/gimpparasite_pdb.c +++ b/libgimp/gimpparasite_pdb.c @@ -44,9 +44,9 @@ gimp_parasite_find (const gchar *name) GimpParasite *parasite = NULL; return_vals = gimp_run_procedure ("gimp-parasite-find", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) parasite = gimp_parasite_copy (&return_vals[1].data.d_parasite); @@ -75,9 +75,9 @@ gimp_parasite_attach (const GimpParasite *parasite) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-parasite-attach", - &nreturn_vals, - GIMP_PDB_PARASITE, parasite, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_PARASITE, parasite, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -105,9 +105,9 @@ gimp_parasite_detach (const gchar *name) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-parasite-detach", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -129,7 +129,7 @@ gimp_parasite_detach (const gchar *name) */ gboolean gimp_parasite_list (gint *num_parasites, - gchar ***parasites) + gchar ***parasites) { GimpParam *return_vals; gint nreturn_vals; @@ -137,8 +137,8 @@ gimp_parasite_list (gint *num_parasites, gint i; return_vals = gimp_run_procedure ("gimp-parasite-list", - &nreturn_vals, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_END); *num_parasites = 0; *parasites = NULL; @@ -172,17 +172,17 @@ gimp_parasite_list (gint *num_parasites, */ GimpParasite * gimp_image_parasite_find (gint32 image_ID, - const gchar *name) + const gchar *name) { GimpParam *return_vals; gint nreturn_vals; GimpParasite *parasite = NULL; return_vals = gimp_run_procedure ("gimp-image-parasite-find", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_STRING, name, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) parasite = gimp_parasite_copy (&return_vals[1].data.d_parasite); @@ -206,17 +206,17 @@ gimp_image_parasite_find (gint32 image_ID, */ gboolean gimp_image_parasite_attach (gint32 image_ID, - const GimpParasite *parasite) + const GimpParasite *parasite) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-parasite-attach", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_PARASITE, parasite, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_PARASITE, parasite, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -239,17 +239,17 @@ gimp_image_parasite_attach (gint32 image_ID, */ gboolean gimp_image_parasite_detach (gint32 image_ID, - const gchar *name) + const gchar *name) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-parasite-detach", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_STRING, name, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -272,8 +272,8 @@ gimp_image_parasite_detach (gint32 image_ID, */ gboolean gimp_image_parasite_list (gint32 image_ID, - gint *num_parasites, - gchar ***parasites) + gint *num_parasites, + gchar ***parasites) { GimpParam *return_vals; gint nreturn_vals; @@ -281,9 +281,9 @@ gimp_image_parasite_list (gint32 image_ID, gint i; return_vals = gimp_run_procedure ("gimp-image-parasite-list", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); *num_parasites = 0; *parasites = NULL; @@ -317,17 +317,17 @@ gimp_image_parasite_list (gint32 image_ID, */ GimpParasite * gimp_drawable_parasite_find (gint32 drawable_ID, - const gchar *name) + const gchar *name) { GimpParam *return_vals; gint nreturn_vals; GimpParasite *parasite = NULL; return_vals = gimp_run_procedure ("gimp-drawable-parasite-find", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_STRING, name, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) parasite = gimp_parasite_copy (&return_vals[1].data.d_parasite); @@ -351,17 +351,17 @@ gimp_drawable_parasite_find (gint32 drawable_ID, */ gboolean gimp_drawable_parasite_attach (gint32 drawable_ID, - const GimpParasite *parasite) + const GimpParasite *parasite) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-drawable-parasite-attach", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_PARASITE, parasite, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_PARASITE, parasite, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -384,17 +384,17 @@ gimp_drawable_parasite_attach (gint32 drawable_ID, */ gboolean gimp_drawable_parasite_detach (gint32 drawable_ID, - const gchar *name) + const gchar *name) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-drawable-parasite-detach", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_STRING, name, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -417,8 +417,8 @@ gimp_drawable_parasite_detach (gint32 drawable_ID, */ gboolean gimp_drawable_parasite_list (gint32 drawable_ID, - gint *num_parasites, - gchar ***parasites) + gint *num_parasites, + gchar ***parasites) { GimpParam *return_vals; gint nreturn_vals; @@ -426,9 +426,9 @@ gimp_drawable_parasite_list (gint32 drawable_ID, gint i; return_vals = gimp_run_procedure ("gimp-drawable-parasite-list", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_END); *num_parasites = 0; *parasites = NULL; @@ -464,17 +464,17 @@ gimp_drawable_parasite_list (gint32 drawable_ID, */ GimpParasite * gimp_vectors_parasite_find (gint32 vectors_ID, - const gchar *name) + const gchar *name) { GimpParam *return_vals; gint nreturn_vals; GimpParasite *parasite = NULL; return_vals = gimp_run_procedure ("gimp-vectors-parasite-find", - &nreturn_vals, - GIMP_PDB_VECTORS, vectors_ID, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_VECTORS, vectors_ID, + GIMP_PDB_STRING, name, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) parasite = gimp_parasite_copy (&return_vals[1].data.d_parasite); @@ -500,17 +500,17 @@ gimp_vectors_parasite_find (gint32 vectors_ID, */ gboolean gimp_vectors_parasite_attach (gint32 vectors_ID, - const GimpParasite *parasite) + const GimpParasite *parasite) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-vectors-parasite-attach", - &nreturn_vals, - GIMP_PDB_VECTORS, vectors_ID, - GIMP_PDB_PARASITE, parasite, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_VECTORS, vectors_ID, + GIMP_PDB_PARASITE, parasite, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -535,17 +535,17 @@ gimp_vectors_parasite_attach (gint32 vectors_ID, */ gboolean gimp_vectors_parasite_detach (gint32 vectors_ID, - const gchar *name) + const gchar *name) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-vectors-parasite-detach", - &nreturn_vals, - GIMP_PDB_VECTORS, vectors_ID, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_VECTORS, vectors_ID, + GIMP_PDB_STRING, name, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -570,8 +570,8 @@ gimp_vectors_parasite_detach (gint32 vectors_ID, */ gboolean gimp_vectors_parasite_list (gint32 vectors_ID, - gint *num_parasites, - gchar ***parasites) + gint *num_parasites, + gchar ***parasites) { GimpParam *return_vals; gint nreturn_vals; @@ -579,9 +579,9 @@ gimp_vectors_parasite_list (gint32 vectors_ID, gint i; return_vals = gimp_run_procedure ("gimp-vectors-parasite-list", - &nreturn_vals, - GIMP_PDB_VECTORS, vectors_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_VECTORS, vectors_ID, + GIMP_PDB_END); *num_parasites = 0; *parasites = NULL; diff --git a/libgimp/gimpparasite_pdb.h b/libgimp/gimpparasite_pdb.h index b124568bdc..f2b9c3f3b7 100644 --- a/libgimp/gimpparasite_pdb.h +++ b/libgimp/gimpparasite_pdb.h @@ -33,34 +33,34 @@ GimpParasite* gimp_parasite_find (const gchar *name); gboolean gimp_parasite_attach (const GimpParasite *parasite); gboolean gimp_parasite_detach (const gchar *name); gboolean gimp_parasite_list (gint *num_parasites, - gchar ***parasites); + gchar ***parasites); GimpParasite* gimp_image_parasite_find (gint32 image_ID, - const gchar *name); + const gchar *name); gboolean gimp_image_parasite_attach (gint32 image_ID, - const GimpParasite *parasite); + const GimpParasite *parasite); gboolean gimp_image_parasite_detach (gint32 image_ID, - const gchar *name); + const gchar *name); gboolean gimp_image_parasite_list (gint32 image_ID, - gint *num_parasites, - gchar ***parasites); + gint *num_parasites, + gchar ***parasites); GimpParasite* gimp_drawable_parasite_find (gint32 drawable_ID, - const gchar *name); + const gchar *name); gboolean gimp_drawable_parasite_attach (gint32 drawable_ID, - const GimpParasite *parasite); + const GimpParasite *parasite); gboolean gimp_drawable_parasite_detach (gint32 drawable_ID, - const gchar *name); + const gchar *name); gboolean gimp_drawable_parasite_list (gint32 drawable_ID, - gint *num_parasites, - gchar ***parasites); + gint *num_parasites, + gchar ***parasites); GimpParasite* gimp_vectors_parasite_find (gint32 vectors_ID, - const gchar *name); + const gchar *name); gboolean gimp_vectors_parasite_attach (gint32 vectors_ID, - const GimpParasite *parasite); + const GimpParasite *parasite); gboolean gimp_vectors_parasite_detach (gint32 vectors_ID, - const gchar *name); + const gchar *name); gboolean gimp_vectors_parasite_list (gint32 vectors_ID, - gint *num_parasites, - gchar ***parasites); + gint *num_parasites, + gchar ***parasites); G_END_DECLS diff --git a/libgimp/gimppaths_pdb.c b/libgimp/gimppaths_pdb.c index 508b9dee0f..09f4bc1464 100644 --- a/libgimp/gimppaths_pdb.c +++ b/libgimp/gimppaths_pdb.c @@ -38,7 +38,7 @@ */ gchar ** gimp_path_list (gint32 image_ID, - gint *num_paths) + gint *num_paths) { GimpParam *return_vals; gint nreturn_vals; @@ -46,9 +46,9 @@ gimp_path_list (gint32 image_ID, gint i; return_vals = gimp_run_procedure ("gimp-path-list", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); *num_paths = 0; @@ -82,9 +82,9 @@ gimp_path_get_current (gint32 image_ID) gchar *name = NULL; return_vals = gimp_run_procedure ("gimp-path-get-current", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) name = g_strdup (return_vals[1].data.d_string); @@ -106,17 +106,17 @@ gimp_path_get_current (gint32 image_ID) */ gboolean gimp_path_set_current (gint32 image_ID, - const gchar *name) + const gchar *name) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-path-set-current", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_STRING, name, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -137,17 +137,17 @@ gimp_path_set_current (gint32 image_ID, */ gboolean gimp_path_delete (gint32 image_ID, - const gchar *name) + const gchar *name) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-path-delete", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_STRING, name, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -172,20 +172,20 @@ gimp_path_delete (gint32 image_ID, */ gint gimp_path_get_points (gint32 image_ID, - const gchar *name, - gint *path_closed, - gint *num_path_point_details, - gdouble **points_pairs) + const gchar *name, + gint *path_closed, + gint *num_path_point_details, + gdouble **points_pairs) { GimpParam *return_vals; gint nreturn_vals; gint path_type = 0; return_vals = gimp_run_procedure ("gimp-path-get-points", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_STRING, name, + GIMP_PDB_END); *num_path_point_details = 0; @@ -220,23 +220,23 @@ gimp_path_get_points (gint32 image_ID, */ gboolean gimp_path_set_points (gint32 image_ID, - const gchar *name, - gint ptype, - gint num_path_points, - const gdouble *points_pairs) + const gchar *name, + gint ptype, + gint num_path_points, + const gdouble *points_pairs) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-path-set-points", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_STRING, name, - GIMP_PDB_INT32, ptype, - GIMP_PDB_INT32, num_path_points, - GIMP_PDB_FLOATARRAY, points_pairs, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_STRING, name, + GIMP_PDB_INT32, ptype, + GIMP_PDB_INT32, num_path_points, + GIMP_PDB_FLOATARRAY, points_pairs, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -263,9 +263,9 @@ gimp_path_stroke_current (gint32 image_ID) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-path-stroke-current", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -288,19 +288,19 @@ gimp_path_stroke_current (gint32 image_ID) */ gint gimp_path_get_point_at_dist (gint32 image_ID, - gdouble distance, - gint *y_point, - gdouble *slope) + gdouble distance, + gint *y_point, + gdouble *slope) { GimpParam *return_vals; gint nreturn_vals; gint x_point = 0; return_vals = gimp_run_procedure ("gimp-path-get-point-at-dist", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_FLOAT, distance, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_FLOAT, distance, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) { @@ -325,17 +325,17 @@ gimp_path_get_point_at_dist (gint32 image_ID, */ gint gimp_path_get_tattoo (gint32 image_ID, - const gchar *name) + const gchar *name) { GimpParam *return_vals; gint nreturn_vals; gint tattoo = 0; return_vals = gimp_run_procedure ("gimp-path-get-tattoo", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_STRING, name, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) tattoo = return_vals[1].data.d_int32; @@ -357,19 +357,19 @@ gimp_path_get_tattoo (gint32 image_ID, */ gboolean gimp_path_set_tattoo (gint32 image_ID, - const gchar *name, - gint tattovalue) + const gchar *name, + gint tattovalue) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-path-set-tattoo", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_STRING, name, - GIMP_PDB_INT32, tattovalue, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_STRING, name, + GIMP_PDB_INT32, tattovalue, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -390,17 +390,17 @@ gimp_path_set_tattoo (gint32 image_ID, */ gchar * gimp_get_path_by_tattoo (gint32 image_ID, - gint tattoo) + gint tattoo) { GimpParam *return_vals; gint nreturn_vals; gchar *name = NULL; return_vals = gimp_run_procedure ("gimp-get-path-by-tattoo", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_INT32, tattoo, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_INT32, tattoo, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) name = g_strdup (return_vals[1].data.d_string); @@ -421,17 +421,17 @@ gimp_get_path_by_tattoo (gint32 image_ID, */ gboolean gimp_path_get_locked (gint32 image_ID, - const gchar *name) + const gchar *name) { GimpParam *return_vals; gint nreturn_vals; gboolean locked = FALSE; return_vals = gimp_run_procedure ("gimp-path-get-locked", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_STRING, name, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) locked = return_vals[1].data.d_int32; @@ -453,19 +453,19 @@ gimp_path_get_locked (gint32 image_ID, */ gboolean gimp_path_set_locked (gint32 image_ID, - const gchar *name, - gboolean locked) + const gchar *name, + gboolean locked) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-path-set-locked", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_STRING, name, - GIMP_PDB_INT32, locked, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_STRING, name, + GIMP_PDB_INT32, locked, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -492,27 +492,27 @@ gimp_path_set_locked (gint32 image_ID, */ gboolean gimp_path_to_selection (gint32 image_ID, - const gchar *name, - GimpChannelOps op, - gboolean antialias, - gboolean feather, - gdouble feather_radius_x, - gdouble feather_radius_y) + const gchar *name, + GimpChannelOps op, + gboolean antialias, + gboolean feather, + gdouble feather_radius_x, + gdouble feather_radius_y) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-path-to-selection", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_STRING, name, - GIMP_PDB_INT32, op, - GIMP_PDB_INT32, antialias, - GIMP_PDB_INT32, feather, - GIMP_PDB_FLOAT, feather_radius_x, - GIMP_PDB_FLOAT, feather_radius_y, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_STRING, name, + GIMP_PDB_INT32, op, + GIMP_PDB_INT32, antialias, + GIMP_PDB_INT32, feather, + GIMP_PDB_FLOAT, feather_radius_x, + GIMP_PDB_FLOAT, feather_radius_y, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -537,21 +537,21 @@ gimp_path_to_selection (gint32 image_ID, */ gboolean gimp_path_import (gint32 image_ID, - const gchar *filename, - gboolean merge, - gboolean scale) + const gchar *filename, + gboolean merge, + gboolean scale) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-path-import", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_STRING, filename, - GIMP_PDB_INT32, merge, - GIMP_PDB_INT32, scale, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_STRING, filename, + GIMP_PDB_INT32, merge, + GIMP_PDB_INT32, scale, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -580,23 +580,23 @@ gimp_path_import (gint32 image_ID, */ gboolean gimp_path_import_string (gint32 image_ID, - const gchar *string, - gint length, - gboolean merge, - gboolean scale) + const gchar *string, + gint length, + gboolean merge, + gboolean scale) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-path-import-string", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_STRING, string, - GIMP_PDB_INT32, length, - GIMP_PDB_INT32, merge, - GIMP_PDB_INT32, scale, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_STRING, string, + GIMP_PDB_INT32, length, + GIMP_PDB_INT32, merge, + GIMP_PDB_INT32, scale, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; diff --git a/libgimp/gimppaths_pdb.h b/libgimp/gimppaths_pdb.h index 7dd4301004..cdc5a158fa 100644 --- a/libgimp/gimppaths_pdb.h +++ b/libgimp/gimppaths_pdb.h @@ -31,58 +31,58 @@ G_BEGIN_DECLS #ifndef GIMP_DISABLE_DEPRECATED gchar** gimp_path_list (gint32 image_ID, - gint *num_paths); + gint *num_paths); gchar* gimp_path_get_current (gint32 image_ID); gboolean gimp_path_set_current (gint32 image_ID, - const gchar *name); + const gchar *name); gboolean gimp_path_delete (gint32 image_ID, - const gchar *name); + const gchar *name); #endif /* GIMP_DISABLE_DEPRECATED */ gint gimp_path_get_points (gint32 image_ID, - const gchar *name, - gint *path_closed, - gint *num_path_point_details, - gdouble **points_pairs); + const gchar *name, + gint *path_closed, + gint *num_path_point_details, + gdouble **points_pairs); gboolean gimp_path_set_points (gint32 image_ID, - const gchar *name, - gint ptype, - gint num_path_points, - const gdouble *points_pairs); + const gchar *name, + gint ptype, + gint num_path_points, + const gdouble *points_pairs); gboolean gimp_path_stroke_current (gint32 image_ID); #ifndef GIMP_DISABLE_DEPRECATED gint gimp_path_get_point_at_dist (gint32 image_ID, - gdouble distance, - gint *y_point, - gdouble *slope); + gdouble distance, + gint *y_point, + gdouble *slope); gint gimp_path_get_tattoo (gint32 image_ID, - const gchar *name); + const gchar *name); gboolean gimp_path_set_tattoo (gint32 image_ID, - const gchar *name, - gint tattovalue); + const gchar *name, + gint tattovalue); gchar* gimp_get_path_by_tattoo (gint32 image_ID, - gint tattoo); + gint tattoo); gboolean gimp_path_get_locked (gint32 image_ID, - const gchar *name); + const gchar *name); gboolean gimp_path_set_locked (gint32 image_ID, - const gchar *name, - gboolean locked); + const gchar *name, + gboolean locked); #endif /* GIMP_DISABLE_DEPRECATED */ gboolean gimp_path_to_selection (gint32 image_ID, - const gchar *name, - GimpChannelOps op, - gboolean antialias, - gboolean feather, - gdouble feather_radius_x, - gdouble feather_radius_y); + const gchar *name, + GimpChannelOps op, + gboolean antialias, + gboolean feather, + gdouble feather_radius_x, + gdouble feather_radius_y); gboolean gimp_path_import (gint32 image_ID, - const gchar *filename, - gboolean merge, - gboolean scale); + const gchar *filename, + gboolean merge, + gboolean scale); gboolean gimp_path_import_string (gint32 image_ID, - const gchar *string, - gint length, - gboolean merge, - gboolean scale); + const gchar *string, + gint length, + gboolean merge, + gboolean scale); G_END_DECLS diff --git a/libgimp/gimppattern_pdb.c b/libgimp/gimppattern_pdb.c index 37cfbde736..c05c904562 100644 --- a/libgimp/gimppattern_pdb.c +++ b/libgimp/gimppattern_pdb.c @@ -45,18 +45,18 @@ */ gboolean gimp_pattern_get_info (const gchar *name, - gint *width, - gint *height, - gint *bpp) + gint *width, + gint *height, + gint *bpp) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-pattern-get-info", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_END); *width = 0; *height = 0; @@ -97,20 +97,20 @@ gimp_pattern_get_info (const gchar *name, */ gboolean gimp_pattern_get_pixels (const gchar *name, - gint *width, - gint *height, - gint *bpp, - gint *num_color_bytes, - guint8 **color_bytes) + gint *width, + gint *height, + gint *bpp, + gint *num_color_bytes, + guint8 **color_bytes) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-pattern-get-pixels", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_END); *width = 0; *height = 0; diff --git a/libgimp/gimppattern_pdb.h b/libgimp/gimppattern_pdb.h index d53e24f781..fa4abd8b89 100644 --- a/libgimp/gimppattern_pdb.h +++ b/libgimp/gimppattern_pdb.h @@ -30,15 +30,15 @@ G_BEGIN_DECLS gboolean gimp_pattern_get_info (const gchar *name, - gint *width, - gint *height, - gint *bpp); + gint *width, + gint *height, + gint *bpp); gboolean gimp_pattern_get_pixels (const gchar *name, - gint *width, - gint *height, - gint *bpp, - gint *num_color_bytes, - guint8 **color_bytes); + gint *width, + gint *height, + gint *bpp, + gint *num_color_bytes, + guint8 **color_bytes); G_END_DECLS diff --git a/libgimp/gimppatterns_pdb.c b/libgimp/gimppatterns_pdb.c index a74b86a494..08b53c587e 100644 --- a/libgimp/gimppatterns_pdb.c +++ b/libgimp/gimppatterns_pdb.c @@ -45,8 +45,8 @@ gimp_patterns_refresh (void) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-patterns-refresh", - &nreturn_vals, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -70,7 +70,7 @@ gimp_patterns_refresh (void) */ gchar ** gimp_patterns_get_list (const gchar *filter, - gint *num_patterns) + gint *num_patterns) { GimpParam *return_vals; gint nreturn_vals; @@ -78,9 +78,9 @@ gimp_patterns_get_list (const gchar *filter, gint i; return_vals = gimp_run_procedure ("gimp-patterns-get-list", - &nreturn_vals, - GIMP_PDB_STRING, filter, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, filter, + GIMP_PDB_END); *num_patterns = 0; @@ -109,15 +109,15 @@ gimp_patterns_get_list (const gchar *filter, */ gchar * gimp_patterns_get_pattern (gint *width, - gint *height) + gint *height) { GimpParam *return_vals; gint nreturn_vals; gchar *name = NULL; return_vals = gimp_run_procedure ("gimp-patterns-get-pattern", - &nreturn_vals, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) { @@ -146,20 +146,20 @@ gimp_patterns_get_pattern (gint *width, */ gchar * gimp_patterns_get_pattern_data (const gchar *name, - gint *width, - gint *height, - gint *mask_bpp, - gint *length, - guint8 **mask_data) + gint *width, + gint *height, + gint *mask_bpp, + gint *length, + guint8 **mask_data) { GimpParam *return_vals; gint nreturn_vals; gchar *actual_name = NULL; return_vals = gimp_run_procedure ("gimp-patterns-get-pattern-data", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_END); *length = 0; diff --git a/libgimp/gimppatterns_pdb.h b/libgimp/gimppatterns_pdb.h index f194899423..ccc807327d 100644 --- a/libgimp/gimppatterns_pdb.h +++ b/libgimp/gimppatterns_pdb.h @@ -31,16 +31,16 @@ G_BEGIN_DECLS gboolean gimp_patterns_refresh (void); gchar** gimp_patterns_get_list (const gchar *filter, - gint *num_patterns); + gint *num_patterns); #ifndef GIMP_DISABLE_DEPRECATED gchar* gimp_patterns_get_pattern (gint *width, - gint *height); + gint *height); gchar* gimp_patterns_get_pattern_data (const gchar *name, - gint *width, - gint *height, - gint *mask_bpp, - gint *length, - guint8 **mask_data); + gint *width, + gint *height, + gint *mask_bpp, + gint *length, + guint8 **mask_data); #endif /* GIMP_DISABLE_DEPRECATED */ diff --git a/libgimp/gimppatternselect_pdb.c b/libgimp/gimppatternselect_pdb.c index 3c6d16b16c..464d30c909 100644 --- a/libgimp/gimppatternselect_pdb.c +++ b/libgimp/gimppatternselect_pdb.c @@ -39,19 +39,19 @@ */ gboolean gimp_patterns_popup (const gchar *pattern_callback, - const gchar *popup_title, - const gchar *initial_pattern) + const gchar *popup_title, + const gchar *initial_pattern) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-patterns-popup", - &nreturn_vals, - GIMP_PDB_STRING, pattern_callback, - GIMP_PDB_STRING, popup_title, - GIMP_PDB_STRING, initial_pattern, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, pattern_callback, + GIMP_PDB_STRING, popup_title, + GIMP_PDB_STRING, initial_pattern, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -78,9 +78,9 @@ gimp_patterns_close_popup (const gchar *pattern_callback) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-patterns-close-popup", - &nreturn_vals, - GIMP_PDB_STRING, pattern_callback, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, pattern_callback, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -102,17 +102,17 @@ gimp_patterns_close_popup (const gchar *pattern_callback) */ gboolean gimp_patterns_set_popup (const gchar *pattern_callback, - const gchar *pattern_name) + const gchar *pattern_name) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-patterns-set-popup", - &nreturn_vals, - GIMP_PDB_STRING, pattern_callback, - GIMP_PDB_STRING, pattern_name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, pattern_callback, + GIMP_PDB_STRING, pattern_name, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; diff --git a/libgimp/gimppatternselect_pdb.h b/libgimp/gimppatternselect_pdb.h index 9ef369a4df..3ae24b5fdc 100644 --- a/libgimp/gimppatternselect_pdb.h +++ b/libgimp/gimppatternselect_pdb.h @@ -30,11 +30,11 @@ G_BEGIN_DECLS gboolean gimp_patterns_popup (const gchar *pattern_callback, - const gchar *popup_title, - const gchar *initial_pattern); + const gchar *popup_title, + const gchar *initial_pattern); gboolean gimp_patterns_close_popup (const gchar *pattern_callback); gboolean gimp_patterns_set_popup (const gchar *pattern_callback, - const gchar *pattern_name); + const gchar *pattern_name); G_END_DECLS diff --git a/libgimp/gimpplugin_pdb.c b/libgimp/gimpplugin_pdb.c index ea9674edea..a8ecd23e1e 100644 --- a/libgimp/gimpplugin_pdb.c +++ b/libgimp/gimpplugin_pdb.c @@ -45,17 +45,17 @@ */ gboolean gimp_plugin_domain_register (const gchar *domain_name, - const gchar *domain_path) + const gchar *domain_path) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-plugin-domain-register", - &nreturn_vals, - GIMP_PDB_STRING, domain_name, - GIMP_PDB_STRING, domain_path, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, domain_name, + GIMP_PDB_STRING, domain_path, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -79,17 +79,17 @@ gimp_plugin_domain_register (const gchar *domain_name, */ gboolean gimp_plugin_help_register (const gchar *domain_name, - const gchar *domain_uri) + const gchar *domain_uri) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-plugin-help-register", - &nreturn_vals, - GIMP_PDB_STRING, domain_name, - GIMP_PDB_STRING, domain_uri, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, domain_name, + GIMP_PDB_STRING, domain_uri, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -114,17 +114,17 @@ gimp_plugin_help_register (const gchar *domain_name, */ gboolean gimp_plugin_menu_register (const gchar *procedure_name, - const gchar *menu_path) + const gchar *menu_path) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-plugin-menu-register", - &nreturn_vals, - GIMP_PDB_STRING, procedure_name, - GIMP_PDB_STRING, menu_path, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, procedure_name, + GIMP_PDB_STRING, menu_path, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -149,17 +149,17 @@ gimp_plugin_menu_register (const gchar *procedure_name, */ gboolean gimp_plugin_menu_branch_register (const gchar *menu_path, - const gchar *menu_name) + const gchar *menu_name) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-plugin-menu-branch-register", - &nreturn_vals, - GIMP_PDB_STRING, menu_path, - GIMP_PDB_STRING, menu_name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, menu_path, + GIMP_PDB_STRING, menu_name, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -185,21 +185,21 @@ gimp_plugin_menu_branch_register (const gchar *menu_path, */ gboolean _gimp_plugin_icon_register (const gchar *procedure_name, - GimpIconType icon_type, - gint icon_data_length, - const guint8 *icon_data) + GimpIconType icon_type, + gint icon_data_length, + const guint8 *icon_data) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-plugin-icon-register", - &nreturn_vals, - GIMP_PDB_STRING, procedure_name, - GIMP_PDB_INT32, icon_type, - GIMP_PDB_INT32, icon_data_length, - GIMP_PDB_INT8ARRAY, icon_data, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, procedure_name, + GIMP_PDB_INT32, icon_type, + GIMP_PDB_INT32, icon_data_length, + GIMP_PDB_INT8ARRAY, icon_data, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; diff --git a/libgimp/gimpplugin_pdb.h b/libgimp/gimpplugin_pdb.h index fb02371262..f4949439aa 100644 --- a/libgimp/gimpplugin_pdb.h +++ b/libgimp/gimpplugin_pdb.h @@ -30,17 +30,17 @@ G_BEGIN_DECLS gboolean gimp_plugin_domain_register (const gchar *domain_name, - const gchar *domain_path); + const gchar *domain_path); gboolean gimp_plugin_help_register (const gchar *domain_name, - const gchar *domain_uri); + const gchar *domain_uri); gboolean gimp_plugin_menu_register (const gchar *procedure_name, - const gchar *menu_path); + const gchar *menu_path); gboolean gimp_plugin_menu_branch_register (const gchar *menu_path, - const gchar *menu_name); + const gchar *menu_name); gboolean _gimp_plugin_icon_register (const gchar *procedure_name, - GimpIconType icon_type, - gint icon_data_length, - const guint8 *icon_data) G_GNUC_INTERNAL; + GimpIconType icon_type, + gint icon_data_length, + const guint8 *icon_data) G_GNUC_INTERNAL; G_END_DECLS diff --git a/libgimp/gimpproceduraldb_pdb.c b/libgimp/gimpproceduraldb_pdb.c index 68813b6cc6..f6844e666b 100644 --- a/libgimp/gimpproceduraldb_pdb.c +++ b/libgimp/gimpproceduraldb_pdb.c @@ -46,8 +46,8 @@ gimp_procedural_db_temp_name (void) gchar *temp_name = NULL; return_vals = gimp_run_procedure ("gimp-procedural-db-temp-name", - &nreturn_vals, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) temp_name = g_strdup (return_vals[1].data.d_string); @@ -79,9 +79,9 @@ gimp_procedural_db_dump (const gchar *filename) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-procedural-db-dump", - &nreturn_vals, - GIMP_PDB_STRING, filename, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, filename, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -122,14 +122,14 @@ gimp_procedural_db_dump (const gchar *filename) */ gboolean gimp_procedural_db_query (const gchar *name, - const gchar *blurb, - const gchar *help, - const gchar *author, - const gchar *copyright, - const gchar *date, - const gchar *proc_type, - gint *num_matches, - gchar ***procedure_names) + const gchar *blurb, + const gchar *help, + const gchar *author, + const gchar *copyright, + const gchar *date, + const gchar *proc_type, + gint *num_matches, + gchar ***procedure_names) { GimpParam *return_vals; gint nreturn_vals; @@ -137,15 +137,15 @@ gimp_procedural_db_query (const gchar *name, gint i; return_vals = gimp_run_procedure ("gimp-procedural-db-query", - &nreturn_vals, - GIMP_PDB_STRING, name, - GIMP_PDB_STRING, blurb, - GIMP_PDB_STRING, help, - GIMP_PDB_STRING, author, - GIMP_PDB_STRING, copyright, - GIMP_PDB_STRING, date, - GIMP_PDB_STRING, proc_type, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, name, + GIMP_PDB_STRING, blurb, + GIMP_PDB_STRING, help, + GIMP_PDB_STRING, author, + GIMP_PDB_STRING, copyright, + GIMP_PDB_STRING, date, + GIMP_PDB_STRING, proc_type, + GIMP_PDB_END); *num_matches = 0; *procedure_names = NULL; @@ -191,23 +191,23 @@ gimp_procedural_db_query (const gchar *name, */ gboolean _gimp_procedural_db_proc_info (const gchar *procedure_name, - gchar **blurb, - gchar **help, - gchar **author, - gchar **copyright, - gchar **date, - GimpPDBProcType *proc_type, - gint *num_args, - gint *num_values) + gchar **blurb, + gchar **help, + gchar **author, + gchar **copyright, + gchar **date, + GimpPDBProcType *proc_type, + gint *num_args, + gint *num_values) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-procedural-db-proc-info", - &nreturn_vals, - GIMP_PDB_STRING, procedure_name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, procedure_name, + GIMP_PDB_END); *blurb = NULL; *help = NULL; @@ -255,20 +255,20 @@ _gimp_procedural_db_proc_info (const gchar *procedure_name, */ gboolean gimp_procedural_db_proc_arg (const gchar *procedure_name, - gint arg_num, - GimpPDBArgType *arg_type, - gchar **arg_name, - gchar **arg_desc) + gint arg_num, + GimpPDBArgType *arg_type, + gchar **arg_name, + gchar **arg_desc) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-procedural-db-proc-arg", - &nreturn_vals, - GIMP_PDB_STRING, procedure_name, - GIMP_PDB_INT32, arg_num, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, procedure_name, + GIMP_PDB_INT32, arg_num, + GIMP_PDB_END); *arg_type = 0; *arg_name = NULL; @@ -307,20 +307,20 @@ gimp_procedural_db_proc_arg (const gchar *procedure_name, */ gboolean gimp_procedural_db_proc_val (const gchar *procedure_name, - gint val_num, - GimpPDBArgType *val_type, - gchar **val_name, - gchar **val_desc) + gint val_num, + GimpPDBArgType *val_type, + gchar **val_name, + gchar **val_desc) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-procedural-db-proc-val", - &nreturn_vals, - GIMP_PDB_STRING, procedure_name, - GIMP_PDB_INT32, val_num, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, procedure_name, + GIMP_PDB_INT32, val_num, + GIMP_PDB_END); *val_type = 0; *val_name = NULL; @@ -357,17 +357,17 @@ gimp_procedural_db_proc_val (const gchar *procedure_name, */ gboolean _gimp_procedural_db_get_data (const gchar *identifier, - gint *bytes, - guint8 **data) + gint *bytes, + guint8 **data) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-procedural-db-get-data", - &nreturn_vals, - GIMP_PDB_STRING, identifier, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, identifier, + GIMP_PDB_END); *bytes = 0; *data = NULL; @@ -407,9 +407,9 @@ gimp_procedural_db_get_data_size (const gchar *identifier) gint bytes = 0; return_vals = gimp_run_procedure ("gimp-procedural-db-get-data-size", - &nreturn_vals, - GIMP_PDB_STRING, identifier, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, identifier, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) bytes = return_vals[1].data.d_int32; @@ -435,19 +435,19 @@ gimp_procedural_db_get_data_size (const gchar *identifier) */ gboolean _gimp_procedural_db_set_data (const gchar *identifier, - gint bytes, - const guint8 *data) + gint bytes, + const guint8 *data) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-procedural-db-set-data", - &nreturn_vals, - GIMP_PDB_STRING, identifier, - GIMP_PDB_INT32, bytes, - GIMP_PDB_INT8ARRAY, data, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, identifier, + GIMP_PDB_INT32, bytes, + GIMP_PDB_INT8ARRAY, data, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; diff --git a/libgimp/gimpproceduraldb_pdb.h b/libgimp/gimpproceduraldb_pdb.h index 79ebdea38f..42f42c5e0a 100644 --- a/libgimp/gimpproceduraldb_pdb.h +++ b/libgimp/gimpproceduraldb_pdb.h @@ -32,40 +32,40 @@ G_BEGIN_DECLS gchar* gimp_procedural_db_temp_name (void); gboolean gimp_procedural_db_dump (const gchar *filename); gboolean gimp_procedural_db_query (const gchar *name, - const gchar *blurb, - const gchar *help, - const gchar *author, - const gchar *copyright, - const gchar *date, - const gchar *proc_type, - gint *num_matches, - gchar ***procedure_names); + const gchar *blurb, + const gchar *help, + const gchar *author, + const gchar *copyright, + const gchar *date, + const gchar *proc_type, + gint *num_matches, + gchar ***procedure_names); gboolean _gimp_procedural_db_proc_info (const gchar *procedure_name, - gchar **blurb, - gchar **help, - gchar **author, - gchar **copyright, - gchar **date, - GimpPDBProcType *proc_type, - gint *num_args, - gint *num_values) G_GNUC_INTERNAL; + gchar **blurb, + gchar **help, + gchar **author, + gchar **copyright, + gchar **date, + GimpPDBProcType *proc_type, + gint *num_args, + gint *num_values) G_GNUC_INTERNAL; gboolean gimp_procedural_db_proc_arg (const gchar *procedure_name, - gint arg_num, - GimpPDBArgType *arg_type, - gchar **arg_name, - gchar **arg_desc); + gint arg_num, + GimpPDBArgType *arg_type, + gchar **arg_name, + gchar **arg_desc); gboolean gimp_procedural_db_proc_val (const gchar *procedure_name, - gint val_num, - GimpPDBArgType *val_type, - gchar **val_name, - gchar **val_desc); + gint val_num, + GimpPDBArgType *val_type, + gchar **val_name, + gchar **val_desc); gboolean _gimp_procedural_db_get_data (const gchar *identifier, - gint *bytes, - guint8 **data) G_GNUC_INTERNAL; + gint *bytes, + guint8 **data) G_GNUC_INTERNAL; gint gimp_procedural_db_get_data_size (const gchar *identifier); gboolean _gimp_procedural_db_set_data (const gchar *identifier, - gint bytes, - const guint8 *data) G_GNUC_INTERNAL; + gint bytes, + const guint8 *data) G_GNUC_INTERNAL; G_END_DECLS diff --git a/libgimp/gimpprogress_pdb.c b/libgimp/gimpprogress_pdb.c index b8e7b44767..98fa4b5ba9 100644 --- a/libgimp/gimpprogress_pdb.c +++ b/libgimp/gimpprogress_pdb.c @@ -39,17 +39,17 @@ */ gboolean _gimp_progress_init (const gchar *message, - gint32 gdisplay_ID) + gint32 gdisplay_ID) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-progress-init", - &nreturn_vals, - GIMP_PDB_STRING, message, - GIMP_PDB_DISPLAY, gdisplay_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, message, + GIMP_PDB_DISPLAY, gdisplay_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -77,9 +77,9 @@ _gimp_progress_update (gdouble percentage) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-progress-update", - &nreturn_vals, - GIMP_PDB_FLOAT, percentage, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_FLOAT, percentage, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -111,8 +111,8 @@ gimp_progress_pulse (void) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-progress-pulse", - &nreturn_vals, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -143,9 +143,9 @@ gimp_progress_set_text (const gchar *message) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-progress-set-text", - &nreturn_vals, - GIMP_PDB_STRING, message, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, message, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -175,8 +175,8 @@ gimp_progress_get_window_handle (void) gint window = 0; return_vals = gimp_run_procedure ("gimp-progress-get-window-handle", - &nreturn_vals, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) window = return_vals[1].data.d_int32; @@ -209,9 +209,9 @@ _gimp_progress_install (const gchar *progress_callback) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-progress-install", - &nreturn_vals, - GIMP_PDB_STRING, progress_callback, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, progress_callback, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -241,9 +241,9 @@ _gimp_progress_uninstall (const gchar *progress_callback) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-progress-uninstall", - &nreturn_vals, - GIMP_PDB_STRING, progress_callback, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, progress_callback, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -272,9 +272,9 @@ gimp_progress_cancel (const gchar *progress_callback) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-progress-cancel", - &nreturn_vals, - GIMP_PDB_STRING, progress_callback, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, progress_callback, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; diff --git a/libgimp/gimpprogress_pdb.h b/libgimp/gimpprogress_pdb.h index a25ee4b427..69f591a4e0 100644 --- a/libgimp/gimpprogress_pdb.h +++ b/libgimp/gimpprogress_pdb.h @@ -30,7 +30,7 @@ G_BEGIN_DECLS gboolean _gimp_progress_init (const gchar *message, - gint32 gdisplay_ID) G_GNUC_INTERNAL; + gint32 gdisplay_ID) G_GNUC_INTERNAL; gboolean _gimp_progress_update (gdouble percentage) G_GNUC_INTERNAL; gboolean gimp_progress_pulse (void); gboolean gimp_progress_set_text (const gchar *message); diff --git a/libgimp/gimpselection_pdb.c b/libgimp/gimpselection_pdb.c index d3309a92fb..d859231b66 100644 --- a/libgimp/gimpselection_pdb.c +++ b/libgimp/gimpselection_pdb.c @@ -49,20 +49,20 @@ */ gboolean gimp_selection_bounds (gint32 image_ID, - gboolean *non_empty, - gint *x1, - gint *y1, - gint *x2, - gint *y2) + gboolean *non_empty, + gint *x1, + gint *y1, + gint *x2, + gint *y2) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-selection-bounds", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); *non_empty = FALSE; *x1 = 0; @@ -101,19 +101,19 @@ gimp_selection_bounds (gint32 image_ID, */ gint gimp_selection_value (gint32 image_ID, - gint x, - gint y) + gint x, + gint y) { GimpParam *return_vals; gint nreturn_vals; gint value = 0; return_vals = gimp_run_procedure ("gimp-selection-value", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_INT32, x, - GIMP_PDB_INT32, y, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_INT32, x, + GIMP_PDB_INT32, y, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) value = return_vals[1].data.d_int32; @@ -142,9 +142,9 @@ gimp_selection_is_empty (gint32 image_ID) gboolean is_empty = FALSE; return_vals = gimp_run_procedure ("gimp-selection-is-empty", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) is_empty = return_vals[1].data.d_int32; @@ -172,19 +172,19 @@ gimp_selection_is_empty (gint32 image_ID) */ gboolean gimp_selection_translate (gint32 image_ID, - gint offx, - gint offy) + gint offx, + gint offy) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-selection-translate", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_INT32, offx, - GIMP_PDB_INT32, offy, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_INT32, offx, + GIMP_PDB_INT32, offy, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -212,19 +212,19 @@ gimp_selection_translate (gint32 image_ID, */ gint32 _gimp_selection_float (gint32 drawable_ID, - gint offx, - gint offy) + gint offx, + gint offy) { GimpParam *return_vals; gint nreturn_vals; gint32 layer_ID = -1; return_vals = gimp_run_procedure ("gimp-selection-float", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, offx, - GIMP_PDB_INT32, offy, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, offx, + GIMP_PDB_INT32, offy, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) layer_ID = return_vals[1].data.d_layer; @@ -253,9 +253,9 @@ gimp_selection_invert (gint32 image_ID) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-selection-invert", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -285,9 +285,9 @@ gimp_selection_sharpen (gint32 image_ID) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-selection-sharpen", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -315,9 +315,9 @@ gimp_selection_all (gint32 image_ID) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-selection-all", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -345,9 +345,9 @@ gimp_selection_none (gint32 image_ID) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-selection-none", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -370,17 +370,17 @@ gimp_selection_none (gint32 image_ID) */ gboolean gimp_selection_feather (gint32 image_ID, - gdouble radius) + gdouble radius) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-selection-feather", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_FLOAT, radius, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_FLOAT, radius, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -404,17 +404,17 @@ gimp_selection_feather (gint32 image_ID, */ gboolean gimp_selection_border (gint32 image_ID, - gint radius) + gint radius) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-selection-border", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_INT32, radius, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_INT32, radius, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -437,17 +437,17 @@ gimp_selection_border (gint32 image_ID, */ gboolean gimp_selection_grow (gint32 image_ID, - gint steps) + gint steps) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-selection-grow", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_INT32, steps, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_INT32, steps, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -471,17 +471,17 @@ gimp_selection_grow (gint32 image_ID, */ gboolean gimp_selection_shrink (gint32 image_ID, - gint steps) + gint steps) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-selection-shrink", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_INT32, steps, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_INT32, steps, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -513,9 +513,9 @@ gimp_selection_layer_alpha (gint32 layer_ID) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-selection-layer-alpha", - &nreturn_vals, - GIMP_PDB_LAYER, layer_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_LAYER, layer_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -542,9 +542,9 @@ gimp_selection_load (gint32 channel_ID) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-selection-load", - &nreturn_vals, - GIMP_PDB_CHANNEL, channel_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_CHANNEL, channel_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -573,9 +573,9 @@ gimp_selection_save (gint32 image_ID) gint32 channel_ID = -1; return_vals = gimp_run_procedure ("gimp-selection-save", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) channel_ID = return_vals[1].data.d_channel; @@ -599,17 +599,17 @@ gimp_selection_save (gint32 image_ID) */ gboolean gimp_selection_combine (gint32 channel_ID, - GimpChannelOps operation) + GimpChannelOps operation) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-selection-combine", - &nreturn_vals, - GIMP_PDB_CHANNEL, channel_ID, - GIMP_PDB_INT32, operation, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_CHANNEL, channel_ID, + GIMP_PDB_INT32, operation, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; diff --git a/libgimp/gimpselection_pdb.h b/libgimp/gimpselection_pdb.h index 816d34c8a0..d9929d1dfa 100644 --- a/libgimp/gimpselection_pdb.h +++ b/libgimp/gimpselection_pdb.h @@ -30,38 +30,38 @@ G_BEGIN_DECLS gboolean gimp_selection_bounds (gint32 image_ID, - gboolean *non_empty, - gint *x1, - gint *y1, - gint *x2, - gint *y2); + gboolean *non_empty, + gint *x1, + gint *y1, + gint *x2, + gint *y2); gint gimp_selection_value (gint32 image_ID, - gint x, - gint y); + gint x, + gint y); gboolean gimp_selection_is_empty (gint32 image_ID); gboolean gimp_selection_translate (gint32 image_ID, - gint offx, - gint offy); + gint offx, + gint offy); gint32 _gimp_selection_float (gint32 drawable_ID, - gint offx, - gint offy) G_GNUC_INTERNAL; + gint offx, + gint offy) G_GNUC_INTERNAL; gboolean gimp_selection_invert (gint32 image_ID); gboolean gimp_selection_sharpen (gint32 image_ID); gboolean gimp_selection_all (gint32 image_ID); gboolean gimp_selection_none (gint32 image_ID); gboolean gimp_selection_feather (gint32 image_ID, - gdouble radius); + gdouble radius); gboolean gimp_selection_border (gint32 image_ID, - gint radius); + gint radius); gboolean gimp_selection_grow (gint32 image_ID, - gint steps); + gint steps); gboolean gimp_selection_shrink (gint32 image_ID, - gint steps); + gint steps); gboolean gimp_selection_layer_alpha (gint32 layer_ID); gboolean gimp_selection_load (gint32 channel_ID); gint32 gimp_selection_save (gint32 image_ID); gboolean gimp_selection_combine (gint32 channel_ID, - GimpChannelOps operation); + GimpChannelOps operation); G_END_DECLS diff --git a/libgimp/gimpselectiontools_pdb.c b/libgimp/gimpselectiontools_pdb.c index 6c8f345a16..7f49c35bf2 100644 --- a/libgimp/gimpselectiontools_pdb.c +++ b/libgimp/gimpselectiontools_pdb.c @@ -57,29 +57,29 @@ */ gboolean gimp_by_color_select (gint32 drawable_ID, - const GimpRGB *color, - gint threshold, - GimpChannelOps operation, - gboolean antialias, - gboolean feather, - gdouble feather_radius, - gboolean sample_merged) + const GimpRGB *color, + gint threshold, + GimpChannelOps operation, + gboolean antialias, + gboolean feather, + gdouble feather_radius, + gboolean sample_merged) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-by-color-select", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_COLOR, color, - GIMP_PDB_INT32, threshold, - GIMP_PDB_INT32, operation, - GIMP_PDB_INT32, antialias, - GIMP_PDB_INT32, feather, - GIMP_PDB_FLOAT, feather_radius, - GIMP_PDB_INT32, sample_merged, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_COLOR, color, + GIMP_PDB_INT32, threshold, + GIMP_PDB_INT32, operation, + GIMP_PDB_INT32, antialias, + GIMP_PDB_INT32, feather, + GIMP_PDB_FLOAT, feather_radius, + GIMP_PDB_INT32, sample_merged, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -116,31 +116,31 @@ gimp_by_color_select (gint32 drawable_ID, */ gboolean gimp_ellipse_select (gint32 image_ID, - gdouble x, - gdouble y, - gdouble width, - gdouble height, - GimpChannelOps operation, - gboolean antialias, - gboolean feather, - gdouble feather_radius) + gdouble x, + gdouble y, + gdouble width, + gdouble height, + GimpChannelOps operation, + gboolean antialias, + gboolean feather, + gdouble feather_radius) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-ellipse-select", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_FLOAT, x, - GIMP_PDB_FLOAT, y, - GIMP_PDB_FLOAT, width, - GIMP_PDB_FLOAT, height, - GIMP_PDB_INT32, operation, - GIMP_PDB_INT32, antialias, - GIMP_PDB_INT32, feather, - GIMP_PDB_FLOAT, feather_radius, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_FLOAT, x, + GIMP_PDB_FLOAT, y, + GIMP_PDB_FLOAT, width, + GIMP_PDB_FLOAT, height, + GIMP_PDB_INT32, operation, + GIMP_PDB_INT32, antialias, + GIMP_PDB_INT32, feather, + GIMP_PDB_FLOAT, feather_radius, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -177,27 +177,27 @@ gimp_ellipse_select (gint32 image_ID, */ gboolean gimp_free_select (gint32 image_ID, - gint num_segs, - const gdouble *segs, - GimpChannelOps operation, - gboolean antialias, - gboolean feather, - gdouble feather_radius) + gint num_segs, + const gdouble *segs, + GimpChannelOps operation, + gboolean antialias, + gboolean feather, + gdouble feather_radius) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-free-select", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_INT32, num_segs, - GIMP_PDB_FLOATARRAY, segs, - GIMP_PDB_INT32, operation, - GIMP_PDB_INT32, antialias, - GIMP_PDB_INT32, feather, - GIMP_PDB_FLOAT, feather_radius, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_INT32, num_segs, + GIMP_PDB_FLOATARRAY, segs, + GIMP_PDB_INT32, operation, + GIMP_PDB_INT32, antialias, + GIMP_PDB_INT32, feather, + GIMP_PDB_FLOAT, feather_radius, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -244,31 +244,31 @@ gimp_free_select (gint32 image_ID, */ gboolean gimp_fuzzy_select (gint32 drawable_ID, - gdouble x, - gdouble y, - gint threshold, - GimpChannelOps operation, - gboolean antialias, - gboolean feather, - gdouble feather_radius, - gboolean sample_merged) + gdouble x, + gdouble y, + gint threshold, + GimpChannelOps operation, + gboolean antialias, + gboolean feather, + gdouble feather_radius, + gboolean sample_merged) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-fuzzy-select", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_FLOAT, x, - GIMP_PDB_FLOAT, y, - GIMP_PDB_INT32, threshold, - GIMP_PDB_INT32, operation, - GIMP_PDB_INT32, antialias, - GIMP_PDB_INT32, feather, - GIMP_PDB_FLOAT, feather_radius, - GIMP_PDB_INT32, sample_merged, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_FLOAT, x, + GIMP_PDB_FLOAT, y, + GIMP_PDB_INT32, threshold, + GIMP_PDB_INT32, operation, + GIMP_PDB_INT32, antialias, + GIMP_PDB_INT32, feather, + GIMP_PDB_FLOAT, feather_radius, + GIMP_PDB_INT32, sample_merged, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -301,29 +301,29 @@ gimp_fuzzy_select (gint32 drawable_ID, */ gboolean gimp_rect_select (gint32 image_ID, - gdouble x, - gdouble y, - gdouble width, - gdouble height, - GimpChannelOps operation, - gboolean feather, - gdouble feather_radius) + gdouble x, + gdouble y, + gdouble width, + gdouble height, + GimpChannelOps operation, + gboolean feather, + gdouble feather_radius) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-rect-select", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_FLOAT, x, - GIMP_PDB_FLOAT, y, - GIMP_PDB_FLOAT, width, - GIMP_PDB_FLOAT, height, - GIMP_PDB_INT32, operation, - GIMP_PDB_INT32, feather, - GIMP_PDB_FLOAT, feather_radius, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_FLOAT, x, + GIMP_PDB_FLOAT, y, + GIMP_PDB_FLOAT, width, + GIMP_PDB_FLOAT, height, + GIMP_PDB_INT32, operation, + GIMP_PDB_INT32, feather, + GIMP_PDB_FLOAT, feather_radius, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; diff --git a/libgimp/gimpselectiontools_pdb.h b/libgimp/gimpselectiontools_pdb.h index cfd817859c..1134b207a3 100644 --- a/libgimp/gimpselectiontools_pdb.h +++ b/libgimp/gimpselectiontools_pdb.h @@ -30,46 +30,46 @@ G_BEGIN_DECLS gboolean gimp_by_color_select (gint32 drawable_ID, - const GimpRGB *color, - gint threshold, - GimpChannelOps operation, - gboolean antialias, - gboolean feather, - gdouble feather_radius, - gboolean sample_merged); + const GimpRGB *color, + gint threshold, + GimpChannelOps operation, + gboolean antialias, + gboolean feather, + gdouble feather_radius, + gboolean sample_merged); gboolean gimp_ellipse_select (gint32 image_ID, - gdouble x, - gdouble y, - gdouble width, - gdouble height, - GimpChannelOps operation, - gboolean antialias, - gboolean feather, - gdouble feather_radius); + gdouble x, + gdouble y, + gdouble width, + gdouble height, + GimpChannelOps operation, + gboolean antialias, + gboolean feather, + gdouble feather_radius); gboolean gimp_free_select (gint32 image_ID, - gint num_segs, - const gdouble *segs, - GimpChannelOps operation, - gboolean antialias, - gboolean feather, - gdouble feather_radius); + gint num_segs, + const gdouble *segs, + GimpChannelOps operation, + gboolean antialias, + gboolean feather, + gdouble feather_radius); gboolean gimp_fuzzy_select (gint32 drawable_ID, - gdouble x, - gdouble y, - gint threshold, - GimpChannelOps operation, - gboolean antialias, - gboolean feather, - gdouble feather_radius, - gboolean sample_merged); + gdouble x, + gdouble y, + gint threshold, + GimpChannelOps operation, + gboolean antialias, + gboolean feather, + gdouble feather_radius, + gboolean sample_merged); gboolean gimp_rect_select (gint32 image_ID, - gdouble x, - gdouble y, - gdouble width, - gdouble height, - GimpChannelOps operation, - gboolean feather, - gdouble feather_radius); + gdouble x, + gdouble y, + gdouble width, + gdouble height, + GimpChannelOps operation, + gboolean feather, + gdouble feather_radius); G_END_DECLS diff --git a/libgimp/gimptexttool_pdb.c b/libgimp/gimptexttool_pdb.c index f4f6519780..e262395eb9 100644 --- a/libgimp/gimptexttool_pdb.c +++ b/libgimp/gimptexttool_pdb.c @@ -56,33 +56,33 @@ */ gint32 gimp_text_fontname (gint32 image_ID, - gint32 drawable_ID, - gdouble x, - gdouble y, - const gchar *text, - gint border, - gboolean antialias, - gdouble size, - GimpSizeType size_type, - const gchar *fontname) + gint32 drawable_ID, + gdouble x, + gdouble y, + const gchar *text, + gint border, + gboolean antialias, + gdouble size, + GimpSizeType size_type, + const gchar *fontname) { GimpParam *return_vals; gint nreturn_vals; gint32 text_layer_ID = -1; return_vals = gimp_run_procedure ("gimp-text-fontname", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_FLOAT, x, - GIMP_PDB_FLOAT, y, - GIMP_PDB_STRING, text, - GIMP_PDB_INT32, border, - GIMP_PDB_INT32, antialias, - GIMP_PDB_FLOAT, size, - GIMP_PDB_INT32, size_type, - GIMP_PDB_STRING, fontname, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_FLOAT, x, + GIMP_PDB_FLOAT, y, + GIMP_PDB_STRING, text, + GIMP_PDB_INT32, border, + GIMP_PDB_INT32, antialias, + GIMP_PDB_FLOAT, size, + GIMP_PDB_INT32, size_type, + GIMP_PDB_STRING, fontname, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) text_layer_ID = return_vals[1].data.d_layer; @@ -113,25 +113,25 @@ gimp_text_fontname (gint32 image_ID, */ gboolean gimp_text_get_extents_fontname (const gchar *text, - gdouble size, - GimpSizeType size_type, - const gchar *fontname, - gint *width, - gint *height, - gint *ascent, - gint *descent) + gdouble size, + GimpSizeType size_type, + const gchar *fontname, + gint *width, + gint *height, + gint *ascent, + gint *descent) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-text-get-extents-fontname", - &nreturn_vals, - GIMP_PDB_STRING, text, - GIMP_PDB_FLOAT, size, - GIMP_PDB_INT32, size_type, - GIMP_PDB_STRING, fontname, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, text, + GIMP_PDB_FLOAT, size, + GIMP_PDB_INT32, size_type, + GIMP_PDB_STRING, fontname, + GIMP_PDB_END); *width = 0; *height = 0; @@ -179,47 +179,47 @@ gimp_text_get_extents_fontname (const gchar *text, */ gint32 gimp_text (gint32 image_ID, - gint32 drawable_ID, - gdouble x, - gdouble y, - const gchar *text, - gint border, - gboolean antialias, - gdouble size, - GimpSizeType size_type, - const gchar *foundry, - const gchar *family, - const gchar *weight, - const gchar *slant, - const gchar *set_width, - const gchar *spacing, - const gchar *registry, - const gchar *encoding) + gint32 drawable_ID, + gdouble x, + gdouble y, + const gchar *text, + gint border, + gboolean antialias, + gdouble size, + GimpSizeType size_type, + const gchar *foundry, + const gchar *family, + const gchar *weight, + const gchar *slant, + const gchar *set_width, + const gchar *spacing, + const gchar *registry, + const gchar *encoding) { GimpParam *return_vals; gint nreturn_vals; gint32 text_layer_ID = -1; return_vals = gimp_run_procedure ("gimp-text", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_FLOAT, x, - GIMP_PDB_FLOAT, y, - GIMP_PDB_STRING, text, - GIMP_PDB_INT32, border, - GIMP_PDB_INT32, antialias, - GIMP_PDB_FLOAT, size, - GIMP_PDB_INT32, size_type, - GIMP_PDB_STRING, foundry, - GIMP_PDB_STRING, family, - GIMP_PDB_STRING, weight, - GIMP_PDB_STRING, slant, - GIMP_PDB_STRING, set_width, - GIMP_PDB_STRING, spacing, - GIMP_PDB_STRING, registry, - GIMP_PDB_STRING, encoding, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_FLOAT, x, + GIMP_PDB_FLOAT, y, + GIMP_PDB_STRING, text, + GIMP_PDB_INT32, border, + GIMP_PDB_INT32, antialias, + GIMP_PDB_FLOAT, size, + GIMP_PDB_INT32, size_type, + GIMP_PDB_STRING, foundry, + GIMP_PDB_STRING, family, + GIMP_PDB_STRING, weight, + GIMP_PDB_STRING, slant, + GIMP_PDB_STRING, set_width, + GIMP_PDB_STRING, spacing, + GIMP_PDB_STRING, registry, + GIMP_PDB_STRING, encoding, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) text_layer_ID = return_vals[1].data.d_layer; @@ -254,39 +254,39 @@ gimp_text (gint32 image_ID, */ gboolean gimp_text_get_extents (const gchar *text, - gdouble size, - GimpSizeType size_type, - const gchar *foundry, - const gchar *family, - const gchar *weight, - const gchar *slant, - const gchar *set_width, - const gchar *spacing, - const gchar *registry, - const gchar *encoding, - gint *width, - gint *height, - gint *ascent, - gint *descent) + gdouble size, + GimpSizeType size_type, + const gchar *foundry, + const gchar *family, + const gchar *weight, + const gchar *slant, + const gchar *set_width, + const gchar *spacing, + const gchar *registry, + const gchar *encoding, + gint *width, + gint *height, + gint *ascent, + gint *descent) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-text-get-extents", - &nreturn_vals, - GIMP_PDB_STRING, text, - GIMP_PDB_FLOAT, size, - GIMP_PDB_INT32, size_type, - GIMP_PDB_STRING, foundry, - GIMP_PDB_STRING, family, - GIMP_PDB_STRING, weight, - GIMP_PDB_STRING, slant, - GIMP_PDB_STRING, set_width, - GIMP_PDB_STRING, spacing, - GIMP_PDB_STRING, registry, - GIMP_PDB_STRING, encoding, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, text, + GIMP_PDB_FLOAT, size, + GIMP_PDB_INT32, size_type, + GIMP_PDB_STRING, foundry, + GIMP_PDB_STRING, family, + GIMP_PDB_STRING, weight, + GIMP_PDB_STRING, slant, + GIMP_PDB_STRING, set_width, + GIMP_PDB_STRING, spacing, + GIMP_PDB_STRING, registry, + GIMP_PDB_STRING, encoding, + GIMP_PDB_END); *width = 0; *height = 0; diff --git a/libgimp/gimptexttool_pdb.h b/libgimp/gimptexttool_pdb.h index ccf10d1e59..d4d8c1b1ea 100644 --- a/libgimp/gimptexttool_pdb.h +++ b/libgimp/gimptexttool_pdb.h @@ -30,56 +30,56 @@ G_BEGIN_DECLS gint32 gimp_text_fontname (gint32 image_ID, - gint32 drawable_ID, - gdouble x, - gdouble y, - const gchar *text, - gint border, - gboolean antialias, - gdouble size, - GimpSizeType size_type, - const gchar *fontname); + gint32 drawable_ID, + gdouble x, + gdouble y, + const gchar *text, + gint border, + gboolean antialias, + gdouble size, + GimpSizeType size_type, + const gchar *fontname); gboolean gimp_text_get_extents_fontname (const gchar *text, - gdouble size, - GimpSizeType size_type, - const gchar *fontname, - gint *width, - gint *height, - gint *ascent, - gint *descent); + gdouble size, + GimpSizeType size_type, + const gchar *fontname, + gint *width, + gint *height, + gint *ascent, + gint *descent); #ifndef GIMP_DISABLE_DEPRECATED gint32 gimp_text (gint32 image_ID, - gint32 drawable_ID, - gdouble x, - gdouble y, - const gchar *text, - gint border, - gboolean antialias, - gdouble size, - GimpSizeType size_type, - const gchar *foundry, - const gchar *family, - const gchar *weight, - const gchar *slant, - const gchar *set_width, - const gchar *spacing, - const gchar *registry, - const gchar *encoding); + gint32 drawable_ID, + gdouble x, + gdouble y, + const gchar *text, + gint border, + gboolean antialias, + gdouble size, + GimpSizeType size_type, + const gchar *foundry, + const gchar *family, + const gchar *weight, + const gchar *slant, + const gchar *set_width, + const gchar *spacing, + const gchar *registry, + const gchar *encoding); gboolean gimp_text_get_extents (const gchar *text, - gdouble size, - GimpSizeType size_type, - const gchar *foundry, - const gchar *family, - const gchar *weight, - const gchar *slant, - const gchar *set_width, - const gchar *spacing, - const gchar *registry, - const gchar *encoding, - gint *width, - gint *height, - gint *ascent, - gint *descent); + gdouble size, + GimpSizeType size_type, + const gchar *foundry, + const gchar *family, + const gchar *weight, + const gchar *slant, + const gchar *set_width, + const gchar *spacing, + const gchar *registry, + const gchar *encoding, + gint *width, + gint *height, + gint *ascent, + gint *descent); #endif /* GIMP_DISABLE_DEPRECATED */ diff --git a/libgimp/gimptransformtools_pdb.c b/libgimp/gimptransformtools_pdb.c index b490600227..b0bed1820f 100644 --- a/libgimp/gimptransformtools_pdb.c +++ b/libgimp/gimptransformtools_pdb.c @@ -37,17 +37,17 @@ */ gint32 gimp_flip (gint32 drawable_ID, - GimpOrientationType flip_type) + GimpOrientationType flip_type) { GimpParam *return_vals; gint nreturn_vals; gint32 ret_drawable_ID = -1; return_vals = gimp_run_procedure ("gimp-flip", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, flip_type, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, flip_type, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) ret_drawable_ID = return_vals[1].data.d_drawable; @@ -77,33 +77,33 @@ gimp_flip (gint32 drawable_ID, */ gint32 gimp_perspective (gint32 drawable_ID, - gboolean interpolation, - gdouble x0, - gdouble y0, - gdouble x1, - gdouble y1, - gdouble x2, - gdouble y2, - gdouble x3, - gdouble y3) + gboolean interpolation, + gdouble x0, + gdouble y0, + gdouble x1, + gdouble y1, + gdouble x2, + gdouble y2, + gdouble x3, + gdouble y3) { GimpParam *return_vals; gint nreturn_vals; gint32 ret_drawable_ID = -1; return_vals = gimp_run_procedure ("gimp-perspective", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, interpolation, - GIMP_PDB_FLOAT, x0, - GIMP_PDB_FLOAT, y0, - GIMP_PDB_FLOAT, x1, - GIMP_PDB_FLOAT, y1, - GIMP_PDB_FLOAT, x2, - GIMP_PDB_FLOAT, y2, - GIMP_PDB_FLOAT, x3, - GIMP_PDB_FLOAT, y3, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, interpolation, + GIMP_PDB_FLOAT, x0, + GIMP_PDB_FLOAT, y0, + GIMP_PDB_FLOAT, x1, + GIMP_PDB_FLOAT, y1, + GIMP_PDB_FLOAT, x2, + GIMP_PDB_FLOAT, y2, + GIMP_PDB_FLOAT, x3, + GIMP_PDB_FLOAT, y3, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) ret_drawable_ID = return_vals[1].data.d_drawable; @@ -126,19 +126,19 @@ gimp_perspective (gint32 drawable_ID, */ gint32 gimp_rotate (gint32 drawable_ID, - gboolean interpolation, - gdouble angle) + gboolean interpolation, + gdouble angle) { GimpParam *return_vals; gint nreturn_vals; gint32 ret_drawable_ID = -1; return_vals = gimp_run_procedure ("gimp-rotate", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, interpolation, - GIMP_PDB_FLOAT, angle, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, interpolation, + GIMP_PDB_FLOAT, angle, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) ret_drawable_ID = return_vals[1].data.d_drawable; @@ -164,25 +164,25 @@ gimp_rotate (gint32 drawable_ID, */ gint32 gimp_scale (gint32 drawable_ID, - gboolean interpolation, - gdouble x0, - gdouble y0, - gdouble x1, - gdouble y1) + gboolean interpolation, + gdouble x0, + gdouble y0, + gdouble x1, + gdouble y1) { GimpParam *return_vals; gint nreturn_vals; gint32 ret_drawable_ID = -1; return_vals = gimp_run_procedure ("gimp-scale", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, interpolation, - GIMP_PDB_FLOAT, x0, - GIMP_PDB_FLOAT, y0, - GIMP_PDB_FLOAT, x1, - GIMP_PDB_FLOAT, y1, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, interpolation, + GIMP_PDB_FLOAT, x0, + GIMP_PDB_FLOAT, y0, + GIMP_PDB_FLOAT, x1, + GIMP_PDB_FLOAT, y1, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) ret_drawable_ID = return_vals[1].data.d_drawable; @@ -206,21 +206,21 @@ gimp_scale (gint32 drawable_ID, */ gint32 gimp_shear (gint32 drawable_ID, - gboolean interpolation, - GimpOrientationType shear_type, - gdouble magnitude) + gboolean interpolation, + GimpOrientationType shear_type, + gdouble magnitude) { GimpParam *return_vals; gint nreturn_vals; gint32 ret_drawable_ID = -1; return_vals = gimp_run_procedure ("gimp-shear", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, interpolation, - GIMP_PDB_INT32, shear_type, - GIMP_PDB_FLOAT, magnitude, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, interpolation, + GIMP_PDB_INT32, shear_type, + GIMP_PDB_FLOAT, magnitude, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) ret_drawable_ID = return_vals[1].data.d_drawable; @@ -249,31 +249,31 @@ gimp_shear (gint32 drawable_ID, */ gint32 gimp_transform_2d (gint32 drawable_ID, - gboolean interpolation, - gdouble source_x, - gdouble source_y, - gdouble scale_x, - gdouble scale_y, - gdouble angle, - gdouble dest_x, - gdouble dest_y) + gboolean interpolation, + gdouble source_x, + gdouble source_y, + gdouble scale_x, + gdouble scale_y, + gdouble angle, + gdouble dest_x, + gdouble dest_y) { GimpParam *return_vals; gint nreturn_vals; gint32 ret_drawable_ID = -1; return_vals = gimp_run_procedure ("gimp-transform-2d", - &nreturn_vals, - GIMP_PDB_DRAWABLE, drawable_ID, - GIMP_PDB_INT32, interpolation, - GIMP_PDB_FLOAT, source_x, - GIMP_PDB_FLOAT, source_y, - GIMP_PDB_FLOAT, scale_x, - GIMP_PDB_FLOAT, scale_y, - GIMP_PDB_FLOAT, angle, - GIMP_PDB_FLOAT, dest_x, - GIMP_PDB_FLOAT, dest_y, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_DRAWABLE, drawable_ID, + GIMP_PDB_INT32, interpolation, + GIMP_PDB_FLOAT, source_x, + GIMP_PDB_FLOAT, source_y, + GIMP_PDB_FLOAT, scale_x, + GIMP_PDB_FLOAT, scale_y, + GIMP_PDB_FLOAT, angle, + GIMP_PDB_FLOAT, dest_x, + GIMP_PDB_FLOAT, dest_y, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) ret_drawable_ID = return_vals[1].data.d_drawable; diff --git a/libgimp/gimptransformtools_pdb.h b/libgimp/gimptransformtools_pdb.h index 6182827c4a..3de7c3bc0b 100644 --- a/libgimp/gimptransformtools_pdb.h +++ b/libgimp/gimptransformtools_pdb.h @@ -31,39 +31,39 @@ G_BEGIN_DECLS #ifndef GIMP_DISABLE_DEPRECATED gint32 gimp_flip (gint32 drawable_ID, - GimpOrientationType flip_type); + GimpOrientationType flip_type); gint32 gimp_perspective (gint32 drawable_ID, - gboolean interpolation, - gdouble x0, - gdouble y0, - gdouble x1, - gdouble y1, - gdouble x2, - gdouble y2, - gdouble x3, - gdouble y3); + gboolean interpolation, + gdouble x0, + gdouble y0, + gdouble x1, + gdouble y1, + gdouble x2, + gdouble y2, + gdouble x3, + gdouble y3); gint32 gimp_rotate (gint32 drawable_ID, - gboolean interpolation, - gdouble angle); + gboolean interpolation, + gdouble angle); gint32 gimp_scale (gint32 drawable_ID, - gboolean interpolation, - gdouble x0, - gdouble y0, - gdouble x1, - gdouble y1); + gboolean interpolation, + gdouble x0, + gdouble y0, + gdouble x1, + gdouble y1); gint32 gimp_shear (gint32 drawable_ID, - gboolean interpolation, - GimpOrientationType shear_type, - gdouble magnitude); + gboolean interpolation, + GimpOrientationType shear_type, + gdouble magnitude); gint32 gimp_transform_2d (gint32 drawable_ID, - gboolean interpolation, - gdouble source_x, - gdouble source_y, - gdouble scale_x, - gdouble scale_y, - gdouble angle, - gdouble dest_x, - gdouble dest_y); + gboolean interpolation, + gdouble source_x, + gdouble source_y, + gdouble scale_x, + gdouble scale_y, + gdouble angle, + gdouble dest_x, + gdouble dest_y); #endif /* GIMP_DISABLE_DEPRECATED */ diff --git a/libgimp/gimpundo_pdb.c b/libgimp/gimpundo_pdb.c index ca0214ff41..a3bb2bfcca 100644 --- a/libgimp/gimpundo_pdb.c +++ b/libgimp/gimpundo_pdb.c @@ -46,9 +46,9 @@ gimp_image_undo_group_start (gint32 image_ID) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-undo-group-start", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -76,9 +76,9 @@ gimp_image_undo_group_end (gint32 image_ID) gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-image-undo-group-end", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -108,9 +108,9 @@ gimp_image_undo_is_enabled (gint32 image_ID) gboolean enabled = FALSE; return_vals = gimp_run_procedure ("gimp-image-undo-is-enabled", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) enabled = return_vals[1].data.d_int32; @@ -142,9 +142,9 @@ gimp_image_undo_disable (gint32 image_ID) gboolean disabled = FALSE; return_vals = gimp_run_procedure ("gimp-image-undo-disable", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) disabled = return_vals[1].data.d_int32; @@ -175,9 +175,9 @@ gimp_image_undo_enable (gint32 image_ID) gboolean enabled = FALSE; return_vals = gimp_run_procedure ("gimp-image-undo-enable", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) enabled = return_vals[1].data.d_int32; @@ -214,9 +214,9 @@ gimp_image_undo_freeze (gint32 image_ID) gboolean frozen = FALSE; return_vals = gimp_run_procedure ("gimp-image-undo-freeze", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) frozen = return_vals[1].data.d_int32; @@ -253,9 +253,9 @@ gimp_image_undo_thaw (gint32 image_ID) gboolean thawed = FALSE; return_vals = gimp_run_procedure ("gimp-image-undo-thaw", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) thawed = return_vals[1].data.d_int32; diff --git a/libgimp/gimpunit_pdb.c b/libgimp/gimpunit_pdb.c index ba60ed4204..3ace336541 100644 --- a/libgimp/gimpunit_pdb.c +++ b/libgimp/gimpunit_pdb.c @@ -42,8 +42,8 @@ _gimp_unit_get_number_of_units (void) gint num_units = GIMP_UNIT_END; return_vals = gimp_run_procedure ("gimp-unit-get-number-of-units", - &nreturn_vals, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) num_units = return_vals[1].data.d_int32; @@ -71,8 +71,8 @@ _gimp_unit_get_number_of_built_in_units (void) gint num_units = GIMP_UNIT_END; return_vals = gimp_run_procedure ("gimp-unit-get-number-of-built-in-units", - &nreturn_vals, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) num_units = return_vals[1].data.d_int32; @@ -103,27 +103,27 @@ _gimp_unit_get_number_of_built_in_units (void) */ GimpUnit _gimp_unit_new (const gchar *identifier, - gdouble factor, - gint digits, - const gchar *symbol, - const gchar *abbreviation, - const gchar *singular, - const gchar *plural) + gdouble factor, + gint digits, + const gchar *symbol, + const gchar *abbreviation, + const gchar *singular, + const gchar *plural) { GimpParam *return_vals; gint nreturn_vals; GimpUnit unit_id = GIMP_UNIT_INCH; return_vals = gimp_run_procedure ("gimp-unit-new", - &nreturn_vals, - GIMP_PDB_STRING, identifier, - GIMP_PDB_FLOAT, factor, - GIMP_PDB_INT32, digits, - GIMP_PDB_STRING, symbol, - GIMP_PDB_STRING, abbreviation, - GIMP_PDB_STRING, singular, - GIMP_PDB_STRING, plural, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_STRING, identifier, + GIMP_PDB_FLOAT, factor, + GIMP_PDB_INT32, digits, + GIMP_PDB_STRING, symbol, + GIMP_PDB_STRING, abbreviation, + GIMP_PDB_STRING, singular, + GIMP_PDB_STRING, plural, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) unit_id = return_vals[1].data.d_unit; @@ -153,9 +153,9 @@ _gimp_unit_get_deletion_flag (GimpUnit unit_id) gboolean deletion_flag = FALSE; return_vals = gimp_run_procedure ("gimp-unit-get-deletion-flag", - &nreturn_vals, - GIMP_PDB_INT32, unit_id, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_INT32, unit_id, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) deletion_flag = return_vals[1].data.d_int32; @@ -180,17 +180,17 @@ _gimp_unit_get_deletion_flag (GimpUnit unit_id) */ gboolean _gimp_unit_set_deletion_flag (GimpUnit unit_id, - gboolean deletion_flag) + gboolean deletion_flag) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-unit-set-deletion-flag", - &nreturn_vals, - GIMP_PDB_INT32, unit_id, - GIMP_PDB_INT32, deletion_flag, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_INT32, unit_id, + GIMP_PDB_INT32, deletion_flag, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -219,9 +219,9 @@ _gimp_unit_get_identifier (GimpUnit unit_id) gchar *identifier = NULL; return_vals = gimp_run_procedure ("gimp-unit-get-identifier", - &nreturn_vals, - GIMP_PDB_INT32, unit_id, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_INT32, unit_id, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) identifier = g_strdup (return_vals[1].data.d_string); @@ -251,9 +251,9 @@ _gimp_unit_get_factor (GimpUnit unit_id) gdouble factor = 0.0; return_vals = gimp_run_procedure ("gimp-unit-get-factor", - &nreturn_vals, - GIMP_PDB_INT32, unit_id, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_INT32, unit_id, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) factor = return_vals[1].data.d_float; @@ -284,9 +284,9 @@ _gimp_unit_get_digits (GimpUnit unit_id) gint digits = 0; return_vals = gimp_run_procedure ("gimp-unit-get-digits", - &nreturn_vals, - GIMP_PDB_INT32, unit_id, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_INT32, unit_id, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) digits = return_vals[1].data.d_int32; @@ -314,9 +314,9 @@ _gimp_unit_get_symbol (GimpUnit unit_id) gchar *symbol = NULL; return_vals = gimp_run_procedure ("gimp-unit-get-symbol", - &nreturn_vals, - GIMP_PDB_INT32, unit_id, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_INT32, unit_id, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) symbol = g_strdup (return_vals[1].data.d_string); @@ -345,9 +345,9 @@ _gimp_unit_get_abbreviation (GimpUnit unit_id) gchar *abbreviation = NULL; return_vals = gimp_run_procedure ("gimp-unit-get-abbreviation", - &nreturn_vals, - GIMP_PDB_INT32, unit_id, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_INT32, unit_id, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) abbreviation = g_strdup (return_vals[1].data.d_string); @@ -375,9 +375,9 @@ _gimp_unit_get_singular (GimpUnit unit_id) gchar *singular = NULL; return_vals = gimp_run_procedure ("gimp-unit-get-singular", - &nreturn_vals, - GIMP_PDB_INT32, unit_id, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_INT32, unit_id, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) singular = g_strdup (return_vals[1].data.d_string); @@ -405,9 +405,9 @@ _gimp_unit_get_plural (GimpUnit unit_id) gchar *plural = NULL; return_vals = gimp_run_procedure ("gimp-unit-get-plural", - &nreturn_vals, - GIMP_PDB_INT32, unit_id, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_INT32, unit_id, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) plural = g_strdup (return_vals[1].data.d_string); diff --git a/libgimp/gimpunit_pdb.h b/libgimp/gimpunit_pdb.h index 2241fe2e4b..083103cd3b 100644 --- a/libgimp/gimpunit_pdb.h +++ b/libgimp/gimpunit_pdb.h @@ -32,15 +32,15 @@ G_BEGIN_DECLS gint _gimp_unit_get_number_of_units (void) G_GNUC_INTERNAL; gint _gimp_unit_get_number_of_built_in_units (void) G_GNUC_INTERNAL; GimpUnit _gimp_unit_new (const gchar *identifier, - gdouble factor, - gint digits, - const gchar *symbol, - const gchar *abbreviation, - const gchar *singular, - const gchar *plural) G_GNUC_INTERNAL; + gdouble factor, + gint digits, + const gchar *symbol, + const gchar *abbreviation, + const gchar *singular, + const gchar *plural) G_GNUC_INTERNAL; gboolean _gimp_unit_get_deletion_flag (GimpUnit unit_id) G_GNUC_INTERNAL; gboolean _gimp_unit_set_deletion_flag (GimpUnit unit_id, - gboolean deletion_flag) G_GNUC_INTERNAL; + gboolean deletion_flag) G_GNUC_INTERNAL; gchar* _gimp_unit_get_identifier (GimpUnit unit_id) G_GNUC_INTERNAL; gdouble _gimp_unit_get_factor (GimpUnit unit_id) G_GNUC_INTERNAL; gint _gimp_unit_get_digits (GimpUnit unit_id) G_GNUC_INTERNAL; diff --git a/libgimp/gimpvectors_pdb.c b/libgimp/gimpvectors_pdb.c index 7e1e3a5710..f48b703c4d 100644 --- a/libgimp/gimpvectors_pdb.c +++ b/libgimp/gimpvectors_pdb.c @@ -43,17 +43,17 @@ */ gint32 gimp_vectors_new (gint32 image_ID, - const gchar *name) + const gchar *name) { GimpParam *return_vals; gint nreturn_vals; gint32 vectors_ID = -1; return_vals = gimp_run_procedure ("gimp-vectors-new", - &nreturn_vals, - GIMP_PDB_IMAGE, image_ID, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_IMAGE, image_ID, + GIMP_PDB_STRING, name, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) vectors_ID = return_vals[1].data.d_vectors; @@ -83,9 +83,9 @@ gimp_vectors_get_image (gint32 vectors_ID) gint32 image_ID = -1; return_vals = gimp_run_procedure ("gimp-vectors-get-image", - &nreturn_vals, - GIMP_PDB_VECTORS, vectors_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_VECTORS, vectors_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) image_ID = return_vals[1].data.d_image; @@ -115,9 +115,9 @@ gimp_vectors_get_name (gint32 vectors_ID) gchar *name = NULL; return_vals = gimp_run_procedure ("gimp-vectors-get-name", - &nreturn_vals, - GIMP_PDB_VECTORS, vectors_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_VECTORS, vectors_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) name = g_strdup (return_vals[1].data.d_string); @@ -142,17 +142,17 @@ gimp_vectors_get_name (gint32 vectors_ID) */ gboolean gimp_vectors_set_name (gint32 vectors_ID, - const gchar *name) + const gchar *name) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-vectors-set-name", - &nreturn_vals, - GIMP_PDB_VECTORS, vectors_ID, - GIMP_PDB_STRING, name, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_VECTORS, vectors_ID, + GIMP_PDB_STRING, name, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -181,9 +181,9 @@ gimp_vectors_get_visible (gint32 vectors_ID) gboolean visible = FALSE; return_vals = gimp_run_procedure ("gimp-vectors-get-visible", - &nreturn_vals, - GIMP_PDB_VECTORS, vectors_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_VECTORS, vectors_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) visible = return_vals[1].data.d_int32; @@ -208,17 +208,17 @@ gimp_vectors_get_visible (gint32 vectors_ID) */ gboolean gimp_vectors_set_visible (gint32 vectors_ID, - gboolean visible) + gboolean visible) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-vectors-set-visible", - &nreturn_vals, - GIMP_PDB_VECTORS, vectors_ID, - GIMP_PDB_INT32, visible, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_VECTORS, vectors_ID, + GIMP_PDB_INT32, visible, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -247,9 +247,9 @@ gimp_vectors_get_linked (gint32 vectors_ID) gboolean linked = FALSE; return_vals = gimp_run_procedure ("gimp-vectors-get-linked", - &nreturn_vals, - GIMP_PDB_VECTORS, vectors_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_VECTORS, vectors_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) linked = return_vals[1].data.d_int32; @@ -274,17 +274,17 @@ gimp_vectors_get_linked (gint32 vectors_ID) */ gboolean gimp_vectors_set_linked (gint32 vectors_ID, - gboolean linked) + gboolean linked) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-vectors-set-linked", - &nreturn_vals, - GIMP_PDB_VECTORS, vectors_ID, - GIMP_PDB_INT32, linked, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_VECTORS, vectors_ID, + GIMP_PDB_INT32, linked, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -313,9 +313,9 @@ gimp_vectors_get_tattoo (gint32 vectors_ID) gint tattoo = 0; return_vals = gimp_run_procedure ("gimp-vectors-get-tattoo", - &nreturn_vals, - GIMP_PDB_VECTORS, vectors_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_VECTORS, vectors_ID, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) tattoo = return_vals[1].data.d_int32; @@ -340,17 +340,17 @@ gimp_vectors_get_tattoo (gint32 vectors_ID) */ gboolean gimp_vectors_set_tattoo (gint32 vectors_ID, - gint tattoo) + gint tattoo) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-vectors-set-tattoo", - &nreturn_vals, - GIMP_PDB_VECTORS, vectors_ID, - GIMP_PDB_INT32, tattoo, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_VECTORS, vectors_ID, + GIMP_PDB_INT32, tattoo, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -375,16 +375,16 @@ gimp_vectors_set_tattoo (gint32 vectors_ID, */ gint * gimp_vectors_get_strokes (gint32 vectors_ID, - gint *num_strokes) + gint *num_strokes) { GimpParam *return_vals; gint nreturn_vals; gint *stroke_ids = NULL; return_vals = gimp_run_procedure ("gimp-vectors-get-strokes", - &nreturn_vals, - GIMP_PDB_VECTORS, vectors_ID, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_VECTORS, vectors_ID, + GIMP_PDB_END); *num_strokes = 0; @@ -417,19 +417,19 @@ gimp_vectors_get_strokes (gint32 vectors_ID, */ gdouble gimp_vectors_stroke_get_length (gint32 vectors_ID, - gint stroke_id, - gdouble prescision) + gint stroke_id, + gdouble prescision) { GimpParam *return_vals; gint nreturn_vals; gdouble length = 0.0; return_vals = gimp_run_procedure ("gimp-vectors-stroke-get-length", - &nreturn_vals, - GIMP_PDB_VECTORS, vectors_ID, - GIMP_PDB_INT32, stroke_id, - GIMP_PDB_FLOAT, prescision, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_VECTORS, vectors_ID, + GIMP_PDB_INT32, stroke_id, + GIMP_PDB_FLOAT, prescision, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) length = return_vals[1].data.d_float; @@ -464,24 +464,24 @@ gimp_vectors_stroke_get_length (gint32 vectors_ID, */ gdouble gimp_vectors_stroke_get_point_at_dist (gint32 vectors_ID, - gint stroke_id, - gdouble dist, - gdouble prescision, - gdouble *y_point, - gdouble *slope, - gboolean *valid) + gint stroke_id, + gdouble dist, + gdouble prescision, + gdouble *y_point, + gdouble *slope, + gboolean *valid) { GimpParam *return_vals; gint nreturn_vals; gdouble x_point = 0.0; return_vals = gimp_run_procedure ("gimp-vectors-stroke-get-point-at-dist", - &nreturn_vals, - GIMP_PDB_VECTORS, vectors_ID, - GIMP_PDB_INT32, stroke_id, - GIMP_PDB_FLOAT, dist, - GIMP_PDB_FLOAT, prescision, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_VECTORS, vectors_ID, + GIMP_PDB_INT32, stroke_id, + GIMP_PDB_FLOAT, dist, + GIMP_PDB_FLOAT, prescision, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) { @@ -511,17 +511,17 @@ gimp_vectors_stroke_get_point_at_dist (gint32 vectors_ID, */ gboolean gimp_vectors_stroke_remove (gint32 vectors_ID, - gint stroke_id) + gint stroke_id) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-vectors-stroke-remove", - &nreturn_vals, - GIMP_PDB_VECTORS, vectors_ID, - GIMP_PDB_INT32, stroke_id, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_VECTORS, vectors_ID, + GIMP_PDB_INT32, stroke_id, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -545,17 +545,17 @@ gimp_vectors_stroke_remove (gint32 vectors_ID, */ gboolean gimp_vectors_stroke_close (gint32 vectors_ID, - gint stroke_id) + gint stroke_id) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-vectors-stroke-close", - &nreturn_vals, - GIMP_PDB_VECTORS, vectors_ID, - GIMP_PDB_INT32, stroke_id, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_VECTORS, vectors_ID, + GIMP_PDB_INT32, stroke_id, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -581,21 +581,21 @@ gimp_vectors_stroke_close (gint32 vectors_ID, */ gboolean gimp_vectors_stroke_translate (gint32 vectors_ID, - gint stroke_id, - gint off_x, - gint off_y) + gint stroke_id, + gint off_x, + gint off_y) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-vectors-stroke-translate", - &nreturn_vals, - GIMP_PDB_VECTORS, vectors_ID, - GIMP_PDB_INT32, stroke_id, - GIMP_PDB_INT32, off_x, - GIMP_PDB_INT32, off_y, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_VECTORS, vectors_ID, + GIMP_PDB_INT32, stroke_id, + GIMP_PDB_INT32, off_x, + GIMP_PDB_INT32, off_y, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -621,21 +621,21 @@ gimp_vectors_stroke_translate (gint32 vectors_ID, */ gboolean gimp_vectors_stroke_scale (gint32 vectors_ID, - gint stroke_id, - gdouble scale_x, - gdouble scale_y) + gint stroke_id, + gdouble scale_x, + gdouble scale_y) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-vectors-stroke-scale", - &nreturn_vals, - GIMP_PDB_VECTORS, vectors_ID, - GIMP_PDB_INT32, stroke_id, - GIMP_PDB_FLOAT, scale_x, - GIMP_PDB_FLOAT, scale_y, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_VECTORS, vectors_ID, + GIMP_PDB_INT32, stroke_id, + GIMP_PDB_FLOAT, scale_x, + GIMP_PDB_FLOAT, scale_y, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -662,21 +662,21 @@ gimp_vectors_stroke_scale (gint32 vectors_ID, */ gboolean gimp_vectors_stroke_interpolate (gint32 vectors_ID, - gint stroke_id, - gdouble prescision, - gint *num_coords, - gdouble **coords) + gint stroke_id, + gdouble prescision, + gint *num_coords, + gdouble **coords) { GimpParam *return_vals; gint nreturn_vals; gboolean closed = FALSE; return_vals = gimp_run_procedure ("gimp-vectors-stroke-interpolate", - &nreturn_vals, - GIMP_PDB_VECTORS, vectors_ID, - GIMP_PDB_INT32, stroke_id, - GIMP_PDB_FLOAT, prescision, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_VECTORS, vectors_ID, + GIMP_PDB_INT32, stroke_id, + GIMP_PDB_FLOAT, prescision, + GIMP_PDB_END); *num_coords = 0; @@ -710,19 +710,19 @@ gimp_vectors_stroke_interpolate (gint32 vectors_ID, */ gint gimp_vectors_bezier_stroke_new_moveto (gint32 vectors_ID, - gdouble x0, - gdouble y0) + gdouble x0, + gdouble y0) { GimpParam *return_vals; gint nreturn_vals; gint stroke_id = 0; return_vals = gimp_run_procedure ("gimp-vectors-bezier-stroke-new-moveto", - &nreturn_vals, - GIMP_PDB_VECTORS, vectors_ID, - GIMP_PDB_FLOAT, x0, - GIMP_PDB_FLOAT, y0, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_VECTORS, vectors_ID, + GIMP_PDB_FLOAT, x0, + GIMP_PDB_FLOAT, y0, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) stroke_id = return_vals[1].data.d_int32; @@ -749,21 +749,21 @@ gimp_vectors_bezier_stroke_new_moveto (gint32 vectors_ID, */ gboolean gimp_vectors_bezier_stroke_lineto (gint32 vectors_ID, - gint stroke_id, - gdouble x0, - gdouble y0) + gint stroke_id, + gdouble x0, + gdouble y0) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-vectors-bezier-stroke-lineto", - &nreturn_vals, - GIMP_PDB_VECTORS, vectors_ID, - GIMP_PDB_INT32, stroke_id, - GIMP_PDB_FLOAT, x0, - GIMP_PDB_FLOAT, y0, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_VECTORS, vectors_ID, + GIMP_PDB_INT32, stroke_id, + GIMP_PDB_FLOAT, x0, + GIMP_PDB_FLOAT, y0, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -793,25 +793,25 @@ gimp_vectors_bezier_stroke_lineto (gint32 vectors_ID, */ gboolean gimp_vectors_bezier_stroke_conicto (gint32 vectors_ID, - gint stroke_id, - gdouble x0, - gdouble y0, - gdouble x1, - gdouble y1) + gint stroke_id, + gdouble x0, + gdouble y0, + gdouble x1, + gdouble y1) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-vectors-bezier-stroke-conicto", - &nreturn_vals, - GIMP_PDB_VECTORS, vectors_ID, - GIMP_PDB_INT32, stroke_id, - GIMP_PDB_FLOAT, x0, - GIMP_PDB_FLOAT, y0, - GIMP_PDB_FLOAT, x1, - GIMP_PDB_FLOAT, y1, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_VECTORS, vectors_ID, + GIMP_PDB_INT32, stroke_id, + GIMP_PDB_FLOAT, x0, + GIMP_PDB_FLOAT, y0, + GIMP_PDB_FLOAT, x1, + GIMP_PDB_FLOAT, y1, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -841,29 +841,29 @@ gimp_vectors_bezier_stroke_conicto (gint32 vectors_ID, */ gboolean gimp_vectors_bezier_stroke_cubicto (gint32 vectors_ID, - gint stroke_id, - gdouble x0, - gdouble y0, - gdouble x1, - gdouble y1, - gdouble x2, - gdouble y2) + gint stroke_id, + gdouble x0, + gdouble y0, + gdouble x1, + gdouble y1, + gdouble x2, + gdouble y2) { GimpParam *return_vals; gint nreturn_vals; gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp-vectors-bezier-stroke-cubicto", - &nreturn_vals, - GIMP_PDB_VECTORS, vectors_ID, - GIMP_PDB_INT32, stroke_id, - GIMP_PDB_FLOAT, x0, - GIMP_PDB_FLOAT, y0, - GIMP_PDB_FLOAT, x1, - GIMP_PDB_FLOAT, y1, - GIMP_PDB_FLOAT, x2, - GIMP_PDB_FLOAT, y2, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_VECTORS, vectors_ID, + GIMP_PDB_INT32, stroke_id, + GIMP_PDB_FLOAT, x0, + GIMP_PDB_FLOAT, y0, + GIMP_PDB_FLOAT, x1, + GIMP_PDB_FLOAT, y1, + GIMP_PDB_FLOAT, x2, + GIMP_PDB_FLOAT, y2, + GIMP_PDB_END); success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; @@ -891,25 +891,25 @@ gimp_vectors_bezier_stroke_cubicto (gint32 vectors_ID, */ gint gimp_vectors_bezier_stroke_new_ellipse (gint32 vectors_ID, - gdouble x0, - gdouble y0, - gdouble radius_x, - gdouble radius_y, - gdouble angle) + gdouble x0, + gdouble y0, + gdouble radius_x, + gdouble radius_y, + gdouble angle) { GimpParam *return_vals; gint nreturn_vals; gint stroke_id = 0; return_vals = gimp_run_procedure ("gimp-vectors-bezier-stroke-new-ellipse", - &nreturn_vals, - GIMP_PDB_VECTORS, vectors_ID, - GIMP_PDB_FLOAT, x0, - GIMP_PDB_FLOAT, y0, - GIMP_PDB_FLOAT, radius_x, - GIMP_PDB_FLOAT, radius_y, - GIMP_PDB_FLOAT, angle, - GIMP_PDB_END); + &nreturn_vals, + GIMP_PDB_VECTORS, vectors_ID, + GIMP_PDB_FLOAT, x0, + GIMP_PDB_FLOAT, y0, + GIMP_PDB_FLOAT, radius_x, + GIMP_PDB_FLOAT, radius_y, + GIMP_PDB_FLOAT, angle, + GIMP_PDB_END); if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) stroke_id = return_vals[1].data.d_int32; diff --git a/libgimp/gimpvectors_pdb.h b/libgimp/gimpvectors_pdb.h index 6c1be98241..b91d54b9e6 100644 --- a/libgimp/gimpvectors_pdb.h +++ b/libgimp/gimpvectors_pdb.h @@ -30,76 +30,76 @@ G_BEGIN_DECLS gint32 gimp_vectors_new (gint32 image_ID, - const gchar *name); + const gchar *name); gint32 gimp_vectors_get_image (gint32 vectors_ID); gchar* gimp_vectors_get_name (gint32 vectors_ID); gboolean gimp_vectors_set_name (gint32 vectors_ID, - const gchar *name); + const gchar *name); gboolean gimp_vectors_get_visible (gint32 vectors_ID); gboolean gimp_vectors_set_visible (gint32 vectors_ID, - gboolean visible); + gboolean visible); gboolean gimp_vectors_get_linked (gint32 vectors_ID); gboolean gimp_vectors_set_linked (gint32 vectors_ID, - gboolean linked); + gboolean linked); gint gimp_vectors_get_tattoo (gint32 vectors_ID); gboolean gimp_vectors_set_tattoo (gint32 vectors_ID, - gint tattoo); + gint tattoo); gint* gimp_vectors_get_strokes (gint32 vectors_ID, - gint *num_strokes); + gint *num_strokes); gdouble gimp_vectors_stroke_get_length (gint32 vectors_ID, - gint stroke_id, - gdouble prescision); + gint stroke_id, + gdouble prescision); gdouble gimp_vectors_stroke_get_point_at_dist (gint32 vectors_ID, - gint stroke_id, - gdouble dist, - gdouble prescision, - gdouble *y_point, - gdouble *slope, - gboolean *valid); + gint stroke_id, + gdouble dist, + gdouble prescision, + gdouble *y_point, + gdouble *slope, + gboolean *valid); gboolean gimp_vectors_stroke_remove (gint32 vectors_ID, - gint stroke_id); + gint stroke_id); gboolean gimp_vectors_stroke_close (gint32 vectors_ID, - gint stroke_id); + gint stroke_id); gboolean gimp_vectors_stroke_translate (gint32 vectors_ID, - gint stroke_id, - gint off_x, - gint off_y); + gint stroke_id, + gint off_x, + gint off_y); gboolean gimp_vectors_stroke_scale (gint32 vectors_ID, - gint stroke_id, - gdouble scale_x, - gdouble scale_y); + gint stroke_id, + gdouble scale_x, + gdouble scale_y); gboolean gimp_vectors_stroke_interpolate (gint32 vectors_ID, - gint stroke_id, - gdouble prescision, - gint *num_coords, - gdouble **coords); + gint stroke_id, + gdouble prescision, + gint *num_coords, + gdouble **coords); gint gimp_vectors_bezier_stroke_new_moveto (gint32 vectors_ID, - gdouble x0, - gdouble y0); + gdouble x0, + gdouble y0); gboolean gimp_vectors_bezier_stroke_lineto (gint32 vectors_ID, - gint stroke_id, - gdouble x0, - gdouble y0); + gint stroke_id, + gdouble x0, + gdouble y0); gboolean gimp_vectors_bezier_stroke_conicto (gint32 vectors_ID, - gint stroke_id, - gdouble x0, - gdouble y0, - gdouble x1, - gdouble y1); + gint stroke_id, + gdouble x0, + gdouble y0, + gdouble x1, + gdouble y1); gboolean gimp_vectors_bezier_stroke_cubicto (gint32 vectors_ID, - gint stroke_id, - gdouble x0, - gdouble y0, - gdouble x1, - gdouble y1, - gdouble x2, - gdouble y2); + gint stroke_id, + gdouble x0, + gdouble y0, + gdouble x1, + gdouble y1, + gdouble x2, + gdouble y2); gint gimp_vectors_bezier_stroke_new_ellipse (gint32 vectors_ID, - gdouble x0, - gdouble y0, - gdouble radius_x, - gdouble radius_y, - gdouble angle); + gdouble x0, + gdouble y0, + gdouble radius_x, + gdouble radius_y, + gdouble angle); G_END_DECLS diff --git a/tools/pdbgen/lib.pl b/tools/pdbgen/lib.pl index 8c0dd6660b..1fb3cca720 100644 --- a/tools/pdbgen/lib.pl +++ b/tools/pdbgen/lib.pl @@ -157,7 +157,7 @@ sub generate { $argdesc .= ": $desc"; # This is what's passed into gimp_run_procedure - $argpass .= "\n\t\t\t\t" . ' ' x 4; + $argpass .= "\n" . ' ' x 36; $argpass .= "GIMP_PDB_$arg->{name}, "; $argpass .= "$_->{name}"; @@ -433,8 +433,7 @@ CODE my $clist = $arglist; my $padlen = length($wrapped) + length($funcname) + 2; - my $padtab = $padlen / 8; my $padspace = $padlen % 8; - my $padding = "\t" x $padtab . ' ' x $padspace; + my $padding = ' ' x $padlen; $clist =~ s/\t/$padding/eg; unless ($retdesc =~ /[\.\!\?]$/) { $retdesc .= '.' } @@ -476,8 +475,8 @@ $wrapped$funcname ($clist) gint nreturn_vals;$return_args return_vals = gimp_run_procedure ("gimp-$proc->{canonical_name}", - \&nreturn_vals,$argpass - GIMP_PDB_END); + \&nreturn_vals,$argpass + GIMP_PDB_END); $return_marshal } @@ -612,8 +611,6 @@ LGPL $arg .= ' ' x ($longest[0] - length($type) + 1) . $func; $arg .= ' ' x ($longest[1] - length($func) + 1) . $arglist; $arg =~ s/\t/' ' x ($longest[0] + $longest[1] + 3)/eg; - - while ($arg =~ /^\t* {8}/m) { $arg =~ s/^(\t*) {8}/$1\t/mg } } else { $arg = $_;