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

Remove GIMP_TYPE_INT32 and GimpParamSpecInt32 

Use gint and GParamSpecInt instead.
This commit is contained in:
Michael Natterer 2019-08-15 14:04:56 +02:00
parent 1bf90ec77f
commit 5a09523214
99 changed files with 2852 additions and 3035 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
app/core/gimpparamspecs-desc.c
View File

@ -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
{

20
app/file-data/file-data.c
View File

@ -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",

186
app/pdb/brush-cmds.c
View File

@ -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);

28
app/pdb/brush-select-cmds.c
View File

@ -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",

12
app/pdb/brushes-cmds.c
View File

@ -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",

50
app/pdb/buffer-cmds.c
View File

@ -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);

52
app/pdb/channel-cmds.c
View File

@ -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);

108
app/pdb/context-cmds.c
View File

@ -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);

12
app/pdb/display-cmds.c
View File

@ -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);

502
app/pdb/drawable-cmds.c
View File

@ -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",

52
app/pdb/drawable-color-cmds.c
View File

@ -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);

18
app/pdb/drawable-edit-cmds.c
View File

@ -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",

12
app/pdb/dynamics-cmds.c
View File

@ -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",

64
app/pdb/fileops-cmds.c
View File

@ -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);

12
app/pdb/fonts-cmds.c
View File

@ -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",

24
app/pdb/gimp-cmds.c
View File

@ -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",

1
app/pdb/gimp-pdb-compat.c
View File

@ -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 },

9
app/pdb/gimppdb.c
View File

@ -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;

500
app/pdb/gradient-cmds.c
View File

@ -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",

12
app/pdb/gradient-select-cmds.c
View File

@ -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);

12
app/pdb/gradients-cmds.c
View File

@ -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",

346
app/pdb/image-cmds.c
View File

@ -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",

52
app/pdb/image-color-profile-cmds.c
View File

@ -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",

54
app/pdb/image-convert-cmds.c
View File

@ -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",

4
app/pdb/image-grid-cmds.c
View File

@ -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));

52
app/pdb/image-guides-cmds.c
View File

@ -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);
}

58
app/pdb/image-sample-points-cmds.c
View File

@ -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);
}

26
app/pdb/image-select-cmds.c
View File

@ -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",

124
app/pdb/image-transform-cmds.c
View File

@ -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);

32
app/pdb/item-cmds.c
View File

@ -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",

6
app/pdb/item-transform-cmds.c
View File

@ -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);

144
app/pdb/layer-cmds.c
View File

@ -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);

4
app/pdb/message-cmds.c
View File

@ -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));

218
app/pdb/paint-tools-cmds.c
View File

@ -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",

120
app/pdb/palette-cmds.c
View File

@ -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",

12
app/pdb/palettes-cmds.c
View File

@ -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",

84
app/pdb/pattern-cmds.c
View File

@ -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",

12
app/pdb/patterns-cmds.c
View File

@ -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",

98
app/pdb/pdb-cmds.c
View File

@ -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",

80
app/pdb/plug-in-cmds.c
View File

@ -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",

1308
app/pdb/plug-in-compat-cmds.c
View File

File diff suppressed because it is too large Load Diff

12
app/pdb/progress-cmds.c
View File

@ -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);

168
app/pdb/selection-cmds.c
View File

@ -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);

12
app/pdb/text-layer-cmds.c
View File

@ -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));

60
app/pdb/text-tool-cmds.c
View File

@ -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);
}

48
app/pdb/unit-cmds.c
View File

@ -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);

318
app/pdb/vectors-cmds.c
View File

@ -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",

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

@ -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,

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

@ -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))))
{

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

@ -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;
}

2
app/widgets/gimpbrushselect.c
View File

@ -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);

2
app/widgets/gimpgradientselect.c
View File

@ -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);

2
app/widgets/gimppatternselect.c
View File

@ -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);

