From 5a0952321463542ef429e8bb7376c9001d519aae Mon Sep 17 00:00:00 2001 From: Michael Natterer Date: Thu, 15 Aug 2019 14:04:56 +0200 Subject: [PATCH] Remove GIMP_TYPE_INT32 and GimpParamSpecInt32 Use gint and GParamSpecInt instead. --- app/core/gimpparamspecs-desc.c | 6 +- app/file-data/file-data.c | 20 +- app/pdb/brush-cmds.c | 186 +-- app/pdb/brush-select-cmds.c | 28 +- app/pdb/brushes-cmds.c | 12 +- app/pdb/buffer-cmds.c | 50 +- app/pdb/channel-cmds.c | 52 +- app/pdb/context-cmds.c | 108 +- app/pdb/display-cmds.c | 12 +- app/pdb/drawable-cmds.c | 502 +++---- app/pdb/drawable-color-cmds.c | 52 +- app/pdb/drawable-edit-cmds.c | 18 +- app/pdb/dynamics-cmds.c | 12 +- app/pdb/fileops-cmds.c | 64 +- app/pdb/fonts-cmds.c | 12 +- app/pdb/gimp-cmds.c | 24 +- app/pdb/gimp-pdb-compat.c | 1 - app/pdb/gimppdb.c | 9 +- app/pdb/gradient-cmds.c | 500 +++---- app/pdb/gradient-select-cmds.c | 12 +- app/pdb/gradients-cmds.c | 12 +- app/pdb/image-cmds.c | 346 ++--- app/pdb/image-color-profile-cmds.c | 52 +- app/pdb/image-convert-cmds.c | 54 +- app/pdb/image-grid-cmds.c | 4 +- app/pdb/image-guides-cmds.c | 52 +- app/pdb/image-sample-points-cmds.c | 58 +- app/pdb/image-select-cmds.c | 26 +- app/pdb/image-transform-cmds.c | 124 +- app/pdb/item-cmds.c | 32 +- app/pdb/item-transform-cmds.c | 6 +- app/pdb/layer-cmds.c | 144 +- app/pdb/message-cmds.c | 4 +- app/pdb/paint-tools-cmds.c | 218 +-- app/pdb/palette-cmds.c | 120 +- app/pdb/palettes-cmds.c | 12 +- app/pdb/pattern-cmds.c | 84 +- app/pdb/patterns-cmds.c | 12 +- app/pdb/pdb-cmds.c | 98 +- app/pdb/plug-in-cmds.c | 80 +- app/pdb/plug-in-compat-cmds.c | 1308 ++++++++--------- app/pdb/progress-cmds.c | 12 +- app/pdb/selection-cmds.c | 168 +-- app/pdb/text-layer-cmds.c | 12 +- app/pdb/text-tool-cmds.c | 60 +- app/pdb/unit-cmds.c | 48 +- app/pdb/vectors-cmds.c | 318 ++-- app/plug-in/gimpgpparams.c | 7 - app/plug-in/gimpplugin-message.c | 4 +- app/plug-in/gimpplugin-progress.c | 6 +- app/widgets/gimpbrushselect.c | 2 +- app/widgets/gimpgradientselect.c | 2 +- app/widgets/gimppatternselect.c | 2 +- .../libgimpbase/libgimpbase3-sections.txt | 9 - devel-docs/libgimpbase/libgimpbase3.types | 2 - libgimp/gimp.c | 2 +- libgimp/gimpbrush_pdb.c | 4 +- libgimp/gimpbrushselect.c | 12 +- libgimp/gimpbrushselect_pdb.c | 4 +- libgimp/gimpchannel_pdb.c | 8 +- libgimp/gimpcontext_pdb.c | 4 +- libgimp/gimpdrawable_pdb.c | 38 +- libgimp/gimpdrawablecolor_pdb.c | 6 +- libgimp/gimpdrawableedit_pdb.c | 2 +- libgimp/gimpfileops_pdb.c | 2 +- libgimp/gimpgpcompat.c | 9 +- libgimp/gimpgpparams-body.c | 11 +- libgimp/gimpgpparams.c | 7 - libgimp/gimpgradient_pdb.c | 76 +- libgimp/gimpgradientselect.c | 10 +- libgimp/gimpgradientselect_pdb.c | 2 +- libgimp/gimpimage_pdb.c | 34 +- libgimp/gimpimagecolorprofile_pdb.c | 4 +- libgimp/gimpimageconvert_pdb.c | 8 +- libgimp/gimpimageguides_pdb.c | 12 +- libgimp/gimpimagesamplepoints_pdb.c | 10 +- libgimp/gimpimageselect_pdb.c | 2 +- libgimp/gimpimagetransform_pdb.c | 20 +- libgimp/gimpitem_pdb.c | 2 +- libgimp/gimplayer_pdb.c | 20 +- libgimp/gimppainttools_pdb.c | 34 +- libgimp/gimppalette_pdb.c | 12 +- libgimp/gimppatternselect.c | 12 +- libgimp/gimppdb_pdb.c | 6 +- libgimp/gimpplugin_pdb.c | 2 +- libgimp/gimpselection_pdb.c | 18 +- libgimp/gimptexttool_pdb.c | 2 +- libgimp/gimpunit_pdb.c | 2 +- libgimp/gimpvectors_pdb.c | 36 +- libgimpbase/gimpbase.def | 3 - libgimpbase/gimpparamspecs.c | 110 -- libgimpbase/gimpparamspecs.h | 37 - pdb/app.pl | 10 +- pdb/pdb.pl | 28 +- plug-ins/common/colormap-remap.c | 12 +- plug-ins/common/file-gih.c | 24 +- plug-ins/common/film.c | 12 +- plug-ins/help-browser/help-browser.c | 20 +- plug-ins/help/help.c | 20 +- 99 files changed, 2852 insertions(+), 3035 deletions(-) diff --git a/app/core/gimpparamspecs-desc.c b/app/core/gimpparamspecs-desc.c index 892b8ef0e3..edf14f299b 100644 --- a/app/core/gimpparamspecs-desc.c +++ b/app/core/gimpparamspecs-desc.c @@ -46,7 +46,7 @@ gimp_param_spec_boolean_desc (GParamSpec *pspec) } static gchar * -gimp_param_spec_int32_desc (GParamSpec *pspec) +gimp_param_spec_int_desc (GParamSpec *pspec) { GParamSpecInt *ispec = G_PARAM_SPEC_INT (pspec); const gchar *blurb = gimp_param_spec_get_blurb (pspec); @@ -170,9 +170,9 @@ gimp_param_spec_get_desc (GParamSpec *pspec) if (GIMP_IS_PARAM_SPEC_UNIT (pspec)) { } - else if (GIMP_IS_PARAM_SPEC_INT32 (pspec)) + else if (G_IS_PARAM_SPEC_INT (pspec)) { - return gimp_param_spec_int32_desc (pspec); + return gimp_param_spec_int_desc (pspec); } else { diff --git a/app/file-data/file-data.c b/app/file-data/file-data.c index 28365f22e2..b6577ec143 100644 --- a/app/file-data/file-data.c +++ b/app/file-data/file-data.c @@ -184,11 +184,11 @@ file_data_init (Gimp *gimp) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("spacing", - "spacing", - "Spacing of the brush", - 1, 1000, 10, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("spacing", + "spacing", + "Spacing of the brush", + 1, 1000, 10, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_string ("name", "name", @@ -334,11 +334,11 @@ file_data_init (Gimp *gimp) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("spacing", - "spacing", - "Spacing of the brush", - 1, 1000, 10, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("spacing", + "spacing", + "Spacing of the brush", + 1, 1000, 10, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_string ("name", "name", diff --git a/app/pdb/brush-cmds.c b/app/pdb/brush-cmds.c index 5373fc41de..271e7dfcfc 100644 --- a/app/pdb/brush-cmds.c +++ b/app/pdb/brush-cmds.c @@ -269,10 +269,10 @@ brush_get_info_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; const gchar *name; - gint32 width = 0; - gint32 height = 0; - gint32 mask_bpp = 0; - gint32 color_bpp = 0; + gint width = 0; + gint height = 0; + gint mask_bpp = 0; + gint color_bpp = 0; name = g_value_get_string (gimp_value_array_index (args, 0)); @@ -330,13 +330,13 @@ brush_get_pixels_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; const gchar *name; - gint32 width = 0; - gint32 height = 0; - gint32 mask_bpp = 0; - gint32 num_mask_bytes = 0; + gint width = 0; + gint height = 0; + gint mask_bpp = 0; + gint num_mask_bytes = 0; guint8 *mask_bytes = NULL; - gint32 color_bpp = 0; - gint32 num_color_bytes = 0; + gint color_bpp = 0; + gint num_color_bytes = 0; guint8 *color_bytes = NULL; name = g_value_get_string (gimp_value_array_index (args, 0)); @@ -413,7 +413,7 @@ brush_get_spacing_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; const gchar *name; - gint32 spacing = 0; + gint spacing = 0; name = g_value_get_string (gimp_value_array_index (args, 0)); @@ -446,7 +446,7 @@ brush_set_spacing_invoker (GimpProcedure *procedure, { gboolean success = TRUE; const gchar *name; - gint32 spacing; + gint spacing; name = g_value_get_string (gimp_value_array_index (args, 0)); spacing = g_value_get_int (gimp_value_array_index (args, 1)); @@ -476,7 +476,7 @@ brush_get_shape_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; const gchar *name; - gint32 shape = 0; + gint shape = 0; name = g_value_get_string (gimp_value_array_index (args, 0)); @@ -510,8 +510,8 @@ brush_set_shape_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; const gchar *name; - gint32 shape_in; - gint32 shape_out = 0; + gint shape_in; + gint shape_out = 0; name = g_value_get_string (gimp_value_array_index (args, 0)); shape_in = g_value_get_enum (gimp_value_array_index (args, 1)); @@ -624,7 +624,7 @@ brush_get_spikes_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; const gchar *name; - gint32 spikes = 0; + gint spikes = 0; name = g_value_get_string (gimp_value_array_index (args, 0)); @@ -658,8 +658,8 @@ brush_set_spikes_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; const gchar *name; - gint32 spikes_in; - gint32 spikes_out = 0; + gint spikes_in; + gint spikes_out = 0; name = g_value_get_string (gimp_value_array_index (args, 0)); spikes_in = g_value_get_int (gimp_value_array_index (args, 1)); @@ -1120,29 +1120,29 @@ register_brush_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("width", - "width", - "The brush width", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("width", + "width", + "The brush width", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("height", - "height", - "The brush height", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("height", + "height", + "The brush height", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("mask-bpp", - "mask bpp", - "The brush mask bpp", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("mask-bpp", + "mask bpp", + "The brush mask bpp", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("color-bpp", - "color bpp", - "The brush color bpp", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("color-bpp", + "color bpp", + "The brush color bpp", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -1168,46 +1168,46 @@ register_brush_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("width", - "width", - "The brush width", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("width", + "width", + "The brush width", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("height", - "height", - "The brush height", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("height", + "height", + "The brush height", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("mask-bpp", - "mask bpp", - "The brush mask bpp", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("mask-bpp", + "mask bpp", + "The brush mask bpp", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-mask-bytes", - "num mask bytes", - "Length of brush mask data", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-mask-bytes", + "num mask bytes", + "Length of brush mask data", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_int8_array ("mask-bytes", "mask bytes", "The brush mask data", GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("color-bpp", - "color bpp", - "The brush color bpp", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("color-bpp", + "color bpp", + "The brush color bpp", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-color-bytes", - "num color bytes", - "Length of brush color data", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-color-bytes", + "num color bytes", + "Length of brush color data", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_int8_array ("color-bytes", "color bytes", @@ -1238,11 +1238,11 @@ register_brush_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("spacing", - "spacing", - "The brush spacing", - 0, 1000, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("spacing", + "spacing", + "The brush spacing", + 0, 1000, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -1268,11 +1268,11 @@ register_brush_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("spacing", - "spacing", - "The brush spacing", - 0, 1000, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("spacing", + "spacing", + "The brush spacing", + 0, 1000, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -1433,11 +1433,11 @@ register_brush_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("spikes", - "spikes", - "The number of spikes on the brush.", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("spikes", + "spikes", + "The number of spikes on the brush.", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -1463,17 +1463,17 @@ register_brush_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("spikes-in", - "spikes in", - "The desired number of spikes", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("spikes-in", + "spikes in", + "The desired number of spikes", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("spikes-out", - "spikes out", - "The number of spikes actually assigned", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("spikes-out", + "spikes out", + "The number of spikes actually assigned", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); diff --git a/app/pdb/brush-select-cmds.c b/app/pdb/brush-select-cmds.c index 180bcbfc96..219216353a 100644 --- a/app/pdb/brush-select-cmds.c +++ b/app/pdb/brush-select-cmds.c @@ -49,8 +49,8 @@ brushes_popup_invoker (GimpProcedure *procedure, const gchar *popup_title; const gchar *initial_brush; gdouble opacity; - gint32 spacing; - gint32 paint_mode; + gint spacing; + gint paint_mode; brush_callback = g_value_get_string (gimp_value_array_index (args, 0)); popup_title = g_value_get_string (gimp_value_array_index (args, 1)); @@ -118,8 +118,8 @@ brushes_set_popup_invoker (GimpProcedure *procedure, const gchar *brush_callback; const gchar *brush_name; gdouble opacity; - gint32 spacing; - gint32 paint_mode; + gint spacing; + gint paint_mode; brush_callback = g_value_get_string (gimp_value_array_index (args, 0)); brush_name = g_value_get_string (gimp_value_array_index (args, 1)); @@ -194,11 +194,11 @@ register_brush_select_procs (GimpPDB *pdb) 0, 100, 0, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("spacing", - "spacing", - "The initial spacing of the brush (if < 0 then use brush default spacing)", - G_MININT32, 1000, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("spacing", + "spacing", + "The initial spacing of the brush (if < 0 then use brush default spacing)", + G_MININT32, 1000, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_enum ("paint-mode", "paint mode", @@ -268,11 +268,11 @@ register_brush_select_procs (GimpPDB *pdb) 0, 100, 0, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("spacing", - "spacing", - "The initial spacing of the brush (if < 0 then use brush default spacing)", - G_MININT32, 1000, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("spacing", + "spacing", + "The initial spacing of the brush (if < 0 then use brush default spacing)", + G_MININT32, 1000, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_enum ("paint-mode", "paint mode", diff --git a/app/pdb/brushes-cmds.c b/app/pdb/brushes-cmds.c index 73bccadbe4..a72dd6d02d 100644 --- a/app/pdb/brushes-cmds.c +++ b/app/pdb/brushes-cmds.c @@ -67,7 +67,7 @@ brushes_get_list_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; const gchar *filter; - gint32 num_brushes = 0; + gint num_brushes = 0; gchar **brush_list = NULL; filter = g_value_get_string (gimp_value_array_index (args, 0)); @@ -134,11 +134,11 @@ register_brushes_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-brushes", - "num brushes", - "The number of brushes in the brush list", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-brushes", + "num brushes", + "The number of brushes in the brush list", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_string_array ("brush-list", "brush list", diff --git a/app/pdb/buffer-cmds.c b/app/pdb/buffer-cmds.c index b849bd40fc..1c6af467c9 100644 --- a/app/pdb/buffer-cmds.c +++ b/app/pdb/buffer-cmds.c @@ -53,7 +53,7 @@ buffers_get_list_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; const gchar *filter; - gint32 num_buffers = 0; + gint num_buffers = 0; gchar **buffer_list = NULL; filter = g_value_get_string (gimp_value_array_index (args, 0)); @@ -153,7 +153,7 @@ buffer_get_width_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; const gchar *buffer_name; - gint32 width = 0; + gint width = 0; buffer_name = g_value_get_string (gimp_value_array_index (args, 0)); @@ -187,7 +187,7 @@ buffer_get_height_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; const gchar *buffer_name; - gint32 height = 0; + gint height = 0; buffer_name = g_value_get_string (gimp_value_array_index (args, 0)); @@ -221,7 +221,7 @@ buffer_get_bytes_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; const gchar *buffer_name; - gint32 bytes = 0; + gint bytes = 0; buffer_name = g_value_get_string (gimp_value_array_index (args, 0)); @@ -259,7 +259,7 @@ buffer_get_image_type_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; const gchar *buffer_name; - gint32 image_type = 0; + gint image_type = 0; buffer_name = g_value_get_string (gimp_value_array_index (args, 0)); @@ -309,11 +309,11 @@ register_buffer_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-buffers", - "num buffers", - "The number of buffers", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-buffers", + "num buffers", + "The number of buffers", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_string_array ("buffer-list", "buffer list", @@ -406,11 +406,11 @@ register_buffer_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("width", - "width", - "The buffer width", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("width", + "width", + "The buffer width", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -436,11 +436,11 @@ register_buffer_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("height", - "height", - "The buffer height", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("height", + "height", + "The buffer height", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -466,11 +466,11 @@ register_buffer_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("bytes", - "bytes", - "The buffer bpp", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("bytes", + "bytes", + "The buffer bpp", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); diff --git a/app/pdb/channel-cmds.c b/app/pdb/channel-cmds.c index 8d706b6766..90ea5b15f1 100644 --- a/app/pdb/channel-cmds.c +++ b/app/pdb/channel-cmds.c @@ -55,8 +55,8 @@ channel_new_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpImage *image; - gint32 width; - gint32 height; + gint width; + gint height; const gchar *name; gdouble opacity; GimpRGB color; @@ -100,7 +100,7 @@ channel_new_from_component_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpImage *image; - gint32 component; + gint component; const gchar *name; GimpChannel *channel = NULL; @@ -183,9 +183,9 @@ channel_combine_masks_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpChannel *channel1; GimpChannel *channel2; - gint32 operation; - gint32 offx; - gint32 offy; + gint operation; + gint offx; + gint offy; channel1 = gimp_value_get_channel (gimp_value_array_index (args, 0), gimp); channel2 = gimp_value_get_channel (gimp_value_array_index (args, 1), gimp); @@ -396,17 +396,17 @@ register_channel_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("width", - "width", - "The channel width", - 1, GIMP_MAX_IMAGE_SIZE, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("width", + "width", + "The channel width", + 1, GIMP_MAX_IMAGE_SIZE, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("height", - "height", - "The channel height", - 1, GIMP_MAX_IMAGE_SIZE, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("height", + "height", + "The channel height", + 1, GIMP_MAX_IMAGE_SIZE, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_string ("name", "name", @@ -544,17 +544,17 @@ register_channel_procs (GimpPDB *pdb) GIMP_CHANNEL_OP_ADD, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("offx", - "offx", - "x offset between upper left corner of channels: (second - first)", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("offx", + "offx", + "x offset between upper left corner of channels: (second - first)", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("offy", - "offy", - "y offset between upper left corner of channels: (second - first)", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("offy", + "offy", + "y offset between upper left corner of channels: (second - first)", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); diff --git a/app/pdb/context-cmds.c b/app/pdb/context-cmds.c index 277b8069e2..a159550fa8 100644 --- a/app/pdb/context-cmds.c +++ b/app/pdb/context-cmds.c @@ -114,7 +114,7 @@ context_list_paint_methods_invoker (GimpProcedure *procedure, GError **error) { GimpValueArray *return_vals; - gint32 num_paint_methods = 0; + gint num_paint_methods = 0; gchar **paint_methods = NULL; paint_methods = gimp_container_get_name_array (gimp->paint_info_list, @@ -192,7 +192,7 @@ context_get_stroke_method_invoker (GimpProcedure *procedure, GError **error) { GimpValueArray *return_vals; - gint32 stroke_method = 0; + gint stroke_method = 0; GimpStrokeOptions *options = gimp_pdb_context_get_stroke_options (GIMP_PDB_CONTEXT (context)); @@ -216,7 +216,7 @@ context_set_stroke_method_invoker (GimpProcedure *procedure, GError **error) { gboolean success = TRUE; - gint32 stroke_method; + gint stroke_method; stroke_method = g_value_get_enum (gimp_value_array_index (args, 0)); @@ -396,7 +396,7 @@ context_get_paint_mode_invoker (GimpProcedure *procedure, GError **error) { GimpValueArray *return_vals; - gint32 paint_mode = 0; + gint paint_mode = 0; paint_mode = gimp_context_get_paint_mode (context); @@ -415,7 +415,7 @@ context_set_paint_mode_invoker (GimpProcedure *procedure, GError **error) { gboolean success = TRUE; - gint32 paint_mode; + gint paint_mode; paint_mode = g_value_get_enum (gimp_value_array_index (args, 0)); @@ -542,7 +542,7 @@ context_get_line_cap_style_invoker (GimpProcedure *procedure, GError **error) { GimpValueArray *return_vals; - gint32 cap_style = 0; + gint cap_style = 0; GimpStrokeOptions *options = gimp_pdb_context_get_stroke_options (GIMP_PDB_CONTEXT (context)); @@ -566,7 +566,7 @@ context_set_line_cap_style_invoker (GimpProcedure *procedure, GError **error) { gboolean success = TRUE; - gint32 cap_style; + gint cap_style; cap_style = g_value_get_enum (gimp_value_array_index (args, 0)); @@ -593,7 +593,7 @@ context_get_line_join_style_invoker (GimpProcedure *procedure, GError **error) { GimpValueArray *return_vals; - gint32 join_style = 0; + gint join_style = 0; GimpStrokeOptions *options = gimp_pdb_context_get_stroke_options (GIMP_PDB_CONTEXT (context)); @@ -617,7 +617,7 @@ context_set_line_join_style_invoker (GimpProcedure *procedure, GError **error) { gboolean success = TRUE; - gint32 join_style; + gint join_style; join_style = g_value_get_enum (gimp_value_array_index (args, 0)); @@ -746,7 +746,7 @@ context_get_line_dash_pattern_invoker (GimpProcedure *procedure, GError **error) { GimpValueArray *return_vals; - gint32 num_dashes = 0; + gint num_dashes = 0; gdouble *dashes = NULL; GimpStrokeOptions *options = @@ -773,7 +773,7 @@ context_set_line_dash_pattern_invoker (GimpProcedure *procedure, GError **error) { gboolean success = TRUE; - gint32 num_dashes; + gint num_dashes; const gdouble *dashes; num_dashes = g_value_get_int (gimp_value_array_index (args, 0)); @@ -1629,7 +1629,7 @@ context_get_gradient_blend_color_space_invoker (GimpProcedure *procedure { gboolean success = TRUE; GimpValueArray *return_vals; - gint32 blend_color_space = 0; + gint blend_color_space = 0; /* all options should have the same value, so pick a random one */ GimpPaintOptions *options = @@ -1661,7 +1661,7 @@ context_set_gradient_blend_color_space_invoker (GimpProcedure *procedure GError **error) { gboolean success = TRUE; - gint32 blend_color_space; + gint blend_color_space; blend_color_space = g_value_get_enum (gimp_value_array_index (args, 0)); @@ -1692,7 +1692,7 @@ context_get_gradient_repeat_mode_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpValueArray *return_vals; - gint32 repeat_mode = 0; + gint repeat_mode = 0; /* all options should have the same value, so pick a random one */ GimpPaintOptions *options = @@ -1724,7 +1724,7 @@ context_set_gradient_repeat_mode_invoker (GimpProcedure *procedure, GError **error) { gboolean success = TRUE; - gint32 repeat_mode; + gint repeat_mode; repeat_mode = g_value_get_enum (gimp_value_array_index (args, 0)); @@ -2114,7 +2114,7 @@ context_get_sample_criterion_invoker (GimpProcedure *procedure, GError **error) { GimpValueArray *return_vals; - gint32 sample_criterion = 0; + gint sample_criterion = 0; g_object_get (context, "sample-criterion", &sample_criterion, @@ -2135,7 +2135,7 @@ context_set_sample_criterion_invoker (GimpProcedure *procedure, GError **error) { gboolean success = TRUE; - gint32 sample_criterion; + gint sample_criterion; sample_criterion = g_value_get_enum (gimp_value_array_index (args, 0)); @@ -2204,7 +2204,7 @@ context_get_sample_threshold_int_invoker (GimpProcedure *procedure, GError **error) { GimpValueArray *return_vals; - gint32 sample_threshold = 0; + gint sample_threshold = 0; gdouble threshold; @@ -2229,7 +2229,7 @@ context_set_sample_threshold_int_invoker (GimpProcedure *procedure, GError **error) { gboolean success = TRUE; - gint32 sample_threshold; + gint sample_threshold; sample_threshold = g_value_get_int (gimp_value_array_index (args, 0)); @@ -2343,7 +2343,7 @@ context_get_distance_metric_invoker (GimpProcedure *procedure, GError **error) { GimpValueArray *return_vals; - gint32 metric = 0; + gint metric = 0; g_object_get (context, "distance-metric", &metric, @@ -2364,7 +2364,7 @@ context_set_distance_metric_invoker (GimpProcedure *procedure, GError **error) { gboolean success = TRUE; - gint32 metric; + gint metric; metric = g_value_get_enum (gimp_value_array_index (args, 0)); @@ -2388,7 +2388,7 @@ context_get_interpolation_invoker (GimpProcedure *procedure, GError **error) { GimpValueArray *return_vals; - gint32 interpolation = 0; + gint interpolation = 0; g_object_get (context, "interpolation", &interpolation, @@ -2409,7 +2409,7 @@ context_set_interpolation_invoker (GimpProcedure *procedure, GError **error) { gboolean success = TRUE; - gint32 interpolation; + gint interpolation; interpolation = g_value_get_enum (gimp_value_array_index (args, 0)); @@ -2433,7 +2433,7 @@ context_get_transform_direction_invoker (GimpProcedure *procedure, GError **error) { GimpValueArray *return_vals; - gint32 transform_direction = 0; + gint transform_direction = 0; g_object_get (context, "transform-direction", &transform_direction, @@ -2454,7 +2454,7 @@ context_set_transform_direction_invoker (GimpProcedure *procedure, GError **error) { gboolean success = TRUE; - gint32 transform_direction; + gint transform_direction; transform_direction = g_value_get_enum (gimp_value_array_index (args, 0)); @@ -2478,7 +2478,7 @@ context_get_transform_resize_invoker (GimpProcedure *procedure, GError **error) { GimpValueArray *return_vals; - gint32 transform_resize = 0; + gint transform_resize = 0; g_object_get (context, "transform-resize", &transform_resize, @@ -2499,7 +2499,7 @@ context_set_transform_resize_invoker (GimpProcedure *procedure, GError **error) { gboolean success = TRUE; - gint32 transform_resize; + gint transform_resize; transform_resize = g_value_get_enum (gimp_value_array_index (args, 0)); @@ -2839,7 +2839,7 @@ context_get_ink_blob_type_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpValueArray *return_vals; - gint32 type = 0; + gint type = 0; GimpPaintOptions *options = gimp_pdb_context_get_paint_options (GIMP_PDB_CONTEXT (context), @@ -2870,7 +2870,7 @@ context_set_ink_blob_type_invoker (GimpProcedure *procedure, GError **error) { gboolean success = TRUE; - gint32 type; + gint type; type = g_value_get_enum (gimp_value_array_index (args, 0)); @@ -3092,11 +3092,11 @@ register_context_procs (GimpPDB *pdb) "2007", NULL); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-paint-methods", - "num paint methods", - "The number of the available paint methods", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-paint-methods", + "num paint methods", + "The number of the available paint methods", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_string_array ("paint-methods", "paint methods", @@ -3737,11 +3737,11 @@ register_context_procs (GimpPDB *pdb) "2015", NULL); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-dashes", - "num dashes", - "The number of dashes in the dash_pattern array", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-dashes", + "num dashes", + "The number of dashes in the dash_pattern array", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_float_array ("dashes", "dashes", @@ -3769,11 +3769,11 @@ register_context_procs (GimpPDB *pdb) "2015", NULL); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("num-dashes", - "num dashes", - "The number of dashes in the dash_pattern array", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-dashes", + "num dashes", + "The number of dashes in the dash_pattern array", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_float_array ("dashes", "dashes", @@ -4972,11 +4972,11 @@ register_context_procs (GimpPDB *pdb) "2011", NULL); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("sample-threshold", - "sample threshold", - "The sample threshold setting", - 0, 255, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("sample-threshold", + "sample threshold", + "The sample threshold setting", + 0, 255, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -4995,11 +4995,11 @@ register_context_procs (GimpPDB *pdb) "2011", NULL); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("sample-threshold", - "sample threshold", - "The sample threshold setting", - 0, 255, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("sample-threshold", + "sample threshold", + "The sample threshold setting", + 0, 255, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); diff --git a/app/pdb/display-cmds.c b/app/pdb/display-cmds.c index cd3525f851..3600a45ad4 100644 --- a/app/pdb/display-cmds.c +++ b/app/pdb/display-cmds.c @@ -134,7 +134,7 @@ display_get_window_handle_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpObject *display; - gint32 window = 0; + gint window = 0; display = gimp_value_get_display (gimp_value_array_index (args, 0), gimp); @@ -307,11 +307,11 @@ register_display_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("window", - "window", - "The native window handle or 0", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("window", + "window", + "The native window handle or 0", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); diff --git a/app/pdb/drawable-cmds.c b/app/pdb/drawable-cmds.c index 60b00274af..83876bf2d7 100644 --- a/app/pdb/drawable-cmds.c +++ b/app/pdb/drawable-cmds.c @@ -128,7 +128,7 @@ drawable_type_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpDrawable *drawable; - gint32 type = 0; + gint type = 0; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); @@ -157,7 +157,7 @@ drawable_type_with_alpha_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpDrawable *drawable; - gint32 type_with_alpha = 0; + gint type_with_alpha = 0; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); @@ -304,7 +304,7 @@ drawable_bpp_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpDrawable *drawable; - gint32 bpp = 0; + gint bpp = 0; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); @@ -335,7 +335,7 @@ drawable_width_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpDrawable *drawable; - gint32 width = 0; + gint width = 0; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); @@ -364,7 +364,7 @@ drawable_height_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpDrawable *drawable; - gint32 height = 0; + gint height = 0; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); @@ -393,8 +393,8 @@ drawable_offsets_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpDrawable *drawable; - gint32 offset_x = 0; - gint32 offset_y = 0; + gint offset_x = 0; + gint offset_y = 0; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); @@ -427,10 +427,10 @@ drawable_mask_bounds_invoker (GimpProcedure *procedure, GimpValueArray *return_vals; GimpDrawable *drawable; gboolean non_empty = FALSE; - gint32 x1 = 0; - gint32 y1 = 0; - gint32 x2 = 0; - gint32 y2 = 0; + gint x1 = 0; + gint y1 = 0; + gint x2 = 0; + gint y2 = 0; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); @@ -469,10 +469,10 @@ drawable_mask_intersect_invoker (GimpProcedure *procedure, GimpValueArray *return_vals; GimpDrawable *drawable; gboolean non_empty = FALSE; - gint32 x = 0; - gint32 y = 0; - gint32 width = 0; - gint32 height = 0; + gint x = 0; + gint y = 0; + gint width = 0; + gint height = 0; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); @@ -572,10 +572,10 @@ drawable_update_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 x; - gint32 y; - gint32 width; - gint32 height; + gint x; + gint y; + gint width; + gint height; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); x = g_value_get_int (gimp_value_array_index (args, 1)); @@ -603,9 +603,9 @@ drawable_get_pixel_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpDrawable *drawable; - gint32 x_coord; - gint32 y_coord; - gint32 num_channels = 0; + gint x_coord; + gint y_coord; + gint num_channels = 0; guint8 *pixel = NULL; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); @@ -652,9 +652,9 @@ drawable_set_pixel_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 x_coord; - gint32 y_coord; - gint32 num_channels; + gint x_coord; + gint y_coord; + gint num_channels; const guint8 *pixel; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); @@ -696,7 +696,7 @@ drawable_fill_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 fill_type; + gint fill_type; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); fill_type = g_value_get_enum (gimp_value_array_index (args, 1)); @@ -728,9 +728,9 @@ drawable_offset_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpDrawable *drawable; gboolean wrap_around; - gint32 fill_type; - gint32 offset_x; - gint32 offset_y; + gint fill_type; + gint offset_x; + gint offset_y; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); wrap_around = g_value_get_boolean (gimp_value_array_index (args, 1)); @@ -764,12 +764,12 @@ drawable_thumbnail_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpDrawable *drawable; - gint32 width; - gint32 height; - gint32 actual_width = 0; - gint32 actual_height = 0; - gint32 bpp = 0; - gint32 thumbnail_data_count = 0; + gint width; + gint height; + gint actual_width = 0; + gint actual_height = 0; + gint bpp = 0; + gint thumbnail_data_count = 0; guint8 *thumbnail_data = NULL; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); @@ -842,16 +842,16 @@ drawable_sub_thumbnail_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpDrawable *drawable; - gint32 src_x; - gint32 src_y; - gint32 src_width; - gint32 src_height; - gint32 dest_width; - gint32 dest_height; - gint32 width = 0; - gint32 height = 0; - gint32 bpp = 0; - gint32 thumbnail_data_count = 0; + gint src_x; + gint src_y; + gint src_width; + gint src_height; + gint dest_width; + gint dest_height; + gint width = 0; + gint height = 0; + gint bpp = 0; + gint thumbnail_data_count = 0; guint8 *thumbnail_data = NULL; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); @@ -923,7 +923,7 @@ drawable_foreground_extract_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 mode; + gint mode; GimpDrawable *mask; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); @@ -1237,11 +1237,11 @@ register_drawable_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("bpp", - "bpp", - "Bytes per pixel", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("bpp", + "bpp", + "Bytes per pixel", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -1266,11 +1266,11 @@ register_drawable_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("width", - "width", - "Width of drawable", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("width", + "width", + "Width of drawable", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -1295,11 +1295,11 @@ register_drawable_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("height", - "height", - "Height of drawable", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("height", + "height", + "Height of drawable", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -1324,17 +1324,17 @@ register_drawable_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("offset-x", - "offset x", - "x offset of drawable", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("offset-x", + "offset x", + "x offset of drawable", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("offset-y", - "offset y", - "y offset of drawable", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("offset-y", + "offset y", + "y offset of drawable", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -1366,29 +1366,29 @@ register_drawable_procs (GimpPDB *pdb) FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("x1", - "x1", - "x coordinate of the upper left corner of selection bounds", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("x1", + "x1", + "x coordinate of the upper left corner of selection bounds", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("y1", - "y1", - "y coordinate of the upper left corner of selection bounds", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("y1", + "y1", + "y coordinate of the upper left corner of selection bounds", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("x2", - "x2", - "x coordinate of the lower right corner of selection bounds", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("x2", + "x2", + "x coordinate of the lower right corner of selection bounds", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("y2", - "y2", - "y coordinate of the lower right corner of selection bounds", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("y2", + "y2", + "y coordinate of the lower right corner of selection bounds", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -1420,29 +1420,29 @@ register_drawable_procs (GimpPDB *pdb) FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("x", - "x", - "x coordinate of the upper left corner of the intersection", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("x", + "x", + "x coordinate of the upper left corner of the intersection", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("y", - "y", - "y coordinate of the upper left corner of the intersection", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("y", + "y", + "y coordinate of the upper left corner of the intersection", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("width", - "width", - "width of the intersection", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("width", + "width", + "width of the intersection", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("height", - "height", - "height of the intersection", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("height", + "height", + "height of the intersection", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -1519,29 +1519,29 @@ register_drawable_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("x", - "x", - "x coordinate of upper left corner of update region", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("x", + "x", + "x coordinate of upper left corner of update region", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("y", - "y", - "y coordinate of upper left corner of update region", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("y", + "y", + "y coordinate of upper left corner of update region", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("width", - "width", - "Width of update region", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("width", + "width", + "Width of update region", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("height", - "height", - "Height of update region", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("height", + "height", + "Height of update region", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -1566,23 +1566,23 @@ register_drawable_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("x-coord", - "x coord", - "The x coordinate", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("x-coord", + "x coord", + "The x coordinate", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("y-coord", - "y coord", - "The y coordinate", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("y-coord", + "y coord", + "The y coordinate", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-channels", - "num channels", - "The number of channels for the pixel", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE)); + g_param_spec_int ("num-channels", + "num channels", + "The number of channels for the pixel", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_int8_array ("pixel", "pixel", @@ -1612,23 +1612,23 @@ register_drawable_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("x-coord", - "x coord", - "The x coordinate", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("x-coord", + "x coord", + "The x coordinate", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("y-coord", - "y coord", - "The y coordinate", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("y-coord", + "y coord", + "The y coordinate", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("num-channels", - "num channels", - "The number of channels for the pixel", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE)); + g_param_spec_int ("num-channels", + "num channels", + "The number of channels for the pixel", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE)); gimp_procedure_add_argument (procedure, gimp_param_spec_int8_array ("pixel", "pixel", @@ -1702,17 +1702,17 @@ register_drawable_procs (GimpPDB *pdb) GIMP_OFFSET_BACKGROUND, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("offset-x", - "offset x", - "offset by this amount in X direction", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("offset-x", + "offset x", + "offset by this amount in X direction", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("offset-y", - "offset y", - "offset by this amount in Y direction", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("offset-y", + "offset y", + "offset by this amount in Y direction", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -1737,41 +1737,41 @@ register_drawable_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("width", - "width", - "The requested thumbnail width", - 1, 1024, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("width", + "width", + "The requested thumbnail width", + 1, 1024, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("height", - "height", - "The requested thumbnail height", - 1, 1024, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("height", + "height", + "The requested thumbnail height", + 1, 1024, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("actual-width", - "actual width", - "The previews width", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("actual-width", + "actual width", + "The previews width", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("actual-height", - "actual height", - "The previews height", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("actual-height", + "actual height", + "The previews height", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("bpp", - "bpp", - "The previews bpp", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("bpp", + "bpp", + "The previews bpp", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("thumbnail-data-count", - "thumbnail data count", - "The number of bytes in thumbnail data", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("thumbnail-data-count", + "thumbnail data count", + "The number of bytes in thumbnail data", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_int8_array ("thumbnail-data", "thumbnail data", @@ -1801,65 +1801,65 @@ register_drawable_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("src-x", - "src x", - "The x coordinate of the area", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("src-x", + "src x", + "The x coordinate of the area", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("src-y", - "src y", - "The y coordinate of the area", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("src-y", + "src y", + "The y coordinate of the area", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("src-width", - "src width", - "The width of the area", - 1, G_MAXINT32, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("src-width", + "src width", + "The width of the area", + 1, G_MAXINT32, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("src-height", - "src height", - "The height of the area", - 1, G_MAXINT32, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("src-height", + "src height", + "The height of the area", + 1, G_MAXINT32, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("dest-width", - "dest width", - "The thumbnail width", - 1, 1024, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("dest-width", + "dest width", + "The thumbnail width", + 1, 1024, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("dest-height", - "dest height", - "The thumbnail height", - 1, 1024, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("dest-height", + "dest height", + "The thumbnail height", + 1, 1024, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("width", - "width", - "The previews width", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("width", + "width", + "The previews width", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("height", - "height", - "The previews height", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("height", + "height", + "The previews height", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("bpp", - "bpp", - "The previews bpp", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("bpp", + "bpp", + "The previews bpp", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("thumbnail-data-count", - "thumbnail data count", - "The number of bytes in thumbnail data", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("thumbnail-data-count", + "thumbnail data count", + "The number of bytes in thumbnail data", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_int8_array ("thumbnail-data", "thumbnail data", diff --git a/app/pdb/drawable-color-cmds.c b/app/pdb/drawable-color-cmds.c index b921d81b9a..e170686a42 100644 --- a/app/pdb/drawable-color-cmds.c +++ b/app/pdb/drawable-color-cmds.c @@ -103,7 +103,7 @@ drawable_color_balance_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 transfer_mode; + gint transfer_mode; gboolean preserve_lum; gdouble cyan_red; gdouble magenta_green; @@ -204,8 +204,8 @@ drawable_curves_explicit_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 channel; - gint32 num_values; + gint channel; + gint num_values; const gdouble *values; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); @@ -253,8 +253,8 @@ drawable_curves_spline_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 channel; - gint32 num_points; + gint channel; + gint num_points; const gdouble *points; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); @@ -301,7 +301,7 @@ drawable_desaturate_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 desaturate_mode; + gint desaturate_mode; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); desaturate_mode = g_value_get_enum (gimp_value_array_index (args, 1)); @@ -373,7 +373,7 @@ drawable_histogram_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpDrawable *drawable; - gint32 channel; + gint channel; gdouble start_range; gdouble end_range; gdouble mean = 0.0; @@ -463,7 +463,7 @@ drawable_hue_saturation_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 hue_range; + gint hue_range; gdouble hue_offset; gdouble lightness; gdouble saturation; @@ -553,7 +553,7 @@ drawable_levels_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 channel; + gint channel; gdouble low_input; gdouble high_input; gboolean clamp_input; @@ -649,7 +649,7 @@ drawable_posterize_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 levels; + gint levels; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); levels = g_value_get_int (gimp_value_array_index (args, 1)); @@ -689,7 +689,7 @@ drawable_threshold_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 channel; + gint channel; gdouble low_threshold; gdouble high_threshold; @@ -888,11 +888,11 @@ register_drawable_color_procs (GimpPDB *pdb) GIMP_HISTOGRAM_VALUE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("num-values", - "num values", - "The number of values in the new curve", - 256, 2096, 256, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-values", + "num values", + "The number of values in the new curve", + 256, 2096, 256, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_float_array ("values", "values", @@ -929,11 +929,11 @@ register_drawable_color_procs (GimpPDB *pdb) GIMP_HISTOGRAM_VALUE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("num-points", - "num points", - "The number of values in the control point array", - 4, 2048, 4, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-points", + "num points", + "The number of values in the control point array", + 4, 2048, 4, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_float_array ("points", "points", @@ -1278,11 +1278,11 @@ register_drawable_color_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("levels", - "levels", - "Levels of posterization", - 2, 255, 2, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("levels", + "levels", + "Levels of posterization", + 2, 255, 2, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); diff --git a/app/pdb/drawable-edit-cmds.c b/app/pdb/drawable-edit-cmds.c index 43a0a4deee..578c5360d0 100644 --- a/app/pdb/drawable-edit-cmds.c +++ b/app/pdb/drawable-edit-cmds.c @@ -91,7 +91,7 @@ drawable_edit_fill_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 fill_type; + gint fill_type; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); fill_type = g_value_get_enum (gimp_value_array_index (args, 1)); @@ -137,7 +137,7 @@ drawable_edit_bucket_fill_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 fill_type; + gint fill_type; gdouble x; gdouble y; @@ -196,10 +196,10 @@ drawable_edit_gradient_fill_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 gradient_type; + gint gradient_type; gdouble offset; gboolean supersample; - gint32 supersample_max_depth; + gint supersample_max_depth; gdouble supersample_threshold; gboolean dither; gdouble x1; @@ -518,11 +518,11 @@ register_drawable_edit_procs (GimpPDB *pdb) FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("supersample-max-depth", - "supersample max depth", - "Maximum recursion levels for supersampling", - 1, 9, 1, - GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE)); + g_param_spec_int ("supersample-max-depth", + "supersample max depth", + "Maximum recursion levels for supersampling", + 1, 9, 1, + GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE)); gimp_procedure_add_argument (procedure, g_param_spec_double ("supersample-threshold", "supersample threshold", diff --git a/app/pdb/dynamics-cmds.c b/app/pdb/dynamics-cmds.c index 34390f6c2d..d0d49cb4bb 100644 --- a/app/pdb/dynamics-cmds.c +++ b/app/pdb/dynamics-cmds.c @@ -62,7 +62,7 @@ dynamics_get_list_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; const gchar *filter; - gint32 num_dynamics = 0; + gint num_dynamics = 0; gchar **dynamics_list = NULL; filter = g_value_get_string (gimp_value_array_index (args, 0)); @@ -129,11 +129,11 @@ register_dynamics_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-dynamics", - "num dynamics", - "The number of available paint dynamics", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-dynamics", + "num dynamics", + "The number of available paint dynamics", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_string_array ("dynamics-list", "dynamics list", diff --git a/app/pdb/fileops-cmds.c b/app/pdb/fileops-cmds.c index 2f606bdb51..5badefda6f 100644 --- a/app/pdb/fileops-cmds.c +++ b/app/pdb/fileops-cmds.c @@ -140,7 +140,7 @@ file_load_layer_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpValueArray *return_vals; - gint32 run_mode; + gint run_mode; GimpImage *image; const gchar *filename; GimpLayer *layer = NULL; @@ -195,10 +195,10 @@ file_load_layers_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpValueArray *return_vals; - gint32 run_mode; + gint run_mode; GimpImage *image; const gchar *filename; - gint32 num_layers = 0; + gint num_layers = 0; gint32 *layer_ids = NULL; run_mode = g_value_get_enum (gimp_value_array_index (args, 0)); @@ -344,9 +344,9 @@ file_load_thumbnail_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; const gchar *filename; - gint32 width = 0; - gint32 height = 0; - gint32 thumb_data_count = 0; + gint width = 0; + gint height = 0; + gint thumb_data_count = 0; guint8 *thumb_data = NULL; filename = g_value_get_string (gimp_value_array_index (args, 0)); @@ -515,7 +515,7 @@ register_file_handler_priority_invoker (GimpProcedure *procedure, { gboolean success = TRUE; const gchar *procedure_name; - gint32 priority; + gint priority; procedure_name = g_value_get_string (gimp_value_array_index (args, 0)); priority = g_value_get_int (gimp_value_array_index (args, 1)); @@ -781,11 +781,11 @@ register_fileops_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-layers", - "num layers", - "The number of loaded layers", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-layers", + "num layers", + "The number of loaded layers", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_int32_array ("layer-ids", "layer ids", @@ -866,23 +866,23 @@ register_fileops_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("width", - "width", - "The width of the thumbnail", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("width", + "width", + "The width of the thumbnail", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("height", - "height", - "The height of the thumbnail", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("height", + "height", + "The height of the thumbnail", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("thumb-data-count", - "thumb data count", - "The number of bytes in thumbnail data", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("thumb-data-count", + "thumb data count", + "The number of bytes in thumbnail data", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_int8_array ("thumb-data", "thumb data", @@ -1064,11 +1064,11 @@ register_fileops_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("priority", - "priority", - "The procedure priority.", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("priority", + "priority", + "The procedure priority.", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); diff --git a/app/pdb/fonts-cmds.c b/app/pdb/fonts-cmds.c index bc28d0287e..47845eb207 100644 --- a/app/pdb/fonts-cmds.c +++ b/app/pdb/fonts-cmds.c @@ -63,7 +63,7 @@ fonts_get_list_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; const gchar *filter; - gint32 num_fonts = 0; + gint num_fonts = 0; gchar **font_list = NULL; filter = g_value_get_string (gimp_value_array_index (args, 0)); @@ -136,11 +136,11 @@ register_fonts_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-fonts", - "num fonts", - "The number of available fonts", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-fonts", + "num fonts", + "The number of available fonts", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_string_array ("font-list", "font list", diff --git a/app/pdb/gimp-cmds.c b/app/pdb/gimp-cmds.c index 66c20ee811..e5802b299e 100644 --- a/app/pdb/gimp-cmds.c +++ b/app/pdb/gimp-cmds.c @@ -67,7 +67,7 @@ getpid_invoker (GimpProcedure *procedure, GError **error) { GimpValueArray *return_vals; - gint32 pid = 0; + gint pid = 0; pid = gimp_get_pid (); @@ -187,7 +187,7 @@ get_parasite_list_invoker (GimpProcedure *procedure, GError **error) { GimpValueArray *return_vals; - gint32 num_parasites = 0; + gint num_parasites = 0; gchar **parasites = NULL; parasites = gimp_parasite_list (gimp, &num_parasites); @@ -277,11 +277,11 @@ register_gimp_procs (GimpPDB *pdb) "2005", NULL); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("pid", - "pid", - "The PID", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("pid", + "pid", + "The PID", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -398,11 +398,11 @@ register_gimp_procs (GimpPDB *pdb) "1999", NULL); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-parasites", - "num parasites", - "The number of attached parasites", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-parasites", + "num parasites", + "The number of attached parasites", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_string_array ("parasites", "parasites", diff --git a/app/pdb/gimp-pdb-compat.c b/app/pdb/gimp-pdb-compat.c index e5822848e6..0902686dcc 100644 --- a/app/pdb/gimp-pdb-compat.c +++ b/app/pdb/gimp-pdb-compat.c @@ -50,7 +50,6 @@ gimp_pdb_compat_arg_type_from_gtype (GType type) } type_mapping[] = { - { GIMP_TYPE_INT32, GIMP_PDB_INT32 }, { G_TYPE_INT, GIMP_PDB_INT32 }, { G_TYPE_UINT, GIMP_PDB_INT32 }, { G_TYPE_ENUM, GIMP_PDB_INT32 }, diff --git a/app/pdb/gimppdb.c b/app/pdb/gimppdb.c index a621246d37..001bf44c49 100644 --- a/app/pdb/gimppdb.c +++ b/app/pdb/gimppdb.c @@ -402,7 +402,7 @@ gimp_pdb_execute_procedure_by_name (GimpPDB *pdb, value_type = G_VALUE_TYPE (value); - /* GIMP_TYPE_INT32 is widely abused for enums and booleans in + /* G_TYPE_INT is widely abused for enums and booleans in * old plug-ins, silently copy stuff into integers when enums * and booleans are passed */ @@ -410,14 +410,11 @@ gimp_pdb_execute_procedure_by_name (GimpPDB *pdb, && - (value_type == G_TYPE_INT || - value_type == GIMP_TYPE_INT32) + value_type == G_TYPE_INT && - (arg_type == G_TYPE_INT || - arg_type == GIMP_TYPE_INT32 || - arg_type == G_TYPE_BOOLEAN || + (arg_type == G_TYPE_BOOLEAN || g_type_is_a (arg_type, G_TYPE_ENUM))) { arg_type = value_type; diff --git a/app/pdb/gradient-cmds.c b/app/pdb/gradient-cmds.c index 589ce33863..2c51a8600a 100644 --- a/app/pdb/gradient-cmds.c +++ b/app/pdb/gradient-cmds.c @@ -284,7 +284,7 @@ gradient_get_number_of_segments_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; const gchar *name; - gint32 num_segments = 0; + gint num_segments = 0; name = g_value_get_string (gimp_value_array_index (args, 0)); @@ -324,9 +324,9 @@ gradient_get_uniform_samples_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; const gchar *name; - gint32 num_samples; + gint num_samples; gboolean reverse; - gint32 num_color_samples = 0; + gint num_color_samples = 0; gdouble *color_samples = NULL; name = g_value_get_string (gimp_value_array_index (args, 0)); @@ -394,10 +394,10 @@ gradient_get_custom_samples_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; const gchar *name; - gint32 num_samples; + gint num_samples; const gdouble *positions; gboolean reverse; - gint32 num_color_samples = 0; + gint num_color_samples = 0; gdouble *color_samples = NULL; name = g_value_get_string (gimp_value_array_index (args, 0)); @@ -465,7 +465,7 @@ gradient_segment_get_left_color_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; const gchar *name; - gint32 segment; + gint segment; GimpRGB color = { 0.0, 0.0, 0.0, 1.0 }; gdouble opacity = 0.0; @@ -511,7 +511,7 @@ gradient_segment_set_left_color_invoker (GimpProcedure *procedure, { gboolean success = TRUE; const gchar *name; - gint32 segment; + gint segment; GimpRGB color; gdouble opacity; @@ -552,7 +552,7 @@ gradient_segment_get_right_color_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; const gchar *name; - gint32 segment; + gint segment; GimpRGB color = { 0.0, 0.0, 0.0, 1.0 }; gdouble opacity = 0.0; @@ -598,7 +598,7 @@ gradient_segment_set_right_color_invoker (GimpProcedure *procedure, { gboolean success = TRUE; const gchar *name; - gint32 segment; + gint segment; GimpRGB color; gdouble opacity; @@ -639,7 +639,7 @@ gradient_segment_get_left_pos_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; const gchar *name; - gint32 segment; + gint segment; gdouble pos = 0.0; name = g_value_get_string (gimp_value_array_index (args, 0)); @@ -681,7 +681,7 @@ gradient_segment_set_left_pos_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; const gchar *name; - gint32 segment; + gint segment; gdouble pos; gdouble final_pos = 0.0; @@ -725,7 +725,7 @@ gradient_segment_get_middle_pos_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; const gchar *name; - gint32 segment; + gint segment; gdouble pos = 0.0; name = g_value_get_string (gimp_value_array_index (args, 0)); @@ -767,7 +767,7 @@ gradient_segment_set_middle_pos_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; const gchar *name; - gint32 segment; + gint segment; gdouble pos; gdouble final_pos = 0.0; @@ -812,7 +812,7 @@ gradient_segment_get_right_pos_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; const gchar *name; - gint32 segment; + gint segment; gdouble pos = 0.0; name = g_value_get_string (gimp_value_array_index (args, 0)); @@ -854,7 +854,7 @@ gradient_segment_set_right_pos_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; const gchar *name; - gint32 segment; + gint segment; gdouble pos; gdouble final_pos = 0.0; @@ -899,8 +899,8 @@ gradient_segment_get_blending_function_invoker (GimpProcedure *procedure gboolean success = TRUE; GimpValueArray *return_vals; const gchar *name; - gint32 segment; - gint32 blend_func = 0; + gint segment; + gint blend_func = 0; name = g_value_get_string (gimp_value_array_index (args, 0)); segment = g_value_get_int (gimp_value_array_index (args, 1)); @@ -941,8 +941,8 @@ gradient_segment_get_coloring_type_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; const gchar *name; - gint32 segment; - gint32 coloring_type = 0; + gint segment; + gint coloring_type = 0; name = g_value_get_string (gimp_value_array_index (args, 0)); segment = g_value_get_int (gimp_value_array_index (args, 1)); @@ -982,9 +982,9 @@ gradient_segment_range_set_blending_function_invoker (GimpProcedure *pro { gboolean success = TRUE; const gchar *name; - gint32 start_segment; - gint32 end_segment; - gint32 blending_function; + gint start_segment; + gint end_segment; + gint blending_function; name = g_value_get_string (gimp_value_array_index (args, 0)); start_segment = g_value_get_int (gimp_value_array_index (args, 1)); @@ -1024,9 +1024,9 @@ gradient_segment_range_set_coloring_type_invoker (GimpProcedure *procedu { gboolean success = TRUE; const gchar *name; - gint32 start_segment; - gint32 end_segment; - gint32 coloring_type; + gint start_segment; + gint end_segment; + gint coloring_type; name = g_value_get_string (gimp_value_array_index (args, 0)); start_segment = g_value_get_int (gimp_value_array_index (args, 1)); @@ -1066,8 +1066,8 @@ gradient_segment_range_flip_invoker (GimpProcedure *procedure, { gboolean success = TRUE; const gchar *name; - gint32 start_segment; - gint32 end_segment; + gint start_segment; + gint end_segment; name = g_value_get_string (gimp_value_array_index (args, 0)); start_segment = g_value_get_int (gimp_value_array_index (args, 1)); @@ -1106,9 +1106,9 @@ gradient_segment_range_replicate_invoker (GimpProcedure *procedure, { gboolean success = TRUE; const gchar *name; - gint32 start_segment; - gint32 end_segment; - gint32 replicate_times; + gint start_segment; + gint end_segment; + gint replicate_times; name = g_value_get_string (gimp_value_array_index (args, 0)); start_segment = g_value_get_int (gimp_value_array_index (args, 1)); @@ -1149,8 +1149,8 @@ gradient_segment_range_split_midpoint_invoker (GimpProcedure *procedure, { gboolean success = TRUE; const gchar *name; - gint32 start_segment; - gint32 end_segment; + gint start_segment; + gint end_segment; name = g_value_get_string (gimp_value_array_index (args, 0)); start_segment = g_value_get_int (gimp_value_array_index (args, 1)); @@ -1190,9 +1190,9 @@ gradient_segment_range_split_uniform_invoker (GimpProcedure *procedure, { gboolean success = TRUE; const gchar *name; - gint32 start_segment; - gint32 end_segment; - gint32 split_parts; + gint start_segment; + gint end_segment; + gint split_parts; name = g_value_get_string (gimp_value_array_index (args, 0)); start_segment = g_value_get_int (gimp_value_array_index (args, 1)); @@ -1234,8 +1234,8 @@ gradient_segment_range_delete_invoker (GimpProcedure *procedure, { gboolean success = TRUE; const gchar *name; - gint32 start_segment; - gint32 end_segment; + gint start_segment; + gint end_segment; name = g_value_get_string (gimp_value_array_index (args, 0)); start_segment = g_value_get_int (gimp_value_array_index (args, 1)); @@ -1274,8 +1274,8 @@ gradient_segment_range_redistribute_handles_invoker (GimpProcedure *proc { gboolean success = TRUE; const gchar *name; - gint32 start_segment; - gint32 end_segment; + gint start_segment; + gint end_segment; name = g_value_get_string (gimp_value_array_index (args, 0)); start_segment = g_value_get_int (gimp_value_array_index (args, 1)); @@ -1313,8 +1313,8 @@ gradient_segment_range_blend_colors_invoker (GimpProcedure *procedure, { gboolean success = TRUE; const gchar *name; - gint32 start_segment; - gint32 end_segment; + gint start_segment; + gint end_segment; name = g_value_get_string (gimp_value_array_index (args, 0)); start_segment = g_value_get_int (gimp_value_array_index (args, 1)); @@ -1358,8 +1358,8 @@ gradient_segment_range_blend_opacity_invoker (GimpProcedure *procedure, { gboolean success = TRUE; const gchar *name; - gint32 start_segment; - gint32 end_segment; + gint start_segment; + gint end_segment; name = g_value_get_string (gimp_value_array_index (args, 0)); start_segment = g_value_get_int (gimp_value_array_index (args, 1)); @@ -1404,8 +1404,8 @@ gradient_segment_range_move_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; const gchar *name; - gint32 start_segment; - gint32 end_segment; + gint start_segment; + gint end_segment; gdouble delta; gboolean control_compress; gdouble final_delta = 0.0; @@ -1626,11 +1626,11 @@ register_gradient_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-segments", - "num segments", - "Number of segments", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-segments", + "num segments", + "Number of segments", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -1656,11 +1656,11 @@ register_gradient_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("num-samples", - "num samples", - "The number of samples to take", - 2, G_MAXINT32, 2, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-samples", + "num samples", + "The number of samples to take", + 2, G_MAXINT32, 2, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_boolean ("reverse", "reverse", @@ -1668,11 +1668,11 @@ register_gradient_procs (GimpPDB *pdb) FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-color-samples", - "num color samples", - "Length of the color_samples array (4 * num_samples)", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-color-samples", + "num color samples", + "Length of the color_samples array (4 * num_samples)", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_float_array ("color-samples", "color samples", @@ -1703,11 +1703,11 @@ register_gradient_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("num-samples", - "num samples", - "The number of samples to take", - 1, G_MAXINT32, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-samples", + "num samples", + "The number of samples to take", + 1, G_MAXINT32, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_float_array ("positions", "positions", @@ -1720,11 +1720,11 @@ register_gradient_procs (GimpPDB *pdb) FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-color-samples", - "num color samples", - "Length of the color_samples array (4 * num_samples)", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-color-samples", + "num color samples", + "Length of the color_samples array (4 * num_samples)", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_float_array ("color-samples", "color samples", @@ -1755,11 +1755,11 @@ register_gradient_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("segment", - "segment", - "The index of the segment within the gradient", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("segment", + "segment", + "The index of the segment within the gradient", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_rgb ("color", "color", @@ -1798,11 +1798,11 @@ register_gradient_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("segment", - "segment", - "The index of the segment within the gradient", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("segment", + "segment", + "The index of the segment within the gradient", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_rgb ("color", "color", @@ -1841,11 +1841,11 @@ register_gradient_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("segment", - "segment", - "The index of the segment within the gradient", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("segment", + "segment", + "The index of the segment within the gradient", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_rgb ("color", "color", @@ -1884,11 +1884,11 @@ register_gradient_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("segment", - "segment", - "The index of the segment within the gradient", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("segment", + "segment", + "The index of the segment within the gradient", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_rgb ("color", "color", @@ -1927,11 +1927,11 @@ register_gradient_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("segment", - "segment", - "The index of the segment within the gradient", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("segment", + "segment", + "The index of the segment within the gradient", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, g_param_spec_double ("pos", "pos", @@ -1964,11 +1964,11 @@ register_gradient_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("segment", - "segment", - "The index of the segment within the gradient", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("segment", + "segment", + "The index of the segment within the gradient", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_double ("pos", "pos", @@ -2006,11 +2006,11 @@ register_gradient_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("segment", - "segment", - "The index of the segment within the gradient", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("segment", + "segment", + "The index of the segment within the gradient", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, g_param_spec_double ("pos", "pos", @@ -2043,11 +2043,11 @@ register_gradient_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("segment", - "segment", - "The index of the segment within the gradient", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("segment", + "segment", + "The index of the segment within the gradient", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_double ("pos", "pos", @@ -2085,11 +2085,11 @@ register_gradient_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("segment", - "segment", - "The index of the segment within the gradient", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("segment", + "segment", + "The index of the segment within the gradient", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, g_param_spec_double ("pos", "pos", @@ -2122,11 +2122,11 @@ register_gradient_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("segment", - "segment", - "The index of the segment within the gradient", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("segment", + "segment", + "The index of the segment within the gradient", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_double ("pos", "pos", @@ -2164,11 +2164,11 @@ register_gradient_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("segment", - "segment", - "The index of the segment within the gradient", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("segment", + "segment", + "The index of the segment within the gradient", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, g_param_spec_enum ("blend-func", "blend func", @@ -2201,11 +2201,11 @@ register_gradient_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("segment", - "segment", - "The index of the segment within the gradient", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("segment", + "segment", + "The index of the segment within the gradient", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, g_param_spec_enum ("coloring-type", "coloring type", @@ -2238,17 +2238,17 @@ register_gradient_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("start-segment", - "start segment", - "The index of the first segment to operate on", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("start-segment", + "start segment", + "The index of the first segment to operate on", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("end-segment", - "end segment", - "The index of the last segment to operate on. If negative, the selection will extend to the end of the string.", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("end-segment", + "end segment", + "The index of the last segment to operate on. If negative, the selection will extend to the end of the string.", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_enum ("blending-function", "blending function", @@ -2281,17 +2281,17 @@ register_gradient_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("start-segment", - "start segment", - "The index of the first segment to operate on", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("start-segment", + "start segment", + "The index of the first segment to operate on", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("end-segment", - "end segment", - "The index of the last segment to operate on. If negative, the selection will extend to the end of the string.", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("end-segment", + "end segment", + "The index of the last segment to operate on. If negative, the selection will extend to the end of the string.", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_enum ("coloring-type", "coloring type", @@ -2324,17 +2324,17 @@ register_gradient_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("start-segment", - "start segment", - "The index of the first segment to operate on", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("start-segment", + "start segment", + "The index of the first segment to operate on", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("end-segment", - "end segment", - "The index of the last segment to operate on. If negative, the selection will extend to the end of the string.", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("end-segment", + "end segment", + "The index of the last segment to operate on. If negative, the selection will extend to the end of the string.", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -2360,23 +2360,23 @@ register_gradient_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("start-segment", - "start segment", - "The index of the first segment to operate on", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("start-segment", + "start segment", + "The index of the first segment to operate on", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("end-segment", - "end segment", - "The index of the last segment to operate on. If negative, the selection will extend to the end of the string.", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("end-segment", + "end segment", + "The index of the last segment to operate on. If negative, the selection will extend to the end of the string.", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("replicate-times", - "replicate times", - "The number of times to replicate", - 2, 20, 2, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("replicate-times", + "replicate times", + "The number of times to replicate", + 2, 20, 2, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -2402,17 +2402,17 @@ register_gradient_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("start-segment", - "start segment", - "The index of the first segment to operate on", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("start-segment", + "start segment", + "The index of the first segment to operate on", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("end-segment", - "end segment", - "The index of the last segment to operate on. If negative, the selection will extend to the end of the string.", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("end-segment", + "end segment", + "The index of the last segment to operate on. If negative, the selection will extend to the end of the string.", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -2438,23 +2438,23 @@ register_gradient_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("start-segment", - "start segment", - "The index of the first segment to operate on", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("start-segment", + "start segment", + "The index of the first segment to operate on", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("end-segment", - "end segment", - "The index of the last segment to operate on. If negative, the selection will extend to the end of the string.", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("end-segment", + "end segment", + "The index of the last segment to operate on. If negative, the selection will extend to the end of the string.", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("split-parts", - "split parts", - "The number of uniform divisions to split each segment to", - 2, 1024, 2, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("split-parts", + "split parts", + "The number of uniform divisions to split each segment to", + 2, 1024, 2, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -2480,17 +2480,17 @@ register_gradient_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("start-segment", - "start segment", - "The index of the first segment to operate on", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("start-segment", + "start segment", + "The index of the first segment to operate on", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("end-segment", - "end segment", - "The index of the last segment to operate on. If negative, the selection will extend to the end of the string.", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("end-segment", + "end segment", + "The index of the last segment to operate on. If negative, the selection will extend to the end of the string.", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -2516,17 +2516,17 @@ register_gradient_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("start-segment", - "start segment", - "The index of the first segment to operate on", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("start-segment", + "start segment", + "The index of the first segment to operate on", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("end-segment", - "end segment", - "The index of the last segment to operate on. If negative, the selection will extend to the end of the string.", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("end-segment", + "end segment", + "The index of the last segment to operate on. If negative, the selection will extend to the end of the string.", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -2552,17 +2552,17 @@ register_gradient_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("start-segment", - "start segment", - "The index of the first segment to operate on", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("start-segment", + "start segment", + "The index of the first segment to operate on", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("end-segment", - "end segment", - "The index of the last segment to operate on. If negative, the selection will extend to the end of the string.", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("end-segment", + "end segment", + "The index of the last segment to operate on. If negative, the selection will extend to the end of the string.", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -2588,17 +2588,17 @@ register_gradient_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("start-segment", - "start segment", - "The index of the first segment to operate on", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("start-segment", + "start segment", + "The index of the first segment to operate on", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("end-segment", - "end segment", - "The index of the last segment to operate on. If negative, the selection will extend to the end of the string.", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("end-segment", + "end segment", + "The index of the last segment to operate on. If negative, the selection will extend to the end of the string.", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -2624,17 +2624,17 @@ register_gradient_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("start-segment", - "start segment", - "The index of the first segment to operate on", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("start-segment", + "start segment", + "The index of the first segment to operate on", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("end-segment", - "end segment", - "The index of the last segment to operate on. If negative, the selection will extend to the end of the string.", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("end-segment", + "end segment", + "The index of the last segment to operate on. If negative, the selection will extend to the end of the string.", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_double ("delta", "delta", diff --git a/app/pdb/gradient-select-cmds.c b/app/pdb/gradient-select-cmds.c index 253944765c..8a35cd48c2 100644 --- a/app/pdb/gradient-select-cmds.c +++ b/app/pdb/gradient-select-cmds.c @@ -49,7 +49,7 @@ gradients_popup_invoker (GimpProcedure *procedure, const gchar *gradient_callback; const gchar *popup_title; const gchar *initial_gradient; - gint32 sample_size; + gint sample_size; gradient_callback = g_value_get_string (gimp_value_array_index (args, 0)); popup_title = g_value_get_string (gimp_value_array_index (args, 1)); @@ -171,11 +171,11 @@ register_gradient_select_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("sample-size", - "sample size", - "Size of the sample to return when the gradient is changed", - 1, 10000, 1, - GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE)); + g_param_spec_int ("sample-size", + "sample size", + "Size of the sample to return when the gradient is changed", + 1, 10000, 1, + GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); diff --git a/app/pdb/gradients-cmds.c b/app/pdb/gradients-cmds.c index e46d117818..37af4129c2 100644 --- a/app/pdb/gradients-cmds.c +++ b/app/pdb/gradients-cmds.c @@ -66,7 +66,7 @@ gradients_get_list_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; const gchar *filter; - gint32 num_gradients = 0; + gint num_gradients = 0; gchar **gradient_list = NULL; filter = g_value_get_string (gimp_value_array_index (args, 0)); @@ -133,11 +133,11 @@ register_gradients_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-gradients", - "num gradients", - "The number of loaded gradients", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-gradients", + "num gradients", + "The number of loaded gradients", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_string_array ("gradient-list", "gradient list", diff --git a/app/pdb/image-cmds.c b/app/pdb/image-cmds.c index 73fabe4875..ed611bca7e 100644 --- a/app/pdb/image-cmds.c +++ b/app/pdb/image-cmds.c @@ -109,7 +109,7 @@ image_list_invoker (GimpProcedure *procedure, GError **error) { GimpValueArray *return_vals; - gint32 num_images = 0; + gint num_images = 0; gint32 *image_ids = NULL; GList *list = gimp_get_image_iter (gimp); @@ -144,9 +144,9 @@ image_new_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpValueArray *return_vals; - gint32 width; - gint32 height; - gint32 type; + gint width; + gint height; + gint type; GimpImage *image = NULL; width = g_value_get_int (gimp_value_array_index (args, 0)); @@ -181,10 +181,10 @@ image_new_with_precision_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpValueArray *return_vals; - gint32 width; - gint32 height; - gint32 type; - gint32 precision; + gint width; + gint height; + gint type; + gint precision; GimpImage *image = NULL; width = g_value_get_int (gimp_value_array_index (args, 0)); @@ -282,7 +282,7 @@ image_base_type_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpImage *image; - gint32 base_type = 0; + gint base_type = 0; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); @@ -311,7 +311,7 @@ image_get_precision_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpImage *image; - gint32 precision = 0; + gint precision = 0; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); @@ -340,7 +340,7 @@ image_get_default_new_layer_mode_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpImage *image; - gint32 mode = 0; + gint mode = 0; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); @@ -369,7 +369,7 @@ image_width_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpImage *image; - gint32 width = 0; + gint width = 0; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); @@ -398,7 +398,7 @@ image_height_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpImage *image; - gint32 height = 0; + gint height = 0; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); @@ -427,7 +427,7 @@ image_get_layers_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpImage *image; - gint32 num_layers = 0; + gint num_layers = 0; gint32 *layer_ids = NULL; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); @@ -472,7 +472,7 @@ image_get_channels_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpImage *image; - gint32 num_channels = 0; + gint num_channels = 0; gint32 *channel_ids = NULL; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); @@ -517,7 +517,7 @@ image_get_vectors_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpImage *image; - gint32 num_vectors = 0; + gint num_vectors = 0; gint32 *vector_ids = NULL; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); @@ -743,8 +743,8 @@ image_pick_correlate_layer_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpImage *image; - gint32 x; - gint32 y; + gint x; + gint y; GimpLayer *layer = NULL; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); @@ -777,7 +777,7 @@ image_insert_layer_invoker (GimpProcedure *procedure, GimpImage *image; GimpLayer *layer; GimpLayer *parent; - gint32 position; + gint position; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); layer = gimp_value_get_layer (gimp_value_array_index (args, 1), gimp); @@ -914,7 +914,7 @@ image_insert_channel_invoker (GimpProcedure *procedure, GimpImage *image; GimpChannel *channel; GimpChannel *parent; - gint32 position; + gint position; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); channel = gimp_value_get_channel (gimp_value_array_index (args, 1), gimp); @@ -1044,7 +1044,7 @@ image_insert_vectors_invoker (GimpProcedure *procedure, GimpImage *image; GimpVectors *vectors; GimpVectors *parent; - gint32 position; + gint position; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); vectors = gimp_value_get_vectors (gimp_value_array_index (args, 1), gimp); @@ -1174,7 +1174,7 @@ image_get_item_position_invoker (GimpProcedure *procedure, GimpValueArray *return_vals; GimpImage *image; GimpItem *item; - gint32 position = 0; + gint position = 0; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); item = gimp_value_get_item (gimp_value_array_index (args, 1), gimp); @@ -1316,7 +1316,7 @@ image_reorder_item_invoker (GimpProcedure *procedure, GimpImage *image; GimpItem *item; GimpItem *parent; - gint32 position; + gint position; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); item = gimp_value_get_item (gimp_value_array_index (args, 1), gimp); @@ -1386,7 +1386,7 @@ image_merge_visible_layers_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpImage *image; - gint32 merge_type; + gint merge_type; GimpLayer *layer = NULL; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); @@ -1423,7 +1423,7 @@ image_merge_down_invoker (GimpProcedure *procedure, GimpValueArray *return_vals; GimpImage *image; GimpLayer *merge_layer; - gint32 merge_type; + gint merge_type; GimpLayer *layer = NULL; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); @@ -1464,7 +1464,7 @@ image_get_colormap_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpImage *image; - gint32 num_bytes = 0; + gint num_bytes = 0; guint8 *colormap = NULL; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); @@ -1497,7 +1497,7 @@ image_set_colormap_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpImage *image; - gint32 num_bytes; + gint num_bytes; const guint8 *colormap; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); @@ -1636,12 +1636,12 @@ image_thumbnail_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpImage *image; - gint32 width; - gint32 height; - gint32 actual_width = 0; - gint32 actual_height = 0; - gint32 bpp = 0; - gint32 thumbnail_data_count = 0; + gint width; + gint height; + gint actual_width = 0; + gint actual_height = 0; + gint bpp = 0; + gint thumbnail_data_count = 0; guint8 *thumbnail_data = NULL; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); @@ -1904,7 +1904,7 @@ image_get_component_active_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpImage *image; - gint32 component; + gint component; gboolean active = FALSE; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); @@ -1942,7 +1942,7 @@ image_set_component_active_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpImage *image; - gint32 component; + gint component; gboolean active; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); @@ -1977,7 +1977,7 @@ image_get_component_visible_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpImage *image; - gint32 component; + gint component; gboolean visible = FALSE; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); @@ -2015,7 +2015,7 @@ image_set_component_visible_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpImage *image; - gint32 component; + gint component; gboolean visible; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); @@ -2412,7 +2412,7 @@ image_get_tattoo_state_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpImage *image; - gint32 tattoo_state = 0; + gint tattoo_state = 0; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); @@ -2440,7 +2440,7 @@ image_set_tattoo_state_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpImage *image; - gint32 tattoo_state; + gint tattoo_state; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); tattoo_state = g_value_get_uint (gimp_value_array_index (args, 1)); @@ -2465,7 +2465,7 @@ image_get_layer_by_tattoo_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpImage *image; - gint32 tattoo; + gint tattoo; GimpLayer *layer = NULL; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); @@ -2496,7 +2496,7 @@ image_get_channel_by_tattoo_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpImage *image; - gint32 tattoo; + gint tattoo; GimpChannel *channel = NULL; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); @@ -2527,7 +2527,7 @@ image_get_vectors_by_tattoo_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpImage *image; - gint32 tattoo; + gint tattoo; GimpVectors *vectors = NULL; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); @@ -2736,7 +2736,7 @@ image_get_parasite_list_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpImage *image; - gint32 num_parasites = 0; + gint num_parasites = 0; gchar **parasites = NULL; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); @@ -2807,11 +2807,11 @@ register_image_procs (GimpPDB *pdb) "1995-1996", NULL); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-images", - "num images", - "The number of images currently open", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-images", + "num images", + "The number of images currently open", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_int32_array ("image-ids", "image ids", @@ -2837,17 +2837,17 @@ register_image_procs (GimpPDB *pdb) "1995-1996", NULL); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("width", - "width", - "The width of the image", - 1, GIMP_MAX_IMAGE_SIZE, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("width", + "width", + "The width of the image", + 1, GIMP_MAX_IMAGE_SIZE, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("height", - "height", - "The height of the image", - 1, GIMP_MAX_IMAGE_SIZE, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("height", + "height", + "The height of the image", + 1, GIMP_MAX_IMAGE_SIZE, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_enum ("type", "type", @@ -2879,17 +2879,17 @@ register_image_procs (GimpPDB *pdb) "2012", NULL); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("width", - "width", - "The width of the image", - 1, GIMP_MAX_IMAGE_SIZE, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("width", + "width", + "The width of the image", + 1, GIMP_MAX_IMAGE_SIZE, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("height", - "height", - "The height of the image", - 1, GIMP_MAX_IMAGE_SIZE, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("height", + "height", + "The height of the image", + 1, GIMP_MAX_IMAGE_SIZE, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_enum ("type", "type", @@ -3076,11 +3076,11 @@ register_image_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("width", - "width", - "The image's width", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("width", + "width", + "The image's width", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -3105,11 +3105,11 @@ register_image_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("height", - "height", - "The image's height", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("height", + "height", + "The image's height", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -3134,11 +3134,11 @@ register_image_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-layers", - "num layers", - "The number of layers contained in the image", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-layers", + "num layers", + "The number of layers contained in the image", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_int32_array ("layer-ids", "layer ids", @@ -3168,11 +3168,11 @@ register_image_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-channels", - "num channels", - "The number of channels contained in the image", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-channels", + "num channels", + "The number of channels contained in the image", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_int32_array ("channel-ids", "channel ids", @@ -3202,11 +3202,11 @@ register_image_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-vectors", - "num vectors", - "The number of vectors contained in the image", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-vectors", + "num vectors", + "The number of vectors contained in the image", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_int32_array ("vector-ids", "vector ids", @@ -3412,17 +3412,17 @@ register_image_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("x", - "x", - "The x coordinate for the pick", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("x", + "x", + "The x coordinate for the pick", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("y", - "y", - "The y coordinate for the pick", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("y", + "y", + "The y coordinate for the pick", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_layer_id ("layer", "layer", @@ -3465,11 +3465,11 @@ register_image_procs (GimpPDB *pdb) pdb->gimp, TRUE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("position", - "position", - "The layer position", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("position", + "position", + "The layer position", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -3585,11 +3585,11 @@ register_image_procs (GimpPDB *pdb) pdb->gimp, TRUE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("position", - "position", - "The channel position", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("position", + "position", + "The channel position", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -3705,11 +3705,11 @@ register_image_procs (GimpPDB *pdb) pdb->gimp, TRUE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("position", - "position", - "The vectors position", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("position", + "position", + "The vectors position", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -3819,11 +3819,11 @@ register_image_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("position", - "position", - "The position of the item in its level in the item tree", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("position", + "position", + "The position of the item in its level in the item tree", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -3976,11 +3976,11 @@ register_image_procs (GimpPDB *pdb) pdb->gimp, TRUE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("position", - "position", - "The new position of the item", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("position", + "position", + "The new position of the item", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -4116,11 +4116,11 @@ register_image_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-bytes", - "num bytes", - "Number of bytes in the colormap array", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-bytes", + "num bytes", + "Number of bytes in the colormap array", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_int8_array ("colormap", "colormap", @@ -4150,11 +4150,11 @@ register_image_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("num-bytes", - "num bytes", - "Number of bytes in the colormap array", - 0, 768, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-bytes", + "num bytes", + "Number of bytes in the colormap array", + 0, 768, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_int8_array ("colormap", "colormap", @@ -4296,41 +4296,41 @@ register_image_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("width", - "width", - "The requested thumbnail width", - 1, 1024, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("width", + "width", + "The requested thumbnail width", + 1, 1024, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("height", - "height", - "The requested thumbnail height", - 1, 1024, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("height", + "height", + "The requested thumbnail height", + 1, 1024, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("actual-width", - "actual width", - "The previews width", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("actual-width", + "actual width", + "The previews width", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("actual-height", - "actual height", - "The previews height", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("actual-height", + "actual height", + "The previews height", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("bpp", - "bpp", - "The previews bpp", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("bpp", + "bpp", + "The previews bpp", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("thumbnail-data-count", - "thumbnail data count", - "The number of bytes in thumbnail data", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("thumbnail-data-count", + "thumbnail data count", + "The number of bytes in thumbnail data", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_int8_array ("thumbnail-data", "thumbnail data", @@ -5413,11 +5413,11 @@ register_image_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-parasites", - "num parasites", - "The number of attached parasites", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-parasites", + "num parasites", + "The number of attached parasites", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_string_array ("parasites", "parasites", diff --git a/app/pdb/image-color-profile-cmds.c b/app/pdb/image-color-profile-cmds.c index a3e70ab85c..6ef5b801f6 100644 --- a/app/pdb/image-color-profile-cmds.c +++ b/app/pdb/image-color-profile-cmds.c @@ -53,7 +53,7 @@ image_get_color_profile_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpImage *image; - gint32 num_bytes = 0; + gint num_bytes = 0; guint8 *profile_data = NULL; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); @@ -99,7 +99,7 @@ image_get_effective_color_profile_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpImage *image; - gint32 num_bytes = 0; + gint num_bytes = 0; guint8 *profile_data = NULL; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); @@ -144,7 +144,7 @@ image_set_color_profile_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpImage *image; - gint32 num_bytes; + gint num_bytes; const guint8 *color_profile; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); @@ -237,9 +237,9 @@ image_convert_color_profile_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpImage *image; - gint32 num_bytes; + gint num_bytes; const guint8 *color_profile; - gint32 intent; + gint intent; gboolean bpc; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); @@ -287,7 +287,7 @@ image_convert_color_profile_from_file_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpImage *image; const gchar *uri; - gint32 intent; + gint intent; gboolean bpc; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); @@ -350,11 +350,11 @@ register_image_color_profile_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-bytes", - "num bytes", - "Number of bytes in the color_profile array", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-bytes", + "num bytes", + "Number of bytes in the color_profile array", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_int8_array ("profile-data", "profile data", @@ -384,11 +384,11 @@ register_image_color_profile_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-bytes", - "num bytes", - "Number of bytes in the color_profile array", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-bytes", + "num bytes", + "Number of bytes in the color_profile array", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_int8_array ("profile-data", "profile data", @@ -418,11 +418,11 @@ register_image_color_profile_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("num-bytes", - "num bytes", - "Number of bytes in the color_profile array", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-bytes", + "num bytes", + "Number of bytes in the color_profile array", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_int8_array ("color-profile", "color profile", @@ -482,11 +482,11 @@ register_image_color_profile_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("num-bytes", - "num bytes", - "Number of bytes in the color_profile array", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-bytes", + "num bytes", + "Number of bytes in the color_profile array", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_int8_array ("color-profile", "color profile", diff --git a/app/pdb/image-convert-cmds.c b/app/pdb/image-convert-cmds.c index 0374032a1c..d708330581 100644 --- a/app/pdb/image-convert-cmds.c +++ b/app/pdb/image-convert-cmds.c @@ -116,9 +116,9 @@ image_convert_indexed_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpImage *image; - gint32 dither_type; - gint32 palette_type; - gint32 num_cols; + gint dither_type; + gint palette_type; + gint num_cols; gboolean alpha_dither; gboolean remove_unused; const gchar *palette; @@ -194,9 +194,9 @@ image_convert_set_dither_matrix_invoker (GimpProcedure *procedure, GError **error) { gboolean success = TRUE; - gint32 width; - gint32 height; - gint32 matrix_length; + gint width; + gint height; + gint matrix_length; const guint8 *matrix; width = g_value_get_int (gimp_value_array_index (args, 0)); @@ -233,7 +233,7 @@ image_convert_precision_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpImage *image; - gint32 precision; + gint precision; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); precision = g_value_get_enum (gimp_value_array_index (args, 1)); @@ -346,11 +346,11 @@ register_image_convert_procs (GimpPDB *pdb) GIMP_CONVERT_PALETTE_GENERATE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("num-cols", - "num cols", - "The number of colors to quantize to, ignored unless (palette_type == GIMP_CONVERT_PALETTE_GENERATE)", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-cols", + "num cols", + "The number of colors to quantize to, ignored unless (palette_type == GIMP_CONVERT_PALETTE_GENERATE)", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_boolean ("alpha-dither", "alpha dither", @@ -388,23 +388,23 @@ register_image_convert_procs (GimpPDB *pdb) "2006", NULL); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("width", - "width", - "Width of the matrix (0 to reset to default matrix)", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("width", + "width", + "Width of the matrix (0 to reset to default matrix)", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("height", - "height", - "Height of the matrix (0 to reset to default matrix)", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("height", + "height", + "Height of the matrix (0 to reset to default matrix)", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("matrix-length", - "matrix length", - "The length of 'matrix'", - 1, 1024, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("matrix-length", + "matrix length", + "The length of 'matrix'", + 1, 1024, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_int8_array ("matrix", "matrix", diff --git a/app/pdb/image-grid-cmds.c b/app/pdb/image-grid-cmds.c index f74309b831..adbcdf0986 100644 --- a/app/pdb/image-grid-cmds.c +++ b/app/pdb/image-grid-cmds.c @@ -329,7 +329,7 @@ image_grid_get_style_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpImage *image; - gint32 style = 0; + gint style = 0; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); @@ -362,7 +362,7 @@ image_grid_set_style_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpImage *image; - gint32 style; + gint style; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); style = g_value_get_enum (gimp_value_array_index (args, 1)); diff --git a/app/pdb/image-guides-cmds.c b/app/pdb/image-guides-cmds.c index 21d36ce375..c69621738c 100644 --- a/app/pdb/image-guides-cmds.c +++ b/app/pdb/image-guides-cmds.c @@ -54,8 +54,8 @@ image_add_hguide_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpImage *image; - gint32 yposition; - gint32 guide = 0; + gint yposition; + gint guide = 0; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); yposition = g_value_get_int (gimp_value_array_index (args, 1)); @@ -93,8 +93,8 @@ image_add_vguide_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpImage *image; - gint32 xposition; - gint32 guide = 0; + gint xposition; + gint guide = 0; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); xposition = g_value_get_int (gimp_value_array_index (args, 1)); @@ -131,7 +131,7 @@ image_delete_guide_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpImage *image; - gint32 guide; + gint guide; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); guide = g_value_get_uint (gimp_value_array_index (args, 1)); @@ -161,8 +161,8 @@ image_find_next_guide_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpImage *image; - gint32 guide; - gint32 next_guide = 0; + gint guide; + gint next_guide = 0; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); guide = g_value_get_uint (gimp_value_array_index (args, 1)); @@ -202,8 +202,8 @@ image_get_guide_orientation_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpImage *image; - gint32 guide; - gint32 orientation = 0; + gint guide; + gint orientation = 0; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); guide = g_value_get_uint (gimp_value_array_index (args, 1)); @@ -238,8 +238,8 @@ image_get_guide_position_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpImage *image; - gint32 guide; - gint32 position = 0; + gint guide; + gint position = 0; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); guide = g_value_get_uint (gimp_value_array_index (args, 1)); @@ -289,11 +289,11 @@ register_image_guides_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("yposition", - "yposition", - "The guide's y-offset from top of image", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("yposition", + "yposition", + "The guide's y-offset from top of image", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, g_param_spec_uint ("guide", "guide", @@ -324,11 +324,11 @@ register_image_guides_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("xposition", - "xposition", - "The guide's x-offset from left of image", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("xposition", + "xposition", + "The guide's x-offset from left of image", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, g_param_spec_uint ("guide", "guide", @@ -467,11 +467,11 @@ register_image_guides_procs (GimpPDB *pdb) 1, G_MAXUINT32, 1, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("position", - "position", - "The guide's position relative to top or left of image", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("position", + "position", + "The guide's position relative to top or left of image", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); } diff --git a/app/pdb/image-sample-points-cmds.c b/app/pdb/image-sample-points-cmds.c index a8a19654bc..577322dd36 100644 --- a/app/pdb/image-sample-points-cmds.c +++ b/app/pdb/image-sample-points-cmds.c @@ -52,9 +52,9 @@ image_add_sample_point_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpImage *image; - gint32 position_x; - gint32 position_y; - gint32 sample_point = 0; + gint position_x; + gint position_y; + gint sample_point = 0; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); position_x = g_value_get_int (gimp_value_array_index (args, 1)); @@ -94,7 +94,7 @@ image_delete_sample_point_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpImage *image; - gint32 sample_point; + gint sample_point; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); sample_point = g_value_get_uint (gimp_value_array_index (args, 1)); @@ -125,8 +125,8 @@ image_find_next_sample_point_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpImage *image; - gint32 sample_point; - gint32 next_sample_point = 0; + gint sample_point; + gint next_sample_point = 0; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); sample_point = g_value_get_uint (gimp_value_array_index (args, 1)); @@ -167,9 +167,9 @@ image_get_sample_point_position_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpImage *image; - gint32 sample_point; - gint32 position_x = 0; - gint32 position_y = 0; + gint sample_point; + gint position_x = 0; + gint position_y = 0; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); sample_point = g_value_get_uint (gimp_value_array_index (args, 1)); @@ -223,17 +223,17 @@ register_image_sample_points_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("position-x", - "position x", - "The guide'sample points x-offset from left of image", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("position-x", + "position x", + "The guide'sample points x-offset from left of image", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("position-y", - "position y", - "The guide'sample points y-offset from top of image", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("position-y", + "position y", + "The guide'sample points y-offset from top of image", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, g_param_spec_uint ("sample-point", "sample point", @@ -334,17 +334,17 @@ register_image_sample_points_procs (GimpPDB *pdb) 1, G_MAXUINT32, 1, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("position-x", - "position x", - "The sample points's position relative to top of image", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("position-x", + "position x", + "The sample points's position relative to top of image", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("position-y", - "position y", - "The sample points's position relative to top of image", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("position-y", + "position y", + "The sample points's position relative to top of image", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); } diff --git a/app/pdb/image-select-cmds.c b/app/pdb/image-select-cmds.c index fc5af260df..ca91fe9896 100644 --- a/app/pdb/image-select-cmds.c +++ b/app/pdb/image-select-cmds.c @@ -57,7 +57,7 @@ image_select_color_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpImage *image; - gint32 operation; + gint operation; GimpDrawable *drawable; GimpRGB color; @@ -103,7 +103,7 @@ image_select_contiguous_color_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpImage *image; - gint32 operation; + gint operation; GimpDrawable *drawable; gdouble x; gdouble y; @@ -154,7 +154,7 @@ image_select_rectangle_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpImage *image; - gint32 operation; + gint operation; gdouble x; gdouble y; gdouble width; @@ -195,7 +195,7 @@ image_select_round_rectangle_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpImage *image; - gint32 operation; + gint operation; gdouble x; gdouble y; gdouble width; @@ -243,7 +243,7 @@ image_select_ellipse_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpImage *image; - gint32 operation; + gint operation; gdouble x; gdouble y; gdouble width; @@ -285,8 +285,8 @@ image_select_polygon_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpImage *image; - gint32 operation; - gint32 num_segs; + gint operation; + gint num_segs; const gdouble *segs; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); @@ -324,7 +324,7 @@ image_select_item_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpImage *image; - gint32 operation; + gint operation; GimpItem *item; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); @@ -665,11 +665,11 @@ register_image_select_procs (GimpPDB *pdb) GIMP_CHANNEL_OP_ADD, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("num-segs", - "num segs", - "Number of points (count 1 coordinate as two points)", - 2, G_MAXINT32, 2, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-segs", + "num segs", + "Number of points (count 1 coordinate as two points)", + 2, G_MAXINT32, 2, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_float_array ("segs", "segs", diff --git a/app/pdb/image-transform-cmds.c b/app/pdb/image-transform-cmds.c index 9b0be7c9cc..91bec06bdc 100644 --- a/app/pdb/image-transform-cmds.c +++ b/app/pdb/image-transform-cmds.c @@ -54,10 +54,10 @@ image_resize_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpImage *image; - gint32 new_width; - gint32 new_height; - gint32 offx; - gint32 offy; + gint new_width; + gint new_height; + gint offx; + gint offy; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); new_width = g_value_get_int (gimp_value_array_index (args, 1)); @@ -107,8 +107,8 @@ image_scale_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpImage *image; - gint32 new_width; - gint32 new_height; + gint new_width; + gint new_height; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); new_width = g_value_get_int (gimp_value_array_index (args, 1)); @@ -143,10 +143,10 @@ image_crop_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpImage *image; - gint32 new_width; - gint32 new_height; - gint32 offx; - gint32 offy; + gint new_width; + gint new_height; + gint offx; + gint offy; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); new_width = g_value_get_int (gimp_value_array_index (args, 1)); @@ -181,7 +181,7 @@ image_flip_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpImage *image; - gint32 flip_type; + gint flip_type; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); flip_type = g_value_get_enum (gimp_value_array_index (args, 1)); @@ -205,7 +205,7 @@ image_rotate_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpImage *image; - gint32 rotate_type; + gint rotate_type; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); rotate_type = g_value_get_enum (gimp_value_array_index (args, 1)); @@ -251,29 +251,29 @@ register_image_transform_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("new-width", - "new width", - "New image width", - 1, GIMP_MAX_IMAGE_SIZE, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("new-width", + "new width", + "New image width", + 1, GIMP_MAX_IMAGE_SIZE, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("new-height", - "new height", - "New image height", - 1, GIMP_MAX_IMAGE_SIZE, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("new-height", + "new height", + "New image height", + 1, GIMP_MAX_IMAGE_SIZE, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("offx", - "offx", - "x offset between upper left corner of old and new images: (new - old)", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("offx", + "offx", + "x offset between upper left corner of old and new images: (new - old)", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("offy", - "offy", - "y offset between upper left corner of old and new images: (new - old)", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("offy", + "offy", + "y offset between upper left corner of old and new images: (new - old)", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -321,17 +321,17 @@ register_image_transform_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("new-width", - "new width", - "New image width", - 1, GIMP_MAX_IMAGE_SIZE, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("new-width", + "new width", + "New image width", + 1, GIMP_MAX_IMAGE_SIZE, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("new-height", - "new height", - "New image height", - 1, GIMP_MAX_IMAGE_SIZE, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("new-height", + "new height", + "New image height", + 1, GIMP_MAX_IMAGE_SIZE, 1, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -356,29 +356,29 @@ register_image_transform_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("new-width", - "new width", - "New image width: (0 < new_width <= width)", - 1, GIMP_MAX_IMAGE_SIZE, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("new-width", + "new width", + "New image width: (0 < new_width <= width)", + 1, GIMP_MAX_IMAGE_SIZE, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("new-height", - "new height", - "New image height: (0 < new_height <= height)", - 1, GIMP_MAX_IMAGE_SIZE, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("new-height", + "new height", + "New image height: (0 < new_height <= height)", + 1, GIMP_MAX_IMAGE_SIZE, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("offx", - "offx", - "X offset: (0 <= offx <= (width - new_width))", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("offx", + "offx", + "X offset: (0 <= offx <= (width - new_width))", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("offy", - "offy", - "Y offset: (0 <= offy <= (height - new_height))", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("offy", + "offy", + "Y offset: (0 <= offy <= (height - new_height))", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); diff --git a/app/pdb/item-cmds.c b/app/pdb/item-cmds.c index f5acfa3901..d3f98a2d8c 100644 --- a/app/pdb/item-cmds.c +++ b/app/pdb/item-cmds.c @@ -399,7 +399,7 @@ item_get_children_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpItem *item; - gint32 num_children = 0; + gint num_children = 0; gint32 *child_ids = NULL; item = gimp_value_get_item (gimp_value_array_index (args, 0), gimp); @@ -779,7 +779,7 @@ item_get_color_tag_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpItem *item; - gint32 color_tag = 0; + gint color_tag = 0; item = gimp_value_get_item (gimp_value_array_index (args, 0), gimp); @@ -807,7 +807,7 @@ item_set_color_tag_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpItem *item; - gint32 color_tag; + gint color_tag; item = gimp_value_get_item (gimp_value_array_index (args, 0), gimp); color_tag = g_value_get_enum (gimp_value_array_index (args, 1)); @@ -832,7 +832,7 @@ item_get_tattoo_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpItem *item; - gint32 tattoo = 0; + gint tattoo = 0; item = gimp_value_get_item (gimp_value_array_index (args, 0), gimp); @@ -860,7 +860,7 @@ item_set_tattoo_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpItem *item; - gint32 tattoo; + gint tattoo; item = gimp_value_get_item (gimp_value_array_index (args, 0), gimp); tattoo = g_value_get_uint (gimp_value_array_index (args, 1)); @@ -970,7 +970,7 @@ item_get_parasite_list_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpItem *item; - gint32 num_parasites = 0; + gint num_parasites = 0; gchar **parasites = NULL; item = gimp_value_get_item (gimp_value_array_index (args, 0), gimp); @@ -1360,11 +1360,11 @@ register_item_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-children", - "num children", - "The item's number of children", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-children", + "num children", + "The item's number of children", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_int32_array ("child-ids", "child ids", @@ -1955,11 +1955,11 @@ register_item_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-parasites", - "num parasites", - "The number of attached parasites", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-parasites", + "num parasites", + "The number of attached parasites", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_string_array ("parasites", "parasites", diff --git a/app/pdb/item-transform-cmds.c b/app/pdb/item-transform-cmds.c index bcf210e3fe..c57d3e0ef8 100644 --- a/app/pdb/item-transform-cmds.c +++ b/app/pdb/item-transform-cmds.c @@ -104,7 +104,7 @@ item_transform_flip_simple_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpItem *item; - gint32 flip_type; + gint flip_type; gboolean auto_center; gdouble axis; @@ -401,7 +401,7 @@ item_transform_rotate_simple_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpItem *item; - gint32 rotate_type; + gint rotate_type; gboolean auto_center; gdouble center_x; gdouble center_y; @@ -701,7 +701,7 @@ item_transform_shear_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpItem *item; - gint32 shear_type; + gint shear_type; gdouble magnitude; item = gimp_value_get_item (gimp_value_array_index (args, 0), gimp); diff --git a/app/pdb/layer-cmds.c b/app/pdb/layer-cmds.c index 479e3cf141..2b81d6e81d 100644 --- a/app/pdb/layer-cmds.c +++ b/app/pdb/layer-cmds.c @@ -67,12 +67,12 @@ layer_new_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpImage *image; - gint32 width; - gint32 height; - gint32 type; + gint width; + gint height; + gint type; const gchar *name; gdouble opacity; - gint32 mode; + gint mode; GimpLayer *layer = NULL; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); @@ -389,8 +389,8 @@ layer_scale_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpLayer *layer; - gint32 new_width; - gint32 new_height; + gint new_width; + gint new_height; gboolean local_origin; layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp); @@ -436,10 +436,10 @@ layer_resize_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpLayer *layer; - gint32 new_width; - gint32 new_height; - gint32 offx; - gint32 offy; + gint new_width; + gint new_height; + gint offx; + gint offy; layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp); new_width = g_value_get_int (gimp_value_array_index (args, 1)); @@ -499,8 +499,8 @@ layer_set_offsets_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpLayer *layer; - gint32 offx; - gint32 offy; + gint offx; + gint offy; layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp); offx = g_value_get_int (gimp_value_array_index (args, 1)); @@ -546,7 +546,7 @@ layer_create_mask_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpLayer *layer; - gint32 mask_type; + gint mask_type; GimpLayerMask *mask = NULL; layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp); @@ -679,7 +679,7 @@ layer_remove_mask_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpLayer *layer; - gint32 mode; + gint mode; layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp); mode = g_value_get_enum (gimp_value_array_index (args, 1)); @@ -1030,7 +1030,7 @@ layer_get_mode_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpLayer *layer; - gint32 mode = 0; + gint mode = 0; layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp); @@ -1058,7 +1058,7 @@ layer_set_mode_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpLayer *layer; - gint32 mode; + gint mode; layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp); mode = g_value_get_enum (gimp_value_array_index (args, 1)); @@ -1098,7 +1098,7 @@ layer_get_blend_space_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpLayer *layer; - gint32 blend_space = 0; + gint blend_space = 0; layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp); @@ -1126,7 +1126,7 @@ layer_set_blend_space_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpLayer *layer; - gint32 blend_space; + gint blend_space; layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp); blend_space = g_value_get_enum (gimp_value_array_index (args, 1)); @@ -1151,7 +1151,7 @@ layer_get_composite_space_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpLayer *layer; - gint32 composite_space = 0; + gint composite_space = 0; layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp); @@ -1179,7 +1179,7 @@ layer_set_composite_space_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpLayer *layer; - gint32 composite_space; + gint composite_space; layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp); composite_space = g_value_get_enum (gimp_value_array_index (args, 1)); @@ -1204,7 +1204,7 @@ layer_get_composite_mode_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpLayer *layer; - gint32 composite_mode = 0; + gint composite_mode = 0; layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp); @@ -1232,7 +1232,7 @@ layer_set_composite_mode_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpLayer *layer; - gint32 composite_mode; + gint composite_mode; layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp); composite_mode = g_value_get_enum (gimp_value_array_index (args, 1)); @@ -1272,17 +1272,17 @@ register_layer_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("width", - "width", - "The layer width", - 1, GIMP_MAX_IMAGE_SIZE, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("width", + "width", + "The layer width", + 1, GIMP_MAX_IMAGE_SIZE, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("height", - "height", - "The layer height", - 1, GIMP_MAX_IMAGE_SIZE, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("height", + "height", + "The layer height", + 1, GIMP_MAX_IMAGE_SIZE, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_enum ("type", "type", @@ -1528,17 +1528,17 @@ register_layer_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("new-width", - "new width", - "New layer width", - 1, GIMP_MAX_IMAGE_SIZE, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("new-width", + "new width", + "New layer width", + 1, GIMP_MAX_IMAGE_SIZE, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("new-height", - "new height", - "New layer height", - 1, GIMP_MAX_IMAGE_SIZE, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("new-height", + "new height", + "New layer height", + 1, GIMP_MAX_IMAGE_SIZE, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_boolean ("local-origin", "local origin", @@ -1569,29 +1569,29 @@ register_layer_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("new-width", - "new width", - "New layer width", - 1, GIMP_MAX_IMAGE_SIZE, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("new-width", + "new width", + "New layer width", + 1, GIMP_MAX_IMAGE_SIZE, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("new-height", - "new height", - "New layer height", - 1, GIMP_MAX_IMAGE_SIZE, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("new-height", + "new height", + "New layer height", + 1, GIMP_MAX_IMAGE_SIZE, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("offx", - "offx", - "x offset between upper left corner of old and new layers: (old - new)", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("offx", + "offx", + "x offset between upper left corner of old and new layers: (old - new)", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("offy", - "offy", - "y offset between upper left corner of old and new layers: (old - new)", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("offy", + "offy", + "y offset between upper left corner of old and new layers: (old - new)", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -1639,17 +1639,17 @@ register_layer_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("offx", - "offx", - "Offset in x direction", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("offx", + "offx", + "Offset in x direction", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("offy", - "offy", - "Offset in y direction", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("offy", + "offy", + "Offset in y direction", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); diff --git a/app/pdb/message-cmds.c b/app/pdb/message-cmds.c index 63e07cf4b9..39518afea5 100644 --- a/app/pdb/message-cmds.c +++ b/app/pdb/message-cmds.c @@ -77,7 +77,7 @@ message_get_handler_invoker (GimpProcedure *procedure, GError **error) { GimpValueArray *return_vals; - gint32 handler = 0; + gint handler = 0; handler = gimp->message_handler; @@ -96,7 +96,7 @@ message_set_handler_invoker (GimpProcedure *procedure, GError **error) { gboolean success = TRUE; - gint32 handler; + gint handler; handler = g_value_get_enum (gimp_value_array_index (args, 0)); diff --git a/app/pdb/paint-tools-cmds.c b/app/pdb/paint-tools-cmds.c index 763cd1411c..71ba08e641 100644 --- a/app/pdb/paint-tools-cmds.c +++ b/app/pdb/paint-tools-cmds.c @@ -111,7 +111,7 @@ airbrush_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpDrawable *drawable; gdouble pressure; - gint32 num_strokes; + gint num_strokes; const gdouble *strokes; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); @@ -159,7 +159,7 @@ airbrush_default_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 num_strokes; + gint num_strokes; const gdouble *strokes; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); @@ -203,10 +203,10 @@ clone_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpDrawable *drawable; GimpDrawable *src_drawable; - gint32 clone_type; + gint clone_type; gdouble src_x; gdouble src_y; - gint32 num_strokes; + gint num_strokes; const gdouble *strokes; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); @@ -260,7 +260,7 @@ clone_default_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 num_strokes; + gint num_strokes; const gdouble *strokes; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); @@ -304,8 +304,8 @@ convolve_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpDrawable *drawable; gdouble pressure; - gint32 convolve_type; - gint32 num_strokes; + gint convolve_type; + gint num_strokes; const gdouble *strokes; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); @@ -355,7 +355,7 @@ convolve_default_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 num_strokes; + gint num_strokes; const gdouble *strokes; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); @@ -399,9 +399,9 @@ dodgeburn_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpDrawable *drawable; gdouble exposure; - gint32 dodgeburn_type; - gint32 dodgeburn_mode; - gint32 num_strokes; + gint dodgeburn_type; + gint dodgeburn_mode; + gint num_strokes; const gdouble *strokes; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); @@ -453,7 +453,7 @@ dodgeburn_default_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 num_strokes; + gint num_strokes; const gdouble *strokes; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); @@ -496,10 +496,10 @@ eraser_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 num_strokes; + gint num_strokes; const gdouble *strokes; - gint32 hardness; - gint32 method; + gint hardness; + gint method; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); num_strokes = g_value_get_int (gimp_value_array_index (args, 1)); @@ -548,7 +548,7 @@ eraser_default_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 num_strokes; + gint num_strokes; const gdouble *strokes; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); @@ -594,7 +594,7 @@ heal_invoker (GimpProcedure *procedure, GimpDrawable *src_drawable; gdouble src_x; gdouble src_y; - gint32 num_strokes; + gint num_strokes; const gdouble *strokes; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); @@ -643,7 +643,7 @@ heal_default_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 num_strokes; + gint num_strokes; const gdouble *strokes; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); @@ -687,9 +687,9 @@ paintbrush_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpDrawable *drawable; gdouble fade_out; - gint32 num_strokes; + gint num_strokes; const gdouble *strokes; - gint32 method; + gint method; gdouble gradient_length; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); @@ -771,7 +771,7 @@ paintbrush_default_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 num_strokes; + gint num_strokes; const gdouble *strokes; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); @@ -814,7 +814,7 @@ pencil_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 num_strokes; + gint num_strokes; const gdouble *strokes; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); @@ -858,7 +858,7 @@ smudge_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpDrawable *drawable; gdouble pressure; - gint32 num_strokes; + gint num_strokes; const gdouble *strokes; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); @@ -906,7 +906,7 @@ smudge_default_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 num_strokes; + gint num_strokes; const gdouble *strokes; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); @@ -971,11 +971,11 @@ register_paint_tools_procs (GimpPDB *pdb) 0, 100, 0, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("num-strokes", - "num strokes", - "Number of stroke control points (count each coordinate as 2 points)", - 2, G_MAXINT32, 2, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-strokes", + "num strokes", + "Number of stroke control points (count each coordinate as 2 points)", + 2, G_MAXINT32, 2, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_float_array ("strokes", "strokes", @@ -1005,11 +1005,11 @@ register_paint_tools_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("num-strokes", - "num strokes", - "Number of stroke control points (count each coordinate as 2 points)", - 2, G_MAXINT32, 2, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-strokes", + "num strokes", + "Number of stroke control points (count each coordinate as 2 points)", + 2, G_MAXINT32, 2, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_float_array ("strokes", "strokes", @@ -1064,11 +1064,11 @@ register_paint_tools_procs (GimpPDB *pdb) -G_MAXDOUBLE, G_MAXDOUBLE, 0, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("num-strokes", - "num strokes", - "Number of stroke control points (count each coordinate as 2 points)", - 2, G_MAXINT32, 2, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-strokes", + "num strokes", + "Number of stroke control points (count each coordinate as 2 points)", + 2, G_MAXINT32, 2, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_float_array ("strokes", "strokes", @@ -1098,11 +1098,11 @@ register_paint_tools_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("num-strokes", - "num strokes", - "Number of stroke control points (count each coordinate as 2 points)", - 2, G_MAXINT32, 2, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-strokes", + "num strokes", + "Number of stroke control points (count each coordinate as 2 points)", + 2, G_MAXINT32, 2, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_float_array ("strokes", "strokes", @@ -1145,11 +1145,11 @@ register_paint_tools_procs (GimpPDB *pdb) GIMP_CONVOLVE_BLUR, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("num-strokes", - "num strokes", - "Number of stroke control points (count each coordinate as 2 points)", - 2, G_MAXINT32, 2, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-strokes", + "num strokes", + "Number of stroke control points (count each coordinate as 2 points)", + 2, G_MAXINT32, 2, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_float_array ("strokes", "strokes", @@ -1179,11 +1179,11 @@ register_paint_tools_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("num-strokes", - "num strokes", - "Number of stroke control points (count each coordinate as 2 points)", - 2, G_MAXINT32, 2, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-strokes", + "num strokes", + "Number of stroke control points (count each coordinate as 2 points)", + 2, G_MAXINT32, 2, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_float_array ("strokes", "strokes", @@ -1233,11 +1233,11 @@ register_paint_tools_procs (GimpPDB *pdb) GIMP_TRANSFER_SHADOWS, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("num-strokes", - "num strokes", - "Number of stroke control points (count each coordinate as 2 points)", - 2, G_MAXINT32, 2, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-strokes", + "num strokes", + "Number of stroke control points (count each coordinate as 2 points)", + 2, G_MAXINT32, 2, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_float_array ("strokes", "strokes", @@ -1267,11 +1267,11 @@ register_paint_tools_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("num-strokes", - "num strokes", - "Number of stroke control points (count each coordinate as 2 points)", - 2, G_MAXINT32, 2, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-strokes", + "num strokes", + "Number of stroke control points (count each coordinate as 2 points)", + 2, G_MAXINT32, 2, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_float_array ("strokes", "strokes", @@ -1301,11 +1301,11 @@ register_paint_tools_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("num-strokes", - "num strokes", - "Number of stroke control points (count each coordinate as 2 points)", - 2, G_MAXINT32, 2, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-strokes", + "num strokes", + "Number of stroke control points (count each coordinate as 2 points)", + 2, G_MAXINT32, 2, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_float_array ("strokes", "strokes", @@ -1349,11 +1349,11 @@ register_paint_tools_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("num-strokes", - "num strokes", - "Number of stroke control points (count each coordinate as 2 points)", - 2, G_MAXINT32, 2, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-strokes", + "num strokes", + "Number of stroke control points (count each coordinate as 2 points)", + 2, G_MAXINT32, 2, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_float_array ("strokes", "strokes", @@ -1401,11 +1401,11 @@ register_paint_tools_procs (GimpPDB *pdb) -G_MAXDOUBLE, G_MAXDOUBLE, 0, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("num-strokes", - "num strokes", - "Number of stroke control points (count each coordinate as 2 points)", - 2, G_MAXINT32, 2, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-strokes", + "num strokes", + "Number of stroke control points (count each coordinate as 2 points)", + 2, G_MAXINT32, 2, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_float_array ("strokes", "strokes", @@ -1435,11 +1435,11 @@ register_paint_tools_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("num-strokes", - "num strokes", - "Number of stroke control points (count each coordinate as 2 points)", - 2, G_MAXINT32, 2, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-strokes", + "num strokes", + "Number of stroke control points (count each coordinate as 2 points)", + 2, G_MAXINT32, 2, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_float_array ("strokes", "strokes", @@ -1475,11 +1475,11 @@ register_paint_tools_procs (GimpPDB *pdb) 0, G_MAXDOUBLE, 0, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("num-strokes", - "num strokes", - "Number of stroke control points (count each coordinate as 2 points)", - 2, G_MAXINT32, 2, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-strokes", + "num strokes", + "Number of stroke control points (count each coordinate as 2 points)", + 2, G_MAXINT32, 2, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_float_array ("strokes", "strokes", @@ -1522,11 +1522,11 @@ register_paint_tools_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("num-strokes", - "num strokes", - "Number of stroke control points (count each coordinate as 2 points)", - 2, G_MAXINT32, 2, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-strokes", + "num strokes", + "Number of stroke control points (count each coordinate as 2 points)", + 2, G_MAXINT32, 2, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_float_array ("strokes", "strokes", @@ -1556,11 +1556,11 @@ register_paint_tools_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("num-strokes", - "num strokes", - "Number of stroke control points (count each coordinate as 2 points)", - 2, G_MAXINT32, 2, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-strokes", + "num strokes", + "Number of stroke control points (count each coordinate as 2 points)", + 2, G_MAXINT32, 2, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_float_array ("strokes", "strokes", @@ -1596,11 +1596,11 @@ register_paint_tools_procs (GimpPDB *pdb) 0, 100, 0, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("num-strokes", - "num strokes", - "Number of stroke control points (count each coordinate as 2 points)", - 2, G_MAXINT32, 2, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-strokes", + "num strokes", + "Number of stroke control points (count each coordinate as 2 points)", + 2, G_MAXINT32, 2, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_float_array ("strokes", "strokes", @@ -1630,11 +1630,11 @@ register_paint_tools_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("num-strokes", - "num strokes", - "Number of stroke control points (count each coordinate as 2 points)", - 2, G_MAXINT32, 2, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-strokes", + "num strokes", + "Number of stroke control points (count each coordinate as 2 points)", + 2, G_MAXINT32, 2, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_float_array ("strokes", "strokes", diff --git a/app/pdb/palette-cmds.c b/app/pdb/palette-cmds.c index ae1a31f11f..2431dcb2d7 100644 --- a/app/pdb/palette-cmds.c +++ b/app/pdb/palette-cmds.c @@ -235,7 +235,7 @@ palette_get_info_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; const gchar *name; - gint32 num_colors = 0; + gint num_colors = 0; name = g_value_get_string (gimp_value_array_index (args, 0)); @@ -269,7 +269,7 @@ palette_get_colors_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; const gchar *name; - gint32 num_colors = 0; + gint num_colors = 0; GimpRGB *colors = NULL; name = g_value_get_string (gimp_value_array_index (args, 0)); @@ -320,7 +320,7 @@ palette_get_columns_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; const gchar *name; - gint32 num_columns = 0; + gint num_columns = 0; name = g_value_get_string (gimp_value_array_index (args, 0)); @@ -353,7 +353,7 @@ palette_set_columns_invoker (GimpProcedure *procedure, { gboolean success = TRUE; const gchar *name; - gint32 columns; + gint columns; name = g_value_get_string (gimp_value_array_index (args, 0)); columns = g_value_get_int (gimp_value_array_index (args, 1)); @@ -385,7 +385,7 @@ palette_add_entry_invoker (GimpProcedure *procedure, const gchar *name; const gchar *entry_name; GimpRGB color; - gint32 entry_num = 0; + gint entry_num = 0; name = g_value_get_string (gimp_value_array_index (args, 0)); entry_name = g_value_get_string (gimp_value_array_index (args, 1)); @@ -425,7 +425,7 @@ palette_delete_entry_invoker (GimpProcedure *procedure, { gboolean success = TRUE; const gchar *name; - gint32 entry_num; + gint entry_num; name = g_value_get_string (gimp_value_array_index (args, 0)); entry_num = g_value_get_int (gimp_value_array_index (args, 1)); @@ -462,7 +462,7 @@ palette_entry_get_color_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; const gchar *name; - gint32 entry_num; + gint entry_num; GimpRGB color = { 0.0, 0.0, 0.0, 1.0 }; name = g_value_get_string (gimp_value_array_index (args, 0)); @@ -504,7 +504,7 @@ palette_entry_set_color_invoker (GimpProcedure *procedure, { gboolean success = TRUE; const gchar *name; - gint32 entry_num; + gint entry_num; GimpRGB color; name = g_value_get_string (gimp_value_array_index (args, 0)); @@ -536,7 +536,7 @@ palette_entry_get_name_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; const gchar *name; - gint32 entry_num; + gint entry_num; gchar *entry_name = NULL; name = g_value_get_string (gimp_value_array_index (args, 0)); @@ -578,7 +578,7 @@ palette_entry_set_name_invoker (GimpProcedure *procedure, { gboolean success = TRUE; const gchar *name; - gint32 entry_num; + gint entry_num; const gchar *entry_name; name = g_value_get_string (gimp_value_array_index (args, 0)); @@ -780,11 +780,11 @@ register_palette_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-colors", - "num colors", - "The number of colors in the palette", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-colors", + "num colors", + "The number of colors in the palette", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -810,11 +810,11 @@ register_palette_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-colors", - "num colors", - "Length of the colors array", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-colors", + "num colors", + "Length of the colors array", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_rgb_array ("colors", "colors", @@ -845,11 +845,11 @@ register_palette_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-columns", - "num columns", - "The number of columns used to display this palette", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-columns", + "num columns", + "The number of columns used to display this palette", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -875,11 +875,11 @@ register_palette_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("columns", - "columns", - "The new number of columns", - 0, 64, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("columns", + "columns", + "The new number of columns", + 0, 64, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -919,11 +919,11 @@ register_palette_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("entry-num", - "entry num", - "The index of the added entry", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("entry-num", + "entry num", + "The index of the added entry", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -949,11 +949,11 @@ register_palette_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("entry-num", - "entry num", - "The index of the added entry", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("entry-num", + "entry num", + "The index of the added entry", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -979,11 +979,11 @@ register_palette_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("entry-num", - "entry num", - "The entry to retrieve", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("entry-num", + "entry num", + "The entry to retrieve", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_rgb ("color", "color", @@ -1016,11 +1016,11 @@ register_palette_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("entry-num", - "entry num", - "The entry to retrieve", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("entry-num", + "entry num", + "The entry to retrieve", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_rgb ("color", "color", @@ -1053,11 +1053,11 @@ register_palette_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("entry-num", - "entry num", - "The entry to retrieve", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("entry-num", + "entry num", + "The entry to retrieve", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_string ("entry-name", "entry name", @@ -1090,11 +1090,11 @@ register_palette_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("entry-num", - "entry num", - "The entry to retrieve", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("entry-num", + "entry num", + "The entry to retrieve", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_string ("entry-name", "entry name", diff --git a/app/pdb/palettes-cmds.c b/app/pdb/palettes-cmds.c index 4c2b5b6ba9..639e183e82 100644 --- a/app/pdb/palettes-cmds.c +++ b/app/pdb/palettes-cmds.c @@ -66,7 +66,7 @@ palettes_get_list_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; const gchar *filter; - gint32 num_palettes = 0; + gint num_palettes = 0; gchar **palette_list = NULL; filter = g_value_get_string (gimp_value_array_index (args, 0)); @@ -133,11 +133,11 @@ register_palettes_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-palettes", - "num palettes", - "The number of palettes in the list", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-palettes", + "num palettes", + "The number of palettes in the list", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_string_array ("palette-list", "palette list", diff --git a/app/pdb/pattern-cmds.c b/app/pdb/pattern-cmds.c index ee1c804049..f5c94ddd6d 100644 --- a/app/pdb/pattern-cmds.c +++ b/app/pdb/pattern-cmds.c @@ -53,9 +53,9 @@ pattern_get_info_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; const gchar *name; - gint32 width = 0; - gint32 height = 0; - gint32 bpp = 0; + gint width = 0; + gint height = 0; + gint bpp = 0; name = g_value_get_string (gimp_value_array_index (args, 0)); @@ -102,10 +102,10 @@ pattern_get_pixels_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; const gchar *name; - gint32 width = 0; - gint32 height = 0; - gint32 bpp = 0; - gint32 num_color_bytes = 0; + gint width = 0; + gint height = 0; + gint bpp = 0; + gint num_color_bytes = 0; guint8 *color_bytes = NULL; name = g_value_get_string (gimp_value_array_index (args, 0)); @@ -177,23 +177,23 @@ register_pattern_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("width", - "width", - "The pattern width", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("width", + "width", + "The pattern width", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("height", - "height", - "The pattern height", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("height", + "height", + "The pattern height", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("bpp", - "bpp", - "The pattern bpp", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("bpp", + "bpp", + "The pattern bpp", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -219,29 +219,29 @@ register_pattern_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("width", - "width", - "The pattern width", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("width", + "width", + "The pattern width", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("height", - "height", - "The pattern height", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("height", + "height", + "The pattern height", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("bpp", - "bpp", - "The pattern bpp", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("bpp", + "bpp", + "The pattern bpp", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-color-bytes", - "num color bytes", - "Number of pattern bytes", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-color-bytes", + "num color bytes", + "Number of pattern bytes", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_int8_array ("color-bytes", "color bytes", diff --git a/app/pdb/patterns-cmds.c b/app/pdb/patterns-cmds.c index 0831381769..884b0ab5e6 100644 --- a/app/pdb/patterns-cmds.c +++ b/app/pdb/patterns-cmds.c @@ -67,7 +67,7 @@ patterns_get_list_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; const gchar *filter; - gint32 num_patterns = 0; + gint num_patterns = 0; gchar **pattern_list = NULL; filter = g_value_get_string (gimp_value_array_index (args, 0)); @@ -134,11 +134,11 @@ register_patterns_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-patterns", - "num patterns", - "The number of patterns in the pattern list", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-patterns", + "num patterns", + "The number of patterns in the pattern list", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_string_array ("pattern-list", "pattern list", diff --git a/app/pdb/pdb-cmds.c b/app/pdb/pdb-cmds.c index 9f9b76d082..27281ff11e 100644 --- a/app/pdb/pdb-cmds.c +++ b/app/pdb/pdb-cmds.c @@ -105,7 +105,7 @@ pdb_query_invoker (GimpProcedure *procedure, const gchar *copyright; const gchar *date; const gchar *proc_type; - gint32 num_matches = 0; + gint num_matches = 0; gchar **procedure_names = NULL; name = g_value_get_string (gimp_value_array_index (args, 0)); @@ -199,9 +199,9 @@ pdb_proc_info_invoker (GimpProcedure *procedure, gchar *authors = NULL; gchar *copyright = NULL; gchar *date = NULL; - gint32 proc_type = 0; - gint32 num_args = 0; - gint32 num_values = 0; + gint proc_type = 0; + gint num_args = 0; + gint num_values = 0; procedure_name = g_value_get_string (gimp_value_array_index (args, 0)); @@ -251,7 +251,7 @@ pdb_proc_argument_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; const gchar *procedure_name; - gint32 arg_num; + gint arg_num; GParamSpec *param_spec = NULL; procedure_name = g_value_get_string (gimp_value_array_index (args, 0)); @@ -306,7 +306,7 @@ pdb_proc_return_value_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; const gchar *procedure_name; - gint32 val_num; + gint val_num; GParamSpec *param_spec = NULL; procedure_name = g_value_get_string (gimp_value_array_index (args, 0)); @@ -361,7 +361,7 @@ pdb_get_data_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; const gchar *identifier; - gint32 bytes = 0; + gint bytes = 0; guint8 *data = NULL; identifier = g_value_get_string (gimp_value_array_index (args, 0)); @@ -405,7 +405,7 @@ pdb_get_data_size_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; const gchar *identifier; - gint32 bytes = 0; + gint bytes = 0; identifier = g_value_get_string (gimp_value_array_index (args, 0)); @@ -439,7 +439,7 @@ pdb_set_data_invoker (GimpProcedure *procedure, { gboolean success = TRUE; const gchar *identifier; - gint32 bytes; + gint bytes; const guint8 *data; identifier = g_value_get_string (gimp_value_array_index (args, 0)); @@ -577,11 +577,11 @@ register_pdb_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-matches", - "num matches", - "The number of matching procedures", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-matches", + "num matches", + "The number of matching procedures", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_string_array ("procedure-names", "procedure names", @@ -684,17 +684,17 @@ register_pdb_procs (GimpPDB *pdb) GIMP_INTERNAL, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-args", - "num args", - "The number of input arguments", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-args", + "num args", + "The number of input arguments", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-values", - "num values", - "The number of return values", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-values", + "num values", + "The number of return values", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -720,11 +720,11 @@ register_pdb_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("arg-num", - "arg num", - "The argument number", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("arg-num", + "arg num", + "The argument number", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, g_param_spec_param ("param-spec", "param spec", @@ -756,11 +756,11 @@ register_pdb_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("val-num", - "val num", - "The return value number", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("val-num", + "val num", + "The return value number", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, g_param_spec_param ("param-spec", "param spec", @@ -792,11 +792,11 @@ register_pdb_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("bytes", - "bytes", - "The number of bytes in the data", - 1, G_MAXINT32, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("bytes", + "bytes", + "The number of bytes in the data", + 1, G_MAXINT32, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_int8_array ("data", "data", @@ -827,11 +827,11 @@ register_pdb_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("bytes", - "bytes", - "The number of bytes in the data", - 1, G_MAXINT32, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("bytes", + "bytes", + "The number of bytes in the data", + 1, G_MAXINT32, 1, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -857,11 +857,11 @@ register_pdb_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("bytes", - "bytes", - "The number of bytes in the data", - 1, G_MAXINT32, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("bytes", + "bytes", + "The number of bytes in the data", + 1, G_MAXINT32, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_int8_array ("data", "data", diff --git a/app/pdb/plug-in-cmds.c b/app/pdb/plug-in-cmds.c index b168ce1c83..994169ae58 100644 --- a/app/pdb/plug-in-cmds.c +++ b/app/pdb/plug-in-cmds.c @@ -56,7 +56,7 @@ plugins_query_invoker (GimpProcedure *procedure, { GimpValueArray *return_vals; const gchar *search_string; - gint32 num_plugins = 0; + gint num_plugins = 0; gchar **menu_path = NULL; gchar **plugin_accelerator = NULL; gchar **plugin_location = NULL; @@ -240,8 +240,8 @@ plugin_icon_register_invoker (GimpProcedure *procedure, { gboolean success = TRUE; const gchar *procedure_name; - gint32 icon_type; - gint32 icon_data_length; + gint icon_type; + gint icon_data_length; const guint8 *icon_data; procedure_name = g_value_get_string (gimp_value_array_index (args, 0)); @@ -290,7 +290,7 @@ plugin_set_pdb_error_handler_invoker (GimpProcedure *procedure, GError **error) { gboolean success = TRUE; - gint32 handler; + gint handler; handler = g_value_get_enum (gimp_value_array_index (args, 0)); @@ -322,7 +322,7 @@ plugin_get_pdb_error_handler_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpValueArray *return_vals; - gint32 handler = 0; + gint handler = 0; GimpPlugIn *plug_in = gimp->plug_in_manager->current_plug_in; @@ -371,66 +371,66 @@ register_plug_in_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-plugins", - "num plugins", - "The number of plug-ins", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-plugins", + "num plugins", + "The number of plug-ins", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_string_array ("menu-path", "menu path", "The menu path of the plug-in", GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-plugins", - "num plugins", - "The number of plug-ins", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-plugins", + "num plugins", + "The number of plug-ins", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_string_array ("plugin-accelerator", "plugin accelerator", "String representing keyboard accelerator (could be empty string)", GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-plugins", - "num plugins", - "The number of plug-ins", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-plugins", + "num plugins", + "The number of plug-ins", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_string_array ("plugin-location", "plugin location", "Location of the plug-in program", GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-plugins", - "num plugins", - "The number of plug-ins", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-plugins", + "num plugins", + "The number of plug-ins", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_string_array ("plugin-image-type", "plugin image type", "Type of image that this plug-in will work on", GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-plugins", - "num plugins", - "The number of plug-ins", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-plugins", + "num plugins", + "The number of plug-ins", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_int32_array ("plugin-install-time", "plugin install time", "Time that the plug-in was installed", GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-plugins", - "num plugins", - "The number of plug-ins", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-plugins", + "num plugins", + "The number of plug-ins", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_string_array ("plugin-real-name", "plugin real name", @@ -592,11 +592,11 @@ register_plug_in_procs (GimpPDB *pdb) GIMP_ICON_TYPE_ICON_NAME, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("icon-data-length", - "icon data length", - "The length of 'icon-data'", - 1, G_MAXINT32, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("icon-data-length", + "icon data length", + "The length of 'icon-data'", + 1, G_MAXINT32, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_int8_array ("icon-data", "icon data", diff --git a/app/pdb/plug-in-compat-cmds.c b/app/pdb/plug-in-compat-cmds.c index 664a0d5f2f..5c4bf643d5 100644 --- a/app/pdb/plug-in-compat-cmds.c +++ b/app/pdb/plug-in-compat-cmds.c @@ -503,8 +503,8 @@ plug_in_apply_canvas_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 direction; - gint32 depth; + gint direction; + gint depth; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 2), gimp); direction = g_value_get_int (gimp_value_array_index (args, 3)); @@ -764,14 +764,14 @@ plug_in_bump_map_invoker (GimpProcedure *procedure, GimpDrawable *bumpmap; gdouble azimuth; gdouble elevation; - gint32 depth; - gint32 xofs; - gint32 yofs; + gint depth; + gint xofs; + gint yofs; gdouble waterlevel; gdouble ambient; gboolean compensate; gboolean invert; - gint32 type; + gint type; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 2), gimp); bumpmap = gimp_value_get_drawable (gimp_value_array_index (args, 3), gimp); @@ -822,14 +822,14 @@ plug_in_bump_map_tiled_invoker (GimpProcedure *procedure, GimpDrawable *bumpmap; gdouble azimuth; gdouble elevation; - gint32 depth; - gint32 xofs; - gint32 yofs; + gint depth; + gint xofs; + gint yofs; gdouble waterlevel; gdouble ambient; gboolean compensate; gboolean invert; - gint32 type; + gint type; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 2), gimp); bumpmap = gimp_value_get_drawable (gimp_value_array_index (args, 3), gimp); @@ -958,7 +958,7 @@ plug_in_colors_channel_mixer_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 monochrome; + gint monochrome; gdouble rr_gain; gdouble rg_gain; gdouble rb_gain; @@ -1081,14 +1081,14 @@ plug_in_convmatrix_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 argc_matrix; + gint argc_matrix; const gdouble *matrix; gboolean alpha_alg; gdouble divisor; gdouble offset; - gint32 argc_channels; + gint argc_channels; const gint32 *channels; - gint32 bmode; + gint bmode; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 2), gimp); argc_matrix = g_value_get_int (gimp_value_array_index (args, 3)); @@ -1209,7 +1209,7 @@ plug_in_cubism_invoker (GimpProcedure *procedure, GimpDrawable *drawable; gdouble tile_size; gdouble tile_saturation; - gint32 bg_color; + gint bg_color; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 2), gimp); tile_size = g_value_get_double (gimp_value_array_index (args, 3)); @@ -1269,7 +1269,7 @@ plug_in_deinterlace_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 evenodd; + gint evenodd; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 2), gimp); evenodd = g_value_get_int (gimp_value_array_index (args, 3)); @@ -1399,7 +1399,7 @@ plug_in_displace_invoker (GimpProcedure *procedure, gboolean do_y; GimpDrawable *displace_map_x; GimpDrawable *displace_map_y; - gint32 displace_type; + gint displace_type; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 2), gimp); amount_x = g_value_get_double (gimp_value_array_index (args, 3)); @@ -1445,7 +1445,7 @@ plug_in_displace_polar_invoker (GimpProcedure *procedure, gboolean do_y; GimpDrawable *displace_map_x; GimpDrawable *displace_map_y; - gint32 displace_type; + gint displace_type; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 2), gimp); amount_x = g_value_get_double (gimp_value_array_index (args, 3)); @@ -1565,8 +1565,8 @@ plug_in_edge_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpDrawable *drawable; gdouble amount; - gint32 warpmode; - gint32 edgemode; + gint warpmode; + gint edgemode; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 2), gimp); amount = g_value_get_double (gimp_value_array_index (args, 3)); @@ -1633,7 +1633,7 @@ plug_in_emboss_invoker (GimpProcedure *procedure, GimpDrawable *drawable; gdouble azimuth; gdouble elevation; - gint32 depth; + gint depth; gboolean emboss; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 2), gimp); @@ -1682,7 +1682,7 @@ plug_in_engrave_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 height; + gint height; gboolean limit; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 2), gimp); @@ -1799,8 +1799,8 @@ plug_in_flarefx_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 pos_x; - gint32 pos_y; + gint pos_x; + gint pos_y; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 2), gimp); pos_x = g_value_get_int (gimp_value_array_index (args, 3)); @@ -1851,8 +1851,8 @@ plug_in_fractal_trace_invoker (GimpProcedure *procedure, gdouble xmax; gdouble ymin; gdouble ymax; - gint32 depth; - gint32 outside_type; + gint depth; + gint outside_type; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 2), gimp); xmin = g_value_get_double (gimp_value_array_index (args, 3)); @@ -2052,8 +2052,8 @@ plug_in_glasstile_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 tilex; - gint32 tiley; + gint tilex; + gint tiley; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 2), gimp); tilex = g_value_get_int (gimp_value_array_index (args, 3)); @@ -2096,10 +2096,10 @@ plug_in_hsv_noise_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 holdness; - gint32 hue_distance; - gint32 saturation_distance; - gint32 value_distance; + gint holdness; + gint hue_distance; + gint saturation_distance; + gint value_distance; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 2), gimp); holdness = g_value_get_int (gimp_value_array_index (args, 3)); @@ -2149,8 +2149,8 @@ plug_in_illusion_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 division; - gint32 type; + gint division; + gint type; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 2), gimp); division = g_value_get_int (gimp_value_array_index (args, 3)); @@ -2349,7 +2349,7 @@ plug_in_maze_invoker (GimpProcedure *procedure, gint16 height; guint8 tileable; guint8 algorithm; - gint32 seed; + gint seed; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 2), gimp); width = g_value_get_int (gimp_value_array_index (args, 3)); @@ -2412,7 +2412,7 @@ plug_in_mblur_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 type; + gint type; gdouble length; gdouble angle; gdouble center_x; @@ -2499,7 +2499,7 @@ plug_in_mblur_inward_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 type; + gint type; gdouble length; gdouble angle; gdouble center_x; @@ -2587,14 +2587,14 @@ plug_in_mosaic_invoker (GimpProcedure *procedure, gdouble tile_height; gdouble tile_spacing; gdouble tile_neatness; - gint32 tile_allow_split; + gint tile_allow_split; gdouble light_dir; gdouble color_variation; - gint32 antialiasing; - gint32 color_averaging; - gint32 tile_type; - gint32 tile_surface; - gint32 grout_color; + gint antialiasing; + gint color_averaging; + gint tile_type; + gint tile_surface; + gint grout_color; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 2), gimp); tile_size = g_value_get_double (gimp_value_array_index (args, 3)); @@ -2724,18 +2724,18 @@ plug_in_newsprint_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 cell_width; - gint32 colorspace; - gint32 k_pullout; + gint cell_width; + gint colorspace; + gint k_pullout; gdouble gry_ang; - gint32 gry_spotfn; + gint gry_spotfn; gdouble red_ang; - gint32 red_spotfn; + gint red_spotfn; gdouble grn_ang; - gint32 grn_spotfn; + gint grn_spotfn; gdouble blu_ang; - gint32 blu_spotfn; - gint32 oversample; + gint blu_spotfn; + gint oversample; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 2), gimp); cell_width = g_value_get_int (gimp_value_array_index (args, 3)); @@ -2852,12 +2852,12 @@ plug_in_nova_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 xcenter; - gint32 ycenter; + gint xcenter; + gint ycenter; GimpRGB color; - gint32 radius; - gint32 nspoke; - gint32 randomhue; + gint radius; + gint nspoke; + gint randomhue; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 2), gimp); xcenter = g_value_get_int (gimp_value_array_index (args, 3)); @@ -2914,8 +2914,8 @@ plug_in_oilify_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 mask_size; - gint32 mode; + gint mask_size; + gint mode; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 2), gimp); mask_size = g_value_get_int (gimp_value_array_index (args, 3)); @@ -2958,10 +2958,10 @@ plug_in_oilify_enhanced_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 mode; - gint32 mask_size; + gint mode; + gint mask_size; GimpDrawable *mask_size_map; - gint32 exponent; + gint exponent; GimpDrawable *exponent_map; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 2), gimp); @@ -3023,12 +3023,12 @@ plug_in_papertile_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 tile_size; + gint tile_size; gdouble move_max; - gint32 fractional_type; + gint fractional_type; gboolean wrap_around; gboolean centering; - gint32 background_type; + gint background_type; GimpRGB background_color; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 2), gimp); @@ -3162,7 +3162,7 @@ plug_in_pixelize_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 pixel_width; + gint pixel_width; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 2), gimp); pixel_width = g_value_get_int (gimp_value_array_index (args, 3)); @@ -3203,8 +3203,8 @@ plug_in_pixelize2_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 pixel_width; - gint32 pixel_height; + gint pixel_width; + gint pixel_height; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 2), gimp); pixel_width = g_value_get_int (gimp_value_array_index (args, 3)); @@ -3246,7 +3246,7 @@ plug_in_plasma_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 seed; + gint seed; gdouble turbulence; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 2), gimp); @@ -3351,7 +3351,7 @@ plug_in_red_eye_removal_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 threshold; + gint threshold; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 2), gimp); threshold = g_value_get_int (gimp_value_array_index (args, 3)); @@ -3394,7 +3394,7 @@ plug_in_randomize_hurl_invoker (GimpProcedure *procedure, gdouble rndm_pct; gdouble rndm_rcount; gboolean randomize; - gint32 seed; + gint seed; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 2), gimp); rndm_pct = g_value_get_double (gimp_value_array_index (args, 3)); @@ -3447,7 +3447,7 @@ plug_in_randomize_pick_invoker (GimpProcedure *procedure, gdouble rndm_pct; gdouble rndm_rcount; gboolean randomize; - gint32 seed; + gint seed; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 2), gimp); rndm_pct = g_value_get_double (gimp_value_array_index (args, 3)); @@ -3500,7 +3500,7 @@ plug_in_randomize_slur_invoker (GimpProcedure *procedure, gdouble rndm_pct; gdouble rndm_rcount; gboolean randomize; - gint32 seed; + gint seed; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 2), gimp); rndm_pct = g_value_get_double (gimp_value_array_index (args, 3)); @@ -3625,11 +3625,11 @@ plug_in_ripple_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 period; - gint32 amplitude; - gint32 orientation; - gint32 edges; - gint32 waveform; + gint period; + gint amplitude; + gint orientation; + gint edges; + gint waveform; gboolean antialias; gboolean tile; @@ -3698,7 +3698,7 @@ plug_in_rotate_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpImage *image; GimpDrawable *drawable; - gint32 angle; + gint angle; gboolean everything; image = gimp_value_get_image (gimp_value_array_index (args, 1), gimp); @@ -3821,7 +3821,7 @@ plug_in_sel_gauss_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpDrawable *drawable; gdouble radius; - gint32 max_delta; + gint max_delta; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 2), gimp); radius = g_value_get_double (gimp_value_array_index (args, 3)); @@ -3908,8 +3908,8 @@ plug_in_shift_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 shift_amount; - gint32 orientation; + gint shift_amount; + gint orientation; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 2), gimp); shift_amount = g_value_get_int (gimp_value_array_index (args, 3)); @@ -3954,15 +3954,15 @@ plug_in_sinus_invoker (GimpProcedure *procedure, gdouble xscale; gdouble yscale; gdouble complex; - gint32 seed; + gint seed; gboolean tiling; gboolean perturb; - gint32 colors; + gint colors; GimpRGB col1; GimpRGB col2; gdouble alpha1; gdouble alpha2; - gint32 blend; + gint blend; gdouble blend_power; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 2), gimp); @@ -4152,8 +4152,8 @@ plug_in_solid_noise_invoker (GimpProcedure *procedure, GimpDrawable *drawable; gboolean tileable; gboolean turbulent; - gint32 seed; - gint32 detail; + gint seed; + gint detail; gdouble xsize; gdouble ysize; @@ -4255,7 +4255,7 @@ plug_in_threshold_alpha_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 threshold; + gint threshold; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 2), gimp); threshold = g_value_get_int (gimp_value_array_index (args, 3)); @@ -4298,7 +4298,7 @@ plug_in_unsharp_mask_invoker (GimpProcedure *procedure, GimpDrawable *drawable; gdouble radius; gdouble amount; - gint32 threshold; + gint threshold; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 2), gimp); radius = g_value_get_double (gimp_value_array_index (args, 3)); @@ -4342,7 +4342,7 @@ plug_in_video_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 pattern_number; + gint pattern_number; gboolean additive; gboolean rotated; @@ -4425,12 +4425,12 @@ plug_in_vpropagate_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 propagate_mode; - gint32 propagating_channel; + gint propagate_mode; + gint propagating_channel; gdouble propagating_rate; - gint32 direction_mask; - gint32 lower_limit; - gint32 upper_limit; + gint direction_mask; + gint lower_limit; + gint upper_limit; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 2), gimp); propagate_mode = g_value_get_int (gimp_value_array_index (args, 3)); @@ -4734,11 +4734,11 @@ plug_in_wind_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpDrawable *drawable; - gint32 threshold; - gint32 direction; - gint32 strength; - gint32 algorithm; - gint32 edge; + gint threshold; + gint direction; + gint strength; + gint algorithm; + gint edge; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 2), gimp); threshold = g_value_get_int (gimp_value_array_index (args, 3)); @@ -4947,17 +4947,17 @@ register_plug_in_compat_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("direction", - "direction", - "Light direction (0 - 3)", - 0, 3, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("direction", + "direction", + "Light direction (0 - 3)", + 0, 3, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("depth", - "depth", - "Texture depth (1 - 50)", - 1, 50, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("depth", + "depth", + "Texture depth (1 - 50)", + 1, 50, 1, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -5181,23 +5181,23 @@ register_plug_in_compat_procs (GimpPDB *pdb) 0.5, 90.0, 0.5, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("depth", - "depth", - "Depth", - 1, 65, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("depth", + "depth", + "Depth", + 1, 65, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("xofs", - "xofs", - "X offset", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("xofs", + "xofs", + "X offset", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("yofs", - "yofs", - "Y offset", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("yofs", + "yofs", + "Y offset", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_double ("waterlevel", "waterlevel", @@ -5223,11 +5223,11 @@ register_plug_in_compat_procs (GimpPDB *pdb) FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("type", - "type", - "Type of map { LINEAR (0), SPHERICAL (1), SINUSOIDAL (2) }", - 0, 3, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("type", + "type", + "Type of map { LINEAR (0), SPHERICAL (1), SINUSOIDAL (2) }", + 0, 3, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -5283,23 +5283,23 @@ register_plug_in_compat_procs (GimpPDB *pdb) 0.5, 90.0, 0.5, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("depth", - "depth", - "Depth", - 1, 65, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("depth", + "depth", + "Depth", + 1, 65, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("xofs", - "xofs", - "X offset", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("xofs", + "xofs", + "X offset", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("yofs", - "yofs", - "Y offset", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("yofs", + "yofs", + "Y offset", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_double ("waterlevel", "waterlevel", @@ -5325,11 +5325,11 @@ register_plug_in_compat_procs (GimpPDB *pdb) FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("type", - "type", - "Type of map { LINEAR (0), SPHERICAL (1), SINUSOIDAL (2) }", - 0, 3, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("type", + "type", + "Type of map { LINEAR (0), SPHERICAL (1), SINUSOIDAL (2) }", + 0, 3, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -5452,11 +5452,11 @@ register_plug_in_compat_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("monochrome", - "monochrome", - "Monochrome { TRUE, FALSE }", - 0, 1, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("monochrome", + "monochrome", + "Monochrome { TRUE, FALSE }", + 0, 1, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_double ("rr-gain", "rr gain", @@ -5591,11 +5591,11 @@ register_plug_in_compat_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("argc-matrix", - "argc matrix", - "The number of elements in the following array, must always be 25", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("argc-matrix", + "argc matrix", + "The number of elements in the following array, must always be 25", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_float_array ("matrix", "matrix", @@ -5620,22 +5620,22 @@ register_plug_in_compat_procs (GimpPDB *pdb) -G_MAXDOUBLE, G_MAXDOUBLE, 0, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("argc-channels", - "argc channels", - "The number of elements in following array, must always be 5", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("argc-channels", + "argc channels", + "The number of elements in following array, must always be 5", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_int32_array ("channels", "channels", "Mask of the channels to be filtered", GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("bmode", - "bmode", - "Mode for treating image borders { EXTEND (0), WRAP (1), CLEAR (2) }", - 0, 2, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("bmode", + "bmode", + "Mode for treating image borders { EXTEND (0), WRAP (1), CLEAR (2) }", + 0, 2, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -5685,11 +5685,11 @@ register_plug_in_compat_procs (GimpPDB *pdb) 0.0, 10.0, 0.0, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("bg-color", - "bg color", - "Background color { BLACK (0), BG (1) }", - 0, 1, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("bg-color", + "bg color", + "Background color { BLACK (0), BG (1) }", + 0, 1, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -5727,11 +5727,11 @@ register_plug_in_compat_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("evenodd", - "evenodd", - "Which lines to keep { KEEP-ODD (0), KEEP-EVEN (1)", - 0, 1, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("evenodd", + "evenodd", + "Which lines to keep { KEEP-ODD (0), KEEP-EVEN (1)", + 0, 1, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -5913,11 +5913,11 @@ register_plug_in_compat_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("displace-type", - "displace type", - "Edge behavior { WRAP (1), SMEAR (2), BLACK (3) }", - 1, 3, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("displace-type", + "displace type", + "Edge behavior { WRAP (1), SMEAR (2), BLACK (3) }", + 1, 3, 1, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -5991,11 +5991,11 @@ register_plug_in_compat_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("displace-type", - "displace type", - "Edge behavior { WRAP (1), SMEAR (2), BLACK (3) }", - 1, 3, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("displace-type", + "displace type", + "Edge behavior { WRAP (1), SMEAR (2), BLACK (3) }", + 1, 3, 1, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -6099,17 +6099,17 @@ register_plug_in_compat_procs (GimpPDB *pdb) 1.0, 10.0, 1.0, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("warpmode", - "warpmode", - "Edge detection behavior { NONE (0), WRAP (1), SMEAR (2), BLACK (3) }", - 0, 3, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("warpmode", + "warpmode", + "Edge detection behavior { NONE (0), WRAP (1), SMEAR (2), BLACK (3) }", + 0, 3, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("edgemode", - "edgemode", - "Edge detection algorithm { SOBEL (0), PREWITT (1), GRADIENT (2), ROBERTS (3), DIFFERENTIAL (4), LAPLACE (5) }", - 0, 5, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("edgemode", + "edgemode", + "Edge detection algorithm { SOBEL (0), PREWITT (1), GRADIENT (2), ROBERTS (3), DIFFERENTIAL (4), LAPLACE (5) }", + 0, 5, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -6159,11 +6159,11 @@ register_plug_in_compat_procs (GimpPDB *pdb) 0.0, 180, 0.0, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("depth", - "depth", - "The Filter Width", - 1, 99, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("depth", + "depth", + "The Filter Width", + 1, 99, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_boolean ("emboss", "emboss", @@ -6207,11 +6207,11 @@ register_plug_in_compat_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("height", - "height", - "Resolution in pixels", - 2, 16, 2, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("height", + "height", + "Resolution in pixels", + 2, 16, 2, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_boolean ("limit", "limit", @@ -6345,17 +6345,17 @@ register_plug_in_compat_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("pos-x", - "pos x", - "X-Position", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("pos-x", + "pos x", + "X-Position", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("pos-y", - "pos y", - "Y-Position", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("pos-y", + "pos y", + "Y-Position", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -6417,17 +6417,17 @@ register_plug_in_compat_procs (GimpPDB *pdb) -50.0, 50.0, -50.0, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("depth", - "depth", - "Trace depth", - 1, 65536, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("depth", + "depth", + "Trace depth", + 1, 65536, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("outside-type", - "outside type", - "Outside type { WRAP (0), TRANS (1), BLACK (2), WHITE (3) }", - 0, 3, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("outside-type", + "outside type", + "Outside type { WRAP (0), TRANS (1), BLACK (2), WHITE (3) }", + 0, 3, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -6477,11 +6477,11 @@ register_plug_in_compat_procs (GimpPDB *pdb) 0.0, 500.0, 0.0, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("method", - "method", - "Blur method { IIR (0), RLE (1) }", - 0, 1, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("method", + "method", + "Blur method { IIR (0), RLE (1) }", + 0, 1, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -6723,17 +6723,17 @@ register_plug_in_compat_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("tilex", - "tilex", - "Tile width", - 10, 500, 10, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("tilex", + "tilex", + "Tile width", + 10, 500, 10, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("tiley", - "tiley", - "Tile height", - 10, 500, 10, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("tiley", + "tiley", + "Tile height", + 10, 500, 10, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -6771,29 +6771,29 @@ register_plug_in_compat_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("holdness", - "holdness", - "Convolution strength", - 1, 8, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("holdness", + "holdness", + "Convolution strength", + 1, 8, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("hue-distance", - "hue distance", - "Scattering of hue angle", - 0, 180, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("hue-distance", + "hue distance", + "Scattering of hue angle", + 0, 180, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("saturation-distance", - "saturation distance", - "Distribution distance on saturation axis", - 0, 255, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("saturation-distance", + "saturation distance", + "Distribution distance on saturation axis", + 0, 255, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("value-distance", - "value distance", - "Distribution distance on value axis", - 0, 255, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("value-distance", + "value distance", + "Distribution distance on value axis", + 0, 255, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -6831,17 +6831,17 @@ register_plug_in_compat_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("division", - "division", - "The number of divisions", - 0, 64, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("division", + "division", + "The number of divisions", + 0, 64, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("type", - "type", - "Illusion type { TYPE1 (0), TYPE2 (1) }", - 0, 1, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("type", + "type", + "Illusion type { TYPE1 (0), TYPE2 (1) }", + 0, 1, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -7047,11 +7047,11 @@ register_plug_in_compat_procs (GimpPDB *pdb) 0, 1, 0, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("seed", - "seed", - "Random Seed", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("seed", + "seed", + "Random Seed", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_int16 ("multiple", "multiple", @@ -7101,11 +7101,11 @@ register_plug_in_compat_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("type", - "type", - "Type of motion blur { LINEAR (0), RADIAL (1), ZOOM (2) }", - 0, 2, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("type", + "type", + "Type of motion blur { LINEAR (0), RADIAL (1), ZOOM (2) }", + 0, 2, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_double ("length", "length", @@ -7167,11 +7167,11 @@ register_plug_in_compat_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("type", - "type", - "Type of motion blur { LINEAR (0), RADIAL (1), ZOOM (2) }", - 0, 2, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("type", + "type", + "Type of motion blur { LINEAR (0), RADIAL (1), ZOOM (2) }", + 0, 2, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_double ("length", "length", @@ -7257,11 +7257,11 @@ register_plug_in_compat_procs (GimpPDB *pdb) 0, 1.0, 0, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("tile-allow-split", - "tile allow split", - "Allows splitting tiles at hard edges", - 0, 1, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("tile-allow-split", + "tile allow split", + "Allows splitting tiles at hard edges", + 0, 1, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_double ("light-dir", "light dir", @@ -7275,35 +7275,35 @@ register_plug_in_compat_procs (GimpPDB *pdb) 0.0, 1.0, 0.0, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("antialiasing", - "antialiasing", - "Enables smoother tile output at the cost of speed", - 0, 1, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("antialiasing", + "antialiasing", + "Enables smoother tile output at the cost of speed", + 0, 1, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("color-averaging", - "color averaging", - "Tile color based on average of subsumed pixels", - 0, 1, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("color-averaging", + "color averaging", + "Tile color based on average of subsumed pixels", + 0, 1, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("tile-type", - "tile type", - "Tile geometry { SQUARES (0), HEXAGONS (1), OCTAGONS (2), TRIANGLES (3) }", - 0, 3, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("tile-type", + "tile type", + "Tile geometry { SQUARES (0), HEXAGONS (1), OCTAGONS (2), TRIANGLES (3) }", + 0, 3, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("tile-surface", - "tile surface", - "Surface characteristics { SMOOTH (0), ROUGH (1) }", - 0, 1, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("tile-surface", + "tile surface", + "Surface characteristics { SMOOTH (0), ROUGH (1) }", + 0, 1, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("grout-color", - "grout color", - "Grout color (black/white or fore/background) { BW (0), FG-BG (1) }", - 0, 1, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("grout-color", + "grout color", + "Grout color (black/white or fore/background) { BW (0), FG-BG (1) }", + 0, 1, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -7389,23 +7389,23 @@ register_plug_in_compat_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("cell-width", - "cell width", - "Screen cell width in pixels", - 0, 1500, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("cell-width", + "cell width", + "Screen cell width in pixels", + 0, 1500, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("colorspace", - "colorspace", - "Separate to { GRAYSCALE (0), RGB (1), CMYK (2), LUMINANCE (3) }", - 0, 3, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("colorspace", + "colorspace", + "Separate to { GRAYSCALE (0), RGB (1), CMYK (2), LUMINANCE (3) }", + 0, 3, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("k-pullout", - "k pullout", - "Percentage of black to pullout (CMYK only)", - 0, 100, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("k-pullout", + "k pullout", + "Percentage of black to pullout (CMYK only)", + 0, 100, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_double ("gry-ang", "gry ang", @@ -7413,11 +7413,11 @@ register_plug_in_compat_procs (GimpPDB *pdb) 0.0, 360.0, 0.0, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("gry-spotfn", - "gry spotfn", - "Grey/black spot function { DOTS (0), LINES (1), DIAMONDS (2), EUCLIDIAN-DOT (3), PS-DIAMONDS (4) }", - 0, 4, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("gry-spotfn", + "gry spotfn", + "Grey/black spot function { DOTS (0), LINES (1), DIAMONDS (2), EUCLIDIAN-DOT (3), PS-DIAMONDS (4) }", + 0, 4, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_double ("red-ang", "red ang", @@ -7425,11 +7425,11 @@ register_plug_in_compat_procs (GimpPDB *pdb) 0.0, 360.0, 0.0, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("red-spotfn", - "red spotfn", - "Red/cyan spot function { DOTS (0), LINES (1), DIAMONDS (2), EUCLIDIAN-DOT (3), PS-DIAMONDS (4) }", - 0, 4, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("red-spotfn", + "red spotfn", + "Red/cyan spot function { DOTS (0), LINES (1), DIAMONDS (2), EUCLIDIAN-DOT (3), PS-DIAMONDS (4) }", + 0, 4, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_double ("grn-ang", "grn ang", @@ -7437,11 +7437,11 @@ register_plug_in_compat_procs (GimpPDB *pdb) 0.0, 360.0, 0.0, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("grn-spotfn", - "grn spotfn", - "Green/magenta spot function { DOTS (0), LINES (1), DIAMONDS (2), EUCLIDIAN-DOT (3), PS-DIAMONDS (4) }", - 0, 4, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("grn-spotfn", + "grn spotfn", + "Green/magenta spot function { DOTS (0), LINES (1), DIAMONDS (2), EUCLIDIAN-DOT (3), PS-DIAMONDS (4) }", + 0, 4, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_double ("blu-ang", "blu ang", @@ -7449,17 +7449,17 @@ register_plug_in_compat_procs (GimpPDB *pdb) 0.0, 360.0, 0.0, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("blu-spotfn", - "blu spotfn", - "Blue/yellow spot function { DOTS (0), LINES (1), DIAMONDS (2), EUCLIDIAN-DOT (3), PS-DIAMONDS (4) }", - 0, 4, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("blu-spotfn", + "blu spotfn", + "Blue/yellow spot function { DOTS (0), LINES (1), DIAMONDS (2), EUCLIDIAN-DOT (3), PS-DIAMONDS (4) }", + 0, 4, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("oversample", - "oversample", - "how many times to oversample spot fn", - 0, 128, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("oversample", + "oversample", + "how many times to oversample spot fn", + 0, 128, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -7533,17 +7533,17 @@ register_plug_in_compat_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("xcenter", - "xcenter", - "X coordinates of the center of supernova", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("xcenter", + "xcenter", + "X coordinates of the center of supernova", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("ycenter", - "ycenter", - "Y coordinates of the center of supernova", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("ycenter", + "ycenter", + "Y coordinates of the center of supernova", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_rgb ("color", "color", @@ -7552,23 +7552,23 @@ register_plug_in_compat_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("radius", - "radius", - "Radius of supernova", - 1, 3000, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("radius", + "radius", + "Radius of supernova", + 1, 3000, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("nspoke", - "nspoke", - "Number of spokes", - 1, 1024, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("nspoke", + "nspoke", + "Number of spokes", + 1, 1024, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("randomhue", - "randomhue", - "Random hue", - 0, 360, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("randomhue", + "randomhue", + "Random hue", + 0, 360, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -7606,17 +7606,17 @@ register_plug_in_compat_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("mask-size", - "mask size", - "Oil paint mask size", - 1, 200, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("mask-size", + "mask size", + "Oil paint mask size", + 1, 200, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("mode", - "mode", - "Algorithm { RGB (0), INTENSITY (1) }", - 0, 1, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("mode", + "mode", + "Algorithm { RGB (0), INTENSITY (1) }", + 0, 1, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -7654,17 +7654,17 @@ register_plug_in_compat_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("mode", - "mode", - "Algorithm { RGB (0), INTENSITY (1) }", - 0, 1, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("mode", + "mode", + "Algorithm { RGB (0), INTENSITY (1) }", + 0, 1, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("mask-size", - "mask size", - "Oil paint mask size", - 1, 200, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("mask-size", + "mask size", + "Oil paint mask size", + 1, 200, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_drawable_id ("mask-size-map", "mask size map", @@ -7672,11 +7672,11 @@ register_plug_in_compat_procs (GimpPDB *pdb) pdb->gimp, TRUE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("exponent", - "exponent", - "Oil paint exponent", - 1, 20, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("exponent", + "exponent", + "Oil paint exponent", + 1, 20, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_drawable_id ("exponent-map", "exponent map", @@ -7720,11 +7720,11 @@ register_plug_in_compat_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("tile-size", - "tile size", - "Tile size (pixels)", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("tile-size", + "tile size", + "Tile size (pixels)", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_double ("move-max", "move max", @@ -7732,11 +7732,11 @@ register_plug_in_compat_procs (GimpPDB *pdb) -G_MAXDOUBLE, G_MAXDOUBLE, 0, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("fractional-type", - "fractional type", - "Fractional type { BACKGROUND (0), IGNORE (1), FORCE (2) }", - 0, 2, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("fractional-type", + "fractional type", + "Fractional type { BACKGROUND (0), IGNORE (1), FORCE (2) }", + 0, 2, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_boolean ("wrap-around", "wrap around", @@ -7750,11 +7750,11 @@ register_plug_in_compat_procs (GimpPDB *pdb) FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("background-type", - "background type", - "Background type { TRANSPARENT (0), INVERTED (1), IMAGE (2), FG (3), BG (4), COLOR (5) }", - 0, 5, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("background-type", + "background type", + "Background type { TRANSPARENT (0), INVERTED (1), IMAGE (2), FG (3), BG (4), COLOR (5) }", + 0, 5, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_rgb ("background-color", "background color", @@ -7763,11 +7763,11 @@ register_plug_in_compat_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("background-alpha", - "background alpha", - "Background alpha (unused)", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("background-alpha", + "background alpha", + "Background alpha (unused)", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -7866,11 +7866,11 @@ register_plug_in_compat_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("pixel-width", - "pixel width", - "Pixel width (the decrease in resolution)", - 1, GIMP_MAX_IMAGE_SIZE, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("pixel-width", + "pixel width", + "Pixel width (the decrease in resolution)", + 1, GIMP_MAX_IMAGE_SIZE, 1, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -7908,17 +7908,17 @@ register_plug_in_compat_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("pixel-width", - "pixel width", - "Pixel width (the decrease in horizontal resolution)", - 1, GIMP_MAX_IMAGE_SIZE, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("pixel-width", + "pixel width", + "Pixel width (the decrease in horizontal resolution)", + 1, GIMP_MAX_IMAGE_SIZE, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("pixel-height", - "pixel height", - "Pixel height (the decrease in vertical resolution)", - 1, GIMP_MAX_IMAGE_SIZE, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("pixel-height", + "pixel height", + "Pixel height (the decrease in vertical resolution)", + 1, GIMP_MAX_IMAGE_SIZE, 1, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -7956,11 +7956,11 @@ register_plug_in_compat_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("seed", - "seed", - "Random seed", - -1, G_MAXINT, -1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("seed", + "seed", + "Random seed", + -1, G_MAXINT, -1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_double ("turbulence", "turbulence", @@ -8070,11 +8070,11 @@ register_plug_in_compat_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("threshold", - "threshold", - "Red eye threshold in percent", - 0, 100, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("threshold", + "threshold", + "Red eye threshold in percent", + 0, 100, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -8130,11 +8130,11 @@ register_plug_in_compat_procs (GimpPDB *pdb) FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("seed", - "seed", - "Seed value (used only if randomize is FALSE)", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("seed", + "seed", + "Seed value (used only if randomize is FALSE)", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -8190,11 +8190,11 @@ register_plug_in_compat_procs (GimpPDB *pdb) FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("seed", - "seed", - "Seed value (used only if randomize is FALSE)", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("seed", + "seed", + "Seed value (used only if randomize is FALSE)", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -8250,11 +8250,11 @@ register_plug_in_compat_procs (GimpPDB *pdb) FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("seed", - "seed", - "Seed value (used only if randomize is FALSE)", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("seed", + "seed", + "Seed value (used only if randomize is FALSE)", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -8364,35 +8364,35 @@ register_plug_in_compat_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("period", - "period", - "Period: number of pixels for one wave to complete", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("period", + "period", + "Period: number of pixels for one wave to complete", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("amplitude", - "amplitude", - "Amplitude: maximum displacement of wave", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("amplitude", + "amplitude", + "Amplitude: maximum displacement of wave", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("orientation", - "orientation", - "Orientation { ORIENTATION-HORIZONTAL (0), ORIENTATION-VERTICAL (1) }", - 0, 1, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("orientation", + "orientation", + "Orientation { ORIENTATION-HORIZONTAL (0), ORIENTATION-VERTICAL (1) }", + 0, 1, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("edges", - "edges", - "Edges { SMEAR (0), WRAP (1), BLANK (2) }", - 0, 2, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("edges", + "edges", + "Edges { SMEAR (0), WRAP (1), BLANK (2) }", + 0, 2, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("waveform", - "waveform", - "Waveform { SAWTOOTH (0), SINE (1) }", - 0, 1, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("waveform", + "waveform", + "Waveform { SAWTOOTH (0), SINE (1) }", + 0, 1, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_boolean ("antialias", "antialias", @@ -8442,11 +8442,11 @@ register_plug_in_compat_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("angle", - "angle", - "Angle { 90 (1), 180 (2), 270 (3) } degrees", - 1, 3, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("angle", + "angle", + "Angle { 90 (1), 180 (2), 270 (3) } degrees", + 1, 3, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_boolean ("everything", "everything", @@ -8562,11 +8562,11 @@ register_plug_in_compat_procs (GimpPDB *pdb) 0.0, G_MAXDOUBLE, 0.0, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("max-delta", - "max delta", - "Maximum delta", - 0, 255, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("max-delta", + "max delta", + "Maximum delta", + 0, 255, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -8640,17 +8640,17 @@ register_plug_in_compat_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("shift-amount", - "shift amount", - "Shift amount", - 0, 200, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("shift-amount", + "shift amount", + "Shift amount", + 0, 200, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("orientation", - "orientation", - "Orientation { ORIENTATION-VERTICAL (0), ORIENTATION-HORIZONTAL (1) }", - 0, 1, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("orientation", + "orientation", + "Orientation { ORIENTATION-VERTICAL (0), ORIENTATION-HORIZONTAL (1) }", + 0, 1, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -8706,11 +8706,11 @@ register_plug_in_compat_procs (GimpPDB *pdb) 0, G_MAXDOUBLE, 0, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("seed", - "seed", - "Seed value for random number generator", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("seed", + "seed", + "Seed value for random number generator", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_boolean ("tiling", "tiling", @@ -8724,11 +8724,11 @@ register_plug_in_compat_procs (GimpPDB *pdb) FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("colors", - "colors", - "where to take the colors (0=B&W, 1=fg/bg, 2=col1/col2)", - 0, 2, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("colors", + "colors", + "where to take the colors (0=B&W, 1=fg/bg, 2=col1/col2)", + 0, 2, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_rgb ("col1", "col1", @@ -8756,11 +8756,11 @@ register_plug_in_compat_procs (GimpPDB *pdb) 0, 1, 0, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("blend", - "blend", - "0=linear, 1=bilinear, 2=sinusoidal", - 0, 2, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("blend", + "blend", + "0=linear, 1=bilinear, 2=sinusoidal", + 0, 2, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_double ("blend-power", "blend power", @@ -8924,17 +8924,17 @@ register_plug_in_compat_procs (GimpPDB *pdb) FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("seed", - "seed", - "Random seed", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("seed", + "seed", + "Random seed", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("detail", - "detail", - "Detail level", - 0, 15, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("detail", + "detail", + "Detail level", + 0, 15, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_double ("xsize", "xsize", @@ -9032,11 +9032,11 @@ register_plug_in_compat_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("threshold", - "threshold", - "Threshold", - 0, 255, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("threshold", + "threshold", + "Threshold", + 0, 255, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -9086,11 +9086,11 @@ register_plug_in_compat_procs (GimpPDB *pdb) 0.0, 300.0, 0.0, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("threshold", - "threshold", - "Threshold", - 0, 255, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("threshold", + "threshold", + "Threshold", + 0, 255, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -9128,11 +9128,11 @@ register_plug_in_compat_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("pattern-number", - "pattern number", - "Type of RGB pattern to use", - 0, 8, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("pattern-number", + "pattern number", + "Type of RGB pattern to use", + 0, 8, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_boolean ("additive", "additive", @@ -9218,17 +9218,17 @@ register_plug_in_compat_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("propagate-mode", - "propagate mode", - "Propagate mode { 0:white, 1:black, 2:middle value 3:foreground to peak, 4:foreground, 5:background, 6:opaque, 7:transparent }", - 0, 7, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("propagate-mode", + "propagate mode", + "Propagate mode { 0:white, 1:black, 2:middle value 3:foreground to peak, 4:foreground, 5:background, 6:opaque, 7:transparent }", + 0, 7, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("propagating-channel", - "propagating channel", - "Channels which values are propagated", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("propagating-channel", + "propagating channel", + "Channels which values are propagated", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_double ("propagating-rate", "propagating rate", @@ -9236,23 +9236,23 @@ register_plug_in_compat_procs (GimpPDB *pdb) 0.0, 1.0, 0.0, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("direction-mask", - "direction mask", - "Direction mask", - 0, 15, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("direction-mask", + "direction mask", + "Direction mask", + 0, 15, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("lower-limit", - "lower limit", - "Lower limit", - 0, 255, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("lower-limit", + "lower limit", + "Lower limit", + 0, 255, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("upper-limit", - "upper limit", - "Upper limit", - 0, 255, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("upper-limit", + "upper limit", + "Upper limit", + 0, 255, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -9290,17 +9290,17 @@ register_plug_in_compat_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("propagate-mode", - "propagate mode", - "Propagate mode { 0:white, 1:black, 2:middle value 3:foreground to peak, 4:foreground, 5:background, 6:opaque, 7:transparent }", - 0, 7, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("propagate-mode", + "propagate mode", + "Propagate mode { 0:white, 1:black, 2:middle value 3:foreground to peak, 4:foreground, 5:background, 6:opaque, 7:transparent }", + 0, 7, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("propagating-channel", - "propagating channel", - "Channels which values are propagated", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("propagating-channel", + "propagating channel", + "Channels which values are propagated", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_double ("propagating-rate", "propagating rate", @@ -9308,23 +9308,23 @@ register_plug_in_compat_procs (GimpPDB *pdb) 0.0, 1.0, 0.0, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("direction-mask", - "direction mask", - "Direction mask", - 0, 15, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("direction-mask", + "direction mask", + "Direction mask", + 0, 15, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("lower-limit", - "lower limit", - "Lower limit", - 0, 255, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("lower-limit", + "lower limit", + "Lower limit", + 0, 255, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("upper-limit", - "upper limit", - "Upper limit", - 0, 255, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("upper-limit", + "upper limit", + "Upper limit", + 0, 255, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -9362,17 +9362,17 @@ register_plug_in_compat_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("propagate-mode", - "propagate mode", - "Propagate mode { 0:white, 1:black, 2:middle value 3:foreground to peak, 4:foreground, 5:background, 6:opaque, 7:transparent }", - 0, 7, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("propagate-mode", + "propagate mode", + "Propagate mode { 0:white, 1:black, 2:middle value 3:foreground to peak, 4:foreground, 5:background, 6:opaque, 7:transparent }", + 0, 7, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("propagating-channel", - "propagating channel", - "Channels which values are propagated", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("propagating-channel", + "propagating channel", + "Channels which values are propagated", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_double ("propagating-rate", "propagating rate", @@ -9380,23 +9380,23 @@ register_plug_in_compat_procs (GimpPDB *pdb) 0.0, 1.0, 0.0, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("direction-mask", - "direction mask", - "Direction mask", - 0, 15, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("direction-mask", + "direction mask", + "Direction mask", + 0, 15, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("lower-limit", - "lower limit", - "Lower limit", - 0, 255, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("lower-limit", + "lower limit", + "Lower limit", + 0, 255, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("upper-limit", - "upper limit", - "Upper limit", - 0, 255, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("upper-limit", + "upper limit", + "Upper limit", + 0, 255, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -9554,35 +9554,35 @@ register_plug_in_compat_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("threshold", - "threshold", - "Controls where blending will be done", - 0, 50, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("threshold", + "threshold", + "Controls where blending will be done", + 0, 50, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("direction", - "direction", - "Wind direction { 0:left, 1:right, 2:top, 3:bottom }", - 0, 3, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("direction", + "direction", + "Wind direction { 0:left, 1:right, 2:top, 3:bottom }", + 0, 3, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("strength", - "strength", - "Controls the extent of the blending", - 1, 100, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("strength", + "strength", + "Controls the extent of the blending", + 1, 100, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("algorithm", - "algorithm", - "Algorithm { WIND (0), BLAST (1) }", - 0, 1, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("algorithm", + "algorithm", + "Algorithm { WIND (0), BLAST (1) }", + 0, 1, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("edge", - "edge", - "Affected edge { BOTH (0), LEADING (1), TRAILING (2) }", - 0, 2, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("edge", + "edge", + "Affected edge { BOTH (0), LEADING (1), TRAILING (2) }", + 0, 2, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); } diff --git a/app/pdb/progress-cmds.c b/app/pdb/progress-cmds.c index 74b843e314..e61824e830 100644 --- a/app/pdb/progress-cmds.c +++ b/app/pdb/progress-cmds.c @@ -187,7 +187,7 @@ progress_get_window_handle_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpValueArray *return_vals; - gint32 window = 0; + gint window = 0; GimpPlugIn *plug_in = gimp->plug_in_manager->current_plug_in; @@ -420,11 +420,11 @@ register_progress_procs (GimpPDB *pdb) "2004", NULL); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("window", - "window", - "The progress bar's toplevel window", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("window", + "window", + "The progress bar's toplevel window", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); diff --git a/app/pdb/selection-cmds.c b/app/pdb/selection-cmds.c index 5e0641ebb0..d9ff516bef 100644 --- a/app/pdb/selection-cmds.c +++ b/app/pdb/selection-cmds.c @@ -57,10 +57,10 @@ selection_bounds_invoker (GimpProcedure *procedure, GimpValueArray *return_vals; GimpImage *image; gboolean non_empty = FALSE; - gint32 x1 = 0; - gint32 y1 = 0; - gint32 x2 = 0; - gint32 y2 = 0; + gint x1 = 0; + gint y1 = 0; + gint x2 = 0; + gint y2 = 0; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); @@ -103,9 +103,9 @@ selection_value_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpImage *image; - gint32 x; - gint32 y; - gint32 value = 0; + gint x; + gint y; + gint value = 0; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); x = g_value_get_int (gimp_value_array_index (args, 1)); @@ -169,8 +169,8 @@ selection_translate_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpImage *image; - gint32 offx; - gint32 offy; + gint offx; + gint offy; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); offx = g_value_get_int (gimp_value_array_index (args, 1)); @@ -197,8 +197,8 @@ selection_float_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpDrawable *drawable; - gint32 offx; - gint32 offy; + gint offx; + gint offy; GimpLayer *layer = NULL; drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); @@ -356,7 +356,7 @@ selection_border_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpImage *image; - gint32 radius; + gint radius; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); radius = g_value_get_int (gimp_value_array_index (args, 1)); @@ -384,7 +384,7 @@ selection_grow_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpImage *image; - gint32 steps; + gint steps; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); steps = g_value_get_int (gimp_value_array_index (args, 1)); @@ -409,7 +409,7 @@ selection_shrink_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpImage *image; - gint32 steps; + gint steps; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); steps = g_value_get_int (gimp_value_array_index (args, 1)); @@ -519,29 +519,29 @@ register_selection_procs (GimpPDB *pdb) FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("x1", - "x1", - "x coordinate of upper left corner of selection bounds", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("x1", + "x1", + "x coordinate of upper left corner of selection bounds", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("y1", - "y1", - "y coordinate of upper left corner of selection bounds", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("y1", + "y1", + "y coordinate of upper left corner of selection bounds", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("x2", - "x2", - "x coordinate of lower right corner of selection bounds", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("x2", + "x2", + "x coordinate of lower right corner of selection bounds", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("y2", - "y2", - "y coordinate of lower right corner of selection bounds", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("y2", + "y2", + "y coordinate of lower right corner of selection bounds", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -566,23 +566,23 @@ register_selection_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("x", - "x", - "x coordinate of value", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("x", + "x", + "x coordinate of value", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("y", - "y", - "y coordinate of value", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("y", + "y", + "y coordinate of value", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("value", - "value", - "Value of the selection", - 0, 255, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("value", + "value", + "Value of the selection", + 0, 255, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -636,17 +636,17 @@ register_selection_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("offx", - "offx", - "x offset for translation", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("offx", + "offx", + "x offset for translation", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("offy", - "offy", - "y offset for translation", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("offy", + "offy", + "y offset for translation", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -671,17 +671,17 @@ register_selection_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("offx", - "offx", - "x offset for translation", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("offx", + "offx", + "x offset for translation", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("offy", - "offy", - "y offset for translation", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("offy", + "offy", + "y offset for translation", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_layer_id ("layer", "layer", @@ -833,11 +833,11 @@ register_selection_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("radius", - "radius", - "Radius of border (in pixels)", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("radius", + "radius", + "Radius of border (in pixels)", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -862,11 +862,11 @@ register_selection_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("steps", - "steps", - "Steps of grow (in pixels)", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("steps", + "steps", + "Steps of grow (in pixels)", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -891,11 +891,11 @@ register_selection_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("steps", - "steps", - "Steps of shrink (in pixels)", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("steps", + "steps", + "Steps of shrink (in pixels)", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); diff --git a/app/pdb/text-layer-cmds.c b/app/pdb/text-layer-cmds.c index e29f3a4d2f..f0bbfa290f 100644 --- a/app/pdb/text-layer-cmds.c +++ b/app/pdb/text-layer-cmds.c @@ -452,7 +452,7 @@ text_layer_get_hint_style_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpLayer *layer; - gint32 style = 0; + gint style = 0; layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp); @@ -489,7 +489,7 @@ text_layer_set_hint_style_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpLayer *layer; - gint32 style; + gint style; layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp); style = g_value_get_enum (gimp_value_array_index (args, 1)); @@ -668,7 +668,7 @@ text_layer_get_base_direction_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpLayer *layer; - gint32 direction = 0; + gint direction = 0; layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp); @@ -705,7 +705,7 @@ text_layer_set_base_direction_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpLayer *layer; - gint32 direction; + gint direction; layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp); direction = g_value_get_enum (gimp_value_array_index (args, 1)); @@ -740,7 +740,7 @@ text_layer_get_justification_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpLayer *layer; - gint32 justify = 0; + gint justify = 0; layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp); @@ -777,7 +777,7 @@ text_layer_set_justification_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpLayer *layer; - gint32 justify; + gint justify; layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp); justify = g_value_get_enum (gimp_value_array_index (args, 1)); diff --git a/app/pdb/text-tool-cmds.c b/app/pdb/text-tool-cmds.c index 7feaa516f6..09a2fa7c92 100644 --- a/app/pdb/text-tool-cmds.c +++ b/app/pdb/text-tool-cmds.c @@ -56,7 +56,7 @@ text_fontname_invoker (GimpProcedure *procedure, gdouble x; gdouble y; const gchar *text; - gint32 border; + gint border; gboolean antialias; gdouble size; const gchar *fontname; @@ -114,10 +114,10 @@ text_get_extents_fontname_invoker (GimpProcedure *procedure, const gchar *text; gdouble size; const gchar *fontname; - gint32 width = 0; - gint32 height = 0; - gint32 ascent = 0; - gint32 descent = 0; + gint width = 0; + gint height = 0; + gint ascent = 0; + gint descent = 0; text = g_value_get_string (gimp_value_array_index (args, 0)); size = g_value_get_double (gimp_value_array_index (args, 1)); @@ -200,11 +200,11 @@ register_text_tool_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("border", - "border", - "The size of the border", - -1, G_MAXINT32, -1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("border", + "border", + "The size of the border", + -1, G_MAXINT32, -1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_boolean ("antialias", "antialias", @@ -282,29 +282,29 @@ register_text_tool_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("width", - "width", - "The width of the specified font", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("width", + "width", + "The width of the specified font", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("height", - "height", - "The height of the specified font", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("height", + "height", + "The height of the specified font", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("ascent", - "ascent", - "The ascent of the specified font", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("ascent", + "ascent", + "The ascent of the specified font", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("descent", - "descent", - "The descent of the specified font", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("descent", + "descent", + "The descent of the specified font", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); } diff --git a/app/pdb/unit-cmds.c b/app/pdb/unit-cmds.c index 590de723c9..060def17de 100644 --- a/app/pdb/unit-cmds.c +++ b/app/pdb/unit-cmds.c @@ -46,7 +46,7 @@ unit_get_number_of_units_invoker (GimpProcedure *procedure, GError **error) { GimpValueArray *return_vals; - gint32 num_units = 0; + gint num_units = 0; num_units = _gimp_unit_get_number_of_units (gimp); @@ -65,7 +65,7 @@ unit_get_number_of_built_in_units_invoker (GimpProcedure *procedure, GError **error) { GimpValueArray *return_vals; - gint32 num_units = 0; + gint num_units = 0; num_units = _gimp_unit_get_number_of_built_in_units (gimp); @@ -87,7 +87,7 @@ unit_new_invoker (GimpProcedure *procedure, GimpValueArray *return_vals; const gchar *identifier; gdouble factor; - gint32 digits; + gint digits; const gchar *symbol; const gchar *abbreviation; const gchar *singular; @@ -239,7 +239,7 @@ unit_get_digits_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpUnit unit_id; - gint32 digits = 0; + gint digits = 0; unit_id = g_value_get_int (gimp_value_array_index (args, 0)); @@ -393,11 +393,11 @@ register_unit_procs (GimpPDB *pdb) "1999", NULL); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-units", - "num units", - "The number of units", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-units", + "num units", + "The number of units", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -416,11 +416,11 @@ register_unit_procs (GimpPDB *pdb) "1999", NULL); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-units", - "num units", - "The number of built-in units", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-units", + "num units", + "The number of built-in units", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -452,11 +452,11 @@ register_unit_procs (GimpPDB *pdb) -G_MAXDOUBLE, G_MAXDOUBLE, 0, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("digits", - "digits", - "The new unit's digits", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("digits", + "digits", + "The new unit's digits", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_string ("symbol", "symbol", @@ -644,11 +644,11 @@ register_unit_procs (GimpPDB *pdb) GIMP_UNIT_PIXEL, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("digits", - "digits", - "The unit's number of digits", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("digits", + "digits", + "The unit's number of digits", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); diff --git a/app/pdb/vectors-cmds.c b/app/pdb/vectors-cmds.c index 32a40742af..1ad4aecda2 100644 --- a/app/pdb/vectors-cmds.c +++ b/app/pdb/vectors-cmds.c @@ -170,7 +170,7 @@ vectors_get_strokes_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpVectors *vectors; - gint32 num_strokes = 0; + gint num_strokes = 0; gint32 *stroke_ids = NULL; vectors = gimp_value_get_vectors (gimp_value_array_index (args, 0), gimp); @@ -219,7 +219,7 @@ vectors_stroke_get_length_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpVectors *vectors; - gint32 stroke_id; + gint stroke_id; gdouble precision; gdouble length = 0.0; @@ -257,7 +257,7 @@ vectors_stroke_get_point_at_dist_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpVectors *vectors; - gint32 stroke_id; + gint stroke_id; gdouble dist; gdouble precision; gdouble x_point = 0.0; @@ -311,7 +311,7 @@ vectors_remove_stroke_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpVectors *vectors; - gint32 stroke_id; + gint stroke_id; vectors = gimp_value_get_vectors (gimp_value_array_index (args, 0), gimp); stroke_id = g_value_get_int (gimp_value_array_index (args, 1)); @@ -348,7 +348,7 @@ vectors_stroke_close_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpVectors *vectors; - gint32 stroke_id; + gint stroke_id; vectors = gimp_value_get_vectors (gimp_value_array_index (args, 0), gimp); stroke_id = g_value_get_int (gimp_value_array_index (args, 1)); @@ -387,9 +387,9 @@ vectors_stroke_translate_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpVectors *vectors; - gint32 stroke_id; - gint32 off_x; - gint32 off_y; + gint stroke_id; + gint off_x; + gint off_y; vectors = gimp_value_get_vectors (gimp_value_array_index (args, 0), gimp); stroke_id = g_value_get_int (gimp_value_array_index (args, 1)); @@ -432,7 +432,7 @@ vectors_stroke_scale_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpVectors *vectors; - gint32 stroke_id; + gint stroke_id; gdouble scale_x; gdouble scale_y; @@ -477,7 +477,7 @@ vectors_stroke_rotate_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpVectors *vectors; - gint32 stroke_id; + gint stroke_id; gdouble center_x; gdouble center_y; gdouble angle; @@ -524,8 +524,8 @@ vectors_stroke_flip_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpVectors *vectors; - gint32 stroke_id; - gint32 flip_type; + gint stroke_id; + gint flip_type; gdouble axis; vectors = gimp_value_get_vectors (gimp_value_array_index (args, 0), gimp); @@ -569,7 +569,7 @@ vectors_stroke_flip_free_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpVectors *vectors; - gint32 stroke_id; + gint stroke_id; gdouble x1; gdouble y1; gdouble x2; @@ -619,9 +619,9 @@ vectors_stroke_get_points_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpVectors *vectors; - gint32 stroke_id; - gint32 type = 0; - gint32 num_points = 0; + gint stroke_id; + gint type = 0; + gint num_points = 0; gdouble *controlpoints = NULL; gboolean closed = FALSE; @@ -687,11 +687,11 @@ vectors_stroke_new_from_points_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpVectors *vectors; - gint32 type; - gint32 num_points; + gint type; + gint num_points; const gdouble *controlpoints; gboolean closed; - gint32 stroke_id = 0; + gint stroke_id = 0; vectors = gimp_value_get_vectors (gimp_value_array_index (args, 0), gimp); type = g_value_get_enum (gimp_value_array_index (args, 1)); @@ -759,9 +759,9 @@ vectors_stroke_interpolate_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpVectors *vectors; - gint32 stroke_id; + gint stroke_id; gdouble precision; - gint32 num_coords = 0; + gint num_coords = 0; gdouble *coords = NULL; gboolean closed = FALSE; @@ -826,7 +826,7 @@ vectors_bezier_stroke_new_moveto_invoker (GimpProcedure *procedure, GimpVectors *vectors; gdouble x0; gdouble y0; - gint32 stroke_id = 0; + gint stroke_id = 0; vectors = gimp_value_get_vectors (gimp_value_array_index (args, 0), gimp); x0 = g_value_get_double (gimp_value_array_index (args, 1)); @@ -879,7 +879,7 @@ vectors_bezier_stroke_lineto_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpVectors *vectors; - gint32 stroke_id; + gint stroke_id; gdouble x0; gdouble y0; @@ -927,7 +927,7 @@ vectors_bezier_stroke_conicto_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpVectors *vectors; - gint32 stroke_id; + gint stroke_id; gdouble x0; gdouble y0; gdouble x1; @@ -983,7 +983,7 @@ vectors_bezier_stroke_cubicto_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpVectors *vectors; - gint32 stroke_id; + gint stroke_id; gdouble x0; gdouble y0; gdouble x1; @@ -1053,7 +1053,7 @@ vectors_bezier_stroke_new_ellipse_invoker (GimpProcedure *procedure, gdouble radius_x; gdouble radius_y; gdouble angle; - gint32 stroke_id = 0; + gint stroke_id = 0; vectors = gimp_value_get_vectors (gimp_value_array_index (args, 0), gimp); x0 = g_value_get_double (gimp_value_array_index (args, 1)); @@ -1113,7 +1113,7 @@ vectors_import_from_file_invoker (GimpProcedure *procedure, const gchar *filename; gboolean merge; gboolean scale; - gint32 num_vectors = 0; + gint num_vectors = 0; gint32 *vectors_ids = NULL; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); @@ -1177,10 +1177,10 @@ vectors_import_from_string_invoker (GimpProcedure *procedure, GimpValueArray *return_vals; GimpImage *image; const gchar *string; - gint32 length; + gint length; gboolean merge; gboolean scale; - gint32 num_vectors = 0; + gint num_vectors = 0; gint32 *vectors_ids = NULL; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); @@ -1418,11 +1418,11 @@ register_vectors_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-strokes", - "num strokes", - "The number of strokes returned.", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-strokes", + "num strokes", + "The number of strokes returned.", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_int32_array ("stroke-ids", "stroke ids", @@ -1452,11 +1452,11 @@ register_vectors_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("stroke-id", - "stroke id", - "The stroke ID", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("stroke-id", + "stroke id", + "The stroke ID", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_double ("precision", "precision", @@ -1493,11 +1493,11 @@ register_vectors_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("stroke-id", - "stroke id", - "The stroke ID", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("stroke-id", + "stroke id", + "The stroke ID", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_double ("dist", "dist", @@ -1558,11 +1558,11 @@ register_vectors_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("stroke-id", - "stroke id", - "The stroke ID", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("stroke-id", + "stroke id", + "The stroke ID", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -1587,11 +1587,11 @@ register_vectors_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("stroke-id", - "stroke id", - "The stroke ID", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("stroke-id", + "stroke id", + "The stroke ID", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -1616,23 +1616,23 @@ register_vectors_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("stroke-id", - "stroke id", - "The stroke ID", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("stroke-id", + "stroke id", + "The stroke ID", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("off-x", - "off x", - "Offset in x direction", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("off-x", + "off x", + "Offset in x direction", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("off-y", - "off y", - "Offset in y direction", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("off-y", + "off y", + "Offset in y direction", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -1657,11 +1657,11 @@ register_vectors_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("stroke-id", - "stroke id", - "The stroke ID", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("stroke-id", + "stroke id", + "The stroke ID", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_double ("scale-x", "scale x", @@ -1698,11 +1698,11 @@ register_vectors_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("stroke-id", - "stroke id", - "The stroke ID", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("stroke-id", + "stroke id", + "The stroke ID", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_double ("center-x", "center x", @@ -1745,11 +1745,11 @@ register_vectors_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("stroke-id", - "stroke id", - "The stroke ID", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("stroke-id", + "stroke id", + "The stroke ID", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_enum ("flip-type", "flip type", @@ -1789,11 +1789,11 @@ register_vectors_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("stroke-id", - "stroke id", - "The stroke ID", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("stroke-id", + "stroke id", + "The stroke ID", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_double ("x1", "x1", @@ -1842,11 +1842,11 @@ register_vectors_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("stroke-id", - "stroke id", - "The stroke ID", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("stroke-id", + "stroke id", + "The stroke ID", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, g_param_spec_enum ("type", "type", @@ -1855,11 +1855,11 @@ register_vectors_procs (GimpPDB *pdb) GIMP_VECTORS_STROKE_TYPE_BEZIER, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-points", - "num points", - "The number of floats returned.", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-points", + "num points", + "The number of floats returned.", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_float_array ("controlpoints", "controlpoints", @@ -1902,11 +1902,11 @@ register_vectors_procs (GimpPDB *pdb) GIMP_VECTORS_STROKE_TYPE_BEZIER, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("num-points", - "num points", - "The number of elements in the array, i.e. the number of controlpoints in the stroke * 2 (x- and y-coordinate).", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-points", + "num points", + "The number of elements in the array, i.e. the number of controlpoints in the stroke * 2 (x- and y-coordinate).", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_float_array ("controlpoints", "controlpoints", @@ -1919,11 +1919,11 @@ register_vectors_procs (GimpPDB *pdb) FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("stroke-id", - "stroke id", - "The stroke ID of the newly created stroke.", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("stroke-id", + "stroke id", + "The stroke ID of the newly created stroke.", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -1948,11 +1948,11 @@ register_vectors_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("stroke-id", - "stroke id", - "The stroke ID", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("stroke-id", + "stroke id", + "The stroke ID", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_double ("precision", "precision", @@ -1960,11 +1960,11 @@ register_vectors_procs (GimpPDB *pdb) -G_MAXDOUBLE, G_MAXDOUBLE, 0, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-coords", - "num coords", - "The number of floats returned.", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-coords", + "num coords", + "The number of floats returned.", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_float_array ("coords", "coords", @@ -2012,11 +2012,11 @@ register_vectors_procs (GimpPDB *pdb) -G_MAXDOUBLE, G_MAXDOUBLE, 0, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("stroke-id", - "stroke id", - "The resulting stroke", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("stroke-id", + "stroke id", + "The resulting stroke", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -2041,11 +2041,11 @@ register_vectors_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("stroke-id", - "stroke id", - "The stroke ID", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("stroke-id", + "stroke id", + "The stroke ID", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_double ("x0", "x0", @@ -2082,11 +2082,11 @@ register_vectors_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("stroke-id", - "stroke id", - "The stroke ID", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("stroke-id", + "stroke id", + "The stroke ID", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_double ("x0", "x0", @@ -2135,11 +2135,11 @@ register_vectors_procs (GimpPDB *pdb) pdb->gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("stroke-id", - "stroke id", - "The stroke ID", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("stroke-id", + "stroke id", + "The stroke ID", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_double ("x0", "x0", @@ -2230,11 +2230,11 @@ register_vectors_procs (GimpPDB *pdb) -G_MAXDOUBLE, G_MAXDOUBLE, 0, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("stroke-id", - "stroke id", - "The resulting stroke", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("stroke-id", + "stroke id", + "The resulting stroke", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -2278,11 +2278,11 @@ register_vectors_procs (GimpPDB *pdb) FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-vectors", - "num vectors", - "The number of newly created vectors", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-vectors", + "num vectors", + "The number of newly created vectors", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_int32_array ("vectors-ids", "vectors ids", @@ -2319,11 +2319,11 @@ register_vectors_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("length", - "length", - "Number of bytes in string or -1 if the string is NULL terminated.", - G_MININT32, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("length", + "length", + "Number of bytes in string or -1 if the string is NULL terminated.", + G_MININT32, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_boolean ("merge", "merge", @@ -2337,11 +2337,11 @@ register_vectors_procs (GimpPDB *pdb) FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_int32 ("num-vectors", - "num vectors", - "The number of newly created vectors", - 0, G_MAXINT32, 0, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("num-vectors", + "num vectors", + "The number of newly created vectors", + 0, G_MAXINT32, 0, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_int32_array ("vectors-ids", "vectors ids", diff --git a/app/plug-in/gimpgpparams.c b/app/plug-in/gimpgpparams.c index 37a10aecf3..7049aa1439 100644 --- a/app/plug-in/gimpgpparams.c +++ b/app/plug-in/gimpgpparams.c @@ -90,13 +90,6 @@ _gimp_gp_param_def_to_param_spec (gpointer gimp, param_def->meta.m_int.default_val, flags); - if (! strcmp (param_def->type_name, "GimpParamInt32")) - return gimp_param_spec_int32 (name, nick, blurb, - param_def->meta.m_int.min_val, - param_def->meta.m_int.max_val, - param_def->meta.m_int.default_val, - flags); - if (! strcmp (param_def->type_name, "GimpParamInt16")) return gimp_param_spec_int16 (name, nick, blurb, param_def->meta.m_int.min_val, diff --git a/app/plug-in/gimpplugin-message.c b/app/plug-in/gimpplugin-message.c index 05e69d33a8..9fa5ddd668 100644 --- a/app/plug-in/gimpplugin-message.c +++ b/app/plug-in/gimpplugin-message.c @@ -725,7 +725,7 @@ gimp_plug_in_handle_proc_install (GimpPlugIn *plug_in, ! strcmp (param_def->type_name, "GimpParamIntStringArray") || ! strcmp (param_def->type_name, "GimpParamIntColorArray")) && - strcmp (prev_param_def->type_name, "GimpParamInt32")) + strcmp (prev_param_def->type_name, "GParamInt")) { gimp_message (plug_in->manager->gimp, NULL, GIMP_MESSAGE_ERROR, "Plug-in \"%s\"\n(%s)\n\n" @@ -876,7 +876,7 @@ gimp_plug_in_handle_proc_install (GimpPlugIn *plug_in, if (pspec) { if (i == 0 && - GIMP_IS_PARAM_SPEC_INT32 (pspec) && + G_IS_PARAM_SPEC_INT (pspec) && (! strcmp ("run-mode", g_param_spec_get_name (pspec)) || ! strcmp ("run_mode", g_param_spec_get_name (pspec)))) { diff --git a/app/plug-in/gimpplugin-progress.c b/app/plug-in/gimpplugin-progress.c index 1664f06abf..af90092181 100644 --- a/app/plug-in/gimpplugin-progress.c +++ b/app/plug-in/gimpplugin-progress.c @@ -263,9 +263,9 @@ gimp_plug_in_progress_install (GimpPlugIn *plug_in, if (! GIMP_IS_TEMPORARY_PROCEDURE (procedure) || GIMP_TEMPORARY_PROCEDURE (procedure)->plug_in != plug_in || procedure->num_args != 3 || - ! GIMP_IS_PARAM_SPEC_INT32 (procedure->args[0]) || - ! G_IS_PARAM_SPEC_STRING (procedure->args[1]) || - ! G_IS_PARAM_SPEC_DOUBLE (procedure->args[2])) + ! G_IS_PARAM_SPEC_INT (procedure->args[0]) || + ! G_IS_PARAM_SPEC_STRING (procedure->args[1]) || + ! G_IS_PARAM_SPEC_DOUBLE (procedure->args[2])) { return FALSE; } diff --git a/app/widgets/gimpbrushselect.c b/app/widgets/gimpbrushselect.c index 352936cc2a..4fdf5682ee 100644 --- a/app/widgets/gimpbrushselect.c +++ b/app/widgets/gimpbrushselect.c @@ -286,7 +286,7 @@ gimp_brush_select_run_callback (GimpPdbDialog *dialog, GIMP_TYPE_LAYER_MODE, gimp_context_get_paint_mode (dialog->context), G_TYPE_INT, gimp_brush_get_width (brush), G_TYPE_INT, gimp_brush_get_height (brush), - GIMP_TYPE_INT32, array->length, + G_TYPE_INT, array->length, GIMP_TYPE_INT8_ARRAY, array, G_TYPE_BOOLEAN, closing, G_TYPE_NONE); diff --git a/app/widgets/gimpgradientselect.c b/app/widgets/gimpgradientselect.c index f3f0800e82..792914747b 100644 --- a/app/widgets/gimpgradientselect.c +++ b/app/widgets/gimpgradientselect.c @@ -184,7 +184,7 @@ gimp_gradient_select_run_callback (GimpPdbDialog *dialog, NULL, error, dialog->callback_name, G_TYPE_STRING, gimp_object_get_name (object), - GIMP_TYPE_INT32, array->length / sizeof (gdouble), + G_TYPE_INT, array->length / sizeof (gdouble), GIMP_TYPE_FLOAT_ARRAY, array, G_TYPE_BOOLEAN, closing, G_TYPE_NONE); diff --git a/app/widgets/gimppatternselect.c b/app/widgets/gimppatternselect.c index 9888ebccf3..135caa8d3e 100644 --- a/app/widgets/gimppatternselect.c +++ b/app/widgets/gimppatternselect.c @@ -129,7 +129,7 @@ gimp_pattern_select_run_callback (GimpPdbDialog *dialog, G_TYPE_INT, gimp_temp_buf_get_width (pattern->mask), G_TYPE_INT, gimp_temp_buf_get_height (pattern->mask), G_TYPE_INT, babl_format_get_bytes_per_pixel (gimp_temp_buf_get_format (pattern->mask)), - GIMP_TYPE_INT32, array->length, + G_TYPE_INT, array->length, GIMP_TYPE_INT8_ARRAY, array, G_TYPE_BOOLEAN, closing, G_TYPE_NONE); diff --git a/devel-docs/libgimpbase/libgimpbase3-sections.txt b/devel-docs/libgimpbase/libgimpbase3-sections.txt index 5e122178c9..dc59dde9e6 100644 --- a/devel-docs/libgimpbase/libgimpbase3-sections.txt +++ b/devel-docs/libgimpbase/libgimpbase3-sections.txt @@ -296,7 +296,6 @@ GIMP_PARAM_STATIC_STRINGS GIMP_PARAM_READABLE GIMP_PARAM_WRITABLE GIMP_PARAM_READWRITE -gimp_param_spec_int32 gimp_param_spec_int16 gimp_param_spec_string gimp_array_new @@ -347,7 +346,6 @@ GIMP_IS_PARAM_SPEC_ARRAY GIMP_IS_PARAM_SPEC_FLOAT_ARRAY GIMP_IS_PARAM_SPEC_INT16 GIMP_IS_PARAM_SPEC_INT16_ARRAY -GIMP_IS_PARAM_SPEC_INT32 GIMP_IS_PARAM_SPEC_INT32_ARRAY GIMP_IS_PARAM_SPEC_INT8_ARRAY GIMP_IS_PARAM_SPEC_RGB_ARRAY @@ -357,7 +355,6 @@ GIMP_PARAM_SPEC_ARRAY GIMP_PARAM_SPEC_FLOAT_ARRAY GIMP_PARAM_SPEC_INT16 GIMP_PARAM_SPEC_INT16_ARRAY -GIMP_PARAM_SPEC_INT32 GIMP_PARAM_SPEC_INT32_ARRAY GIMP_PARAM_SPEC_INT8_ARRAY GIMP_PARAM_SPEC_RGB_ARRAY @@ -367,14 +364,12 @@ GIMP_TYPE_ARRAY GIMP_TYPE_FLOAT_ARRAY GIMP_TYPE_INT16 GIMP_TYPE_INT16_ARRAY -GIMP_TYPE_INT32 GIMP_TYPE_INT32_ARRAY GIMP_TYPE_INT8_ARRAY GIMP_TYPE_PARAM_ARRAY GIMP_TYPE_PARAM_FLOAT_ARRAY GIMP_TYPE_PARAM_INT16 GIMP_TYPE_PARAM_INT16_ARRAY -GIMP_TYPE_PARAM_INT32 GIMP_TYPE_PARAM_INT32_ARRAY GIMP_TYPE_PARAM_INT8_ARRAY GIMP_TYPE_PARAM_RGB_ARRAY @@ -386,7 +381,6 @@ GIMP_VALUE_HOLDS_ARRAY GIMP_VALUE_HOLDS_FLOAT_ARRAY GIMP_VALUE_HOLDS_INT16 GIMP_VALUE_HOLDS_INT16_ARRAY -GIMP_VALUE_HOLDS_INT32 GIMP_VALUE_HOLDS_INT32_ARRAY GIMP_VALUE_HOLDS_INT8_ARRAY GIMP_VALUE_HOLDS_RGB_ARRAY @@ -397,7 +391,6 @@ GimpParamSpecArray GimpParamSpecFloatArray GimpParamSpecInt16 GimpParamSpecInt16Array -GimpParamSpecInt32 GimpParamSpecInt32Array GimpParamSpecInt8Array GimpParamSpecRGBArray @@ -408,14 +401,12 @@ gimp_float_array_get_type gimp_int16_array_get_type gimp_int16_get_type gimp_int32_array_get_type -gimp_int32_get_type gimp_int8_array_get_type gimp_param_array_get_type gimp_param_float_array_get_type gimp_param_int16_array_get_type gimp_param_int16_get_type gimp_param_int32_array_get_type -gimp_param_int32_get_type gimp_param_int8_array_get_type gimp_param_rgb_array_get_type gimp_param_string_array_get_type diff --git a/devel-docs/libgimpbase/libgimpbase3.types b/devel-docs/libgimpbase/libgimpbase3.types index 5963336e86..9626887dca 100644 --- a/devel-docs/libgimpbase/libgimpbase3.types +++ b/devel-docs/libgimpbase/libgimpbase3.types @@ -3,7 +3,6 @@ gimp_float_array_get_type gimp_int16_array_get_type gimp_int16_get_type gimp_int32_array_get_type -gimp_int32_get_type gimp_int8_array_get_type gimp_memsize_get_type gimp_metadata_get_type @@ -12,7 +11,6 @@ gimp_param_float_array_get_type gimp_param_int16_array_get_type gimp_param_int16_get_type gimp_param_int32_array_get_type -gimp_param_int32_get_type gimp_param_int8_array_get_type gimp_param_rgb_array_get_type gimp_param_string_array_get_type diff --git a/libgimp/gimp.c b/libgimp/gimp.c index cfe2738d44..16b16666aa 100644 --- a/libgimp/gimp.c +++ b/libgimp/gimp.c @@ -446,7 +446,7 @@ _gimp_main_internal (GType plug_in_type, { GType init_types[] = { - GIMP_TYPE_INT32, GIMP_TYPE_PARAM_INT32, + G_TYPE_INT, G_TYPE_PARAM_INT, GIMP_TYPE_INT16, GIMP_TYPE_PARAM_INT16, G_TYPE_UCHAR, G_TYPE_PARAM_UCHAR, diff --git a/libgimp/gimpbrush_pdb.c b/libgimp/gimpbrush_pdb.c index cccbf67fab..af67bd2954 100644 --- a/libgimp/gimpbrush_pdb.c +++ b/libgimp/gimpbrush_pdb.c @@ -499,7 +499,7 @@ gimp_brush_set_spacing (const gchar *name, args = gimp_value_array_new_from_types (NULL, G_TYPE_STRING, name, - GIMP_TYPE_INT32, spacing, + G_TYPE_INT, spacing, G_TYPE_NONE); if (pdb) @@ -767,7 +767,7 @@ gimp_brush_set_spikes (const gchar *name, args = gimp_value_array_new_from_types (NULL, G_TYPE_STRING, name, - GIMP_TYPE_INT32, spikes_in, + G_TYPE_INT, spikes_in, G_TYPE_NONE); if (pdb) diff --git a/libgimp/gimpbrushselect.c b/libgimp/gimpbrushselect.c index 6fdcbd4342..1fa241c5ef 100644 --- a/libgimp/gimpbrushselect.c +++ b/libgimp/gimpbrushselect.c @@ -123,12 +123,12 @@ gimp_brush_select_new (const gchar *title, 0, 10000, 0, G_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("mask-len", - "Mask length", - "Length of brush " - "mask data", - 0, G_MAXINT, 0, - G_PARAM_READWRITE)); + g_param_spec_int ("mask-len", + "Mask length", + "Length of brush " + "mask data", + 0, G_MAXINT, 0, + G_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_int8_array ("mask-data", "Mask data", diff --git a/libgimp/gimpbrushselect_pdb.c b/libgimp/gimpbrushselect_pdb.c index 32e9ebdb98..ef2bfb3fd5 100644 --- a/libgimp/gimpbrushselect_pdb.c +++ b/libgimp/gimpbrushselect_pdb.c @@ -67,7 +67,7 @@ gimp_brushes_popup (const gchar *brush_callback, G_TYPE_STRING, popup_title, G_TYPE_STRING, initial_brush, G_TYPE_DOUBLE, opacity, - GIMP_TYPE_INT32, spacing, + G_TYPE_INT, spacing, GIMP_TYPE_LAYER_MODE, paint_mode, G_TYPE_NONE); @@ -155,7 +155,7 @@ gimp_brushes_set_popup (const gchar *brush_callback, G_TYPE_STRING, brush_callback, G_TYPE_STRING, brush_name, G_TYPE_DOUBLE, opacity, - GIMP_TYPE_INT32, spacing, + G_TYPE_INT, spacing, GIMP_TYPE_LAYER_MODE, paint_mode, G_TYPE_NONE); diff --git a/libgimp/gimpchannel_pdb.c b/libgimp/gimpchannel_pdb.c index 8022d0c5f0..d95e2cd255 100644 --- a/libgimp/gimpchannel_pdb.c +++ b/libgimp/gimpchannel_pdb.c @@ -70,8 +70,8 @@ _gimp_channel_new (gint32 image_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE_ID, image_ID, - GIMP_TYPE_INT32, width, - GIMP_TYPE_INT32, height, + G_TYPE_INT, width, + G_TYPE_INT, height, G_TYPE_STRING, name, G_TYPE_DOUBLE, opacity, GIMP_TYPE_RGB, color, @@ -217,8 +217,8 @@ gimp_channel_combine_masks (gint32 channel1_ID, GIMP_TYPE_CHANNEL_ID, channel1_ID, GIMP_TYPE_CHANNEL_ID, channel2_ID, GIMP_TYPE_CHANNEL_OPS, operation, - GIMP_TYPE_INT32, offx, - GIMP_TYPE_INT32, offy, + G_TYPE_INT, offx, + G_TYPE_INT, offy, G_TYPE_NONE); if (pdb) diff --git a/libgimp/gimpcontext_pdb.c b/libgimp/gimpcontext_pdb.c index 5100e1eb4b..51c62cbb66 100644 --- a/libgimp/gimpcontext_pdb.c +++ b/libgimp/gimpcontext_pdb.c @@ -1378,7 +1378,7 @@ gimp_context_set_line_dash_pattern (gint num_dashes, gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, - GIMP_TYPE_INT32, num_dashes, + G_TYPE_INT, num_dashes, GIMP_TYPE_FLOAT_ARRAY, NULL, G_TYPE_NONE); gimp_value_set_float_array (gimp_value_array_index (args, 1), dashes, num_dashes); @@ -3593,7 +3593,7 @@ gimp_context_set_sample_threshold_int (gint sample_threshold) gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, - GIMP_TYPE_INT32, sample_threshold, + G_TYPE_INT, sample_threshold, G_TYPE_NONE); if (pdb) diff --git a/libgimp/gimpdrawable_pdb.c b/libgimp/gimpdrawable_pdb.c index ac372e760d..708082563a 100644 --- a/libgimp/gimpdrawable_pdb.c +++ b/libgimp/gimpdrawable_pdb.c @@ -778,10 +778,10 @@ gimp_drawable_update (gint32 drawable_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_DRAWABLE_ID, drawable_ID, - GIMP_TYPE_INT32, x, - GIMP_TYPE_INT32, y, - GIMP_TYPE_INT32, width, - GIMP_TYPE_INT32, height, + G_TYPE_INT, x, + G_TYPE_INT, y, + G_TYPE_INT, width, + G_TYPE_INT, height, G_TYPE_NONE); if (pdb) @@ -830,8 +830,8 @@ gimp_drawable_get_pixel (gint32 drawable_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_DRAWABLE_ID, drawable_ID, - GIMP_TYPE_INT32, x_coord, - GIMP_TYPE_INT32, y_coord, + G_TYPE_INT, x_coord, + G_TYPE_INT, y_coord, G_TYPE_NONE); if (pdb) @@ -888,9 +888,9 @@ gimp_drawable_set_pixel (gint32 drawable_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_DRAWABLE_ID, drawable_ID, - GIMP_TYPE_INT32, x_coord, - GIMP_TYPE_INT32, y_coord, - GIMP_TYPE_INT32, num_channels, + G_TYPE_INT, x_coord, + G_TYPE_INT, y_coord, + G_TYPE_INT, num_channels, GIMP_TYPE_INT8_ARRAY, NULL, G_TYPE_NONE); gimp_value_set_int8_array (gimp_value_array_index (args, 4), pixel, num_channels); @@ -998,8 +998,8 @@ gimp_drawable_offset (gint32 drawable_ID, GIMP_TYPE_DRAWABLE_ID, drawable_ID, G_TYPE_BOOLEAN, wrap_around, GIMP_TYPE_OFFSET_TYPE, fill_type, - GIMP_TYPE_INT32, offset_x, - GIMP_TYPE_INT32, offset_y, + G_TYPE_INT, offset_x, + G_TYPE_INT, offset_y, G_TYPE_NONE); if (pdb) @@ -1055,8 +1055,8 @@ _gimp_drawable_thumbnail (gint32 drawable_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_DRAWABLE_ID, drawable_ID, - GIMP_TYPE_INT32, width, - GIMP_TYPE_INT32, height, + G_TYPE_INT, width, + G_TYPE_INT, height, G_TYPE_NONE); if (pdb) @@ -1137,12 +1137,12 @@ _gimp_drawable_sub_thumbnail (gint32 drawable_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_DRAWABLE_ID, drawable_ID, - GIMP_TYPE_INT32, src_x, - GIMP_TYPE_INT32, src_y, - GIMP_TYPE_INT32, src_width, - GIMP_TYPE_INT32, src_height, - GIMP_TYPE_INT32, dest_width, - GIMP_TYPE_INT32, dest_height, + G_TYPE_INT, src_x, + G_TYPE_INT, src_y, + G_TYPE_INT, src_width, + G_TYPE_INT, src_height, + G_TYPE_INT, dest_width, + G_TYPE_INT, dest_height, G_TYPE_NONE); if (pdb) diff --git a/libgimp/gimpdrawablecolor_pdb.c b/libgimp/gimpdrawablecolor_pdb.c index cb5dbe7dd1..f5576c17e7 100644 --- a/libgimp/gimpdrawablecolor_pdb.c +++ b/libgimp/gimpdrawablecolor_pdb.c @@ -231,7 +231,7 @@ gimp_drawable_curves_explicit (gint32 drawable_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_DRAWABLE_ID, drawable_ID, GIMP_TYPE_HISTOGRAM_CHANNEL, channel, - GIMP_TYPE_INT32, num_values, + G_TYPE_INT, num_values, GIMP_TYPE_FLOAT_ARRAY, NULL, G_TYPE_NONE); gimp_value_set_float_array (gimp_value_array_index (args, 3), values, num_values); @@ -286,7 +286,7 @@ gimp_drawable_curves_spline (gint32 drawable_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_DRAWABLE_ID, drawable_ID, GIMP_TYPE_HISTOGRAM_CHANNEL, channel, - GIMP_TYPE_INT32, num_points, + G_TYPE_INT, num_points, GIMP_TYPE_FLOAT_ARRAY, NULL, G_TYPE_NONE); gimp_value_set_float_array (gimp_value_array_index (args, 3), points, num_points); @@ -742,7 +742,7 @@ gimp_drawable_posterize (gint32 drawable_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_DRAWABLE_ID, drawable_ID, - GIMP_TYPE_INT32, levels, + G_TYPE_INT, levels, G_TYPE_NONE); if (pdb) diff --git a/libgimp/gimpdrawableedit_pdb.c b/libgimp/gimpdrawableedit_pdb.c index de60fbe5dc..8ca9fe6cf7 100644 --- a/libgimp/gimpdrawableedit_pdb.c +++ b/libgimp/gimpdrawableedit_pdb.c @@ -245,7 +245,7 @@ gimp_drawable_edit_gradient_fill (gint32 drawable_ID, GIMP_TYPE_GRADIENT_TYPE, gradient_type, G_TYPE_DOUBLE, offset, G_TYPE_BOOLEAN, supersample, - GIMP_TYPE_INT32, supersample_max_depth, + G_TYPE_INT, supersample_max_depth, G_TYPE_DOUBLE, supersample_threshold, G_TYPE_BOOLEAN, dither, G_TYPE_DOUBLE, x1, diff --git a/libgimp/gimpfileops_pdb.c b/libgimp/gimpfileops_pdb.c index dcd7affb3c..c147bc1d0f 100644 --- a/libgimp/gimpfileops_pdb.c +++ b/libgimp/gimpfileops_pdb.c @@ -462,7 +462,7 @@ _gimp_register_file_handler_priority (const gchar *procedure_name, args = gimp_value_array_new_from_types (NULL, G_TYPE_STRING, procedure_name, - GIMP_TYPE_INT32, priority, + G_TYPE_INT, priority, G_TYPE_NONE); if (pdb) diff --git a/libgimp/gimpgpcompat.c b/libgimp/gimpgpcompat.c index abf45adc9f..098eca0d0a 100644 --- a/libgimp/gimpgpcompat.c +++ b/libgimp/gimpgpcompat.c @@ -46,9 +46,9 @@ _gimp_gp_compat_param_spec (GimpPDBArgType arg_type, switch (arg_type) { case GIMP_PDB_INT32: - pspec = gimp_param_spec_int32 (name, nick, blurb, - G_MININT32, G_MAXINT32, 0, - G_PARAM_READWRITE); + pspec = g_param_spec_int (name, nick, blurb, + G_MININT32, G_MAXINT32, 0, + G_PARAM_READWRITE); break; case GIMP_PDB_INT16: @@ -189,7 +189,7 @@ _gimp_pdb_arg_type_to_gtype (GimpPDBArgType type) switch (type) { case GIMP_PDB_INT32: - return GIMP_TYPE_INT32; + return G_TYPE_INT; case GIMP_PDB_INT16: return GIMP_TYPE_INT16; @@ -279,7 +279,6 @@ _gimp_pdb_gtype_to_arg_type (GType type) } type_mapping[] = { - { GIMP_TYPE_INT32, GIMP_PDB_INT32 }, { G_TYPE_INT, GIMP_PDB_INT32 }, { G_TYPE_UINT, GIMP_PDB_INT32 }, { G_TYPE_ENUM, GIMP_PDB_INT32 }, diff --git a/libgimp/gimpgpparams-body.c b/libgimp/gimpgpparams-body.c index 2380527745..74ef4af94c 100644 --- a/libgimp/gimpgpparams-body.c +++ b/libgimp/gimpgpparams-body.c @@ -39,8 +39,7 @@ _gimp_param_spec_to_gp_param_def (GParamSpec *pspec, pspec_type = G_PARAM_SPEC_TYPE (pspec); - if (pspec_type == G_TYPE_PARAM_INT || - pspec_type == GIMP_TYPE_PARAM_INT32 || + if (pspec_type == G_TYPE_PARAM_INT || pspec_type == GIMP_TYPE_PARAM_INT16) { GParamSpecInt *ispec = G_PARAM_SPEC_INT (pspec); @@ -192,7 +191,6 @@ _gimp_gp_param_to_value (gpointer gimp, g_value_init (value, type); if (type == G_TYPE_INT || - type == GIMP_TYPE_INT32 || type == GIMP_TYPE_INT16 || type == GIMP_TYPE_UNIT) { @@ -386,19 +384,19 @@ _gimp_gp_params_to_value_array (gpointer gimp, */ type = pspec_type; } - else if (type == GIMP_TYPE_INT32) + else if (type == G_TYPE_INT) { if (g_type_is_a (pspec_type, G_TYPE_ENUM)) { /* if the param spec's type is enum, but an - * int32 was passed, use the enum type. + * int was passed, use the enum type. */ type = pspec_type; } else if (g_type_is_a (pspec_type, G_TYPE_BOOLEAN)) { /* if the param spec's type is boolean, but - * an int32 was passed, use the boolean + * an int was passed, use the boolean * type. */ type = pspec_type; @@ -437,7 +435,6 @@ _gimp_value_to_gp_param (const GValue *value, param->type_name = (gchar *) g_type_name (type); if (type == G_TYPE_INT || - type == GIMP_TYPE_INT32 || type == GIMP_TYPE_INT16 || type == GIMP_TYPE_UNIT) { diff --git a/libgimp/gimpgpparams.c b/libgimp/gimpgpparams.c index e098aa18bf..45001aa00c 100644 --- a/libgimp/gimpgpparams.c +++ b/libgimp/gimpgpparams.c @@ -81,13 +81,6 @@ _gimp_gp_param_def_to_param_spec (gpointer gimp, param_def->meta.m_int.default_val, flags); - if (! strcmp (param_def->type_name, "GimpParamInt32")) - return gimp_param_spec_int32 (name, nick, blurb, - param_def->meta.m_int.min_val, - param_def->meta.m_int.max_val, - param_def->meta.m_int.default_val, - flags); - if (! strcmp (param_def->type_name, "GimpParamInt16")) return gimp_param_spec_int16 (name, nick, blurb, param_def->meta.m_int.min_val, diff --git a/libgimp/gimpgradient_pdb.c b/libgimp/gimpgradient_pdb.c index e2c9a201fd..eed5178b6b 100644 --- a/libgimp/gimpgradient_pdb.c +++ b/libgimp/gimpgradient_pdb.c @@ -322,7 +322,7 @@ gimp_gradient_get_uniform_samples (const gchar *name, args = gimp_value_array_new_from_types (NULL, G_TYPE_STRING, name, - GIMP_TYPE_INT32, num_samples, + G_TYPE_INT, num_samples, G_TYPE_BOOLEAN, reverse, G_TYPE_NONE); @@ -388,7 +388,7 @@ gimp_gradient_get_custom_samples (const gchar *name, args = gimp_value_array_new_from_types (NULL, G_TYPE_STRING, name, - GIMP_TYPE_INT32, num_samples, + G_TYPE_INT, num_samples, GIMP_TYPE_FLOAT_ARRAY, NULL, G_TYPE_BOOLEAN, reverse, G_TYPE_NONE); @@ -448,7 +448,7 @@ gimp_gradient_segment_get_left_color (const gchar *name, args = gimp_value_array_new_from_types (NULL, G_TYPE_STRING, name, - GIMP_TYPE_INT32, segment, + G_TYPE_INT, segment, G_TYPE_NONE); if (pdb) @@ -504,7 +504,7 @@ gimp_gradient_segment_set_left_color (const gchar *name, args = gimp_value_array_new_from_types (NULL, G_TYPE_STRING, name, - GIMP_TYPE_INT32, segment, + G_TYPE_INT, segment, GIMP_TYPE_RGB, color, G_TYPE_DOUBLE, opacity, G_TYPE_NONE); @@ -554,7 +554,7 @@ gimp_gradient_segment_get_right_color (const gchar *name, args = gimp_value_array_new_from_types (NULL, G_TYPE_STRING, name, - GIMP_TYPE_INT32, segment, + G_TYPE_INT, segment, G_TYPE_NONE); if (pdb) @@ -610,7 +610,7 @@ gimp_gradient_segment_set_right_color (const gchar *name, args = gimp_value_array_new_from_types (NULL, G_TYPE_STRING, name, - GIMP_TYPE_INT32, segment, + G_TYPE_INT, segment, GIMP_TYPE_RGB, color, G_TYPE_DOUBLE, opacity, G_TYPE_NONE); @@ -658,7 +658,7 @@ gimp_gradient_segment_get_left_pos (const gchar *name, args = gimp_value_array_new_from_types (NULL, G_TYPE_STRING, name, - GIMP_TYPE_INT32, segment, + G_TYPE_INT, segment, G_TYPE_NONE); if (pdb) @@ -714,7 +714,7 @@ gimp_gradient_segment_set_left_pos (const gchar *name, args = gimp_value_array_new_from_types (NULL, G_TYPE_STRING, name, - GIMP_TYPE_INT32, segment, + G_TYPE_INT, segment, G_TYPE_DOUBLE, pos, G_TYPE_NONE); @@ -766,7 +766,7 @@ gimp_gradient_segment_get_middle_pos (const gchar *name, args = gimp_value_array_new_from_types (NULL, G_TYPE_STRING, name, - GIMP_TYPE_INT32, segment, + G_TYPE_INT, segment, G_TYPE_NONE); if (pdb) @@ -821,7 +821,7 @@ gimp_gradient_segment_set_middle_pos (const gchar *name, args = gimp_value_array_new_from_types (NULL, G_TYPE_STRING, name, - GIMP_TYPE_INT32, segment, + G_TYPE_INT, segment, G_TYPE_DOUBLE, pos, G_TYPE_NONE); @@ -873,7 +873,7 @@ gimp_gradient_segment_get_right_pos (const gchar *name, args = gimp_value_array_new_from_types (NULL, G_TYPE_STRING, name, - GIMP_TYPE_INT32, segment, + G_TYPE_INT, segment, G_TYPE_NONE); if (pdb) @@ -929,7 +929,7 @@ gimp_gradient_segment_set_right_pos (const gchar *name, args = gimp_value_array_new_from_types (NULL, G_TYPE_STRING, name, - GIMP_TYPE_INT32, segment, + G_TYPE_INT, segment, G_TYPE_DOUBLE, pos, G_TYPE_NONE); @@ -981,7 +981,7 @@ gimp_gradient_segment_get_blending_function (const gchar *name, args = gimp_value_array_new_from_types (NULL, G_TYPE_STRING, name, - GIMP_TYPE_INT32, segment, + G_TYPE_INT, segment, G_TYPE_NONE); if (pdb) @@ -1032,7 +1032,7 @@ gimp_gradient_segment_get_coloring_type (const gchar *name, args = gimp_value_array_new_from_types (NULL, G_TYPE_STRING, name, - GIMP_TYPE_INT32, segment, + G_TYPE_INT, segment, G_TYPE_NONE); if (pdb) @@ -1085,8 +1085,8 @@ gimp_gradient_segment_range_set_blending_function (const gchar *name args = gimp_value_array_new_from_types (NULL, G_TYPE_STRING, name, - GIMP_TYPE_INT32, start_segment, - GIMP_TYPE_INT32, end_segment, + G_TYPE_INT, start_segment, + G_TYPE_INT, end_segment, GIMP_TYPE_GRADIENT_SEGMENT_TYPE, blending_function, G_TYPE_NONE); @@ -1135,8 +1135,8 @@ gimp_gradient_segment_range_set_coloring_type (const gchar *name, args = gimp_value_array_new_from_types (NULL, G_TYPE_STRING, name, - GIMP_TYPE_INT32, start_segment, - GIMP_TYPE_INT32, end_segment, + G_TYPE_INT, start_segment, + G_TYPE_INT, end_segment, GIMP_TYPE_GRADIENT_SEGMENT_COLOR, coloring_type, G_TYPE_NONE); @@ -1182,8 +1182,8 @@ gimp_gradient_segment_range_flip (const gchar *name, args = gimp_value_array_new_from_types (NULL, G_TYPE_STRING, name, - GIMP_TYPE_INT32, start_segment, - GIMP_TYPE_INT32, end_segment, + G_TYPE_INT, start_segment, + G_TYPE_INT, end_segment, G_TYPE_NONE); if (pdb) @@ -1232,9 +1232,9 @@ gimp_gradient_segment_range_replicate (const gchar *name, args = gimp_value_array_new_from_types (NULL, G_TYPE_STRING, name, - GIMP_TYPE_INT32, start_segment, - GIMP_TYPE_INT32, end_segment, - GIMP_TYPE_INT32, replicate_times, + G_TYPE_INT, start_segment, + G_TYPE_INT, end_segment, + G_TYPE_INT, replicate_times, G_TYPE_NONE); if (pdb) @@ -1280,8 +1280,8 @@ gimp_gradient_segment_range_split_midpoint (const gchar *name, args = gimp_value_array_new_from_types (NULL, G_TYPE_STRING, name, - GIMP_TYPE_INT32, start_segment, - GIMP_TYPE_INT32, end_segment, + G_TYPE_INT, start_segment, + G_TYPE_INT, end_segment, G_TYPE_NONE); if (pdb) @@ -1329,9 +1329,9 @@ gimp_gradient_segment_range_split_uniform (const gchar *name, args = gimp_value_array_new_from_types (NULL, G_TYPE_STRING, name, - GIMP_TYPE_INT32, start_segment, - GIMP_TYPE_INT32, end_segment, - GIMP_TYPE_INT32, split_parts, + G_TYPE_INT, start_segment, + G_TYPE_INT, end_segment, + G_TYPE_INT, split_parts, G_TYPE_NONE); if (pdb) @@ -1376,8 +1376,8 @@ gimp_gradient_segment_range_delete (const gchar *name, args = gimp_value_array_new_from_types (NULL, G_TYPE_STRING, name, - GIMP_TYPE_INT32, start_segment, - GIMP_TYPE_INT32, end_segment, + G_TYPE_INT, start_segment, + G_TYPE_INT, end_segment, G_TYPE_NONE); if (pdb) @@ -1423,8 +1423,8 @@ gimp_gradient_segment_range_redistribute_handles (const gchar *name, args = gimp_value_array_new_from_types (NULL, G_TYPE_STRING, name, - GIMP_TYPE_INT32, start_segment, - GIMP_TYPE_INT32, end_segment, + G_TYPE_INT, start_segment, + G_TYPE_INT, end_segment, G_TYPE_NONE); if (pdb) @@ -1471,8 +1471,8 @@ gimp_gradient_segment_range_blend_colors (const gchar *name, args = gimp_value_array_new_from_types (NULL, G_TYPE_STRING, name, - GIMP_TYPE_INT32, start_segment, - GIMP_TYPE_INT32, end_segment, + G_TYPE_INT, start_segment, + G_TYPE_INT, end_segment, G_TYPE_NONE); if (pdb) @@ -1519,8 +1519,8 @@ gimp_gradient_segment_range_blend_opacity (const gchar *name, args = gimp_value_array_new_from_types (NULL, G_TYPE_STRING, name, - GIMP_TYPE_INT32, start_segment, - GIMP_TYPE_INT32, end_segment, + G_TYPE_INT, start_segment, + G_TYPE_INT, end_segment, G_TYPE_NONE); if (pdb) @@ -1571,8 +1571,8 @@ gimp_gradient_segment_range_move (const gchar *name, args = gimp_value_array_new_from_types (NULL, G_TYPE_STRING, name, - GIMP_TYPE_INT32, start_segment, - GIMP_TYPE_INT32, end_segment, + G_TYPE_INT, start_segment, + G_TYPE_INT, end_segment, G_TYPE_DOUBLE, delta, G_TYPE_BOOLEAN, control_compress, G_TYPE_NONE); diff --git a/libgimp/gimpgradientselect.c b/libgimp/gimpgradientselect.c index 3d2ec60973..2b8c5e0111 100644 --- a/libgimp/gimpgradientselect.c +++ b/libgimp/gimpgradientselect.c @@ -86,11 +86,11 @@ gimp_gradient_select_new (const gchar *title, NULL, G_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("gradient-width", - "Gradient width", - "The gradient width", - 0, G_MAXINT, 0, - G_PARAM_READWRITE)); + g_param_spec_int ("gradient-width", + "Gradient width", + "The gradient width", + 0, G_MAXINT, 0, + G_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_float_array ("gradient-data", "Gradient data", diff --git a/libgimp/gimpgradientselect_pdb.c b/libgimp/gimpgradientselect_pdb.c index ee55d1ddbf..adfb10b8cf 100644 --- a/libgimp/gimpgradientselect_pdb.c +++ b/libgimp/gimpgradientselect_pdb.c @@ -62,7 +62,7 @@ gimp_gradients_popup (const gchar *gradient_callback, G_TYPE_STRING, gradient_callback, G_TYPE_STRING, popup_title, G_TYPE_STRING, initial_gradient, - GIMP_TYPE_INT32, sample_size, + G_TYPE_INT, sample_size, G_TYPE_NONE); if (pdb) diff --git a/libgimp/gimpimage_pdb.c b/libgimp/gimpimage_pdb.c index 4a81f6817d..e990667db5 100644 --- a/libgimp/gimpimage_pdb.c +++ b/libgimp/gimpimage_pdb.c @@ -154,8 +154,8 @@ gimp_image_new (gint width, gint32 image_ID = -1; args = gimp_value_array_new_from_types (NULL, - GIMP_TYPE_INT32, width, - GIMP_TYPE_INT32, height, + G_TYPE_INT, width, + G_TYPE_INT, height, GIMP_TYPE_IMAGE_BASE_TYPE, type, G_TYPE_NONE); @@ -207,8 +207,8 @@ gimp_image_new_with_precision (gint width, gint32 image_ID = -1; args = gimp_value_array_new_from_types (NULL, - GIMP_TYPE_INT32, width, - GIMP_TYPE_INT32, height, + G_TYPE_INT, width, + G_TYPE_INT, height, GIMP_TYPE_IMAGE_BASE_TYPE, type, GIMP_TYPE_PRECISION, precision, G_TYPE_NONE); @@ -932,8 +932,8 @@ gimp_image_pick_correlate_layer (gint32 image_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE_ID, image_ID, - GIMP_TYPE_INT32, x, - GIMP_TYPE_INT32, y, + G_TYPE_INT, x, + G_TYPE_INT, y, G_TYPE_NONE); if (pdb) @@ -991,7 +991,7 @@ gimp_image_insert_layer (gint32 image_ID, GIMP_TYPE_IMAGE_ID, image_ID, GIMP_TYPE_LAYER_ID, layer_ID, GIMP_TYPE_LAYER_ID, parent_ID, - GIMP_TYPE_INT32, position, + G_TYPE_INT, position, G_TYPE_NONE); if (pdb) @@ -1178,7 +1178,7 @@ gimp_image_insert_channel (gint32 image_ID, GIMP_TYPE_IMAGE_ID, image_ID, GIMP_TYPE_CHANNEL_ID, channel_ID, GIMP_TYPE_CHANNEL_ID, parent_ID, - GIMP_TYPE_INT32, position, + G_TYPE_INT, position, G_TYPE_NONE); if (pdb) @@ -1363,7 +1363,7 @@ gimp_image_insert_vectors (gint32 image_ID, GIMP_TYPE_IMAGE_ID, image_ID, GIMP_TYPE_VECTORS_ID, vectors_ID, GIMP_TYPE_VECTORS_ID, parent_ID, - GIMP_TYPE_INT32, position, + G_TYPE_INT, position, G_TYPE_NONE); if (pdb) @@ -1771,7 +1771,7 @@ gimp_image_reorder_item (gint32 image_ID, GIMP_TYPE_IMAGE_ID, image_ID, GIMP_TYPE_ITEM_ID, item_ID, GIMP_TYPE_ITEM_ID, parent_ID, - GIMP_TYPE_INT32, position, + G_TYPE_INT, position, G_TYPE_NONE); if (pdb) @@ -2010,7 +2010,7 @@ _gimp_image_set_colormap (gint32 image_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE_ID, image_ID, - GIMP_TYPE_INT32, num_bytes, + G_TYPE_INT, num_bytes, GIMP_TYPE_INT8_ARRAY, NULL, G_TYPE_NONE); gimp_value_set_int8_array (gimp_value_array_index (args, 2), colormap, num_bytes); @@ -2234,8 +2234,8 @@ _gimp_image_thumbnail (gint32 image_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE_ID, image_ID, - GIMP_TYPE_INT32, width, - GIMP_TYPE_INT32, height, + G_TYPE_INT, width, + G_TYPE_INT, height, G_TYPE_NONE); if (pdb) @@ -3314,7 +3314,7 @@ gimp_image_set_tattoo_state (gint32 image_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE_ID, image_ID, - GIMP_TYPE_INT32, tattoo_state, + G_TYPE_INT, tattoo_state, G_TYPE_NONE); if (pdb) @@ -3356,7 +3356,7 @@ gimp_image_get_layer_by_tattoo (gint32 image_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE_ID, image_ID, - GIMP_TYPE_INT32, tattoo, + G_TYPE_INT, tattoo, G_TYPE_NONE); if (pdb) @@ -3399,7 +3399,7 @@ gimp_image_get_channel_by_tattoo (gint32 image_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE_ID, image_ID, - GIMP_TYPE_INT32, tattoo, + G_TYPE_INT, tattoo, G_TYPE_NONE); if (pdb) @@ -3444,7 +3444,7 @@ gimp_image_get_vectors_by_tattoo (gint32 image_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE_ID, image_ID, - GIMP_TYPE_INT32, tattoo, + G_TYPE_INT, tattoo, G_TYPE_NONE); if (pdb) diff --git a/libgimp/gimpimagecolorprofile_pdb.c b/libgimp/gimpimagecolorprofile_pdb.c index e450b6cab2..3dbcb22b83 100644 --- a/libgimp/gimpimagecolorprofile_pdb.c +++ b/libgimp/gimpimagecolorprofile_pdb.c @@ -169,7 +169,7 @@ _gimp_image_set_color_profile (gint32 image_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE_ID, image_ID, - GIMP_TYPE_INT32, num_bytes, + G_TYPE_INT, num_bytes, GIMP_TYPE_INT8_ARRAY, NULL, G_TYPE_NONE); gimp_value_set_int8_array (gimp_value_array_index (args, 2), color_profile, num_bytes); @@ -271,7 +271,7 @@ _gimp_image_convert_color_profile (gint32 image_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE_ID, image_ID, - GIMP_TYPE_INT32, num_bytes, + G_TYPE_INT, num_bytes, GIMP_TYPE_INT8_ARRAY, NULL, GIMP_TYPE_COLOR_RENDERING_INTENT, intent, G_TYPE_BOOLEAN, bpc, diff --git a/libgimp/gimpimageconvert_pdb.c b/libgimp/gimpimageconvert_pdb.c index 7dcf1e324e..9b182cedbe 100644 --- a/libgimp/gimpimageconvert_pdb.c +++ b/libgimp/gimpimageconvert_pdb.c @@ -160,7 +160,7 @@ gimp_image_convert_indexed (gint32 image_ID, GIMP_TYPE_IMAGE_ID, image_ID, GIMP_TYPE_CONVERT_DITHER_TYPE, dither_type, GIMP_TYPE_CONVERT_PALETTE_TYPE, palette_type, - GIMP_TYPE_INT32, num_cols, + G_TYPE_INT, num_cols, G_TYPE_BOOLEAN, alpha_dither, G_TYPE_BOOLEAN, remove_unused, G_TYPE_STRING, palette, @@ -210,9 +210,9 @@ gimp_image_convert_set_dither_matrix (gint width, gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, - GIMP_TYPE_INT32, width, - GIMP_TYPE_INT32, height, - GIMP_TYPE_INT32, matrix_length, + G_TYPE_INT, width, + G_TYPE_INT, height, + G_TYPE_INT, matrix_length, GIMP_TYPE_INT8_ARRAY, NULL, G_TYPE_NONE); gimp_value_set_int8_array (gimp_value_array_index (args, 3), matrix, matrix_length); diff --git a/libgimp/gimpimageguides_pdb.c b/libgimp/gimpimageguides_pdb.c index 3fd2edfdd0..ccf93248ae 100644 --- a/libgimp/gimpimageguides_pdb.c +++ b/libgimp/gimpimageguides_pdb.c @@ -58,7 +58,7 @@ gimp_image_add_hguide (gint32 image_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE_ID, image_ID, - GIMP_TYPE_INT32, yposition, + G_TYPE_INT, yposition, G_TYPE_NONE); if (pdb) @@ -102,7 +102,7 @@ gimp_image_add_vguide (gint32 image_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE_ID, image_ID, - GIMP_TYPE_INT32, xposition, + G_TYPE_INT, xposition, G_TYPE_NONE); if (pdb) @@ -145,7 +145,7 @@ gimp_image_delete_guide (gint32 image_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE_ID, image_ID, - GIMP_TYPE_INT32, guide_ID, + G_TYPE_INT, guide_ID, G_TYPE_NONE); if (pdb) @@ -190,7 +190,7 @@ gimp_image_find_next_guide (gint32 image_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE_ID, image_ID, - GIMP_TYPE_INT32, guide_ID, + G_TYPE_INT, guide_ID, G_TYPE_NONE); if (pdb) @@ -233,7 +233,7 @@ gimp_image_get_guide_orientation (gint32 image_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE_ID, image_ID, - GIMP_TYPE_INT32, guide_ID, + G_TYPE_INT, guide_ID, G_TYPE_NONE); if (pdb) @@ -276,7 +276,7 @@ gimp_image_get_guide_position (gint32 image_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE_ID, image_ID, - GIMP_TYPE_INT32, guide_ID, + G_TYPE_INT, guide_ID, G_TYPE_NONE); if (pdb) diff --git a/libgimp/gimpimagesamplepoints_pdb.c b/libgimp/gimpimagesamplepoints_pdb.c index 68d1090b82..3fa3d25d80 100644 --- a/libgimp/gimpimagesamplepoints_pdb.c +++ b/libgimp/gimpimagesamplepoints_pdb.c @@ -62,8 +62,8 @@ gimp_image_add_sample_point (gint32 image_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE_ID, image_ID, - GIMP_TYPE_INT32, position_x, - GIMP_TYPE_INT32, position_y, + G_TYPE_INT, position_x, + G_TYPE_INT, position_y, G_TYPE_NONE); if (pdb) @@ -108,7 +108,7 @@ gimp_image_delete_sample_point (gint32 image_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE_ID, image_ID, - GIMP_TYPE_INT32, sample_point_ID, + G_TYPE_INT, sample_point_ID, G_TYPE_NONE); if (pdb) @@ -156,7 +156,7 @@ gimp_image_find_next_sample_point (gint32 image_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE_ID, image_ID, - GIMP_TYPE_INT32, sample_point_ID, + G_TYPE_INT, sample_point_ID, G_TYPE_NONE); if (pdb) @@ -204,7 +204,7 @@ gimp_image_get_sample_point_position (gint32 image_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE_ID, image_ID, - GIMP_TYPE_INT32, sample_point_ID, + G_TYPE_INT, sample_point_ID, G_TYPE_NONE); if (pdb) diff --git a/libgimp/gimpimageselect_pdb.c b/libgimp/gimpimageselect_pdb.c index 674c833658..3dde26e17d 100644 --- a/libgimp/gimpimageselect_pdb.c +++ b/libgimp/gimpimageselect_pdb.c @@ -406,7 +406,7 @@ gimp_image_select_polygon (gint32 image_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE_ID, image_ID, GIMP_TYPE_CHANNEL_OPS, operation, - GIMP_TYPE_INT32, num_segs, + G_TYPE_INT, num_segs, GIMP_TYPE_FLOAT_ARRAY, NULL, G_TYPE_NONE); gimp_value_set_float_array (gimp_value_array_index (args, 3), segs, num_segs); diff --git a/libgimp/gimpimagetransform_pdb.c b/libgimp/gimpimagetransform_pdb.c index d1133148bd..33988861e1 100644 --- a/libgimp/gimpimagetransform_pdb.c +++ b/libgimp/gimpimagetransform_pdb.c @@ -68,10 +68,10 @@ gimp_image_resize (gint32 image_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE_ID, image_ID, - GIMP_TYPE_INT32, new_width, - GIMP_TYPE_INT32, new_height, - GIMP_TYPE_INT32, offx, - GIMP_TYPE_INT32, offy, + G_TYPE_INT, new_width, + G_TYPE_INT, new_height, + G_TYPE_INT, offx, + G_TYPE_INT, offy, G_TYPE_NONE); if (pdb) @@ -161,8 +161,8 @@ gimp_image_scale (gint32 image_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE_ID, image_ID, - GIMP_TYPE_INT32, new_width, - GIMP_TYPE_INT32, new_height, + G_TYPE_INT, new_width, + G_TYPE_INT, new_height, G_TYPE_NONE); if (pdb) @@ -214,10 +214,10 @@ gimp_image_crop (gint32 image_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE_ID, image_ID, - GIMP_TYPE_INT32, new_width, - GIMP_TYPE_INT32, new_height, - GIMP_TYPE_INT32, offx, - GIMP_TYPE_INT32, offy, + G_TYPE_INT, new_width, + G_TYPE_INT, new_height, + G_TYPE_INT, offx, + G_TYPE_INT, offy, G_TYPE_NONE); if (pdb) diff --git a/libgimp/gimpitem_pdb.c b/libgimp/gimpitem_pdb.c index 5f5f0b4641..8b4b0a1c75 100644 --- a/libgimp/gimpitem_pdb.c +++ b/libgimp/gimpitem_pdb.c @@ -1240,7 +1240,7 @@ gimp_item_set_tattoo (gint32 item_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_ITEM_ID, item_ID, - GIMP_TYPE_INT32, tattoo, + G_TYPE_INT, tattoo, G_TYPE_NONE); if (pdb) diff --git a/libgimp/gimplayer_pdb.c b/libgimp/gimplayer_pdb.c index 84aefecfda..6b9c575a4f 100644 --- a/libgimp/gimplayer_pdb.c +++ b/libgimp/gimplayer_pdb.c @@ -71,8 +71,8 @@ _gimp_layer_new (gint32 image_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE_ID, image_ID, - GIMP_TYPE_INT32, width, - GIMP_TYPE_INT32, height, + G_TYPE_INT, width, + G_TYPE_INT, height, GIMP_TYPE_IMAGE_TYPE, type, G_TYPE_STRING, name, G_TYPE_DOUBLE, opacity, @@ -403,8 +403,8 @@ gimp_layer_scale (gint32 layer_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_LAYER_ID, layer_ID, - GIMP_TYPE_INT32, new_width, - GIMP_TYPE_INT32, new_height, + G_TYPE_INT, new_width, + G_TYPE_INT, new_height, G_TYPE_BOOLEAN, local_origin, G_TYPE_NONE); @@ -455,10 +455,10 @@ gimp_layer_resize (gint32 layer_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_LAYER_ID, layer_ID, - GIMP_TYPE_INT32, new_width, - GIMP_TYPE_INT32, new_height, - GIMP_TYPE_INT32, offx, - GIMP_TYPE_INT32, offy, + G_TYPE_INT, new_width, + G_TYPE_INT, new_height, + G_TYPE_INT, offx, + G_TYPE_INT, offy, G_TYPE_NONE); if (pdb) @@ -542,8 +542,8 @@ gimp_layer_set_offsets (gint32 layer_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_LAYER_ID, layer_ID, - GIMP_TYPE_INT32, offx, - GIMP_TYPE_INT32, offy, + G_TYPE_INT, offx, + G_TYPE_INT, offy, G_TYPE_NONE); if (pdb) diff --git a/libgimp/gimppainttools_pdb.c b/libgimp/gimppainttools_pdb.c index e79d6e8357..6f782f4e6e 100644 --- a/libgimp/gimppainttools_pdb.c +++ b/libgimp/gimppainttools_pdb.c @@ -65,7 +65,7 @@ gimp_airbrush (gint32 drawable_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_DRAWABLE_ID, drawable_ID, G_TYPE_DOUBLE, pressure, - GIMP_TYPE_INT32, num_strokes, + G_TYPE_INT, num_strokes, GIMP_TYPE_FLOAT_ARRAY, NULL, G_TYPE_NONE); gimp_value_set_float_array (gimp_value_array_index (args, 3), strokes, num_strokes); @@ -114,7 +114,7 @@ gimp_airbrush_default (gint32 drawable_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_DRAWABLE_ID, drawable_ID, - GIMP_TYPE_INT32, num_strokes, + G_TYPE_INT, num_strokes, GIMP_TYPE_FLOAT_ARRAY, NULL, G_TYPE_NONE); gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes); @@ -182,7 +182,7 @@ gimp_clone (gint32 drawable_ID, GIMP_TYPE_CLONE_TYPE, clone_type, G_TYPE_DOUBLE, src_x, G_TYPE_DOUBLE, src_y, - GIMP_TYPE_INT32, num_strokes, + G_TYPE_INT, num_strokes, GIMP_TYPE_FLOAT_ARRAY, NULL, G_TYPE_NONE); gimp_value_set_float_array (gimp_value_array_index (args, 6), strokes, num_strokes); @@ -232,7 +232,7 @@ gimp_clone_default (gint32 drawable_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_DRAWABLE_ID, drawable_ID, - GIMP_TYPE_INT32, num_strokes, + G_TYPE_INT, num_strokes, GIMP_TYPE_FLOAT_ARRAY, NULL, G_TYPE_NONE); gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes); @@ -286,7 +286,7 @@ gimp_convolve (gint32 drawable_ID, GIMP_TYPE_DRAWABLE_ID, drawable_ID, G_TYPE_DOUBLE, pressure, GIMP_TYPE_CONVOLVE_TYPE, convolve_type, - GIMP_TYPE_INT32, num_strokes, + G_TYPE_INT, num_strokes, GIMP_TYPE_FLOAT_ARRAY, NULL, G_TYPE_NONE); gimp_value_set_float_array (gimp_value_array_index (args, 4), strokes, num_strokes); @@ -335,7 +335,7 @@ gimp_convolve_default (gint32 drawable_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_DRAWABLE_ID, drawable_ID, - GIMP_TYPE_INT32, num_strokes, + G_TYPE_INT, num_strokes, GIMP_TYPE_FLOAT_ARRAY, NULL, G_TYPE_NONE); gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes); @@ -389,7 +389,7 @@ gimp_dodgeburn (gint32 drawable_ID, G_TYPE_DOUBLE, exposure, GIMP_TYPE_DODGE_BURN_TYPE, dodgeburn_type, GIMP_TYPE_TRANSFER_MODE, dodgeburn_mode, - GIMP_TYPE_INT32, num_strokes, + G_TYPE_INT, num_strokes, GIMP_TYPE_FLOAT_ARRAY, NULL, G_TYPE_NONE); gimp_value_set_float_array (gimp_value_array_index (args, 5), strokes, num_strokes); @@ -437,7 +437,7 @@ gimp_dodgeburn_default (gint32 drawable_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_DRAWABLE_ID, drawable_ID, - GIMP_TYPE_INT32, num_strokes, + G_TYPE_INT, num_strokes, GIMP_TYPE_FLOAT_ARRAY, NULL, G_TYPE_NONE); gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes); @@ -490,7 +490,7 @@ gimp_eraser (gint32 drawable_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_DRAWABLE_ID, drawable_ID, - GIMP_TYPE_INT32, num_strokes, + G_TYPE_INT, num_strokes, GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_BRUSH_APPLICATION_MODE, hardness, GIMP_TYPE_PAINT_APPLICATION_MODE, method, @@ -541,7 +541,7 @@ gimp_eraser_default (gint32 drawable_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_DRAWABLE_ID, drawable_ID, - GIMP_TYPE_INT32, num_strokes, + G_TYPE_INT, num_strokes, GIMP_TYPE_FLOAT_ARRAY, NULL, G_TYPE_NONE); gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes); @@ -602,7 +602,7 @@ gimp_heal (gint32 drawable_ID, GIMP_TYPE_DRAWABLE_ID, src_drawable_ID, G_TYPE_DOUBLE, src_x, G_TYPE_DOUBLE, src_y, - GIMP_TYPE_INT32, num_strokes, + G_TYPE_INT, num_strokes, GIMP_TYPE_FLOAT_ARRAY, NULL, G_TYPE_NONE); gimp_value_set_float_array (gimp_value_array_index (args, 5), strokes, num_strokes); @@ -654,7 +654,7 @@ gimp_heal_default (gint32 drawable_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_DRAWABLE_ID, drawable_ID, - GIMP_TYPE_INT32, num_strokes, + G_TYPE_INT, num_strokes, GIMP_TYPE_FLOAT_ARRAY, NULL, G_TYPE_NONE); gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes); @@ -715,7 +715,7 @@ gimp_paintbrush (gint32 drawable_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_DRAWABLE_ID, drawable_ID, G_TYPE_DOUBLE, fade_out, - GIMP_TYPE_INT32, num_strokes, + G_TYPE_INT, num_strokes, GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_PAINT_APPLICATION_MODE, method, G_TYPE_DOUBLE, gradient_length, @@ -775,7 +775,7 @@ gimp_paintbrush_default (gint32 drawable_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_DRAWABLE_ID, drawable_ID, - GIMP_TYPE_INT32, num_strokes, + G_TYPE_INT, num_strokes, GIMP_TYPE_FLOAT_ARRAY, NULL, G_TYPE_NONE); gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes); @@ -825,7 +825,7 @@ gimp_pencil (gint32 drawable_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_DRAWABLE_ID, drawable_ID, - GIMP_TYPE_INT32, num_strokes, + G_TYPE_INT, num_strokes, GIMP_TYPE_FLOAT_ARRAY, NULL, G_TYPE_NONE); gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes); @@ -875,7 +875,7 @@ gimp_smudge (gint32 drawable_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_DRAWABLE_ID, drawable_ID, G_TYPE_DOUBLE, pressure, - GIMP_TYPE_INT32, num_strokes, + G_TYPE_INT, num_strokes, GIMP_TYPE_FLOAT_ARRAY, NULL, G_TYPE_NONE); gimp_value_set_float_array (gimp_value_array_index (args, 3), strokes, num_strokes); @@ -923,7 +923,7 @@ gimp_smudge_default (gint32 drawable_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_DRAWABLE_ID, drawable_ID, - GIMP_TYPE_INT32, num_strokes, + G_TYPE_INT, num_strokes, GIMP_TYPE_FLOAT_ARRAY, NULL, G_TYPE_NONE); gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes); diff --git a/libgimp/gimppalette_pdb.c b/libgimp/gimppalette_pdb.c index 7cc84d9bf0..c1ea29be0d 100644 --- a/libgimp/gimppalette_pdb.c +++ b/libgimp/gimppalette_pdb.c @@ -410,7 +410,7 @@ gimp_palette_set_columns (const gchar *name, args = gimp_value_array_new_from_types (NULL, G_TYPE_STRING, name, - GIMP_TYPE_INT32, columns, + G_TYPE_INT, columns, G_TYPE_NONE); if (pdb) @@ -508,7 +508,7 @@ gimp_palette_delete_entry (const gchar *name, args = gimp_value_array_new_from_types (NULL, G_TYPE_STRING, name, - GIMP_TYPE_INT32, entry_num, + G_TYPE_INT, entry_num, G_TYPE_NONE); if (pdb) @@ -555,7 +555,7 @@ gimp_palette_entry_get_color (const gchar *name, args = gimp_value_array_new_from_types (NULL, G_TYPE_STRING, name, - GIMP_TYPE_INT32, entry_num, + G_TYPE_INT, entry_num, G_TYPE_NONE); if (pdb) @@ -605,7 +605,7 @@ gimp_palette_entry_set_color (const gchar *name, args = gimp_value_array_new_from_types (NULL, G_TYPE_STRING, name, - GIMP_TYPE_INT32, entry_num, + G_TYPE_INT, entry_num, GIMP_TYPE_RGB, color, G_TYPE_NONE); @@ -653,7 +653,7 @@ gimp_palette_entry_get_name (const gchar *name, args = gimp_value_array_new_from_types (NULL, G_TYPE_STRING, name, - GIMP_TYPE_INT32, entry_num, + G_TYPE_INT, entry_num, G_TYPE_NONE); if (pdb) @@ -705,7 +705,7 @@ gimp_palette_entry_set_name (const gchar *name, args = gimp_value_array_new_from_types (NULL, G_TYPE_STRING, name, - GIMP_TYPE_INT32, entry_num, + G_TYPE_INT, entry_num, G_TYPE_STRING, entry_name, G_TYPE_NONE); diff --git a/libgimp/gimppatternselect.c b/libgimp/gimppatternselect.c index af7b9b738d..7217638d48 100644 --- a/libgimp/gimppatternselect.c +++ b/libgimp/gimppatternselect.c @@ -105,12 +105,12 @@ gimp_pattern_select_new (const gchar *title, 0, 10000, 0, G_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("mask-len", - "Mask length", - "Length of pattern " - "mask data", - 0, G_MAXINT, 0, - G_PARAM_READWRITE)); + g_param_spec_int ("mask-len", + "Mask length", + "Length of pattern " + "mask data", + 0, G_MAXINT, 0, + G_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_int8_array ("mask-data", "Mask data", diff --git a/libgimp/gimppdb_pdb.c b/libgimp/gimppdb_pdb.c index 80fbdbcbea..0e122b3d15 100644 --- a/libgimp/gimppdb_pdb.c +++ b/libgimp/gimppdb_pdb.c @@ -334,7 +334,7 @@ _gimp_pdb_proc_argument (const gchar *procedure_name, args = gimp_value_array_new_from_types (NULL, G_TYPE_STRING, procedure_name, - GIMP_TYPE_INT32, arg_num, + G_TYPE_INT, arg_num, G_TYPE_NONE); if (pdb) @@ -381,7 +381,7 @@ _gimp_pdb_proc_return_value (const gchar *procedure_name, args = gimp_value_array_new_from_types (NULL, G_TYPE_STRING, procedure_name, - GIMP_TYPE_INT32, val_num, + G_TYPE_INT, val_num, G_TYPE_NONE); if (pdb) @@ -522,7 +522,7 @@ _gimp_pdb_set_data (const gchar *identifier, args = gimp_value_array_new_from_types (NULL, G_TYPE_STRING, identifier, - GIMP_TYPE_INT32, bytes, + G_TYPE_INT, bytes, GIMP_TYPE_INT8_ARRAY, NULL, G_TYPE_NONE); gimp_value_set_int8_array (gimp_value_array_index (args, 2), data, bytes); diff --git a/libgimp/gimpplugin_pdb.c b/libgimp/gimpplugin_pdb.c index e60ed18ad9..769a5a7ae9 100644 --- a/libgimp/gimpplugin_pdb.c +++ b/libgimp/gimpplugin_pdb.c @@ -237,7 +237,7 @@ _gimp_plugin_icon_register (const gchar *procedure_name, args = gimp_value_array_new_from_types (NULL, G_TYPE_STRING, procedure_name, GIMP_TYPE_ICON_TYPE, icon_type, - GIMP_TYPE_INT32, icon_data_length, + G_TYPE_INT, icon_data_length, GIMP_TYPE_INT8_ARRAY, NULL, G_TYPE_NONE); gimp_value_set_int8_array (gimp_value_array_index (args, 3), icon_data, icon_data_length); diff --git a/libgimp/gimpselection_pdb.c b/libgimp/gimpselection_pdb.c index 4124561b4f..006e416f9e 100644 --- a/libgimp/gimpselection_pdb.c +++ b/libgimp/gimpselection_pdb.c @@ -129,8 +129,8 @@ gimp_selection_value (gint32 image_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE_ID, image_ID, - GIMP_TYPE_INT32, x, - GIMP_TYPE_INT32, y, + G_TYPE_INT, x, + G_TYPE_INT, y, G_TYPE_NONE); if (pdb) @@ -218,8 +218,8 @@ gimp_selection_translate (gint32 image_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE_ID, image_ID, - GIMP_TYPE_INT32, offx, - GIMP_TYPE_INT32, offy, + G_TYPE_INT, offx, + G_TYPE_INT, offy, G_TYPE_NONE); if (pdb) @@ -267,8 +267,8 @@ _gimp_selection_float (gint32 drawable_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_DRAWABLE_ID, drawable_ID, - GIMP_TYPE_INT32, offx, - GIMP_TYPE_INT32, offy, + G_TYPE_INT, offx, + G_TYPE_INT, offy, G_TYPE_NONE); if (pdb) @@ -512,7 +512,7 @@ gimp_selection_border (gint32 image_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE_ID, image_ID, - GIMP_TYPE_INT32, radius, + G_TYPE_INT, radius, G_TYPE_NONE); if (pdb) @@ -554,7 +554,7 @@ gimp_selection_grow (gint32 image_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE_ID, image_ID, - GIMP_TYPE_INT32, steps, + G_TYPE_INT, steps, G_TYPE_NONE); if (pdb) @@ -597,7 +597,7 @@ gimp_selection_shrink (gint32 image_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE_ID, image_ID, - GIMP_TYPE_INT32, steps, + G_TYPE_INT, steps, G_TYPE_NONE); if (pdb) diff --git a/libgimp/gimptexttool_pdb.c b/libgimp/gimptexttool_pdb.c index 87fc632e2f..66f8b2552a 100644 --- a/libgimp/gimptexttool_pdb.c +++ b/libgimp/gimptexttool_pdb.c @@ -89,7 +89,7 @@ gimp_text_fontname (gint32 image_ID, G_TYPE_DOUBLE, x, G_TYPE_DOUBLE, y, G_TYPE_STRING, text, - GIMP_TYPE_INT32, border, + G_TYPE_INT, border, G_TYPE_BOOLEAN, antialias, G_TYPE_DOUBLE, size, GIMP_TYPE_SIZE_TYPE, size_type, diff --git a/libgimp/gimpunit_pdb.c b/libgimp/gimpunit_pdb.c index 1c74f5f73a..42fd992322 100644 --- a/libgimp/gimpunit_pdb.c +++ b/libgimp/gimpunit_pdb.c @@ -135,7 +135,7 @@ _gimp_unit_new (const gchar *identifier, args = gimp_value_array_new_from_types (NULL, G_TYPE_STRING, identifier, G_TYPE_DOUBLE, factor, - GIMP_TYPE_INT32, digits, + G_TYPE_INT, digits, G_TYPE_STRING, symbol, G_TYPE_STRING, abbreviation, G_TYPE_STRING, singular, diff --git a/libgimp/gimpvectors_pdb.c b/libgimp/gimpvectors_pdb.c index b2bd3c2697..be86bad146 100644 --- a/libgimp/gimpvectors_pdb.c +++ b/libgimp/gimpvectors_pdb.c @@ -243,7 +243,7 @@ gimp_vectors_stroke_get_length (gint32 vectors_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_VECTORS_ID, vectors_ID, - GIMP_TYPE_INT32, stroke_id, + G_TYPE_INT, stroke_id, G_TYPE_DOUBLE, precision, G_TYPE_NONE); @@ -305,7 +305,7 @@ gimp_vectors_stroke_get_point_at_dist (gint32 vectors_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_VECTORS_ID, vectors_ID, - GIMP_TYPE_INT32, stroke_id, + G_TYPE_INT, stroke_id, G_TYPE_DOUBLE, dist, G_TYPE_DOUBLE, precision, G_TYPE_NONE); @@ -363,7 +363,7 @@ gimp_vectors_remove_stroke (gint32 vectors_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_VECTORS_ID, vectors_ID, - GIMP_TYPE_INT32, stroke_id, + G_TYPE_INT, stroke_id, G_TYPE_NONE); if (pdb) @@ -406,7 +406,7 @@ gimp_vectors_stroke_close (gint32 vectors_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_VECTORS_ID, vectors_ID, - GIMP_TYPE_INT32, stroke_id, + G_TYPE_INT, stroke_id, G_TYPE_NONE); if (pdb) @@ -453,9 +453,9 @@ gimp_vectors_stroke_translate (gint32 vectors_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_VECTORS_ID, vectors_ID, - GIMP_TYPE_INT32, stroke_id, - GIMP_TYPE_INT32, off_x, - GIMP_TYPE_INT32, off_y, + G_TYPE_INT, stroke_id, + G_TYPE_INT, off_x, + G_TYPE_INT, off_y, G_TYPE_NONE); if (pdb) @@ -502,7 +502,7 @@ gimp_vectors_stroke_scale (gint32 vectors_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_VECTORS_ID, vectors_ID, - GIMP_TYPE_INT32, stroke_id, + G_TYPE_INT, stroke_id, G_TYPE_DOUBLE, scale_x, G_TYPE_DOUBLE, scale_y, G_TYPE_NONE); @@ -553,7 +553,7 @@ gimp_vectors_stroke_rotate (gint32 vectors_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_VECTORS_ID, vectors_ID, - GIMP_TYPE_INT32, stroke_id, + G_TYPE_INT, stroke_id, G_TYPE_DOUBLE, center_x, G_TYPE_DOUBLE, center_y, G_TYPE_DOUBLE, angle, @@ -603,7 +603,7 @@ gimp_vectors_stroke_flip (gint32 vectors_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_VECTORS_ID, vectors_ID, - GIMP_TYPE_INT32, stroke_id, + G_TYPE_INT, stroke_id, GIMP_TYPE_ORIENTATION_TYPE, flip_type, G_TYPE_DOUBLE, axis, G_TYPE_NONE); @@ -658,7 +658,7 @@ gimp_vectors_stroke_flip_free (gint32 vectors_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_VECTORS_ID, vectors_ID, - GIMP_TYPE_INT32, stroke_id, + G_TYPE_INT, stroke_id, G_TYPE_DOUBLE, x1, G_TYPE_DOUBLE, y1, G_TYPE_DOUBLE, x2, @@ -714,7 +714,7 @@ gimp_vectors_stroke_get_points (gint32 vectors_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_VECTORS_ID, vectors_ID, - GIMP_TYPE_INT32, stroke_id, + G_TYPE_INT, stroke_id, G_TYPE_NONE); if (pdb) @@ -779,7 +779,7 @@ gimp_vectors_stroke_new_from_points (gint32 vectors_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_VECTORS_ID, vectors_ID, GIMP_TYPE_VECTORS_STROKE_TYPE, type, - GIMP_TYPE_INT32, num_points, + G_TYPE_INT, num_points, GIMP_TYPE_FLOAT_ARRAY, NULL, G_TYPE_BOOLEAN, closed, G_TYPE_NONE); @@ -834,7 +834,7 @@ gimp_vectors_stroke_interpolate (gint32 vectors_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_VECTORS_ID, vectors_ID, - GIMP_TYPE_INT32, stroke_id, + G_TYPE_INT, stroke_id, G_TYPE_DOUBLE, precision, G_TYPE_NONE); @@ -936,7 +936,7 @@ gimp_vectors_bezier_stroke_lineto (gint32 vectors_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_VECTORS_ID, vectors_ID, - GIMP_TYPE_INT32, stroke_id, + G_TYPE_INT, stroke_id, G_TYPE_DOUBLE, x0, G_TYPE_DOUBLE, y0, G_TYPE_NONE); @@ -991,7 +991,7 @@ gimp_vectors_bezier_stroke_conicto (gint32 vectors_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_VECTORS_ID, vectors_ID, - GIMP_TYPE_INT32, stroke_id, + G_TYPE_INT, stroke_id, G_TYPE_DOUBLE, x0, G_TYPE_DOUBLE, y0, G_TYPE_DOUBLE, x1, @@ -1050,7 +1050,7 @@ gimp_vectors_bezier_stroke_cubicto (gint32 vectors_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_VECTORS_ID, vectors_ID, - GIMP_TYPE_INT32, stroke_id, + G_TYPE_INT, stroke_id, G_TYPE_DOUBLE, x0, G_TYPE_DOUBLE, y0, G_TYPE_DOUBLE, x1, @@ -1231,7 +1231,7 @@ gimp_vectors_import_from_string (gint32 image_ID, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE_ID, image_ID, G_TYPE_STRING, string, - GIMP_TYPE_INT32, length, + G_TYPE_INT, length, G_TYPE_BOOLEAN, merge, G_TYPE_BOOLEAN, scale, G_TYPE_NONE); diff --git a/libgimpbase/gimpbase.def b/libgimpbase/gimpbase.def index d3ecac6a24..52c8769113 100644 --- a/libgimpbase/gimpbase.def +++ b/libgimpbase/gimpbase.def @@ -69,7 +69,6 @@ EXPORTS gimp_int16_array_get_type gimp_int16_get_type gimp_int32_array_get_type - gimp_int32_get_type gimp_int8_array_get_type gimp_int8_get_type gimp_interpolation_type_get_type @@ -113,7 +112,6 @@ EXPORTS gimp_param_int16_array_get_type gimp_param_int16_get_type gimp_param_int32_array_get_type - gimp_param_int32_get_type gimp_param_int8_array_get_type gimp_param_memsize_get_type gimp_param_parasite_get_type @@ -122,7 +120,6 @@ EXPORTS gimp_param_spec_float_array gimp_param_spec_int16 gimp_param_spec_int16_array - gimp_param_spec_int32 gimp_param_spec_int32_array gimp_param_spec_int8_array gimp_param_spec_memsize diff --git a/libgimpbase/gimpparamspecs.c b/libgimpbase/gimpparamspecs.c index 6527f24fcf..a0027ce319 100644 --- a/libgimpbase/gimpparamspecs.c +++ b/libgimpbase/gimpparamspecs.c @@ -25,116 +25,6 @@ #include "gimpbase.h" -/* - * GIMP_TYPE_INT32 - */ - -GType -gimp_int32_get_type (void) -{ - static GType type = 0; - - if (! type) - { - const GTypeInfo info = { 0, }; - - type = g_type_register_static (G_TYPE_INT, "GimpInt32", &info, 0); - } - - return type; -} - - -/* - * GIMP_TYPE_PARAM_INT32 - */ - -static void gimp_param_int32_class_init (GParamSpecClass *klass); -static void gimp_param_int32_init (GParamSpec *pspec); - -GType -gimp_param_int32_get_type (void) -{ - static GType type = 0; - - if (! type) - { - const GTypeInfo info = - { - sizeof (GParamSpecClass), - NULL, NULL, - (GClassInitFunc) gimp_param_int32_class_init, - NULL, NULL, - sizeof (GimpParamSpecInt32), - 0, - (GInstanceInitFunc) gimp_param_int32_init - }; - - type = g_type_register_static (G_TYPE_PARAM_INT, - "GimpParamInt32", &info, 0); - } - - return type; -} - -static void -gimp_param_int32_class_init (GParamSpecClass *klass) -{ - klass->value_type = GIMP_TYPE_INT32; -} - -static void -gimp_param_int32_init (GParamSpec *pspec) -{ -} - -/** - * gimp_param_spec_int32: - * @name: Canonical name of the property specified. - * @nick: Nick name of the property specified. - * @blurb: Description of the property specified. - * @minimum: The minimum accepted value. - * @maximum: The maximum accepted value. - * @default_value: The default value. - * @flags: Flags for the property specified. - * - * Creates a new #GimpParamSpecInt32 specifying a - * #GIMP_TYPE_INT32 property. - * - * See g_param_spec_internal() for details on property names. - * - * Returns: (transfer full): The newly created - * #GimpParamSpecInt32. - * - * Since: 3.0 - **/ -GParamSpec * -gimp_param_spec_int32 (const gchar *name, - const gchar *nick, - const gchar *blurb, - gint minimum, - gint maximum, - gint default_value, - GParamFlags flags) -{ - GParamSpecInt *ispec; - - g_return_val_if_fail (minimum >= G_MININT32, NULL); - g_return_val_if_fail (maximum <= G_MAXINT32, NULL); - g_return_val_if_fail (default_value >= minimum && - default_value <= maximum, NULL); - - ispec = g_param_spec_internal (GIMP_TYPE_PARAM_INT32, - name, nick, blurb, flags); - - ispec->minimum = minimum; - ispec->maximum = maximum; - ispec->default_value = default_value; - - return G_PARAM_SPEC (ispec); -} - - /* * GIMP_TYPE_INT16 */ diff --git a/libgimpbase/gimpparamspecs.h b/libgimpbase/gimpparamspecs.h index d7a197ae27..58f5b8b2cf 100644 --- a/libgimpbase/gimpparamspecs.h +++ b/libgimpbase/gimpparamspecs.h @@ -74,43 +74,6 @@ G_BEGIN_DECLS GIMP_PARAM_STATIC_STRINGS) -/* - * GIMP_TYPE_INT32 - */ - -#define GIMP_TYPE_INT32 (gimp_int32_get_type ()) -#define GIMP_VALUE_HOLDS_INT32(value) (G_TYPE_CHECK_VALUE_TYPE ((value),\ - GIMP_TYPE_INT32)) - -GType gimp_int32_get_type (void) G_GNUC_CONST; - - -/* - * GIMP_TYPE_PARAM_INT32 - */ - -#define GIMP_TYPE_PARAM_INT32 (gimp_param_int32_get_type ()) -#define GIMP_PARAM_SPEC_INT32(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_INT32, GimpParamSpecInt32)) -#define GIMP_IS_PARAM_SPEC_INT32(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_INT32)) - -typedef struct _GimpParamSpecInt32 GimpParamSpecInt32; - -struct _GimpParamSpecInt32 -{ - GParamSpecInt parent_instance; -}; - -GType gimp_param_int32_get_type (void) G_GNUC_CONST; - -GParamSpec * gimp_param_spec_int32 (const gchar *name, - const gchar *nick, - const gchar *blurb, - gint minimum, - gint maximum, - gint default_value, - GParamFlags flags); - - /* * GIMP_TYPE_INT16 */ diff --git a/pdb/app.pl b/pdb/app.pl index ff21841fe1..8a34336a48 100644 --- a/pdb/app.pl +++ b/pdb/app.pl @@ -363,11 +363,11 @@ CODE } $default = exists $arg->{default} ? $arg->{default} : defined $typeinfo[0] ? $typeinfo[0] : 0; $pspec = < { name => 'INT32', - gtype => 'GIMP_TYPE_INT32', - type => 'gint32 ', - const_type => 'gint32 ', + gtype => 'G_TYPE_INT', + type => 'gint ', + const_type => 'gint ', init_value => '0', get_value_func => '$var = g_value_get_int ($value)', dup_value_func => '$var = g_value_get_int ($value)', @@ -291,8 +291,8 @@ package Gimp::CodeGen::pdb; # Special cases enum => { name => 'INT32', gtype => 'G_TYPE_ENUM', - type => 'gint32 ', - const_type => 'gint32 ', + type => 'gint ', + const_type => 'gint ', init_value => '0', get_value_func => '$var = g_value_get_enum ($value)', dup_value_func => '$var = g_value_get_enum ($value)', @@ -310,9 +310,9 @@ package Gimp::CodeGen::pdb; take_value_func => 'g_value_set_boolean ($value, $var)' }, tattoo => { name => 'INT32', - gtype => 'GIMP_TYPE_INT32', - type => 'gint32 ', - const_type => 'gint32 ', + gtype => 'G_TYPE_INT', + type => 'gint ', + const_type => 'gint ', init_value => '0', get_value_func => '$var = g_value_get_uint ($value)', dup_value_func => '$var = g_value_get_uint ($value)', @@ -320,9 +320,9 @@ package Gimp::CodeGen::pdb; take_value_func => 'g_value_set_uint ($value, $var)' }, guide => { name => 'INT32', - gtype => 'GIMP_TYPE_INT32', - type => 'gint32 ', - const_type => 'gint32 ', + gtype => 'G_TYPE_INT', + type => 'gint ', + const_type => 'gint ', id => 1, init_value => '0', get_value_func => '$var = g_value_get_uint ($value)', @@ -331,9 +331,9 @@ package Gimp::CodeGen::pdb; take_value_func => 'g_value_set_uint ($value, $var)' }, sample_point => { name => 'INT32', - gtype => 'GIMP_TYPE_INT32', - type => 'gint32 ', - const_type => 'gint32 ', + gtype => 'G_TYPE_INT', + type => 'gint ', + const_type => 'gint ', id => 1, init_value => '0', get_value_func => '$var = g_value_get_uint ($value)', diff --git a/plug-ins/common/colormap-remap.c b/plug-ins/common/colormap-remap.c index a8f4f5fa4e..1d2cb57389 100644 --- a/plug-ins/common/colormap-remap.c +++ b/plug-ins/common/colormap-remap.c @@ -159,12 +159,12 @@ remap_create_procedure (GimpPlugIn *plug_in, FALSE, G_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("num-colors", - "Num colors", - "Length of 'map' " - "argument", - 1, 256, 1, - G_PARAM_READWRITE)); + g_param_spec_int ("num-colors", + "Num colors", + "Length of 'map' " + "argument", + 1, 256, 1, + G_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_int8_array ("map", "Map", diff --git a/plug-ins/common/file-gih.c b/plug-ins/common/file-gih.c index 47b2f129b7..3e6f5ba00d 100644 --- a/plug-ins/common/file-gih.c +++ b/plug-ins/common/file-gih.c @@ -239,12 +239,12 @@ gih_create_procedure (GimpPlugIn *plug_in, 1, 1000, 1, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("dimension", - "Dimension", - "Dimension of the " - "brush pipe", - 1, 4, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("dimension", + "Dimension", + "Dimension of the " + "brush pipe", + 1, 4, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_int8_array ("rank", "Rank", @@ -252,12 +252,12 @@ gih_create_procedure (GimpPlugIn *plug_in, "dimensions", GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("dimension", - "Dimension", - "Dimension of the " - "brush pipe", - 1, 4, 1, - GIMP_PARAM_READWRITE)); + g_param_spec_int ("dimension", + "Dimension", + "Dimension of the " + "brush pipe", + 1, 4, 1, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_int8_array ("sel", "Sel", diff --git a/plug-ins/common/film.c b/plug-ins/common/film.c index b0789967d7..4cdb231a92 100644 --- a/plug-ins/common/film.c +++ b/plug-ins/common/film.c @@ -299,12 +299,12 @@ film_create_procedure (GimpPlugIn *plug_in, TRUE, G_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("num-images", - "Num images", - "Number of images to " - "be used for film", - 1, MAX_FILM_PICTURES, 1, - G_PARAM_READWRITE)); + g_param_spec_int ("num-images", + "Num images", + "Number of images to " + "be used for film", + 1, MAX_FILM_PICTURES, 1, + G_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_int32_array ("image-ids", "Image IDs", diff --git a/plug-ins/help-browser/help-browser.c b/plug-ins/help-browser/help-browser.c index 3d65bfaa1f..bb9e637fa4 100644 --- a/plug-ins/help-browser/help-browser.c +++ b/plug-ins/help-browser/help-browser.c @@ -140,22 +140,22 @@ help_browser_create_procedure (GimpPlugIn *plug_in, GIMP_RUN_INTERACTIVE, G_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("num-domain-names", - "Num domain names", - "Num domain names", - 0, G_MAXINT, 0, - G_PARAM_READWRITE)); + g_param_spec_int ("num-domain-names", + "Num domain names", + "Num domain names", + 0, G_MAXINT, 0, + G_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_string_array ("domain-names", "Domain names", "Domain names", G_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("num-domain-uris", - "Num domain URIs", - "Num domain URIs", - 0, G_MAXINT, 0, - G_PARAM_READWRITE)); + g_param_spec_int ("num-domain-uris", + "Num domain URIs", + "Num domain URIs", + 0, G_MAXINT, 0, + G_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_string_array ("domain-uris", "Domain URIs", diff --git a/plug-ins/help/help.c b/plug-ins/help/help.c index 1a2cc4275f..61a945837d 100644 --- a/plug-ins/help/help.c +++ b/plug-ins/help/help.c @@ -137,22 +137,22 @@ help_create_procedure (GimpPlugIn *plug_in, "1999-2008"); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("num-domain-names", - "Num Domain Names", - "Num domain names", - 0, G_MAXINT, 0, - G_PARAM_READWRITE)); + g_param_spec_int ("num-domain-names", + "Num Domain Names", + "Num domain names", + 0, G_MAXINT, 0, + G_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_string_array ("domain-names", "Domain Names", "Domain names", G_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_int32 ("num-domain-uris", - "Num Domain URIs", - "Num domain URIs", - 0, G_MAXINT, 0, - G_PARAM_READWRITE)); + g_param_spec_int ("num-domain-uris", + "Num Domain URIs", + "Num domain URIs", + 0, G_MAXINT, 0, + G_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_string_array ("domain-uris", "Domain URIs",