diff --git a/ChangeLog b/ChangeLog index f8782c5254..4bf9cad7d9 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,15 @@ +Tue Aug 22 18:42:04 PDT 2000 Manish Singh + + * configure.in: $srcdir != $builddir fix for GIMP_CONTRIBUTORS + + * plug-ins/common/plugin-defs.pl: More tidying up after Daniel Egger + + * tools/pdbgen/Makefile.am: parse pdb defs only once for app and lib + + * tools/pdbgen/lib.pl + * tools/pdbgen/pdb/procedural_db.pdb: all void rets now return a + boolean for success/failure + 2000-08-23 Nick Lamb * plug-ins/Makefile.am: diff --git a/configure.in b/configure.in index f5e43cb441..18cfbcda7c 100644 --- a/configure.in +++ b/configure.in @@ -677,7 +677,7 @@ rm -f confauthorsgen IFS="${IFS= }"; gimp_save_IFS="$IFS"; IFS=' ' -for i in `sed -e '/^#/d' -e 's/\.*\[.*\]//' -e 's/^ *//' -e 's/ *$//' -e '/^$/d' < tools/authorsgen/contributors`; do +for i in `sed -e '/^#/d' -e 's/\.*\[.*\]//' -e 's/^ *//' -e 's/ *$//' -e '/^$/d' < $srcdir/tools/authorsgen/contributors`; do echo $ac_n "$i, $ac_c" >> confauthorsgen done diff --git a/libgimp/gimpbrushselect_pdb.c b/libgimp/gimpbrushselect_pdb.c index 1d688df6a0..ba231effa3 100644 --- a/libgimp/gimpbrushselect_pdb.c +++ b/libgimp/gimpbrushselect_pdb.c @@ -23,7 +23,7 @@ #include "gimp.h" -void +gboolean gimp_brushes_popup (gchar *brush_callback, gchar *popup_title, gchar *initial_brush, @@ -33,6 +33,7 @@ gimp_brushes_popup (gchar *brush_callback, { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_brushes_popup", &nreturn_vals, @@ -44,24 +45,33 @@ gimp_brushes_popup (gchar *brush_callback, GIMP_PDB_INT32, paint_mode, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_brushes_close_popup (gchar *brush_callback) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_brushes_close_popup", &nreturn_vals, GIMP_PDB_STRING, brush_callback, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_brushes_set_popup (gchar *brush_callback, gchar *brush_name, gdouble opacity, @@ -70,6 +80,7 @@ gimp_brushes_set_popup (gchar *brush_callback, { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_brushes_set_popup", &nreturn_vals, @@ -80,5 +91,9 @@ gimp_brushes_set_popup (gchar *brush_callback, GIMP_PDB_INT32, paint_mode, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } diff --git a/libgimp/gimpbrushselect_pdb.h b/libgimp/gimpbrushselect_pdb.h index 45891eaaf0..a28b8bad6e 100644 --- a/libgimp/gimpbrushselect_pdb.h +++ b/libgimp/gimpbrushselect_pdb.h @@ -31,18 +31,18 @@ extern "C" { /* For information look into the C source or the html documentation */ -void gimp_brushes_popup (gchar *brush_callback, - gchar *popup_title, - gchar *initial_brush, - gdouble opacity, - gint spacing, - GimpLayerModeEffects paint_mode); -void gimp_brushes_close_popup (gchar *brush_callback); -void gimp_brushes_set_popup (gchar *brush_callback, - gchar *brush_name, - gdouble opacity, - gint spacing, - GimpLayerModeEffects paint_mode); +gboolean gimp_brushes_popup (gchar *brush_callback, + gchar *popup_title, + gchar *initial_brush, + gdouble opacity, + gint spacing, + GimpLayerModeEffects paint_mode); +gboolean gimp_brushes_close_popup (gchar *brush_callback); +gboolean gimp_brushes_set_popup (gchar *brush_callback, + gchar *brush_name, + gdouble opacity, + gint spacing, + GimpLayerModeEffects paint_mode); #ifdef __cplusplus diff --git a/libgimp/gimpchannel_pdb.c b/libgimp/gimpchannel_pdb.c index 6737ccef5e..b6ddbad537 100644 --- a/libgimp/gimpchannel_pdb.c +++ b/libgimp/gimpchannel_pdb.c @@ -80,18 +80,23 @@ gimp_channel_copy (gint32 channel_ID) return channel_copy_ID; } -void +gboolean gimp_channel_delete (gint32 channel_ID) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_channel_delete", &nreturn_vals, GIMP_PDB_CHANNEL, channel_ID, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } gchar * @@ -114,12 +119,13 @@ gimp_channel_get_name (gint32 channel_ID) return name; } -void +gboolean gimp_channel_set_name (gint32 channel_ID, gchar *name) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_channel_set_name", &nreturn_vals, @@ -127,7 +133,11 @@ gimp_channel_set_name (gint32 channel_ID, GIMP_PDB_STRING, name, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } gboolean @@ -150,12 +160,13 @@ gimp_channel_get_visible (gint32 channel_ID) return visible; } -void +gboolean gimp_channel_set_visible (gint32 channel_ID, gboolean visible) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_channel_set_visible", &nreturn_vals, @@ -163,7 +174,11 @@ gimp_channel_set_visible (gint32 channel_ID, GIMP_PDB_INT32, visible, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } gboolean @@ -186,12 +201,13 @@ gimp_channel_get_show_masked (gint32 channel_ID) return show_masked; } -void +gboolean gimp_channel_set_show_masked (gint32 channel_ID, gboolean show_masked) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_channel_set_show_masked", &nreturn_vals, @@ -199,7 +215,11 @@ gimp_channel_set_show_masked (gint32 channel_ID, GIMP_PDB_INT32, show_masked, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } gdouble @@ -222,12 +242,13 @@ gimp_channel_get_opacity (gint32 channel_ID) return opacity; } -void +gboolean gimp_channel_set_opacity (gint32 channel_ID, gdouble opacity) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_channel_set_opacity", &nreturn_vals, @@ -235,10 +256,14 @@ gimp_channel_set_opacity (gint32 channel_ID, GIMP_PDB_FLOAT, opacity, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_channel_get_color (gint32 channel_ID, guchar *red, guchar *green, @@ -246,13 +271,16 @@ gimp_channel_get_color (gint32 channel_ID, { 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); - if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + + if (success) { *red = return_vals[1].data.d_color.red; *green = return_vals[1].data.d_color.green; @@ -260,9 +288,11 @@ gimp_channel_get_color (gint32 channel_ID, } gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_channel_set_color (gint32 channel_ID, guchar red, guchar green, @@ -270,6 +300,7 @@ gimp_channel_set_color (gint32 channel_ID, { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; guchar color[3]; color[0] = red; @@ -282,7 +313,11 @@ gimp_channel_set_color (gint32 channel_ID, GIMP_PDB_COLOR, color, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } gint @@ -305,12 +340,13 @@ gimp_channel_get_tattoo (gint32 channel_ID) return tattoo; } -void +gboolean gimp_channel_set_tattoo (gint32 channel_ID, gint tattoo) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_channel_set_tattoo", &nreturn_vals, @@ -318,5 +354,9 @@ gimp_channel_set_tattoo (gint32 channel_ID, GIMP_PDB_INT32, tattoo, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } diff --git a/libgimp/gimpchannel_pdb.h b/libgimp/gimpchannel_pdb.h index 4771cac423..66e4c373db 100644 --- a/libgimp/gimpchannel_pdb.h +++ b/libgimp/gimpchannel_pdb.h @@ -40,29 +40,29 @@ gint32 _gimp_channel_new (gint32 image_ID, guchar green, guchar blue); gint32 gimp_channel_copy (gint32 channel_ID); -void gimp_channel_delete (gint32 channel_ID); +gboolean gimp_channel_delete (gint32 channel_ID); gchar* gimp_channel_get_name (gint32 channel_ID); -void gimp_channel_set_name (gint32 channel_ID, +gboolean gimp_channel_set_name (gint32 channel_ID, gchar *name); gboolean gimp_channel_get_visible (gint32 channel_ID); -void gimp_channel_set_visible (gint32 channel_ID, +gboolean gimp_channel_set_visible (gint32 channel_ID, gboolean visible); gboolean gimp_channel_get_show_masked (gint32 channel_ID); -void gimp_channel_set_show_masked (gint32 channel_ID, +gboolean gimp_channel_set_show_masked (gint32 channel_ID, gboolean show_masked); gdouble gimp_channel_get_opacity (gint32 channel_ID); -void gimp_channel_set_opacity (gint32 channel_ID, +gboolean gimp_channel_set_opacity (gint32 channel_ID, gdouble opacity); -void gimp_channel_get_color (gint32 channel_ID, +gboolean gimp_channel_get_color (gint32 channel_ID, guchar *red, guchar *green, guchar *blue); -void gimp_channel_set_color (gint32 channel_ID, +gboolean gimp_channel_set_color (gint32 channel_ID, guchar red, guchar green, guchar blue); gint gimp_channel_get_tattoo (gint32 channel_ID); -void gimp_channel_set_tattoo (gint32 channel_ID, +gboolean gimp_channel_set_tattoo (gint32 channel_ID, gint tattoo); diff --git a/libgimp/gimpchannelops_pdb.c b/libgimp/gimpchannelops_pdb.c index 1818277245..c03e4f5688 100644 --- a/libgimp/gimpchannelops_pdb.c +++ b/libgimp/gimpchannelops_pdb.c @@ -23,7 +23,7 @@ #include "gimp.h" -void +gboolean gimp_channel_ops_offset (gint32 drawable_ID, gboolean wrap_around, GimpChannelOffsetType fill_type, @@ -32,6 +32,7 @@ gimp_channel_ops_offset (gint32 drawable_ID, { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_channel_ops_offset", &nreturn_vals, @@ -42,7 +43,11 @@ gimp_channel_ops_offset (gint32 drawable_ID, GIMP_PDB_INT32, offset_y, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } gint32 diff --git a/libgimp/gimpchannelops_pdb.h b/libgimp/gimpchannelops_pdb.h index 4ec6b0b540..c900000ab1 100644 --- a/libgimp/gimpchannelops_pdb.h +++ b/libgimp/gimpchannelops_pdb.h @@ -31,12 +31,12 @@ extern "C" { /* For information look into the C source or the html documentation */ -void gimp_channel_ops_offset (gint32 drawable_ID, - gboolean wrap_around, - GimpChannelOffsetType fill_type, - gint offset_x, - gint offset_y); -gint32 gimp_channel_ops_duplicate (gint32 image_ID); +gboolean gimp_channel_ops_offset (gint32 drawable_ID, + gboolean wrap_around, + GimpChannelOffsetType fill_type, + gint offset_x, + gint offset_y); +gint32 gimp_channel_ops_duplicate (gint32 image_ID); #ifdef __cplusplus diff --git a/libgimp/gimpcolor_pdb.c b/libgimp/gimpcolor_pdb.c index af93b0c0c9..2c8cc37dc4 100644 --- a/libgimp/gimpcolor_pdb.c +++ b/libgimp/gimpcolor_pdb.c @@ -23,13 +23,14 @@ #include "gimp.h" -void +gboolean gimp_brightness_contrast (gint32 drawable_ID, gint brightness, gint contrast) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_brightness_contrast", &nreturn_vals, @@ -38,10 +39,14 @@ gimp_brightness_contrast (gint32 drawable_ID, GIMP_PDB_INT32, contrast, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_levels (gint32 drawable_ID, GimpChannelLutType channel, gint low_input, @@ -52,6 +57,7 @@ gimp_levels (gint32 drawable_ID, { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_levels", &nreturn_vals, @@ -64,15 +70,20 @@ gimp_levels (gint32 drawable_ID, GIMP_PDB_INT32, high_output, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_posterize (gint32 drawable_ID, gint levels) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_posterize", &nreturn_vals, @@ -80,29 +91,39 @@ gimp_posterize (gint32 drawable_ID, GIMP_PDB_INT32, levels, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_desaturate (gint32 drawable_ID) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_desaturate", &nreturn_vals, GIMP_PDB_DRAWABLE, drawable_ID, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_equalize (gint32 drawable_ID, gboolean mask_only) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_equalize", &nreturn_vals, @@ -110,24 +131,33 @@ gimp_equalize (gint32 drawable_ID, GIMP_PDB_INT32, mask_only, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_invert (gint32 drawable_ID) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_invert", &nreturn_vals, GIMP_PDB_DRAWABLE, drawable_ID, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_curves_spline (gint32 drawable_ID, GimpChannelLutType channel, gint num_points, @@ -135,6 +165,7 @@ gimp_curves_spline (gint32 drawable_ID, { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_curves_spline", &nreturn_vals, @@ -144,10 +175,14 @@ gimp_curves_spline (gint32 drawable_ID, GIMP_PDB_INT8ARRAY, control_pts, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_curves_explicit (gint32 drawable_ID, GimpChannelLutType channel, gint num_bytes, @@ -155,6 +190,7 @@ gimp_curves_explicit (gint32 drawable_ID, { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_curves_explicit", &nreturn_vals, @@ -164,10 +200,14 @@ gimp_curves_explicit (gint32 drawable_ID, GIMP_PDB_INT8ARRAY, curve, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_color_balance (gint32 drawable_ID, GimpTransferMode transfer_mode, gboolean preserve_lum, @@ -177,6 +217,7 @@ gimp_color_balance (gint32 drawable_ID, { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_color_balance", &nreturn_vals, @@ -188,10 +229,14 @@ gimp_color_balance (gint32 drawable_ID, GIMP_PDB_FLOAT, yellow_blue, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_histogram (gint32 drawable_ID, GimpChannelLutType channel, gint start_range, @@ -205,6 +250,7 @@ gimp_histogram (gint32 drawable_ID, { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_histogram", &nreturn_vals, @@ -221,7 +267,9 @@ gimp_histogram (gint32 drawable_ID, *count = 0.0; *percentile = 0.0; - if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + + if (success) { *mean = return_vals[1].data.d_float; *std_dev = return_vals[2].data.d_float; @@ -232,9 +280,11 @@ gimp_histogram (gint32 drawable_ID, } gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_hue_saturation (gint32 drawable_ID, GimpHueRange hue_range, gdouble hue_offset, @@ -243,6 +293,7 @@ gimp_hue_saturation (gint32 drawable_ID, { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_hue_saturation", &nreturn_vals, @@ -253,16 +304,21 @@ gimp_hue_saturation (gint32 drawable_ID, GIMP_PDB_FLOAT, saturation, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_threshold (gint32 drawable_ID, gint low_threshold, gint high_threshold) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_threshold", &nreturn_vals, @@ -271,5 +327,9 @@ gimp_threshold (gint32 drawable_ID, GIMP_PDB_INT32, high_threshold, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } diff --git a/libgimp/gimpcolor_pdb.h b/libgimp/gimpcolor_pdb.h index 05139bd691..7d80478007 100644 --- a/libgimp/gimpcolor_pdb.h +++ b/libgimp/gimpcolor_pdb.h @@ -31,54 +31,54 @@ extern "C" { /* For information look into the C source or the html documentation */ -void gimp_brightness_contrast (gint32 drawable_ID, - gint brightness, - gint contrast); -void gimp_levels (gint32 drawable_ID, - GimpChannelLutType channel, - gint low_input, - gint high_input, - gdouble gamma, - gint low_output, - gint high_output); -void gimp_posterize (gint32 drawable_ID, - gint levels); -void gimp_desaturate (gint32 drawable_ID); -void gimp_equalize (gint32 drawable_ID, - gboolean mask_only); -void gimp_invert (gint32 drawable_ID); -void gimp_curves_spline (gint32 drawable_ID, - GimpChannelLutType channel, - gint num_points, - guint8 *control_pts); -void gimp_curves_explicit (gint32 drawable_ID, - GimpChannelLutType channel, - gint num_bytes, - guint8 *curve); -void gimp_color_balance (gint32 drawable_ID, - GimpTransferMode transfer_mode, - gboolean preserve_lum, - gdouble cyan_red, - gdouble magenta_green, - gdouble yellow_blue); -void gimp_histogram (gint32 drawable_ID, - GimpChannelLutType channel, - gint start_range, - gint end_range, - gdouble *mean, - gdouble *std_dev, - gdouble *median, - gdouble *pixels, - gdouble *count, - gdouble *percentile); -void gimp_hue_saturation (gint32 drawable_ID, - GimpHueRange hue_range, - gdouble hue_offset, - gdouble lightness, - gdouble saturation); -void gimp_threshold (gint32 drawable_ID, - gint low_threshold, - gint high_threshold); +gboolean gimp_brightness_contrast (gint32 drawable_ID, + gint brightness, + gint contrast); +gboolean gimp_levels (gint32 drawable_ID, + GimpChannelLutType channel, + gint low_input, + gint high_input, + gdouble gamma, + gint low_output, + gint high_output); +gboolean gimp_posterize (gint32 drawable_ID, + gint levels); +gboolean gimp_desaturate (gint32 drawable_ID); +gboolean gimp_equalize (gint32 drawable_ID, + gboolean mask_only); +gboolean gimp_invert (gint32 drawable_ID); +gboolean gimp_curves_spline (gint32 drawable_ID, + GimpChannelLutType channel, + gint num_points, + guint8 *control_pts); +gboolean gimp_curves_explicit (gint32 drawable_ID, + GimpChannelLutType channel, + gint num_bytes, + guint8 *curve); +gboolean gimp_color_balance (gint32 drawable_ID, + GimpTransferMode transfer_mode, + gboolean preserve_lum, + gdouble cyan_red, + gdouble magenta_green, + gdouble yellow_blue); +gboolean gimp_histogram (gint32 drawable_ID, + GimpChannelLutType 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); +gboolean gimp_threshold (gint32 drawable_ID, + gint low_threshold, + gint high_threshold); #ifdef __cplusplus diff --git a/libgimp/gimpconvert_pdb.c b/libgimp/gimpconvert_pdb.c index e79fb0cf32..e3f4b863fa 100644 --- a/libgimp/gimpconvert_pdb.c +++ b/libgimp/gimpconvert_pdb.c @@ -23,35 +23,45 @@ #include "gimp.h" -void +gboolean gimp_convert_rgb (gint32 image_ID) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_convert_rgb", &nreturn_vals, GIMP_PDB_IMAGE, image_ID, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_convert_grayscale (gint32 image_ID) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_convert_grayscale", &nreturn_vals, GIMP_PDB_IMAGE, image_ID, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_convert_indexed (gint32 image_ID, GimpConvertDitherType dither_type, GimpConvertPaletteType palette_type, @@ -62,6 +72,7 @@ gimp_convert_indexed (gint32 image_ID, { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_convert_indexed", &nreturn_vals, @@ -74,5 +85,9 @@ gimp_convert_indexed (gint32 image_ID, GIMP_PDB_STRING, palette, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } diff --git a/libgimp/gimpconvert_pdb.h b/libgimp/gimpconvert_pdb.h index ccfeec9800..9a3a3817db 100644 --- a/libgimp/gimpconvert_pdb.h +++ b/libgimp/gimpconvert_pdb.h @@ -31,15 +31,15 @@ extern "C" { /* For information look into the C source or the html documentation */ -void gimp_convert_rgb (gint32 image_ID); -void gimp_convert_grayscale (gint32 image_ID); -void gimp_convert_indexed (gint32 image_ID, - GimpConvertDitherType dither_type, - GimpConvertPaletteType palette_type, - gint num_cols, - gboolean alpha_dither, - gboolean remove_unused, - gchar *palette); +gboolean gimp_convert_rgb (gint32 image_ID); +gboolean gimp_convert_grayscale (gint32 image_ID); +gboolean gimp_convert_indexed (gint32 image_ID, + GimpConvertDitherType dither_type, + GimpConvertPaletteType palette_type, + gint num_cols, + gboolean alpha_dither, + gboolean remove_unused, + gchar *palette); #ifdef __cplusplus diff --git a/libgimp/gimpdisplay_pdb.c b/libgimp/gimpdisplay_pdb.c index 5f2a5ce407..63ad06247a 100644 --- a/libgimp/gimpdisplay_pdb.c +++ b/libgimp/gimpdisplay_pdb.c @@ -43,29 +43,39 @@ gimp_display_new (gint32 image_ID) return display_ID; } -void +gboolean gimp_display_delete (gint32 display_ID) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_display_delete", &nreturn_vals, GIMP_PDB_DISPLAY, display_ID, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_displays_flush (void) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_displays_flush", &nreturn_vals, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } diff --git a/libgimp/gimpdisplay_pdb.h b/libgimp/gimpdisplay_pdb.h index 3be29f9d35..388e314090 100644 --- a/libgimp/gimpdisplay_pdb.h +++ b/libgimp/gimpdisplay_pdb.h @@ -31,9 +31,9 @@ extern "C" { /* For information look into the C source or the html documentation */ -gint32 gimp_display_new (gint32 image_ID); -void gimp_display_delete (gint32 display_ID); -void gimp_displays_flush (void); +gint32 gimp_display_new (gint32 image_ID); +gboolean gimp_display_delete (gint32 display_ID); +gboolean gimp_displays_flush (void); #ifdef __cplusplus diff --git a/libgimp/gimpdrawable_pdb.c b/libgimp/gimpdrawable_pdb.c index 9438792bf2..424dd29ea8 100644 --- a/libgimp/gimpdrawable_pdb.c +++ b/libgimp/gimpdrawable_pdb.c @@ -23,12 +23,13 @@ #include "gimp.h" -void +gboolean gimp_drawable_merge_shadow (gint32 drawable_ID, gboolean undo) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_drawable_merge_shadow", &nreturn_vals, @@ -36,15 +37,20 @@ gimp_drawable_merge_shadow (gint32 drawable_ID, GIMP_PDB_INT32, undo, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_drawable_fill (gint32 drawable_ID, GimpFillType fill_type) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_drawable_fill", &nreturn_vals, @@ -52,10 +58,14 @@ gimp_drawable_fill (gint32 drawable_ID, GIMP_PDB_INT32, fill_type, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_drawable_update (gint32 drawable_ID, gint x, gint y, @@ -64,6 +74,7 @@ gimp_drawable_update (gint32 drawable_ID, { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_drawable_update", &nreturn_vals, @@ -74,7 +85,11 @@ gimp_drawable_update (gint32 drawable_ID, GIMP_PDB_INT32, height, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } gboolean @@ -307,13 +322,14 @@ gimp_drawable_height (gint32 drawable_ID) return height; } -void +gboolean gimp_drawable_offsets (gint32 drawable_ID, 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, @@ -323,13 +339,17 @@ gimp_drawable_offsets (gint32 drawable_ID, *offset_x = 0; *offset_y = 0; - if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + + if (success) { *offset_x = return_vals[1].data.d_int32; *offset_y = return_vals[2].data.d_int32; } gimp_destroy_params (return_vals, nreturn_vals); + + return success; } gboolean @@ -392,7 +412,7 @@ gimp_drawable_is_channel (gint32 drawable_ID) return channel; } -void +gboolean _gimp_drawable_thumbnail (gint32 drawable_ID, gint width, gint height, @@ -404,6 +424,7 @@ _gimp_drawable_thumbnail (gint32 drawable_ID, { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_drawable_thumbnail", &nreturn_vals, @@ -418,7 +439,9 @@ _gimp_drawable_thumbnail (gint32 drawable_ID, *thumbnail_data_count = 0; *thumbnail_data = NULL; - if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + + if (success) { *ret_width = return_vals[1].data.d_int32; *ret_height = return_vals[2].data.d_int32; @@ -430,4 +453,6 @@ _gimp_drawable_thumbnail (gint32 drawable_ID, } gimp_destroy_params (return_vals, nreturn_vals); + + return success; } diff --git a/libgimp/gimpdrawable_pdb.h b/libgimp/gimpdrawable_pdb.h index 8997690391..1d9de3b494 100644 --- a/libgimp/gimpdrawable_pdb.h +++ b/libgimp/gimpdrawable_pdb.h @@ -31,11 +31,11 @@ extern "C" { /* For information look into the C source or the html documentation */ -void gimp_drawable_merge_shadow (gint32 drawable_ID, +gboolean gimp_drawable_merge_shadow (gint32 drawable_ID, gboolean undo); -void gimp_drawable_fill (gint32 drawable_ID, +gboolean gimp_drawable_fill (gint32 drawable_ID, GimpFillType fill_type); -void gimp_drawable_update (gint32 drawable_ID, +gboolean gimp_drawable_update (gint32 drawable_ID, gint x, gint y, gint width, @@ -55,13 +55,13 @@ gboolean gimp_drawable_is_indexed (gint32 drawable_ID); gint gimp_drawable_bytes (gint32 drawable_ID); gint gimp_drawable_width (gint32 drawable_ID); gint gimp_drawable_height (gint32 drawable_ID); -void gimp_drawable_offsets (gint32 drawable_ID, +gboolean gimp_drawable_offsets (gint32 drawable_ID, gint *offset_x, gint *offset_y); gboolean gimp_drawable_is_layer (gint32 drawable_ID); gboolean gimp_drawable_is_layer_mask (gint32 drawable_ID); gboolean gimp_drawable_is_channel (gint32 drawable_ID); -void _gimp_drawable_thumbnail (gint32 drawable_ID, +gboolean _gimp_drawable_thumbnail (gint32 drawable_ID, gint width, gint height, gint *ret_width, diff --git a/libgimp/gimpedit_pdb.c b/libgimp/gimpedit_pdb.c index 87de1738fd..534cc9216a 100644 --- a/libgimp/gimpedit_pdb.c +++ b/libgimp/gimpedit_pdb.c @@ -23,32 +23,42 @@ #include "gimp.h" -void +gboolean gimp_edit_cut (gint32 drawable_ID) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_edit_cut", &nreturn_vals, GIMP_PDB_DRAWABLE, drawable_ID, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_edit_copy (gint32 drawable_ID) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_edit_copy", &nreturn_vals, GIMP_PDB_DRAWABLE, drawable_ID, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } gint32 @@ -73,26 +83,32 @@ gimp_edit_paste (gint32 drawable_ID, return floating_sel_ID; } -void +gboolean gimp_edit_clear (gint32 drawable_ID) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_edit_clear", &nreturn_vals, GIMP_PDB_DRAWABLE, drawable_ID, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_edit_fill (gint32 drawable_ID, GimpFillType fill_type) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_edit_fill", &nreturn_vals, @@ -100,19 +116,28 @@ gimp_edit_fill (gint32 drawable_ID, GIMP_PDB_INT32, fill_type, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_edit_stroke (gint32 drawable_ID) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_edit_stroke", &nreturn_vals, GIMP_PDB_DRAWABLE, drawable_ID, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } diff --git a/libgimp/gimpedit_pdb.h b/libgimp/gimpedit_pdb.h index 2c88e7a50f..d4b1d833e6 100644 --- a/libgimp/gimpedit_pdb.h +++ b/libgimp/gimpedit_pdb.h @@ -31,14 +31,14 @@ extern "C" { /* For information look into the C source or the html documentation */ -void gimp_edit_cut (gint32 drawable_ID); -void gimp_edit_copy (gint32 drawable_ID); -gint32 gimp_edit_paste (gint32 drawable_ID, - gboolean paste_into); -void gimp_edit_clear (gint32 drawable_ID); -void gimp_edit_fill (gint32 drawable_ID, - GimpFillType fill_type); -void gimp_edit_stroke (gint32 drawable_ID); +gboolean gimp_edit_cut (gint32 drawable_ID); +gboolean gimp_edit_copy (gint32 drawable_ID); +gint32 gimp_edit_paste (gint32 drawable_ID, + gboolean paste_into); +gboolean gimp_edit_clear (gint32 drawable_ID); +gboolean gimp_edit_fill (gint32 drawable_ID, + GimpFillType fill_type); +gboolean gimp_edit_stroke (gint32 drawable_ID); #ifdef __cplusplus diff --git a/libgimp/gimpfileops_pdb.c b/libgimp/gimpfileops_pdb.c index c99ecb0bc1..4c72b8b2ef 100644 --- a/libgimp/gimpfileops_pdb.c +++ b/libgimp/gimpfileops_pdb.c @@ -23,7 +23,7 @@ #include "gimp.h" -void +gboolean gimp_register_magic_load_handler (gchar *procedure_name, gchar *extensions, gchar *prefixes, @@ -31,6 +31,7 @@ gimp_register_magic_load_handler (gchar *procedure_name, { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_register_magic_load_handler", &nreturn_vals, @@ -40,16 +41,21 @@ gimp_register_magic_load_handler (gchar *procedure_name, GIMP_PDB_STRING, magics, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_register_load_handler (gchar *procedure_name, gchar *extensions, gchar *prefixes) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_register_load_handler", &nreturn_vals, @@ -58,16 +64,21 @@ gimp_register_load_handler (gchar *procedure_name, GIMP_PDB_STRING, prefixes, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_register_save_handler (gchar *procedure_name, gchar *extensions, gchar *prefixes) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_register_save_handler", &nreturn_vals, @@ -76,5 +87,9 @@ gimp_register_save_handler (gchar *procedure_name, GIMP_PDB_STRING, prefixes, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } diff --git a/libgimp/gimpfileops_pdb.h b/libgimp/gimpfileops_pdb.h index f79ebc1051..81f15d01cd 100644 --- a/libgimp/gimpfileops_pdb.h +++ b/libgimp/gimpfileops_pdb.h @@ -31,16 +31,16 @@ extern "C" { /* For information look into the C source or the html documentation */ -void gimp_register_magic_load_handler (gchar *procedure_name, - gchar *extensions, - gchar *prefixes, - gchar *magics); -void gimp_register_load_handler (gchar *procedure_name, - gchar *extensions, - gchar *prefixes); -void gimp_register_save_handler (gchar *procedure_name, - gchar *extensions, - gchar *prefixes); +gboolean gimp_register_magic_load_handler (gchar *procedure_name, + gchar *extensions, + gchar *prefixes, + gchar *magics); +gboolean gimp_register_load_handler (gchar *procedure_name, + gchar *extensions, + gchar *prefixes); +gboolean gimp_register_save_handler (gchar *procedure_name, + gchar *extensions, + gchar *prefixes); #ifdef __cplusplus diff --git a/libgimp/gimpfloatingsel_pdb.c b/libgimp/gimpfloatingsel_pdb.c index 5b69f6c3f3..141a73f854 100644 --- a/libgimp/gimpfloatingsel_pdb.c +++ b/libgimp/gimpfloatingsel_pdb.c @@ -23,54 +23,70 @@ #include "gimp.h" -void +gboolean gimp_floating_sel_remove (gint32 floating_sel_ID) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_floating_sel_remove", &nreturn_vals, GIMP_PDB_LAYER, floating_sel_ID, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_floating_sel_anchor (gint32 floating_sel_ID) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_floating_sel_anchor", &nreturn_vals, GIMP_PDB_LAYER, floating_sel_ID, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_floating_sel_to_layer (gint32 floating_sel_ID) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_floating_sel_to_layer", &nreturn_vals, GIMP_PDB_LAYER, floating_sel_ID, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_floating_sel_attach (gint32 layer_ID, gint32 drawable_ID) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_floating_sel_attach", &nreturn_vals, @@ -78,15 +94,20 @@ gimp_floating_sel_attach (gint32 layer_ID, GIMP_PDB_DRAWABLE, drawable_ID, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_floating_sel_rigor (gint32 floating_sel_ID, gboolean undo) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_floating_sel_rigor", &nreturn_vals, @@ -94,15 +115,20 @@ gimp_floating_sel_rigor (gint32 floating_sel_ID, GIMP_PDB_INT32, undo, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_floating_sel_relax (gint32 floating_sel_ID, gboolean undo) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_floating_sel_relax", &nreturn_vals, @@ -110,5 +136,9 @@ gimp_floating_sel_relax (gint32 floating_sel_ID, GIMP_PDB_INT32, undo, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } diff --git a/libgimp/gimpfloatingsel_pdb.h b/libgimp/gimpfloatingsel_pdb.h index c5431277db..ed8aa1fa3e 100644 --- a/libgimp/gimpfloatingsel_pdb.h +++ b/libgimp/gimpfloatingsel_pdb.h @@ -31,15 +31,15 @@ extern "C" { /* For information look into the C source or the html documentation */ -void gimp_floating_sel_remove (gint32 floating_sel_ID); -void gimp_floating_sel_anchor (gint32 floating_sel_ID); -void gimp_floating_sel_to_layer (gint32 floating_sel_ID); -void gimp_floating_sel_attach (gint32 layer_ID, - gint32 drawable_ID); -void gimp_floating_sel_rigor (gint32 floating_sel_ID, - gboolean undo); -void gimp_floating_sel_relax (gint32 floating_sel_ID, - gboolean undo); +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); +gboolean gimp_floating_sel_rigor (gint32 floating_sel_ID, + gboolean undo); +gboolean gimp_floating_sel_relax (gint32 floating_sel_ID, + gboolean undo); #ifdef __cplusplus diff --git a/libgimp/gimpgimprc_pdb.c b/libgimp/gimpgimprc_pdb.c index e076238af4..4320d52ba8 100644 --- a/libgimp/gimpgimprc_pdb.c +++ b/libgimp/gimpgimprc_pdb.c @@ -43,12 +43,13 @@ gimp_gimprc_query (gchar *token) return value; } -void +gboolean gimp_gimprc_set (gchar *token, gchar *value) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_gimprc_set", &nreturn_vals, @@ -56,15 +57,20 @@ gimp_gimprc_set (gchar *token, GIMP_PDB_STRING, value, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_get_monitor_resolution (gdouble *xres, gdouble *yres) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_get_monitor_resolution", &nreturn_vals, @@ -73,11 +79,15 @@ gimp_get_monitor_resolution (gdouble *xres, *xres = 0.0; *yres = 0.0; - if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + + if (success) { *xres = return_vals[1].data.d_float; *yres = return_vals[2].data.d_float; } gimp_destroy_params (return_vals, nreturn_vals); + + return success; } diff --git a/libgimp/gimpgimprc_pdb.h b/libgimp/gimpgimprc_pdb.h index 351facf9af..238197a98b 100644 --- a/libgimp/gimpgimprc_pdb.h +++ b/libgimp/gimpgimprc_pdb.h @@ -31,11 +31,11 @@ extern "C" { /* For information look into the C source or the html documentation */ -gchar* gimp_gimprc_query (gchar *token); -void gimp_gimprc_set (gchar *token, - gchar *value); -void gimp_get_monitor_resolution (gdouble *xres, - gdouble *yres); +gchar* gimp_gimprc_query (gchar *token); +gboolean gimp_gimprc_set (gchar *token, + gchar *value); +gboolean gimp_get_monitor_resolution (gdouble *xres, + gdouble *yres); #ifdef __cplusplus diff --git a/libgimp/gimpgradients_pdb.c b/libgimp/gimpgradients_pdb.c index b725a321ad..a6e07ec87f 100644 --- a/libgimp/gimpgradients_pdb.c +++ b/libgimp/gimpgradients_pdb.c @@ -69,18 +69,23 @@ gimp_gradients_get_active (void) return name; } -void +gboolean gimp_gradients_set_active (gchar *name) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_gradients_set_active", &nreturn_vals, GIMP_PDB_STRING, name, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } gdouble * diff --git a/libgimp/gimpgradients_pdb.h b/libgimp/gimpgradients_pdb.h index ff33faca68..6788f4093c 100644 --- a/libgimp/gimpgradients_pdb.h +++ b/libgimp/gimpgradients_pdb.h @@ -33,7 +33,7 @@ extern "C" { gchar** gimp_gradients_get_list (gint *num_gradients); gchar* gimp_gradients_get_active (void); -void gimp_gradients_set_active (gchar *name); +gboolean gimp_gradients_set_active (gchar *name); gdouble* gimp_gradients_sample_uniform (gint num_samples); gdouble* gimp_gradients_sample_custom (gint num_samples, gdouble *positions); diff --git a/libgimp/gimpgradientselect_pdb.c b/libgimp/gimpgradientselect_pdb.c index 1f3bf2559b..138dc50c81 100644 --- a/libgimp/gimpgradientselect_pdb.c +++ b/libgimp/gimpgradientselect_pdb.c @@ -23,7 +23,7 @@ #include "gimp.h" -void +gboolean gimp_gradients_popup (gchar *gradients_callback, gchar *popup_title, gchar *initial_gradient, @@ -31,6 +31,7 @@ gimp_gradients_popup (gchar *gradients_callback, { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_gradients_popup", &nreturn_vals, @@ -40,29 +41,39 @@ gimp_gradients_popup (gchar *gradients_callback, GIMP_PDB_INT32, sample_size, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_gradients_close_popup (gchar *gradients_callback) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_gradients_close_popup", &nreturn_vals, GIMP_PDB_STRING, gradients_callback, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_gradients_set_popup (gchar *gradients_callback, gchar *gradient_name) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_gradients_set_popup", &nreturn_vals, @@ -70,7 +81,11 @@ gimp_gradients_set_popup (gchar *gradients_callback, GIMP_PDB_STRING, gradient_name, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } gchar * diff --git a/libgimp/gimpgradientselect_pdb.h b/libgimp/gimpgradientselect_pdb.h index d0fac9f596..81ba18f7dd 100644 --- a/libgimp/gimpgradientselect_pdb.h +++ b/libgimp/gimpgradientselect_pdb.h @@ -31,17 +31,17 @@ extern "C" { /* For information look into the C source or the html documentation */ -void gimp_gradients_popup (gchar *gradients_callback, - gchar *popup_title, - gchar *initial_gradient, - gint sample_size); -void gimp_gradients_close_popup (gchar *gradients_callback); -void gimp_gradients_set_popup (gchar *gradients_callback, - gchar *gradient_name); -gchar* _gimp_gradients_get_gradient_data (gchar *name, - gint sample_size, - gint *width, - gdouble **grad_data); +gboolean gimp_gradients_popup (gchar *gradients_callback, + gchar *popup_title, + gchar *initial_gradient, + gint sample_size); +gboolean gimp_gradients_close_popup (gchar *gradients_callback); +gboolean gimp_gradients_set_popup (gchar *gradients_callback, + gchar *gradient_name); +gchar* _gimp_gradients_get_gradient_data (gchar *name, + gint sample_size, + gint *width, + gdouble **grad_data); #ifdef __cplusplus diff --git a/libgimp/gimpguides_pdb.c b/libgimp/gimpguides_pdb.c index 1055913824..63a8c88082 100644 --- a/libgimp/gimpguides_pdb.c +++ b/libgimp/gimpguides_pdb.c @@ -67,12 +67,13 @@ gimp_image_add_vguide (gint32 image_ID, return guide_ID; } -void +gboolean gimp_image_delete_guide (gint32 image_ID, gint32 guide_ID) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_image_delete_guide", &nreturn_vals, @@ -80,7 +81,11 @@ gimp_image_delete_guide (gint32 image_ID, GIMP_PDB_INT32, guide_ID, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } gint32 diff --git a/libgimp/gimpguides_pdb.h b/libgimp/gimpguides_pdb.h index 85015ebfab..a97fcf7f1d 100644 --- a/libgimp/gimpguides_pdb.h +++ b/libgimp/gimpguides_pdb.h @@ -35,7 +35,7 @@ gint32 gimp_image_add_hguide (gint32 image_ID, gint yposition); gint32 gimp_image_add_vguide (gint32 image_ID, gint xposition); -void gimp_image_delete_guide (gint32 image_ID, +gboolean gimp_image_delete_guide (gint32 image_ID, gint32 guide_ID); gint32 gimp_image_find_next_guide (gint32 image_ID, gint32 guide_ID); diff --git a/libgimp/gimphelp_pdb.c b/libgimp/gimphelp_pdb.c index 93e1728b83..a6cfe55ab7 100644 --- a/libgimp/gimphelp_pdb.c +++ b/libgimp/gimphelp_pdb.c @@ -23,12 +23,13 @@ #include "gimp.h" -void +gboolean gimp_help (gchar *prog_name, gchar *help_page) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_help", &nreturn_vals, @@ -36,5 +37,9 @@ gimp_help (gchar *prog_name, GIMP_PDB_STRING, help_page, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } diff --git a/libgimp/gimphelp_pdb.h b/libgimp/gimphelp_pdb.h index c1c22c4cad..86236ccaf8 100644 --- a/libgimp/gimphelp_pdb.h +++ b/libgimp/gimphelp_pdb.h @@ -31,8 +31,8 @@ extern "C" { /* For information look into the C source or the html documentation */ -void gimp_help (gchar *prog_name, - gchar *help_page); +gboolean gimp_help (gchar *prog_name, + gchar *help_page); #ifdef __cplusplus diff --git a/libgimp/gimpimage_pdb.c b/libgimp/gimpimage_pdb.c index 586f8a6fd2..6150f26daa 100644 --- a/libgimp/gimpimage_pdb.c +++ b/libgimp/gimpimage_pdb.c @@ -73,7 +73,7 @@ gimp_image_new (gint width, return image_ID; } -void +gboolean gimp_image_resize (gint32 image_ID, gint new_width, gint new_height, @@ -82,6 +82,7 @@ gimp_image_resize (gint32 image_ID, { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_image_resize", &nreturn_vals, @@ -92,16 +93,21 @@ gimp_image_resize (gint32 image_ID, GIMP_PDB_INT32, offy, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_image_scale (gint32 image_ID, 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, @@ -110,35 +116,49 @@ gimp_image_scale (gint32 image_ID, GIMP_PDB_INT32, new_height, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_image_delete (gint32 image_ID) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_image_delete", &nreturn_vals, GIMP_PDB_IMAGE, image_ID, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_image_free_shadow (gint32 image_ID) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_image_free_shadow", &nreturn_vals, GIMP_PDB_IMAGE, image_ID, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } gint * @@ -197,18 +217,23 @@ gimp_image_get_channels (gint32 image_ID, return channel_ids; } -void +gboolean gimp_image_unset_active_channel (gint32 image_ID) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_image_unset_active_channel", &nreturn_vals, GIMP_PDB_IMAGE, image_ID, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } gint32 @@ -235,12 +260,13 @@ gimp_image_pick_correlate_layer (gint32 image_ID, return layer_ID; } -void +gboolean gimp_image_raise_layer (gint32 image_ID, gint32 layer_ID) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_image_raise_layer", &nreturn_vals, @@ -248,15 +274,20 @@ gimp_image_raise_layer (gint32 image_ID, GIMP_PDB_LAYER, layer_ID, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_image_lower_layer (gint32 image_ID, gint32 layer_ID) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_image_lower_layer", &nreturn_vals, @@ -264,15 +295,20 @@ gimp_image_lower_layer (gint32 image_ID, GIMP_PDB_LAYER, layer_ID, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_image_raise_layer_to_top (gint32 image_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, @@ -280,15 +316,20 @@ gimp_image_raise_layer_to_top (gint32 image_ID, GIMP_PDB_LAYER, layer_ID, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_image_lower_layer_to_bottom (gint32 image_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, @@ -296,7 +337,11 @@ gimp_image_lower_layer_to_bottom (gint32 image_ID, GIMP_PDB_LAYER, layer_ID, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } gint32 @@ -365,13 +410,14 @@ gimp_image_flatten (gint32 image_ID) return layer_ID; } -void +gboolean gimp_image_add_layer (gint32 image_ID, 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, @@ -380,15 +426,20 @@ gimp_image_add_layer (gint32 image_ID, GIMP_PDB_INT32, position, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_image_remove_layer (gint32 image_ID, gint32 layer_ID) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_image_remove_layer", &nreturn_vals, @@ -396,16 +447,21 @@ gimp_image_remove_layer (gint32 image_ID, GIMP_PDB_LAYER, layer_ID, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_image_add_layer_mask (gint32 image_ID, gint32 layer_ID, gint32 mask_ID) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_image_add_layer_mask", &nreturn_vals, @@ -414,16 +470,21 @@ gimp_image_add_layer_mask (gint32 image_ID, GIMP_PDB_CHANNEL, mask_ID, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_image_remove_layer_mask (gint32 image_ID, gint32 layer_ID, GimpMaskApplyMode mode) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_image_remove_layer_mask", &nreturn_vals, @@ -432,15 +493,20 @@ gimp_image_remove_layer_mask (gint32 image_ID, GIMP_PDB_INT32, mode, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_image_raise_channel (gint32 image_ID, gint32 channel_ID) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_image_raise_channel", &nreturn_vals, @@ -448,15 +514,20 @@ gimp_image_raise_channel (gint32 image_ID, GIMP_PDB_CHANNEL, channel_ID, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_image_lower_channel (gint32 image_ID, gint32 layer_ID) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_image_lower_channel", &nreturn_vals, @@ -464,16 +535,21 @@ gimp_image_lower_channel (gint32 image_ID, GIMP_PDB_LAYER, layer_ID, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_image_add_channel (gint32 image_ID, 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, @@ -482,15 +558,20 @@ gimp_image_add_channel (gint32 image_ID, GIMP_PDB_INT32, position, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_image_remove_channel (gint32 image_ID, gint32 channel_ID) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_image_remove_channel", &nreturn_vals, @@ -498,7 +579,11 @@ gimp_image_remove_channel (gint32 image_ID, GIMP_PDB_CHANNEL, channel_ID, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } gint32 @@ -569,13 +654,14 @@ _gimp_image_get_cmap (gint32 image_ID, return cmap; } -void +gboolean _gimp_image_set_cmap (gint32 image_ID, gint num_bytes, guint8 *cmap) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_image_set_cmap", &nreturn_vals, @@ -584,7 +670,11 @@ _gimp_image_set_cmap (gint32 image_ID, GIMP_PDB_INT8ARRAY, cmap, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } gboolean @@ -687,18 +777,23 @@ gimp_image_undo_thaw (gint32 image_ID) return thawed; } -void +gboolean gimp_image_clean_all (gint32 image_ID) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_image_clean_all", &nreturn_vals, GIMP_PDB_IMAGE, image_ID, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } gint32 @@ -741,7 +836,7 @@ gimp_image_floating_sel_attached_to (gint32 image_ID) return drawable_ID; } -void +gboolean _gimp_image_thumbnail (gint32 image_ID, gint width, gint height, @@ -753,6 +848,7 @@ _gimp_image_thumbnail (gint32 image_ID, { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_image_thumbnail", &nreturn_vals, @@ -767,7 +863,9 @@ _gimp_image_thumbnail (gint32 image_ID, *thumbnail_data_count = 0; *thumbnail_data = NULL; - if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + + if (success) { *ret_width = return_vals[1].data.d_int32; *ret_height = return_vals[2].data.d_int32; @@ -779,14 +877,17 @@ _gimp_image_thumbnail (gint32 image_ID, } gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_image_set_tattoo_state (gint32 image_ID, gint tattoo) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_image_set_tattoo_state", &nreturn_vals, @@ -794,7 +895,11 @@ gimp_image_set_tattoo_state (gint32 image_ID, GIMP_PDB_INT32, tattoo, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } gint @@ -877,12 +982,13 @@ gimp_image_get_active_layer (gint32 image_ID) return active_layer_ID; } -void +gboolean gimp_image_set_active_layer (gint32 image_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, @@ -890,7 +996,11 @@ gimp_image_set_active_layer (gint32 image_ID, GIMP_PDB_LAYER, active_layer_ID, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } gint32 @@ -913,12 +1023,13 @@ gimp_image_get_active_channel (gint32 image_ID) return active_channel_ID; } -void +gboolean gimp_image_set_active_channel (gint32 image_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, @@ -926,7 +1037,11 @@ gimp_image_set_active_channel (gint32 image_ID, GIMP_PDB_CHANNEL, active_channel_ID, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } gint32 @@ -971,13 +1086,14 @@ gimp_image_get_component_active (gint32 image_ID, return active; } -void +gboolean gimp_image_set_component_active (gint32 image_ID, 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, @@ -986,7 +1102,11 @@ gimp_image_set_component_active (gint32 image_ID, GIMP_PDB_INT32, active, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } gboolean @@ -1011,13 +1131,14 @@ gimp_image_get_component_visible (gint32 image_ID, return visible; } -void +gboolean gimp_image_set_component_visible (gint32 image_ID, 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, @@ -1026,7 +1147,11 @@ gimp_image_set_component_visible (gint32 image_ID, GIMP_PDB_INT32, visible, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } gchar * @@ -1049,12 +1174,13 @@ gimp_image_get_filename (gint32 image_ID) return filename; } -void +gboolean gimp_image_set_filename (gint32 image_ID, gchar *filename) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_image_set_filename", &nreturn_vals, @@ -1062,16 +1188,21 @@ gimp_image_set_filename (gint32 image_ID, GIMP_PDB_STRING, filename, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_image_get_resolution (gint32 image_ID, gdouble *xresolution, gdouble *yresolution) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_image_get_resolution", &nreturn_vals, @@ -1081,22 +1212,27 @@ gimp_image_get_resolution (gint32 image_ID, *xresolution = 0.0; *yresolution = 0.0; - if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + + if (success) { *xresolution = return_vals[1].data.d_float; *yresolution = return_vals[2].data.d_float; } gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_image_set_resolution (gint32 image_ID, gdouble xresolution, gdouble yresolution) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_image_set_resolution", &nreturn_vals, @@ -1105,7 +1241,11 @@ gimp_image_set_resolution (gint32 image_ID, GIMP_PDB_FLOAT, yresolution, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } GimpUnit @@ -1128,12 +1268,13 @@ gimp_image_get_unit (gint32 image_ID) return unit; } -void +gboolean gimp_image_set_unit (gint32 image_ID, GimpUnit unit) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_image_set_unit", &nreturn_vals, @@ -1141,7 +1282,11 @@ gimp_image_set_unit (gint32 image_ID, GIMP_PDB_INT32, unit, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } gint32 diff --git a/libgimp/gimpimage_pdb.h b/libgimp/gimpimage_pdb.h index 9e62ebd525..8561bf2e11 100644 --- a/libgimp/gimpimage_pdb.h +++ b/libgimp/gimpimage_pdb.h @@ -35,31 +35,31 @@ gint* gimp_image_list (gint *num_i gint32 gimp_image_new (gint width, gint height, GimpImageBaseType type); -void gimp_image_resize (gint32 image_ID, +gboolean gimp_image_resize (gint32 image_ID, gint new_width, gint new_height, gint offx, gint offy); -void gimp_image_scale (gint32 image_ID, +gboolean gimp_image_scale (gint32 image_ID, gint new_width, gint new_height); -void gimp_image_delete (gint32 image_ID); -void gimp_image_free_shadow (gint32 image_ID); +gboolean gimp_image_delete (gint32 image_ID); +gboolean gimp_image_free_shadow (gint32 image_ID); gint* gimp_image_get_layers (gint32 image_ID, gint *num_layers); gint* gimp_image_get_channels (gint32 image_ID, gint *num_channels); -void gimp_image_unset_active_channel (gint32 image_ID); +gboolean gimp_image_unset_active_channel (gint32 image_ID); gint32 gimp_image_pick_correlate_layer (gint32 image_ID, gint x, gint y); -void gimp_image_raise_layer (gint32 image_ID, +gboolean gimp_image_raise_layer (gint32 image_ID, gint32 layer_ID); -void gimp_image_lower_layer (gint32 image_ID, +gboolean gimp_image_lower_layer (gint32 image_ID, gint32 layer_ID); -void gimp_image_raise_layer_to_top (gint32 image_ID, +gboolean gimp_image_raise_layer_to_top (gint32 image_ID, gint32 layer_ID); -void gimp_image_lower_layer_to_bottom (gint32 image_ID, +gboolean gimp_image_lower_layer_to_bottom (gint32 image_ID, gint32 layer_ID); gint32 gimp_image_merge_visible_layers (gint32 image_ID, GimpMergeType merge_type); @@ -67,31 +67,31 @@ gint32 gimp_image_merge_down (gint32 image gint32 merge_layer_ID, GimpMergeType merge_type); gint32 gimp_image_flatten (gint32 image_ID); -void gimp_image_add_layer (gint32 image_ID, +gboolean gimp_image_add_layer (gint32 image_ID, gint32 layer_ID, gint position); -void gimp_image_remove_layer (gint32 image_ID, +gboolean gimp_image_remove_layer (gint32 image_ID, gint32 layer_ID); -void gimp_image_add_layer_mask (gint32 image_ID, +gboolean gimp_image_add_layer_mask (gint32 image_ID, gint32 layer_ID, gint32 mask_ID); -void gimp_image_remove_layer_mask (gint32 image_ID, +gboolean gimp_image_remove_layer_mask (gint32 image_ID, gint32 layer_ID, GimpMaskApplyMode mode); -void gimp_image_raise_channel (gint32 image_ID, +gboolean gimp_image_raise_channel (gint32 image_ID, gint32 channel_ID); -void gimp_image_lower_channel (gint32 image_ID, +gboolean gimp_image_lower_channel (gint32 image_ID, gint32 layer_ID); -void gimp_image_add_channel (gint32 image_ID, +gboolean gimp_image_add_channel (gint32 image_ID, gint32 channel_ID, gint position); -void gimp_image_remove_channel (gint32 image_ID, +gboolean gimp_image_remove_channel (gint32 image_ID, gint32 channel_ID); gint32 gimp_image_active_drawable (gint32 image_ID); GimpImageBaseType gimp_image_base_type (gint32 image_ID); guint8* _gimp_image_get_cmap (gint32 image_ID, gint *num_bytes); -void _gimp_image_set_cmap (gint32 image_ID, +gboolean _gimp_image_set_cmap (gint32 image_ID, gint num_bytes, guint8 *cmap); gboolean gimp_image_undo_is_enabled (gint32 image_ID); @@ -99,10 +99,10 @@ gboolean gimp_image_undo_enable (gint32 image gboolean gimp_image_undo_disable (gint32 image_ID); gboolean gimp_image_undo_freeze (gint32 image_ID); gboolean gimp_image_undo_thaw (gint32 image_ID); -void gimp_image_clean_all (gint32 image_ID); +gboolean gimp_image_clean_all (gint32 image_ID); gint32 gimp_image_floating_selection (gint32 image_ID); gint32 gimp_image_floating_sel_attached_to (gint32 image_ID); -void _gimp_image_thumbnail (gint32 image_ID, +gboolean _gimp_image_thumbnail (gint32 image_ID, gint width, gint height, gint *ret_width, @@ -110,39 +110,39 @@ void _gimp_image_thumbnail (gint32 image gint *bpp, gint *thumbnail_data_count, guint8 **thumbnail_data); -void gimp_image_set_tattoo_state (gint32 image_ID, +gboolean gimp_image_set_tattoo_state (gint32 image_ID, gint tattoo); gint gimp_image_get_tattoo_state (gint32 image_ID); gint gimp_image_width (gint32 image_ID); gint gimp_image_height (gint32 image_ID); gint32 gimp_image_get_active_layer (gint32 image_ID); -void gimp_image_set_active_layer (gint32 image_ID, +gboolean gimp_image_set_active_layer (gint32 image_ID, gint32 active_layer_ID); gint32 gimp_image_get_active_channel (gint32 image_ID); -void gimp_image_set_active_channel (gint32 image_ID, +gboolean gimp_image_set_active_channel (gint32 image_ID, gint32 active_channel_ID); gint32 gimp_image_get_selection (gint32 image_ID); gboolean gimp_image_get_component_active (gint32 image_ID, GimpChannelType component); -void gimp_image_set_component_active (gint32 image_ID, +gboolean gimp_image_set_component_active (gint32 image_ID, GimpChannelType component, gboolean active); gboolean gimp_image_get_component_visible (gint32 image_ID, GimpChannelType component); -void gimp_image_set_component_visible (gint32 image_ID, +gboolean gimp_image_set_component_visible (gint32 image_ID, GimpChannelType component, gboolean visible); gchar* gimp_image_get_filename (gint32 image_ID); -void gimp_image_set_filename (gint32 image_ID, +gboolean gimp_image_set_filename (gint32 image_ID, gchar *filename); -void gimp_image_get_resolution (gint32 image_ID, +gboolean gimp_image_get_resolution (gint32 image_ID, gdouble *xresolution, gdouble *yresolution); -void gimp_image_set_resolution (gint32 image_ID, +gboolean gimp_image_set_resolution (gint32 image_ID, gdouble xresolution, gdouble yresolution); GimpUnit gimp_image_get_unit (gint32 image_ID); -void gimp_image_set_unit (gint32 image_ID, +gboolean gimp_image_set_unit (gint32 image_ID, GimpUnit unit); gint32 gimp_image_get_layer_by_tattoo (gint32 image_ID, gint tattoo); diff --git a/libgimp/gimplayer_pdb.c b/libgimp/gimplayer_pdb.c index 55efd97f14..a93b9eecb8 100644 --- a/libgimp/gimplayer_pdb.c +++ b/libgimp/gimplayer_pdb.c @@ -99,7 +99,7 @@ gimp_layer_create_mask (gint32 layer_ID, return mask_ID; } -void +gboolean gimp_layer_scale (gint32 layer_ID, gint new_width, gint new_height, @@ -107,6 +107,7 @@ gimp_layer_scale (gint32 layer_ID, { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_layer_scale", &nreturn_vals, @@ -116,10 +117,14 @@ gimp_layer_scale (gint32 layer_ID, GIMP_PDB_INT32, local_origin, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_layer_resize (gint32 layer_ID, gint new_width, gint new_height, @@ -128,6 +133,7 @@ gimp_layer_resize (gint32 layer_ID, { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_layer_resize", &nreturn_vals, @@ -138,30 +144,40 @@ gimp_layer_resize (gint32 layer_ID, GIMP_PDB_INT32, offy, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_layer_delete (gint32 layer_ID) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_layer_delete", &nreturn_vals, GIMP_PDB_LAYER, layer_ID, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_layer_translate (gint32 layer_ID, gint offx, gint offy) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_layer_translate", &nreturn_vals, @@ -170,30 +186,40 @@ gimp_layer_translate (gint32 layer_ID, GIMP_PDB_INT32, offy, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_layer_add_alpha (gint32 layer_ID) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_layer_add_alpha", &nreturn_vals, GIMP_PDB_LAYER, layer_ID, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_layer_set_offsets (gint32 layer_ID, gint offx, gint offy) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_layer_set_offsets", &nreturn_vals, @@ -202,7 +228,11 @@ gimp_layer_set_offsets (gint32 layer_ID, GIMP_PDB_INT32, offy, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } gint32 @@ -265,12 +295,13 @@ gimp_layer_get_name (gint32 layer_ID) return name; } -void +gboolean gimp_layer_set_name (gint32 layer_ID, gchar *name) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_layer_set_name", &nreturn_vals, @@ -278,7 +309,11 @@ gimp_layer_set_name (gint32 layer_ID, GIMP_PDB_STRING, name, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } gboolean @@ -301,12 +336,13 @@ gimp_layer_get_visible (gint32 layer_ID) return visible; } -void +gboolean gimp_layer_set_visible (gint32 layer_ID, gboolean visible) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_layer_set_visible", &nreturn_vals, @@ -314,7 +350,11 @@ gimp_layer_set_visible (gint32 layer_ID, GIMP_PDB_INT32, visible, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } gboolean @@ -337,12 +377,13 @@ gimp_layer_get_preserve_trans (gint32 layer_ID) return preserve_trans; } -void +gboolean gimp_layer_set_preserve_trans (gint32 layer_ID, gboolean preserve_trans) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_layer_set_preserve_trans", &nreturn_vals, @@ -350,7 +391,11 @@ gimp_layer_set_preserve_trans (gint32 layer_ID, GIMP_PDB_INT32, preserve_trans, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } gboolean @@ -373,12 +418,13 @@ gimp_layer_get_apply_mask (gint32 layer_ID) return apply_mask; } -void +gboolean gimp_layer_set_apply_mask (gint32 layer_ID, gboolean apply_mask) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_layer_set_apply_mask", &nreturn_vals, @@ -386,7 +432,11 @@ gimp_layer_set_apply_mask (gint32 layer_ID, GIMP_PDB_INT32, apply_mask, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } gboolean @@ -409,12 +459,13 @@ gimp_layer_get_show_mask (gint32 layer_ID) return show_mask; } -void +gboolean gimp_layer_set_show_mask (gint32 layer_ID, gboolean show_mask) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_layer_set_show_mask", &nreturn_vals, @@ -422,7 +473,11 @@ gimp_layer_set_show_mask (gint32 layer_ID, GIMP_PDB_INT32, show_mask, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } gboolean @@ -445,12 +500,13 @@ gimp_layer_get_edit_mask (gint32 layer_ID) return edit_mask; } -void +gboolean gimp_layer_set_edit_mask (gint32 layer_ID, gboolean edit_mask) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_layer_set_edit_mask", &nreturn_vals, @@ -458,7 +514,11 @@ gimp_layer_set_edit_mask (gint32 layer_ID, GIMP_PDB_INT32, edit_mask, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } gdouble @@ -481,12 +541,13 @@ gimp_layer_get_opacity (gint32 layer_ID) return opacity; } -void +gboolean gimp_layer_set_opacity (gint32 layer_ID, gdouble opacity) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_layer_set_opacity", &nreturn_vals, @@ -494,7 +555,11 @@ gimp_layer_set_opacity (gint32 layer_ID, GIMP_PDB_FLOAT, opacity, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } GimpLayerModeEffects @@ -517,12 +582,13 @@ gimp_layer_get_mode (gint32 layer_ID) return mode; } -void +gboolean gimp_layer_set_mode (gint32 layer_ID, GimpLayerModeEffects mode) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_layer_set_mode", &nreturn_vals, @@ -530,7 +596,11 @@ gimp_layer_set_mode (gint32 layer_ID, GIMP_PDB_INT32, mode, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } gboolean @@ -553,12 +623,13 @@ gimp_layer_get_linked (gint32 layer_ID) return linked; } -void +gboolean gimp_layer_set_linked (gint32 layer_ID, gboolean linked) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_layer_set_linked", &nreturn_vals, @@ -566,7 +637,11 @@ gimp_layer_set_linked (gint32 layer_ID, GIMP_PDB_INT32, linked, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } gint @@ -589,12 +664,13 @@ gimp_layer_get_tattoo (gint32 layer_ID) return tattoo; } -void +gboolean gimp_layer_set_tattoo (gint32 layer_ID, gint tattoo) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_layer_set_tattoo", &nreturn_vals, @@ -602,5 +678,9 @@ gimp_layer_set_tattoo (gint32 layer_ID, GIMP_PDB_INT32, tattoo, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } diff --git a/libgimp/gimplayer_pdb.h b/libgimp/gimplayer_pdb.h index 1bf96a3a18..a6652c198e 100644 --- a/libgimp/gimplayer_pdb.h +++ b/libgimp/gimplayer_pdb.h @@ -42,54 +42,54 @@ gint32 _gimp_layer_copy (gint32 layer_ gboolean add_alpha); gint32 gimp_layer_create_mask (gint32 layer_ID, GimpAddMaskType mask_type); -void gimp_layer_scale (gint32 layer_ID, +gboolean gimp_layer_scale (gint32 layer_ID, gint new_width, gint new_height, gboolean local_origin); -void gimp_layer_resize (gint32 layer_ID, +gboolean gimp_layer_resize (gint32 layer_ID, gint new_width, gint new_height, gint offx, gint offy); -void gimp_layer_delete (gint32 layer_ID); -void gimp_layer_translate (gint32 layer_ID, +gboolean gimp_layer_delete (gint32 layer_ID); +gboolean gimp_layer_translate (gint32 layer_ID, gint offx, gint offy); -void gimp_layer_add_alpha (gint32 layer_ID); -void gimp_layer_set_offsets (gint32 layer_ID, +gboolean gimp_layer_add_alpha (gint32 layer_ID); +gboolean gimp_layer_set_offsets (gint32 layer_ID, gint offx, gint offy); gint32 gimp_layer_mask (gint32 layer_ID); gboolean gimp_layer_is_floating_sel (gint32 layer_ID); gchar* gimp_layer_get_name (gint32 layer_ID); -void gimp_layer_set_name (gint32 layer_ID, +gboolean gimp_layer_set_name (gint32 layer_ID, gchar *name); gboolean gimp_layer_get_visible (gint32 layer_ID); -void gimp_layer_set_visible (gint32 layer_ID, +gboolean gimp_layer_set_visible (gint32 layer_ID, gboolean visible); gboolean gimp_layer_get_preserve_trans (gint32 layer_ID); -void gimp_layer_set_preserve_trans (gint32 layer_ID, +gboolean gimp_layer_set_preserve_trans (gint32 layer_ID, gboolean preserve_trans); gboolean gimp_layer_get_apply_mask (gint32 layer_ID); -void gimp_layer_set_apply_mask (gint32 layer_ID, +gboolean gimp_layer_set_apply_mask (gint32 layer_ID, gboolean apply_mask); gboolean gimp_layer_get_show_mask (gint32 layer_ID); -void gimp_layer_set_show_mask (gint32 layer_ID, +gboolean gimp_layer_set_show_mask (gint32 layer_ID, gboolean show_mask); gboolean gimp_layer_get_edit_mask (gint32 layer_ID); -void gimp_layer_set_edit_mask (gint32 layer_ID, +gboolean gimp_layer_set_edit_mask (gint32 layer_ID, gboolean edit_mask); gdouble gimp_layer_get_opacity (gint32 layer_ID); -void gimp_layer_set_opacity (gint32 layer_ID, +gboolean gimp_layer_set_opacity (gint32 layer_ID, gdouble opacity); GimpLayerModeEffects gimp_layer_get_mode (gint32 layer_ID); -void gimp_layer_set_mode (gint32 layer_ID, +gboolean gimp_layer_set_mode (gint32 layer_ID, GimpLayerModeEffects mode); gboolean gimp_layer_get_linked (gint32 layer_ID); -void gimp_layer_set_linked (gint32 layer_ID, +gboolean gimp_layer_set_linked (gint32 layer_ID, gboolean linked); gint gimp_layer_get_tattoo (gint32 layer_ID); -void gimp_layer_set_tattoo (gint32 layer_ID, +gboolean gimp_layer_set_tattoo (gint32 layer_ID, gint tattoo); diff --git a/libgimp/gimpmessage_pdb.c b/libgimp/gimpmessage_pdb.c index 16a619a747..039d68023d 100644 --- a/libgimp/gimpmessage_pdb.c +++ b/libgimp/gimpmessage_pdb.c @@ -23,18 +23,23 @@ #include "gimp.h" -void +gboolean gimp_message (gchar *message) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_message", &nreturn_vals, GIMP_PDB_STRING, message, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } GimpMessageHandlerType @@ -56,16 +61,21 @@ gimp_message_get_handler (void) return handler; } -void +gboolean gimp_message_set_handler (GimpMessageHandlerType handler) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_message_set_handler", &nreturn_vals, GIMP_PDB_INT32, handler, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } diff --git a/libgimp/gimpmessage_pdb.h b/libgimp/gimpmessage_pdb.h index a1b055cb3e..c90a5e2d7e 100644 --- a/libgimp/gimpmessage_pdb.h +++ b/libgimp/gimpmessage_pdb.h @@ -31,9 +31,9 @@ extern "C" { /* For information look into the C source or the html documentation */ -void gimp_message (gchar *message); +gboolean gimp_message (gchar *message); GimpMessageHandlerType gimp_message_get_handler (void); -void gimp_message_set_handler (GimpMessageHandlerType handler); +gboolean gimp_message_set_handler (GimpMessageHandlerType handler); #ifdef __cplusplus diff --git a/libgimp/gimppalette_pdb.c b/libgimp/gimppalette_pdb.c index e106c395f9..d947d50e17 100644 --- a/libgimp/gimppalette_pdb.c +++ b/libgimp/gimppalette_pdb.c @@ -23,19 +23,22 @@ #include "gimp.h" -void +gboolean gimp_palette_get_foreground (guchar *red, guchar *green, guchar *blue) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_palette_get_foreground", &nreturn_vals, GIMP_PDB_END); - if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + + if (success) { *red = return_vals[1].data.d_color.red; *green = return_vals[1].data.d_color.green; @@ -43,21 +46,26 @@ gimp_palette_get_foreground (guchar *red, } gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_palette_get_background (guchar *red, guchar *green, guchar *blue) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_palette_get_background", &nreturn_vals, GIMP_PDB_END); - if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + + if (success) { *red = return_vals[1].data.d_color.red; *green = return_vals[1].data.d_color.green; @@ -65,15 +73,18 @@ gimp_palette_get_background (guchar *red, } gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_palette_set_foreground (guchar red, guchar green, guchar blue) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; guchar foreground[3]; foreground[0] = red; @@ -85,16 +96,21 @@ gimp_palette_set_foreground (guchar red, GIMP_PDB_COLOR, foreground, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_palette_set_background (guchar red, guchar green, guchar blue) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; guchar background[3]; background[0] = red; @@ -106,44 +122,63 @@ gimp_palette_set_background (guchar red, GIMP_PDB_COLOR, background, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_palette_set_default_colors (void) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_palette_set_default_colors", &nreturn_vals, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_palette_swap_colors (void) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_palette_swap_colors", &nreturn_vals, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_palette_refresh (void) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_palette_refresh", &nreturn_vals, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } diff --git a/libgimp/gimppalette_pdb.h b/libgimp/gimppalette_pdb.h index 0b8e217438..f26454bd4b 100644 --- a/libgimp/gimppalette_pdb.h +++ b/libgimp/gimppalette_pdb.h @@ -31,21 +31,21 @@ extern "C" { /* For information look into the C source or the html documentation */ -void gimp_palette_get_foreground (guchar *red, - guchar *green, - guchar *blue); -void gimp_palette_get_background (guchar *red, - guchar *green, - guchar *blue); -void gimp_palette_set_foreground (guchar red, - guchar green, - guchar blue); -void gimp_palette_set_background (guchar red, - guchar green, - guchar blue); -void gimp_palette_set_default_colors (void); -void gimp_palette_swap_colors (void); -void gimp_palette_refresh (void); +gboolean gimp_palette_get_foreground (guchar *red, + guchar *green, + guchar *blue); +gboolean gimp_palette_get_background (guchar *red, + guchar *green, + guchar *blue); +gboolean gimp_palette_set_foreground (guchar red, + guchar green, + guchar blue); +gboolean gimp_palette_set_background (guchar red, + guchar green, + guchar blue); +gboolean gimp_palette_set_default_colors (void); +gboolean gimp_palette_swap_colors (void); +gboolean gimp_palette_refresh (void); #ifdef __cplusplus diff --git a/libgimp/gimpparasite_pdb.c b/libgimp/gimpparasite_pdb.c index 11fe67d62a..1e4432c121 100644 --- a/libgimp/gimpparasite_pdb.c +++ b/libgimp/gimpparasite_pdb.c @@ -43,40 +43,51 @@ gimp_parasite_find (gchar *name) return parasite; } -void +gboolean gimp_parasite_attach (GimpParasite *parasite) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_parasite_attach", &nreturn_vals, GIMP_PDB_PARASITE, parasite, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_parasite_detach (gchar *name) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_parasite_detach", &nreturn_vals, GIMP_PDB_STRING, name, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_parasite_list (gint *num_parasites, gchar ***parasites) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; gint i; return_vals = gimp_run_procedure ("gimp_parasite_list", @@ -86,7 +97,9 @@ gimp_parasite_list (gint *num_parasites, *num_parasites = 0; *parasites = NULL; - if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + + if (success) { *num_parasites = return_vals[1].data.d_int32; *parasites = g_new (gchar *, *num_parasites); @@ -95,6 +108,8 @@ gimp_parasite_list (gint *num_parasites, } gimp_destroy_params (return_vals, nreturn_vals); + + return success; } GimpParasite * @@ -119,12 +134,13 @@ gimp_drawable_parasite_find (gint32 drawable_ID, return parasite; } -void +gboolean gimp_drawable_parasite_attach (gint32 drawable_ID, GimpParasite *parasite) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_drawable_parasite_attach", &nreturn_vals, @@ -132,15 +148,20 @@ gimp_drawable_parasite_attach (gint32 drawable_ID, GIMP_PDB_PARASITE, parasite, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_drawable_parasite_detach (gint32 drawable_ID, gchar *name) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_drawable_parasite_detach", &nreturn_vals, @@ -148,16 +169,21 @@ gimp_drawable_parasite_detach (gint32 drawable_ID, GIMP_PDB_STRING, name, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_drawable_parasite_list (gint32 drawable_ID, gint *num_parasites, gchar ***parasites) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; gint i; return_vals = gimp_run_procedure ("gimp_drawable_parasite_list", @@ -168,7 +194,9 @@ gimp_drawable_parasite_list (gint32 drawable_ID, *num_parasites = 0; *parasites = NULL; - if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + + if (success) { *num_parasites = return_vals[1].data.d_int32; *parasites = g_new (gchar *, *num_parasites); @@ -177,6 +205,8 @@ gimp_drawable_parasite_list (gint32 drawable_ID, } gimp_destroy_params (return_vals, nreturn_vals); + + return success; } GimpParasite * @@ -201,12 +231,13 @@ gimp_image_parasite_find (gint32 image_ID, return parasite; } -void +gboolean gimp_image_parasite_attach (gint32 image_ID, GimpParasite *parasite) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_image_parasite_attach", &nreturn_vals, @@ -214,15 +245,20 @@ gimp_image_parasite_attach (gint32 image_ID, GIMP_PDB_PARASITE, parasite, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_image_parasite_detach (gint32 image_ID, gchar *name) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_image_parasite_detach", &nreturn_vals, @@ -230,16 +266,21 @@ gimp_image_parasite_detach (gint32 image_ID, GIMP_PDB_STRING, name, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_image_parasite_list (gint32 image_ID, gint *num_parasites, gchar ***parasites) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; gint i; return_vals = gimp_run_procedure ("gimp_image_parasite_list", @@ -250,7 +291,9 @@ gimp_image_parasite_list (gint32 image_ID, *num_parasites = 0; *parasites = NULL; - if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + + if (success) { *num_parasites = return_vals[1].data.d_int32; *parasites = g_new (gchar *, *num_parasites); @@ -259,4 +302,6 @@ gimp_image_parasite_list (gint32 image_ID, } gimp_destroy_params (return_vals, nreturn_vals); + + return success; } diff --git a/libgimp/gimpparasite_pdb.h b/libgimp/gimpparasite_pdb.h index daf4181b7a..4e0c2cd9ee 100644 --- a/libgimp/gimpparasite_pdb.h +++ b/libgimp/gimpparasite_pdb.h @@ -32,26 +32,26 @@ extern "C" { GimpParasite* gimp_parasite_find (gchar *name); -void gimp_parasite_attach (GimpParasite *parasite); -void gimp_parasite_detach (gchar *name); -void gimp_parasite_list (gint *num_parasites, +gboolean gimp_parasite_attach (GimpParasite *parasite); +gboolean gimp_parasite_detach (gchar *name); +gboolean gimp_parasite_list (gint *num_parasites, gchar ***parasites); GimpParasite* gimp_drawable_parasite_find (gint32 drawable_ID, gchar *name); -void gimp_drawable_parasite_attach (gint32 drawable_ID, +gboolean gimp_drawable_parasite_attach (gint32 drawable_ID, GimpParasite *parasite); -void gimp_drawable_parasite_detach (gint32 drawable_ID, +gboolean gimp_drawable_parasite_detach (gint32 drawable_ID, gchar *name); -void gimp_drawable_parasite_list (gint32 drawable_ID, +gboolean gimp_drawable_parasite_list (gint32 drawable_ID, gint *num_parasites, gchar ***parasites); GimpParasite* gimp_image_parasite_find (gint32 image_ID, gchar *name); -void gimp_image_parasite_attach (gint32 image_ID, +gboolean gimp_image_parasite_attach (gint32 image_ID, GimpParasite *parasite); -void gimp_image_parasite_detach (gint32 image_ID, +gboolean gimp_image_parasite_detach (gint32 image_ID, gchar *name); -void gimp_image_parasite_list (gint32 image_ID, +gboolean gimp_image_parasite_list (gint32 image_ID, gint *num_parasites, gchar ***parasites); diff --git a/libgimp/gimppaths_pdb.c b/libgimp/gimppaths_pdb.c index 6c2036ab7b..7e3dfc5bbf 100644 --- a/libgimp/gimppaths_pdb.c +++ b/libgimp/gimppaths_pdb.c @@ -106,12 +106,13 @@ gimp_path_get_current (gint32 image_ID) return current_path_name; } -void +gboolean gimp_path_set_current (gint32 image_ID, gchar *set_current_path_name) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_path_set_current", &nreturn_vals, @@ -119,10 +120,14 @@ gimp_path_set_current (gint32 image_ID, GIMP_PDB_STRING, set_current_path_name, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_path_set_points (gint32 image_ID, gchar *pathname, gint ptype, @@ -131,6 +136,7 @@ gimp_path_set_points (gint32 image_ID, { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_path_set_points", &nreturn_vals, @@ -141,21 +147,30 @@ gimp_path_set_points (gint32 image_ID, GIMP_PDB_FLOATARRAY, points_pairs, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_path_stroke_current (gint32 image_ID) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_path_stroke_current", &nreturn_vals, GIMP_PDB_IMAGE, image_ID, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } gint @@ -230,12 +245,13 @@ gimp_get_path_by_tattoo (gint32 image_ID, return path_name; } -void +gboolean gimp_path_delete (gint32 image_ID, gchar *path_name_to_del) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_path_delete", &nreturn_vals, @@ -243,7 +259,11 @@ gimp_path_delete (gint32 image_ID, GIMP_PDB_STRING, path_name_to_del, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } gint @@ -268,13 +288,14 @@ gimp_path_get_locked (gint32 image_ID, return lockstatus; } -void +gboolean gimp_path_set_locked (gint32 image_ID, gchar *pathname, gint lockstatus) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_path_set_locked", &nreturn_vals, @@ -283,16 +304,21 @@ gimp_path_set_locked (gint32 image_ID, GIMP_PDB_INT32, lockstatus, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_path_set_tattoo (gint32 image_ID, gchar *pathname, gint tattovalue) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_path_set_tattoo", &nreturn_vals, @@ -301,5 +327,9 @@ gimp_path_set_tattoo (gint32 image_ID, GIMP_PDB_INT32, tattovalue, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } diff --git a/libgimp/gimppaths_pdb.h b/libgimp/gimppaths_pdb.h index ff9261e7dc..319e7a46ff 100644 --- a/libgimp/gimppaths_pdb.h +++ b/libgimp/gimppaths_pdb.h @@ -31,40 +31,40 @@ extern "C" { /* For information look into the C source or the html documentation */ -gchar** gimp_path_list (gint32 image_ID, - gint *num_paths); -gint gimp_path_get_points (gint32 image_ID, - gchar *pathname, - gint *path_closed, - gint *num_path_point_details, - gdouble **points_pairs); -gchar* gimp_path_get_current (gint32 image_ID); -void gimp_path_set_current (gint32 image_ID, - gchar *set_current_path_name); -void gimp_path_set_points (gint32 image_ID, - gchar *pathname, - gint ptype, - gint num_path_points, - gdouble *points_pairs); -void gimp_path_stroke_current (gint32 image_ID); -gint gimp_path_get_point_at_dist (gint32 image_ID, - gdouble distance, - gint *y_point, - gdouble *gradient); -gint gimp_path_get_tattoo (gint32 image_ID, - gchar *pathname); -gchar* gimp_get_path_by_tattoo (gint32 image_ID, - gint tattoo); -void gimp_path_delete (gint32 image_ID, - gchar *path_name_to_del); -gint gimp_path_get_locked (gint32 image_ID, - gchar *pathname); -void gimp_path_set_locked (gint32 image_ID, - gchar *pathname, - gint lockstatus); -void gimp_path_set_tattoo (gint32 image_ID, - gchar *pathname, - gint tattovalue); +gchar** gimp_path_list (gint32 image_ID, + gint *num_paths); +gint gimp_path_get_points (gint32 image_ID, + gchar *pathname, + gint *path_closed, + gint *num_path_point_details, + gdouble **points_pairs); +gchar* gimp_path_get_current (gint32 image_ID); +gboolean gimp_path_set_current (gint32 image_ID, + gchar *set_current_path_name); +gboolean gimp_path_set_points (gint32 image_ID, + gchar *pathname, + gint ptype, + gint num_path_points, + gdouble *points_pairs); +gboolean gimp_path_stroke_current (gint32 image_ID); +gint gimp_path_get_point_at_dist (gint32 image_ID, + gdouble distance, + gint *y_point, + gdouble *gradient); +gint gimp_path_get_tattoo (gint32 image_ID, + gchar *pathname); +gchar* gimp_get_path_by_tattoo (gint32 image_ID, + gint tattoo); +gboolean gimp_path_delete (gint32 image_ID, + gchar *path_name_to_del); +gint gimp_path_get_locked (gint32 image_ID, + gchar *pathname); +gboolean gimp_path_set_locked (gint32 image_ID, + gchar *pathname, + gint lockstatus); +gboolean gimp_path_set_tattoo (gint32 image_ID, + gchar *pathname, + gint tattovalue); #ifdef __cplusplus diff --git a/libgimp/gimppatternselect_pdb.c b/libgimp/gimppatternselect_pdb.c index 153fa93d23..6308a58206 100644 --- a/libgimp/gimppatternselect_pdb.c +++ b/libgimp/gimppatternselect_pdb.c @@ -23,13 +23,14 @@ #include "gimp.h" -void +gboolean gimp_patterns_popup (gchar *pattern_callback, gchar *popup_title, gchar *initial_pattern) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_patterns_popup", &nreturn_vals, @@ -38,29 +39,39 @@ gimp_patterns_popup (gchar *pattern_callback, GIMP_PDB_STRING, initial_pattern, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_patterns_close_popup (gchar *pattern_callback) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_patterns_close_popup", &nreturn_vals, GIMP_PDB_STRING, pattern_callback, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_patterns_set_popup (gchar *pattern_callback, gchar *pattern_name) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_patterns_set_popup", &nreturn_vals, @@ -68,5 +79,9 @@ gimp_patterns_set_popup (gchar *pattern_callback, GIMP_PDB_STRING, pattern_name, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } diff --git a/libgimp/gimppatternselect_pdb.h b/libgimp/gimppatternselect_pdb.h index 30b392fe73..6a8a4a2e22 100644 --- a/libgimp/gimppatternselect_pdb.h +++ b/libgimp/gimppatternselect_pdb.h @@ -31,12 +31,12 @@ extern "C" { /* For information look into the C source or the html documentation */ -void gimp_patterns_popup (gchar *pattern_callback, - gchar *popup_title, - gchar *initial_pattern); -void gimp_patterns_close_popup (gchar *pattern_callback); -void gimp_patterns_set_popup (gchar *pattern_callback, - gchar *pattern_name); +gboolean gimp_patterns_popup (gchar *pattern_callback, + gchar *popup_title, + gchar *initial_pattern); +gboolean gimp_patterns_close_popup (gchar *pattern_callback); +gboolean gimp_patterns_set_popup (gchar *pattern_callback, + gchar *pattern_name); #ifdef __cplusplus diff --git a/libgimp/gimpplugin_pdb.c b/libgimp/gimpplugin_pdb.c index 89b20956cc..eaa39a5b13 100644 --- a/libgimp/gimpplugin_pdb.c +++ b/libgimp/gimpplugin_pdb.c @@ -23,11 +23,12 @@ #include "gimp.h" -void +gboolean gimp_progress_init (gchar *message) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_progress_init", &nreturn_vals, @@ -35,21 +36,30 @@ gimp_progress_init (gchar *message) GIMP_PDB_INT32, gimp_default_display (), GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_progress_update (gdouble percentage) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_progress_update", &nreturn_vals, GIMP_PDB_FLOAT, percentage, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } gchar * @@ -71,12 +81,13 @@ gimp_temp_PDB_name (void) return temp_name; } -void +gboolean gimp_plugin_domain_register (gchar *domain_name, gchar *domain_path) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_plugin_domain_register", &nreturn_vals, @@ -84,19 +95,28 @@ gimp_plugin_domain_register (gchar *domain_name, GIMP_PDB_STRING, domain_path, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_plugin_help_register (gchar *help_path) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_plugin_help_register", &nreturn_vals, GIMP_PDB_STRING, help_path, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } diff --git a/libgimp/gimpplugin_pdb.h b/libgimp/gimpplugin_pdb.h index befe4f41f6..9c55e5004c 100644 --- a/libgimp/gimpplugin_pdb.h +++ b/libgimp/gimpplugin_pdb.h @@ -31,12 +31,12 @@ extern "C" { /* For information look into the C source or the html documentation */ -void gimp_progress_init (gchar *message); -void gimp_progress_update (gdouble percentage); -gchar* gimp_temp_PDB_name (void); -void gimp_plugin_domain_register (gchar *domain_name, - gchar *domain_path); -void gimp_plugin_help_register (gchar *help_path); +gboolean gimp_progress_init (gchar *message); +gboolean gimp_progress_update (gdouble percentage); +gchar* gimp_temp_PDB_name (void); +gboolean gimp_plugin_domain_register (gchar *domain_name, + gchar *domain_path); +gboolean gimp_plugin_help_register (gchar *help_path); #ifdef __cplusplus diff --git a/libgimp/gimpproceduraldb.c b/libgimp/gimpproceduraldb.c index 5d073ea73a..a132eee216 100644 --- a/libgimp/gimpproceduraldb.c +++ b/libgimp/gimpproceduraldb.c @@ -21,38 +21,6 @@ #include "gimp.h" -gboolean -gimp_procedural_db_proc_arg (gchar *procedure, - gint arg_num, - GimpPDBArgType *arg_type, - gchar **arg_name, - gchar **arg_desc) -{ - _gimp_procedural_db_proc_arg (procedure, - arg_num, - arg_type, - arg_name, - arg_desc); - - return (*arg_name != NULL); -} - -gboolean -gimp_procedural_db_proc_val (gchar *procedure, - gint val_num, - GimpPDBArgType *val_type, - gchar **val_name, - gchar **val_desc) -{ - _gimp_procedural_db_proc_val (procedure, - val_num, - val_type, - val_name, - val_desc); - - return (*val_name != NULL); -} - gboolean gimp_procedural_db_proc_info (gchar *procedure, gchar **blurb, @@ -69,17 +37,15 @@ gimp_procedural_db_proc_info (gchar *procedure, gint i; gboolean success = TRUE; - _gimp_procedural_db_proc_info (procedure, - blurb, - help, - author, - copyright, - date, - proc_type, - num_args, - num_values); - - success = (*blurb != NULL); + success = _gimp_procedural_db_proc_info (procedure, + blurb, + help, + author, + copyright, + date, + proc_type, + num_args, + num_values); if (success) { diff --git a/libgimp/gimpproceduraldb.h b/libgimp/gimpproceduraldb.h index 5a3abc6d26..8e46649437 100644 --- a/libgimp/gimpproceduraldb.h +++ b/libgimp/gimpproceduraldb.h @@ -28,16 +28,7 @@ extern "C" { /* For information look into the C source or the html documentation */ -gboolean gimp_procedural_db_proc_arg (gchar *procedure, - gint arg_num, - GimpPDBArgType *arg_type, - gchar **arg_name, - gchar **arg_desc); -gboolean gimp_procedural_db_proc_val (gchar *procedure, - gint val_num, - GimpPDBArgType *val_type, - gchar **val_name, - gchar **val_desc); + gboolean gimp_procedural_db_proc_info (gchar *procedure, gchar **blurb, gchar **help, diff --git a/libgimp/gimpproceduraldb_pdb.c b/libgimp/gimpproceduraldb_pdb.c index a668b6f5f3..ecbebc41da 100644 --- a/libgimp/gimpproceduraldb_pdb.c +++ b/libgimp/gimpproceduraldb_pdb.c @@ -23,21 +23,26 @@ #include "gimp.h" -void +gboolean gimp_procedural_db_dump (gchar *filename) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_procedural_db_dump", &nreturn_vals, GIMP_PDB_STRING, filename, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_procedural_db_query (gchar *name, gchar *blurb, gchar *help, @@ -50,6 +55,7 @@ gimp_procedural_db_query (gchar *name, { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; gint i; return_vals = gimp_run_procedure ("gimp_procedural_db_query", @@ -66,7 +72,9 @@ gimp_procedural_db_query (gchar *name, *num_matches = 0; *procedure_names = NULL; - if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + + if (success) { *num_matches = return_vals[1].data.d_int32; *procedure_names = g_new (gchar *, *num_matches); @@ -75,9 +83,11 @@ gimp_procedural_db_query (gchar *name, } gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean _gimp_procedural_db_proc_info (gchar *procedure, gchar **blurb, gchar **help, @@ -90,6 +100,7 @@ _gimp_procedural_db_proc_info (gchar *procedure, { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_procedural_db_proc_info", &nreturn_vals, @@ -105,7 +116,9 @@ _gimp_procedural_db_proc_info (gchar *procedure, *num_args = 0; *num_values = 0; - if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + + if (success) { *blurb = g_strdup (return_vals[1].data.d_string); *help = g_strdup (return_vals[2].data.d_string); @@ -118,17 +131,20 @@ _gimp_procedural_db_proc_info (gchar *procedure, } gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void -_gimp_procedural_db_proc_arg (gchar *procedure, - gint arg_num, - GimpPDBArgType *arg_type, - gchar **arg_name, - gchar **arg_desc) +gboolean +gimp_procedural_db_proc_arg (gchar *procedure, + 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, @@ -140,7 +156,9 @@ _gimp_procedural_db_proc_arg (gchar *procedure, *arg_name = NULL; *arg_desc = NULL; - if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + + if (success) { *arg_type = return_vals[1].data.d_int32; *arg_name = g_strdup (return_vals[2].data.d_string); @@ -148,17 +166,20 @@ _gimp_procedural_db_proc_arg (gchar *procedure, } gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void -_gimp_procedural_db_proc_val (gchar *procedure, - gint val_num, - GimpPDBArgType *val_type, - gchar **val_name, - gchar **val_desc) +gboolean +gimp_procedural_db_proc_val (gchar *procedure, + 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, @@ -170,7 +191,9 @@ _gimp_procedural_db_proc_val (gchar *procedure, *val_name = NULL; *val_desc = NULL; - if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + + if (success) { *val_type = return_vals[1].data.d_int32; *val_name = g_strdup (return_vals[2].data.d_string); @@ -178,15 +201,18 @@ _gimp_procedural_db_proc_val (gchar *procedure, } gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean _gimp_procedural_db_get_data (gchar *identifier, 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, @@ -196,7 +222,9 @@ _gimp_procedural_db_get_data (gchar *identifier, *bytes = 0; *data = NULL; - if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + + if (success) { *bytes = return_vals[1].data.d_int32; *data = g_new (guint8, *bytes); @@ -205,6 +233,8 @@ _gimp_procedural_db_get_data (gchar *identifier, } gimp_destroy_params (return_vals, nreturn_vals); + + return success; } gint @@ -227,13 +257,14 @@ gimp_procedural_db_get_data_size (gchar *identifier) return bytes; } -void +gboolean _gimp_procedural_db_set_data (gchar *identifier, gint bytes, guint8 *data) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_procedural_db_set_data", &nreturn_vals, @@ -242,5 +273,9 @@ _gimp_procedural_db_set_data (gchar *identifier, GIMP_PDB_INT8ARRAY, data, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } diff --git a/libgimp/gimpproceduraldb_pdb.h b/libgimp/gimpproceduraldb_pdb.h index 6a61e39389..541916b07c 100644 --- a/libgimp/gimpproceduraldb_pdb.h +++ b/libgimp/gimpproceduraldb_pdb.h @@ -31,42 +31,42 @@ extern "C" { /* For information look into the C source or the html documentation */ -void gimp_procedural_db_dump (gchar *filename); -void gimp_procedural_db_query (gchar *name, - gchar *blurb, - gchar *help, - gchar *author, - gchar *copyright, - gchar *date, - gchar *proc_type, - gint *num_matches, - gchar ***procedure_names); -void _gimp_procedural_db_proc_info (gchar *procedure, - gchar **blurb, - gchar **help, - gchar **author, - gchar **copyright, - gchar **date, - GimpPDBProcType *proc_type, - gint *num_args, - gint *num_values); -void _gimp_procedural_db_proc_arg (gchar *procedure, - gint arg_num, - GimpPDBArgType *arg_type, - gchar **arg_name, - gchar **arg_desc); -void _gimp_procedural_db_proc_val (gchar *procedure, - gint val_num, - GimpPDBArgType *val_type, - gchar **val_name, - gchar **val_desc); -void _gimp_procedural_db_get_data (gchar *identifier, - gint *bytes, - guint8 **data); -gint gimp_procedural_db_get_data_size (gchar *identifier); -void _gimp_procedural_db_set_data (gchar *identifier, - gint bytes, - guint8 *data); +gboolean gimp_procedural_db_dump (gchar *filename); +gboolean gimp_procedural_db_query (gchar *name, + gchar *blurb, + gchar *help, + gchar *author, + gchar *copyright, + gchar *date, + gchar *proc_type, + gint *num_matches, + gchar ***procedure_names); +gboolean _gimp_procedural_db_proc_info (gchar *procedure, + gchar **blurb, + gchar **help, + gchar **author, + gchar **copyright, + gchar **date, + GimpPDBProcType *proc_type, + gint *num_args, + gint *num_values); +gboolean gimp_procedural_db_proc_arg (gchar *procedure, + gint arg_num, + GimpPDBArgType *arg_type, + gchar **arg_name, + gchar **arg_desc); +gboolean gimp_procedural_db_proc_val (gchar *procedure, + gint val_num, + GimpPDBArgType *val_type, + gchar **val_name, + gchar **val_desc); +gboolean _gimp_procedural_db_get_data (gchar *identifier, + gint *bytes, + guint8 **data); +gint gimp_procedural_db_get_data_size (gchar *identifier); +gboolean _gimp_procedural_db_set_data (gchar *identifier, + gint bytes, + guint8 *data); #ifdef __cplusplus diff --git a/libgimp/gimpselection_pdb.c b/libgimp/gimpselection_pdb.c index 70ba6fce57..d539710066 100644 --- a/libgimp/gimpselection_pdb.c +++ b/libgimp/gimpselection_pdb.c @@ -23,7 +23,7 @@ #include "gimp.h" -void +gboolean gimp_selection_bounds (gint32 image_ID, gboolean *non_empty, gint *x1, @@ -33,6 +33,7 @@ gimp_selection_bounds (gint32 image_ID, { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_selection_bounds", &nreturn_vals, @@ -45,7 +46,9 @@ gimp_selection_bounds (gint32 image_ID, *x2 = 0; *y2 = 0; - if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + + if (success) { *non_empty = return_vals[1].data.d_int32; *x1 = return_vals[2].data.d_int32; @@ -55,6 +58,8 @@ gimp_selection_bounds (gint32 image_ID, } gimp_destroy_params (return_vals, nreturn_vals); + + return success; } gboolean @@ -101,16 +106,21 @@ _gimp_selection_float (gint32 drawable_ID, return layer_ID; } -void +gboolean gimp_selection_none (gint32 image_ID) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_selection_none", &nreturn_vals, GIMP_PDB_IMAGE, image_ID, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } diff --git a/libgimp/gimpselection_pdb.h b/libgimp/gimpselection_pdb.h index 29c6f35c2d..501966099a 100644 --- a/libgimp/gimpselection_pdb.h +++ b/libgimp/gimpselection_pdb.h @@ -31,7 +31,7 @@ extern "C" { /* For information look into the C source or the html documentation */ -void gimp_selection_bounds (gint32 image_ID, +gboolean gimp_selection_bounds (gint32 image_ID, gboolean *non_empty, gint *x1, gint *y1, @@ -41,7 +41,7 @@ gboolean gimp_selection_is_empty (gint32 image_ID); gint32 _gimp_selection_float (gint32 drawable_ID, gint offx, gint offy); -void gimp_selection_none (gint32 image_ID); +gboolean gimp_selection_none (gint32 image_ID); #ifdef __cplusplus diff --git a/libgimp/gimptexttool_pdb.c b/libgimp/gimptexttool_pdb.c index eb635a3cbc..dc1334355c 100644 --- a/libgimp/gimptexttool_pdb.c +++ b/libgimp/gimptexttool_pdb.c @@ -61,7 +61,7 @@ gimp_text_fontname (gint32 image_ID, return text_layer_ID; } -void +gboolean gimp_text_get_extents_fontname (gchar *text, gdouble size, GimpSizeType size_type, @@ -73,6 +73,7 @@ gimp_text_get_extents_fontname (gchar *text, { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_text_get_extents_fontname", &nreturn_vals, @@ -87,7 +88,9 @@ gimp_text_get_extents_fontname (gchar *text, *ascent = 0; *descent = 0; - if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + + if (success) { *width = return_vals[1].data.d_int32; *height = return_vals[2].data.d_int32; @@ -96,6 +99,8 @@ gimp_text_get_extents_fontname (gchar *text, } gimp_destroy_params (return_vals, nreturn_vals); + + return success; } gint32 @@ -150,7 +155,7 @@ gimp_text (gint32 image_ID, return text_layer_ID; } -void +gboolean gimp_text_get_extents (gchar *text, gdouble size, GimpSizeType size_type, @@ -169,6 +174,7 @@ gimp_text_get_extents (gchar *text, { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_text_get_extents", &nreturn_vals, @@ -190,7 +196,9 @@ gimp_text_get_extents (gchar *text, *ascent = 0; *descent = 0; - if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + + if (success) { *width = return_vals[1].data.d_int32; *height = return_vals[2].data.d_int32; @@ -199,4 +207,6 @@ gimp_text_get_extents (gchar *text, } gimp_destroy_params (return_vals, nreturn_vals); + + return success; } diff --git a/libgimp/gimptexttool_pdb.h b/libgimp/gimptexttool_pdb.h index 594e9cb42f..1fc1948b21 100644 --- a/libgimp/gimptexttool_pdb.h +++ b/libgimp/gimptexttool_pdb.h @@ -31,56 +31,56 @@ extern "C" { /* For information look into the C source or the html documentation */ -gint32 gimp_text_fontname (gint32 image_ID, - gint32 drawable_ID, - gdouble x, - gdouble y, - gchar *text, - gint border, - gboolean antialias, - gdouble size, - GimpSizeType size_type, - gchar *fontname); -void gimp_text_get_extents_fontname (gchar *text, - gdouble size, - GimpSizeType size_type, - gchar *fontname, - gint *width, - gint *height, - gint *ascent, - gint *descent); -gint32 gimp_text (gint32 image_ID, - gint32 drawable_ID, - gdouble x, - gdouble y, - gchar *text, - gint border, - gboolean antialias, - gdouble size, - GimpSizeType size_type, - gchar *foundry, - gchar *family, - gchar *weight, - gchar *slant, - gchar *set_width, - gchar *spacing, - gchar *registry, - gchar *encoding); -void gimp_text_get_extents (gchar *text, - gdouble size, - GimpSizeType size_type, - gchar *foundry, - gchar *family, - gchar *weight, - gchar *slant, - gchar *set_width, - gchar *spacing, - gchar *registry, - gchar *encoding, - gint *width, - gint *height, - gint *ascent, - gint *descent); +gint32 gimp_text_fontname (gint32 image_ID, + gint32 drawable_ID, + gdouble x, + gdouble y, + gchar *text, + gint border, + gboolean antialias, + gdouble size, + GimpSizeType size_type, + gchar *fontname); +gboolean gimp_text_get_extents_fontname (gchar *text, + gdouble size, + GimpSizeType size_type, + gchar *fontname, + gint *width, + gint *height, + gint *ascent, + gint *descent); +gint32 gimp_text (gint32 image_ID, + gint32 drawable_ID, + gdouble x, + gdouble y, + gchar *text, + gint border, + gboolean antialias, + gdouble size, + GimpSizeType size_type, + gchar *foundry, + gchar *family, + gchar *weight, + gchar *slant, + gchar *set_width, + gchar *spacing, + gchar *registry, + gchar *encoding); +gboolean gimp_text_get_extents (gchar *text, + gdouble size, + GimpSizeType size_type, + gchar *foundry, + gchar *family, + gchar *weight, + gchar *slant, + gchar *set_width, + gchar *spacing, + gchar *registry, + gchar *encoding, + gint *width, + gint *height, + gint *ascent, + gint *descent); #ifdef __cplusplus diff --git a/libgimp/gimptools_pdb.c b/libgimp/gimptools_pdb.c index aea6a9dc19..f8e13321f2 100644 --- a/libgimp/gimptools_pdb.c +++ b/libgimp/gimptools_pdb.c @@ -23,7 +23,7 @@ #include "gimp.h" -void +gboolean gimp_airbrush (gint32 drawable_ID, gdouble pressure, gint num_strokes, @@ -31,6 +31,7 @@ gimp_airbrush (gint32 drawable_ID, { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_airbrush", &nreturn_vals, @@ -40,16 +41,21 @@ gimp_airbrush (gint32 drawable_ID, GIMP_PDB_FLOATARRAY, strokes, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_airbrush_default (gint32 drawable_ID, gint num_strokes, gdouble *strokes) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_airbrush_default", &nreturn_vals, @@ -58,10 +64,14 @@ gimp_airbrush_default (gint32 drawable_ID, GIMP_PDB_FLOATARRAY, strokes, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_blend (gint32 drawable_ID, GimpBlendMode blend_mode, GimpLayerModeEffects paint_mode, @@ -79,6 +89,7 @@ gimp_blend (gint32 drawable_ID, { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_blend", &nreturn_vals, @@ -98,10 +109,14 @@ gimp_blend (gint32 drawable_ID, GIMP_PDB_FLOAT, y2, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_bucket_fill (gint32 drawable_ID, GimpBucketFillMode fill_mode, GimpLayerModeEffects paint_mode, @@ -113,6 +128,7 @@ gimp_bucket_fill (gint32 drawable_ID, { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_bucket_fill", &nreturn_vals, @@ -126,10 +142,14 @@ gimp_bucket_fill (gint32 drawable_ID, GIMP_PDB_FLOAT, y, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_by_color_select (gint32 drawable_ID, guchar red, guchar green, @@ -143,6 +163,7 @@ gimp_by_color_select (gint32 drawable_ID, { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; guchar color[3]; color[0] = red; @@ -161,10 +182,14 @@ gimp_by_color_select (gint32 drawable_ID, GIMP_PDB_INT32, sample_merged, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_clone (gint32 drawable_ID, gint32 src_drawable_ID, GimpCloneType clone_type, @@ -175,6 +200,7 @@ gimp_clone (gint32 drawable_ID, { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_clone", &nreturn_vals, @@ -187,16 +213,21 @@ gimp_clone (gint32 drawable_ID, GIMP_PDB_FLOATARRAY, strokes, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_clone_default (gint32 drawable_ID, gint num_strokes, gdouble *strokes) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_clone_default", &nreturn_vals, @@ -205,10 +236,14 @@ gimp_clone_default (gint32 drawable_ID, GIMP_PDB_FLOATARRAY, strokes, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_color_picker (gint32 image_ID, gint32 drawable_ID, gdouble x, @@ -223,6 +258,7 @@ gimp_color_picker (gint32 image_ID, { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_color_picker", &nreturn_vals, @@ -236,7 +272,9 @@ gimp_color_picker (gint32 image_ID, GIMP_PDB_INT32, save_color, GIMP_PDB_END); - if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + + if (success) { *red = return_vals[1].data.d_color.red; *green = return_vals[1].data.d_color.green; @@ -244,9 +282,11 @@ gimp_color_picker (gint32 image_ID, } gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_convolve (gint32 drawable_ID, gdouble pressure, GimpConvolveType convolve_type, @@ -255,6 +295,7 @@ gimp_convolve (gint32 drawable_ID, { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_convolve", &nreturn_vals, @@ -265,16 +306,21 @@ gimp_convolve (gint32 drawable_ID, GIMP_PDB_FLOATARRAY, strokes, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_convolve_default (gint32 drawable_ID, gint num_strokes, gdouble *strokes) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_convolve_default", &nreturn_vals, @@ -283,10 +329,14 @@ gimp_convolve_default (gint32 drawable_ID, GIMP_PDB_FLOATARRAY, strokes, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_crop (gint32 image_ID, gint new_width, gint new_height, @@ -295,6 +345,7 @@ gimp_crop (gint32 image_ID, { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_crop", &nreturn_vals, @@ -305,10 +356,14 @@ gimp_crop (gint32 image_ID, GIMP_PDB_INT32, offy, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_dodgeburn (gint32 drawable_ID, gdouble exposure, GimpDodgeBurnType dodgeburn_type, @@ -318,6 +373,7 @@ gimp_dodgeburn (gint32 drawable_ID, { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_dodgeburn", &nreturn_vals, @@ -329,16 +385,21 @@ gimp_dodgeburn (gint32 drawable_ID, GIMP_PDB_FLOATARRAY, strokes, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_dodgeburn_default (gint32 drawable_ID, gint num_strokes, gdouble *strokes) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_dodgeburn_default", &nreturn_vals, @@ -347,10 +408,14 @@ gimp_dodgeburn_default (gint32 drawable_ID, GIMP_PDB_FLOATARRAY, strokes, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_ellipse_select (gint32 image_ID, gdouble x, gdouble y, @@ -363,6 +428,7 @@ gimp_ellipse_select (gint32 image_ID, { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_ellipse_select", &nreturn_vals, @@ -377,10 +443,14 @@ gimp_ellipse_select (gint32 image_ID, GIMP_PDB_FLOAT, feather_radius, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_eraser (gint32 drawable_ID, gint num_strokes, gdouble *strokes, @@ -389,6 +459,7 @@ gimp_eraser (gint32 drawable_ID, { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_eraser", &nreturn_vals, @@ -399,16 +470,21 @@ gimp_eraser (gint32 drawable_ID, GIMP_PDB_INT32, method, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_eraser_default (gint32 drawable_ID, gint num_strokes, gdouble *strokes) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_eraser_default", &nreturn_vals, @@ -417,7 +493,11 @@ gimp_eraser_default (gint32 drawable_ID, GIMP_PDB_FLOATARRAY, strokes, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } gint32 @@ -442,7 +522,7 @@ gimp_flip (gint32 drawable_ID, return ret_drawable_ID; } -void +gboolean gimp_free_select (gint32 image_ID, gint num_segs, gdouble *segs, @@ -453,6 +533,7 @@ gimp_free_select (gint32 image_ID, { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_free_select", &nreturn_vals, @@ -465,10 +546,14 @@ gimp_free_select (gint32 image_ID, GIMP_PDB_FLOAT, feather_radius, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_fuzzy_select (gint32 drawable_ID, gdouble x, gdouble y, @@ -481,6 +566,7 @@ gimp_fuzzy_select (gint32 drawable_ID, { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_fuzzy_select", &nreturn_vals, @@ -495,10 +581,14 @@ gimp_fuzzy_select (gint32 drawable_ID, GIMP_PDB_INT32, sample_merged, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_paintbrush (gint32 drawable_ID, gdouble fade_out, gint num_strokes, @@ -508,6 +598,7 @@ gimp_paintbrush (gint32 drawable_ID, { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_paintbrush", &nreturn_vals, @@ -519,16 +610,21 @@ gimp_paintbrush (gint32 drawable_ID, GIMP_PDB_FLOAT, gradient_length, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_paintbrush_default (gint32 drawable_ID, gint num_strokes, gdouble *strokes) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_paintbrush_default", &nreturn_vals, @@ -537,16 +633,21 @@ gimp_paintbrush_default (gint32 drawable_ID, GIMP_PDB_FLOATARRAY, strokes, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_pencil (gint32 drawable_ID, gint num_strokes, gdouble *strokes) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_pencil", &nreturn_vals, @@ -555,7 +656,11 @@ gimp_pencil (gint32 drawable_ID, GIMP_PDB_FLOATARRAY, strokes, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } gint32 @@ -596,7 +701,7 @@ gimp_perspective (gint32 drawable_ID, return ret_drawable_ID; } -void +gboolean gimp_rect_select (gint32 image_ID, gdouble x, gdouble y, @@ -608,6 +713,7 @@ gimp_rect_select (gint32 image_ID, { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_rect_select", &nreturn_vals, @@ -621,7 +727,11 @@ gimp_rect_select (gint32 image_ID, GIMP_PDB_FLOAT, feather_radius, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } gint32 @@ -704,7 +814,7 @@ gimp_shear (gint32 drawable_ID, return ret_drawable_ID; } -void +gboolean gimp_smudge (gint32 drawable_ID, gdouble pressure, gint num_strokes, @@ -712,6 +822,7 @@ gimp_smudge (gint32 drawable_ID, { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_smudge", &nreturn_vals, @@ -721,16 +832,21 @@ gimp_smudge (gint32 drawable_ID, GIMP_PDB_FLOATARRAY, strokes, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_smudge_default (gint32 drawable_ID, gint num_strokes, gdouble *strokes) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_smudge_default", &nreturn_vals, @@ -739,7 +855,11 @@ gimp_smudge_default (gint32 drawable_ID, GIMP_PDB_FLOATARRAY, strokes, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } gint32 diff --git a/libgimp/gimptools_pdb.h b/libgimp/gimptools_pdb.h index a9aecd3444..8bf5c42805 100644 --- a/libgimp/gimptools_pdb.h +++ b/libgimp/gimptools_pdb.h @@ -31,182 +31,182 @@ extern "C" { /* For information look into the C source or the html documentation */ -void gimp_airbrush (gint32 drawable_ID, - gdouble pressure, - gint num_strokes, - gdouble *strokes); -void gimp_airbrush_default (gint32 drawable_ID, - gint num_strokes, - gdouble *strokes); -void gimp_blend (gint32 drawable_ID, - GimpBlendMode blend_mode, - GimpLayerModeEffects paint_mode, - GimpGradientType gradient_type, - gdouble opacity, - gdouble offset, - GimpRepeatMode repeat, - gboolean supersample, - gint max_depth, - gdouble threshold, - gdouble x1, - gdouble y1, - gdouble x2, - gdouble y2); -void gimp_bucket_fill (gint32 drawable_ID, - GimpBucketFillMode fill_mode, - GimpLayerModeEffects paint_mode, - gdouble opacity, - gdouble threshold, - gboolean sample_merged, - gdouble x, - gdouble y); -void gimp_by_color_select (gint32 drawable_ID, - guchar red, - guchar green, - guchar blue, - gint threshold, - GimpChannelOps operation, - gboolean antialias, - gboolean feather, - gdouble feather_radius, - gboolean sample_merged); -void gimp_clone (gint32 drawable_ID, - gint32 src_drawable_ID, - GimpCloneType clone_type, - gdouble src_x, - gdouble src_y, - gint num_strokes, - gdouble *strokes); -void gimp_clone_default (gint32 drawable_ID, - gint num_strokes, - gdouble *strokes); -void gimp_color_picker (gint32 image_ID, - gint32 drawable_ID, - gdouble x, - gdouble y, - gboolean sample_merged, - gboolean sample_average, - gdouble average_radius, - gboolean save_color, - guchar *red, - guchar *green, - guchar *blue); -void gimp_convolve (gint32 drawable_ID, - gdouble pressure, - GimpConvolveType convolve_type, - gint num_strokes, - gdouble *strokes); -void gimp_convolve_default (gint32 drawable_ID, - gint num_strokes, - gdouble *strokes); -void gimp_crop (gint32 image_ID, - gint new_width, - gint new_height, - gint offx, - gint offy); -void gimp_dodgeburn (gint32 drawable_ID, - gdouble exposure, - GimpDodgeBurnType dodgeburn_type, - GimpDodgeBurnMode dodgeburn_mode, - gint num_strokes, - gdouble *strokes); -void gimp_dodgeburn_default (gint32 drawable_ID, - gint num_strokes, - gdouble *strokes); -void gimp_ellipse_select (gint32 image_ID, - gdouble x, - gdouble y, - gdouble width, - gdouble height, - GimpChannelOps operation, - gboolean antialias, - gboolean feather, - gdouble feather_radius); -void gimp_eraser (gint32 drawable_ID, - gint num_strokes, - gdouble *strokes, - GimpBrushApplicationMode hardness, - GimpPaintApplicationMode method); -void gimp_eraser_default (gint32 drawable_ID, - gint num_strokes, - gdouble *strokes); -gint32 gimp_flip (gint32 drawable_ID, - GimpOrientationType flip_type); -void gimp_free_select (gint32 image_ID, - gint num_segs, - gdouble *segs, - GimpChannelOps operation, - gboolean antialias, - gboolean feather, - gdouble feather_radius); -void gimp_fuzzy_select (gint32 drawable_ID, - gdouble x, - gdouble y, - gint threshold, - GimpChannelOps operation, - gboolean antialias, - gboolean feather, - gdouble feather_radius, - gboolean sample_merged); -void gimp_paintbrush (gint32 drawable_ID, - gdouble fade_out, - gint num_strokes, - gdouble *strokes, - GimpPaintApplicationMode method, - gdouble gradient_length); -void gimp_paintbrush_default (gint32 drawable_ID, - gint num_strokes, - gdouble *strokes); -void gimp_pencil (gint32 drawable_ID, - gint num_strokes, - gdouble *strokes); -gint32 gimp_perspective (gint32 drawable_ID, - gboolean interpolation, - gdouble x0, - gdouble y0, - gdouble x1, - gdouble y1, - gdouble x2, - gdouble y2, - gdouble x3, - gdouble y3); -void gimp_rect_select (gint32 image_ID, - gdouble x, - gdouble y, - gdouble width, - gdouble height, - GimpChannelOps operation, - gboolean feather, - gdouble feather_radius); -gint32 gimp_rotate (gint32 drawable_ID, - gboolean interpolation, - gdouble angle); -gint32 gimp_scale (gint32 drawable_ID, - gboolean interpolation, - gdouble x0, - gdouble y0, - gdouble x1, - gdouble y1); -gint32 gimp_shear (gint32 drawable_ID, - gboolean interpolation, - GimpOrientationType shear_type, - gdouble magnitude); -void gimp_smudge (gint32 drawable_ID, - gdouble pressure, - gint num_strokes, - gdouble *strokes); -void gimp_smudge_default (gint32 drawable_ID, - gint num_strokes, - gdouble *strokes); -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 gimp_airbrush (gint32 drawable_ID, + gdouble pressure, + gint num_strokes, + gdouble *strokes); +gboolean gimp_airbrush_default (gint32 drawable_ID, + gint num_strokes, + gdouble *strokes); +gboolean gimp_blend (gint32 drawable_ID, + GimpBlendMode blend_mode, + GimpLayerModeEffects paint_mode, + GimpGradientType gradient_type, + gdouble opacity, + gdouble offset, + GimpRepeatMode repeat, + gboolean supersample, + gint max_depth, + gdouble threshold, + gdouble x1, + gdouble y1, + gdouble x2, + gdouble y2); +gboolean gimp_bucket_fill (gint32 drawable_ID, + GimpBucketFillMode fill_mode, + GimpLayerModeEffects paint_mode, + gdouble opacity, + gdouble threshold, + gboolean sample_merged, + gdouble x, + gdouble y); +gboolean gimp_by_color_select (gint32 drawable_ID, + guchar red, + guchar green, + guchar blue, + gint threshold, + GimpChannelOps operation, + gboolean antialias, + gboolean feather, + gdouble feather_radius, + gboolean sample_merged); +gboolean gimp_clone (gint32 drawable_ID, + gint32 src_drawable_ID, + GimpCloneType clone_type, + gdouble src_x, + gdouble src_y, + gint num_strokes, + gdouble *strokes); +gboolean gimp_clone_default (gint32 drawable_ID, + gint num_strokes, + gdouble *strokes); +gboolean gimp_color_picker (gint32 image_ID, + gint32 drawable_ID, + gdouble x, + gdouble y, + gboolean sample_merged, + gboolean sample_average, + gdouble average_radius, + gboolean save_color, + guchar *red, + guchar *green, + guchar *blue); +gboolean gimp_convolve (gint32 drawable_ID, + gdouble pressure, + GimpConvolveType convolve_type, + gint num_strokes, + gdouble *strokes); +gboolean gimp_convolve_default (gint32 drawable_ID, + gint num_strokes, + gdouble *strokes); +gboolean gimp_crop (gint32 image_ID, + gint new_width, + gint new_height, + gint offx, + gint offy); +gboolean gimp_dodgeburn (gint32 drawable_ID, + gdouble exposure, + GimpDodgeBurnType dodgeburn_type, + GimpDodgeBurnMode dodgeburn_mode, + gint num_strokes, + gdouble *strokes); +gboolean gimp_dodgeburn_default (gint32 drawable_ID, + gint num_strokes, + gdouble *strokes); +gboolean gimp_ellipse_select (gint32 image_ID, + gdouble x, + gdouble y, + gdouble width, + gdouble height, + GimpChannelOps operation, + gboolean antialias, + gboolean feather, + gdouble feather_radius); +gboolean gimp_eraser (gint32 drawable_ID, + gint num_strokes, + gdouble *strokes, + GimpBrushApplicationMode hardness, + GimpPaintApplicationMode method); +gboolean gimp_eraser_default (gint32 drawable_ID, + gint num_strokes, + gdouble *strokes); +gint32 gimp_flip (gint32 drawable_ID, + GimpOrientationType flip_type); +gboolean gimp_free_select (gint32 image_ID, + gint num_segs, + 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); +gboolean gimp_paintbrush (gint32 drawable_ID, + gdouble fade_out, + gint num_strokes, + gdouble *strokes, + GimpPaintApplicationMode method, + gdouble gradient_length); +gboolean gimp_paintbrush_default (gint32 drawable_ID, + gint num_strokes, + gdouble *strokes); +gboolean gimp_pencil (gint32 drawable_ID, + gint num_strokes, + gdouble *strokes); +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 gimp_rect_select (gint32 image_ID, + gdouble x, + gdouble y, + gdouble width, + gdouble height, + GimpChannelOps operation, + gboolean feather, + gdouble feather_radius); +gint32 gimp_rotate (gint32 drawable_ID, + gboolean interpolation, + gdouble angle); +gint32 gimp_scale (gint32 drawable_ID, + gboolean interpolation, + gdouble x0, + gdouble y0, + gdouble x1, + gdouble y1); +gint32 gimp_shear (gint32 drawable_ID, + gboolean interpolation, + GimpOrientationType shear_type, + gdouble magnitude); +gboolean gimp_smudge (gint32 drawable_ID, + gdouble pressure, + gint num_strokes, + gdouble *strokes); +gboolean gimp_smudge_default (gint32 drawable_ID, + gint num_strokes, + gdouble *strokes); +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); #ifdef __cplusplus diff --git a/libgimp/gimpundo_pdb.c b/libgimp/gimpundo_pdb.c index 9b7099d4a7..cfcafd77e8 100644 --- a/libgimp/gimpundo_pdb.c +++ b/libgimp/gimpundo_pdb.c @@ -23,30 +23,40 @@ #include "gimp.h" -void +gboolean gimp_undo_push_group_start (gint32 image_ID) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_undo_push_group_start", &nreturn_vals, GIMP_PDB_IMAGE, image_ID, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } -void +gboolean gimp_undo_push_group_end (gint32 image_ID) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_undo_push_group_end", &nreturn_vals, GIMP_PDB_IMAGE, image_ID, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } diff --git a/libgimp/gimpundo_pdb.h b/libgimp/gimpundo_pdb.h index c8dd393e30..1aa30a2fd4 100644 --- a/libgimp/gimpundo_pdb.h +++ b/libgimp/gimpundo_pdb.h @@ -31,8 +31,8 @@ extern "C" { /* For information look into the C source or the html documentation */ -void gimp_undo_push_group_start (gint32 image_ID); -void gimp_undo_push_group_end (gint32 image_ID); +gboolean gimp_undo_push_group_start (gint32 image_ID); +gboolean gimp_undo_push_group_end (gint32 image_ID); #ifdef __cplusplus diff --git a/libgimp/gimpunit_pdb.c b/libgimp/gimpunit_pdb.c index 74f6b01bdf..7e57cb5e9c 100644 --- a/libgimp/gimpunit_pdb.c +++ b/libgimp/gimpunit_pdb.c @@ -113,12 +113,13 @@ _gimp_unit_get_deletion_flag (GimpUnit unit_id) return deletion_flag; } -void +gboolean _gimp_unit_set_deletion_flag (GimpUnit unit_id, gboolean deletion_flag) { GimpParam *return_vals; gint nreturn_vals; + gboolean success = TRUE; return_vals = gimp_run_procedure ("gimp_unit_set_deletion_flag", &nreturn_vals, @@ -126,7 +127,11 @@ _gimp_unit_set_deletion_flag (GimpUnit unit_id, GIMP_PDB_INT32, deletion_flag, GIMP_PDB_END); + success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS; + gimp_destroy_params (return_vals, nreturn_vals); + + return success; } gchar * diff --git a/libgimp/gimpunit_pdb.h b/libgimp/gimpunit_pdb.h index a9b78f5961..f9db004b61 100644 --- a/libgimp/gimpunit_pdb.h +++ b/libgimp/gimpunit_pdb.h @@ -41,7 +41,7 @@ GimpUnit _gimp_unit_new (gchar *identifier, gchar *singular, gchar *plural); gboolean _gimp_unit_get_deletion_flag (GimpUnit unit_id); -void _gimp_unit_set_deletion_flag (GimpUnit unit_id, +gboolean _gimp_unit_set_deletion_flag (GimpUnit unit_id, gboolean deletion_flag); gchar* _gimp_unit_get_identifier (GimpUnit unit_id); gdouble _gimp_unit_get_factor (GimpUnit unit_id); diff --git a/plug-ins/common/plugin-defs.pl b/plug-ins/common/plugin-defs.pl index 0b909398ee..5f4faa3759 100644 --- a/plug-ins/common/plugin-defs.pl +++ b/plug-ins/common/plugin-defs.pl @@ -1,4 +1,6 @@ %plugins = ( + 'AlienMap' => { libdep => 'gtk', ui => 1 }, + 'AlienMap2' => { libdep => 'gtk', ui => 1 }, 'CEL' => { libdep => 'gtk', ui => 1 }, 'CML_explorer' => { libdep => 'gtk', ui => 1 }, 'aa' => { libdep => 'gtk', ui => 1, optional => 1 }, @@ -95,12 +97,14 @@ 'semiflatten' => { libdep => 'glib' }, 'sharpen' => { libdep => 'gtk', ui => 1 }, 'shift' => { libdep => 'gtk', ui => 1 }, + 'sinus' => { libdep => 'gtk', ui => 1 }, 'smooth_palette' => { libdep => 'gtk', ui => 1 }, 'snoise' => { libdep => 'gtk', ui => 1 }, 'sobel' => { libdep => 'gtk', ui => 1 }, 'sparkle' => { libdep => 'gtk', ui => 1 }, 'spheredesigner' => { libdep => 'gtk', ui => 1 }, 'spread' => { libdep => 'gtk', ui => 1 }, + 'struc' => { libdep => 'gtk', ui => 1 }, 'sunras' => { libdep => 'gtk', ui => 1 }, 'tga' => { libdep => 'gtk', ui => 1 }, 'threshold_alpha' => { libdep => 'gtk', ui => 1 }, diff --git a/tools/pdbgen/.cvsignore b/tools/pdbgen/.cvsignore index a716a21eaf..6cb7642468 100644 --- a/tools/pdbgen/.cvsignore +++ b/tools/pdbgen/.cvsignore @@ -2,6 +2,5 @@ Makefile Makefile.in stamp-enums stamp-groups -stamp-app -stamp-lib +stamp-pdbgen stamp-enum-code diff --git a/tools/pdbgen/Makefile.am b/tools/pdbgen/Makefile.am index 88f1298e19..0ced6d1239 100644 --- a/tools/pdbgen/Makefile.am +++ b/tools/pdbgen/Makefile.am @@ -106,21 +106,13 @@ stamp-groups: Makefile.am && rm groups.pl.tmp \ && echo timestamp > $$rootme/stamp-groups -stamp-app: $(srcdir)/app.pl $(pdb_scripts) $(pdb_sources) +stamp-pdbgen: $(srcdir)/app.pl $(srcdir)/lib.pl $(pdb_scripts) $(pdb_sources) rootme=`pwd`; \ destdir=`cd $(top_srcdir) && pwd`; export destdir; \ cd $(srcdir) && \ PDBGEN_BACKUP=$(PDBGEN_BACKUP) PDBGEN_GROUPS=$(PDBGEN_GROUPS) \ - $(PERL) pdbgen.pl app \ - && echo timestamp > $$rootme/stamp-app - -stamp-lib: $(srcdir)/lib.pl $(pdb_scripts) $(pdb_sources) - rootme=`pwd`; \ - destdir=`cd $(top_srcdir) && pwd`; export destdir; \ - cd $(srcdir) && \ - PDBGEN_BACKUP=$(PDBGEN_BACKUP) PDBGEN_GROUPS=$(PDBGEN_GROUPS) \ - $(PERL) pdbgen.pl lib \ - && echo timestamp > $$rootme/stamp-lib + $(PERL) pdbgen.pl app lib \ + && echo timestamp > $$rootme/stamp-pdbgen stamp-enum-code: $(srcdir)/enumcode.pl enums.pl util.pl rootme=`pwd`; \ @@ -130,4 +122,4 @@ stamp-enum-code: $(srcdir)/enumcode.pl enums.pl util.pl $(PERL) enumcode.pl \ && echo timestamp > $$rootme/stamp-enum-code -all-local: stamp-app stamp-lib stamp-enum-code +all-local: stamp-pdbgen stamp-enum-code diff --git a/tools/pdbgen/lib.pl b/tools/pdbgen/lib.pl index 8ee46a487c..bd112a0b49 100644 --- a/tools/pdbgen/lib.pl +++ b/tools/pdbgen/lib.pl @@ -153,6 +153,11 @@ CODE my $return_args = ""; my $return_marshal = "gimp_destroy_params (return_vals, nreturn_vals);"; + # return success/failure boolean if we don't have anything else + if ($rettype eq 'void') { + $return_args .= "\n" . ' ' x 2 . "gboolean success = TRUE;"; + } + # We only need to bother with this if we have to return a value if ($rettype ne 'void' || $retcol || $retvoid) { my $once = 0; @@ -234,9 +239,18 @@ CODE $return_marshal =~ s/\n $/\n\n /s; } - $return_marshal .= <{code} .= < "${type}_type", type => 'enum PDBArgType (no PDB_END)', desc => "The type of $long_type { %%desc%% }", void_ret => 1, - alias => "${type}->arg_type", no_declare => 1, wrap => 1 }, + alias => "${type}->arg_type", no_declare => 1 }, { name => "${type}_name", type => 'string', desc => "The name of the $long_type", alias => "g_strdup (${type}->name)", no_declare => 1 },