9
devel-docs/libgimpbase/libgimpbase3-sections.txt
View File

@ -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

2
devel-docs/libgimpbase/libgimpbase3.types
View File

@ -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

2
libgimp/gimp.c
View File

@ -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,

4
libgimp/gimpbrush_pdb.c
View File

@ -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)

12
libgimp/gimpbrushselect.c
View File

@ -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",

4
libgimp/gimpbrushselect_pdb.c
View File

@ -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);

8
libgimp/gimpchannel_pdb.c
View File

@ -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)

4
libgimp/gimpcontext_pdb.c
View File

@ -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)

38
libgimp/gimpdrawable_pdb.c
View File

@ -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)

6
libgimp/gimpdrawablecolor_pdb.c
View File

@ -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)

2
libgimp/gimpdrawableedit_pdb.c
View File

@ -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,

2
libgimp/gimpfileops_pdb.c
View File

@ -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)

9
libgimp/gimpgpcompat.c
View File

@ -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 },

11
libgimp/gimpgpparams-body.c
View File

@ -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)
{

7
libgimp/gimpgpparams.c
View File

@ -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,

76
libgimp/gimpgradient_pdb.c
View File

@ -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);

10
libgimp/gimpgradientselect.c
View File

@ -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",

2
libgimp/gimpgradientselect_pdb.c
View File

@ -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)

34
libgimp/gimpimage_pdb.c
View File

@ -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)

4
libgimp/gimpimagecolorprofile_pdb.c
View File

@ -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,

8
libgimp/gimpimageconvert_pdb.c
View File

@ -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);

12
libgimp/gimpimageguides_pdb.c
View File

@ -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)

10
libgimp/gimpimagesamplepoints_pdb.c
View File

@ -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)

2
libgimp/gimpimageselect_pdb.c
View File

@ -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);

20
libgimp/gimpimagetransform_pdb.c
View File

@ -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)

2
libgimp/gimpitem_pdb.c
View File

@ -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)

20
libgimp/gimplayer_pdb.c
View File

@ -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)

34
libgimp/gimppainttools_pdb.c
View File

@ -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);

12
libgimp/gimppalette_pdb.c
View File

@ -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);

12
libgimp/gimppatternselect.c
View File

@ -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",

6
libgimp/gimppdb_pdb.c
View File

@ -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);

2
libgimp/gimpplugin_pdb.c
View File

@ -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);

18
libgimp/gimpselection_pdb.c
View File

@ -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)

2
libgimp/gimptexttool_pdb.c
View File

@ -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,

2
libgimp/gimpunit_pdb.c
View File

@ -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,

36
libgimp/gimpvectors_pdb.c
View File

@ -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);

3
libgimpbase/gimpbase.def
View File

@ -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

110
libgimpbase/gimpparamspecs.c
View File

@ -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
*/

37
libgimpbase/gimpparamspecs.h
View File

@ -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
*/

10
pdb/app.pl
View File

@ -363,11 +363,11 @@ CODE
}
$default = exists $arg->{default} ? $arg->{default} : defined $typeinfo[0] ? $typeinfo[0] : 0;
$pspec = <<CODE;
gimp_param_spec_int32 ("$name",
"$nick",
"$blurb",
$min, $max, $default,
$flags)
g_param_spec_int ("$name",
"$nick",
"$blurb",
$min, $max, $default,
$flags)
CODE
}
elsif ($pdbtype eq 'int16') {

28
pdb/pdb.pl
View File

@ -18,9 +18,9 @@ package Gimp::CodeGen::pdb;
%arg_types = (
int32 => { 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)',

12
plug-ins/common/colormap-remap.c
View File

@ -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",

24
plug-ins/common/file-gih.c
View File

@ -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",

12
plug-ins/common/film.c
View File

@ -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",

20
plug-ins/help-browser/help-browser.c
View File

@ -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",

20
plug-ins/help/help.c
View File

@ -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",