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 * static gchar *
gimp_param_spec_int32_desc (GParamSpec *pspec) gimp_param_spec_int_desc (GParamSpec *pspec)
{ {
GParamSpecInt *ispec = G_PARAM_SPEC_INT (pspec); GParamSpecInt *ispec = G_PARAM_SPEC_INT (pspec);
const gchar *blurb = gimp_param_spec_get_blurb (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)) 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 else
{ {

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

@ -184,11 +184,11 @@ file_data_init (Gimp *gimp)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("spacing", g_param_spec_int ("spacing",
"spacing", "spacing",
"Spacing of the brush", "Spacing of the brush",
1, 1000, 10, 1, 1000, 10,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("name", gimp_param_spec_string ("name",
"name", "name",
@ -334,11 +334,11 @@ file_data_init (Gimp *gimp)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("spacing", g_param_spec_int ("spacing",
"spacing", "spacing",
"Spacing of the brush", "Spacing of the brush",
1, 1000, 10, 1, 1000, 10,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("name", gimp_param_spec_string ("name",
"name", "name",

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

@ -269,10 +269,10 @@ brush_get_info_invoker (GimpProcedure *procedure,
gboolean success = TRUE; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *name; const gchar *name;
gint32 width = 0; gint width = 0;
gint32 height = 0; gint height = 0;
gint32 mask_bpp = 0; gint mask_bpp = 0;
gint32 color_bpp = 0; gint color_bpp = 0;
name = g_value_get_string (gimp_value_array_index (args, 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *name; const gchar *name;
gint32 width = 0; gint width = 0;
gint32 height = 0; gint height = 0;
gint32 mask_bpp = 0; gint mask_bpp = 0;
gint32 num_mask_bytes = 0; gint num_mask_bytes = 0;
guint8 *mask_bytes = NULL; guint8 *mask_bytes = NULL;
gint32 color_bpp = 0; gint color_bpp = 0;
gint32 num_color_bytes = 0; gint num_color_bytes = 0;
guint8 *color_bytes = NULL; guint8 *color_bytes = NULL;
name = g_value_get_string (gimp_value_array_index (args, 0)); name = g_value_get_string (gimp_value_array_index (args, 0));
@ -413,7 +413,7 @@ brush_get_spacing_invoker (GimpProcedure *procedure,
gboolean success = TRUE; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *name; const gchar *name;
gint32 spacing = 0; gint spacing = 0;
name = g_value_get_string (gimp_value_array_index (args, 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; gboolean success = TRUE;
const gchar *name; const gchar *name;
gint32 spacing; gint spacing;
name = g_value_get_string (gimp_value_array_index (args, 0)); name = g_value_get_string (gimp_value_array_index (args, 0));
spacing = g_value_get_int (gimp_value_array_index (args, 1)); spacing = g_value_get_int (gimp_value_array_index (args, 1));
@ -476,7 +476,7 @@ brush_get_shape_invoker (GimpProcedure *procedure,
gboolean success = TRUE; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *name; const gchar *name;
gint32 shape = 0; gint shape = 0;
name = g_value_get_string (gimp_value_array_index (args, 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *name; const gchar *name;
gint32 shape_in; gint shape_in;
gint32 shape_out = 0; gint shape_out = 0;
name = g_value_get_string (gimp_value_array_index (args, 0)); name = g_value_get_string (gimp_value_array_index (args, 0));
shape_in = g_value_get_enum (gimp_value_array_index (args, 1)); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *name; const gchar *name;
gint32 spikes = 0; gint spikes = 0;
name = g_value_get_string (gimp_value_array_index (args, 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *name; const gchar *name;
gint32 spikes_in; gint spikes_in;
gint32 spikes_out = 0; gint spikes_out = 0;
name = g_value_get_string (gimp_value_array_index (args, 0)); name = g_value_get_string (gimp_value_array_index (args, 0));
spikes_in = g_value_get_int (gimp_value_array_index (args, 1)); spikes_in = g_value_get_int (gimp_value_array_index (args, 1));
@ -1120,29 +1120,29 @@ register_brush_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("width", g_param_spec_int ("width",
"width", "width",
"The brush width", "The brush width",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("height", g_param_spec_int ("height",
"height", "height",
"The brush height", "The brush height",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("mask-bpp", g_param_spec_int ("mask-bpp",
"mask bpp", "mask bpp",
"The brush mask bpp", "The brush mask bpp",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("color-bpp", g_param_spec_int ("color-bpp",
"color bpp", "color bpp",
"The brush color bpp", "The brush color bpp",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -1168,46 +1168,46 @@ register_brush_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("width", g_param_spec_int ("width",
"width", "width",
"The brush width", "The brush width",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("height", g_param_spec_int ("height",
"height", "height",
"The brush height", "The brush height",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("mask-bpp", g_param_spec_int ("mask-bpp",
"mask bpp", "mask bpp",
"The brush mask bpp", "The brush mask bpp",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-mask-bytes", g_param_spec_int ("num-mask-bytes",
"num mask bytes", "num mask bytes",
"Length of brush mask data", "Length of brush mask data",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int8_array ("mask-bytes", gimp_param_spec_int8_array ("mask-bytes",
"mask bytes", "mask bytes",
"The brush mask data", "The brush mask data",
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("color-bpp", g_param_spec_int ("color-bpp",
"color bpp", "color bpp",
"The brush color bpp", "The brush color bpp",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-color-bytes", g_param_spec_int ("num-color-bytes",
"num color bytes", "num color bytes",
"Length of brush color data", "Length of brush color data",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int8_array ("color-bytes", gimp_param_spec_int8_array ("color-bytes",
"color bytes", "color bytes",
@ -1238,11 +1238,11 @@ register_brush_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("spacing", g_param_spec_int ("spacing",
"spacing", "spacing",
"The brush spacing", "The brush spacing",
0, 1000, 0, 0, 1000, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -1268,11 +1268,11 @@ register_brush_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("spacing", g_param_spec_int ("spacing",
"spacing", "spacing",
"The brush spacing", "The brush spacing",
0, 1000, 0, 0, 1000, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -1433,11 +1433,11 @@ register_brush_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("spikes", g_param_spec_int ("spikes",
"spikes", "spikes",
"The number of spikes on the brush.", "The number of spikes on the brush.",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -1463,17 +1463,17 @@ register_brush_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("spikes-in", g_param_spec_int ("spikes-in",
"spikes in", "spikes in",
"The desired number of spikes", "The desired number of spikes",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("spikes-out", g_param_spec_int ("spikes-out",
"spikes out", "spikes out",
"The number of spikes actually assigned", "The number of spikes actually assigned",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (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 *popup_title;
const gchar *initial_brush; const gchar *initial_brush;
gdouble opacity; gdouble opacity;
gint32 spacing; gint spacing;
gint32 paint_mode; gint paint_mode;
brush_callback = g_value_get_string (gimp_value_array_index (args, 0)); brush_callback = g_value_get_string (gimp_value_array_index (args, 0));
popup_title = g_value_get_string (gimp_value_array_index (args, 1)); 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_callback;
const gchar *brush_name; const gchar *brush_name;
gdouble opacity; gdouble opacity;
gint32 spacing; gint spacing;
gint32 paint_mode; gint paint_mode;
brush_callback = g_value_get_string (gimp_value_array_index (args, 0)); brush_callback = g_value_get_string (gimp_value_array_index (args, 0));
brush_name = g_value_get_string (gimp_value_array_index (args, 1)); 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, 0, 100, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("spacing", g_param_spec_int ("spacing",
"spacing", "spacing",
"The initial spacing of the brush (if < 0 then use brush default spacing)", "The initial spacing of the brush (if < 0 then use brush default spacing)",
G_MININT32, 1000, 0, G_MININT32, 1000, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
g_param_spec_enum ("paint-mode", g_param_spec_enum ("paint-mode",
"paint mode", "paint mode",
@ -268,11 +268,11 @@ register_brush_select_procs (GimpPDB *pdb)
0, 100, 0, 0, 100, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("spacing", g_param_spec_int ("spacing",
"spacing", "spacing",
"The initial spacing of the brush (if < 0 then use brush default spacing)", "The initial spacing of the brush (if < 0 then use brush default spacing)",
G_MININT32, 1000, 0, G_MININT32, 1000, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
g_param_spec_enum ("paint-mode", g_param_spec_enum ("paint-mode",
"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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *filter; const gchar *filter;
gint32 num_brushes = 0; gint num_brushes = 0;
gchar **brush_list = NULL; gchar **brush_list = NULL;
filter = g_value_get_string (gimp_value_array_index (args, 0)); filter = g_value_get_string (gimp_value_array_index (args, 0));
@ -134,11 +134,11 @@ register_brushes_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-brushes", g_param_spec_int ("num-brushes",
"num brushes", "num brushes",
"The number of brushes in the brush list", "The number of brushes in the brush list",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_string_array ("brush-list", gimp_param_spec_string_array ("brush-list",
"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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *filter; const gchar *filter;
gint32 num_buffers = 0; gint num_buffers = 0;
gchar **buffer_list = NULL; gchar **buffer_list = NULL;
filter = g_value_get_string (gimp_value_array_index (args, 0)); filter = g_value_get_string (gimp_value_array_index (args, 0));
@ -153,7 +153,7 @@ buffer_get_width_invoker (GimpProcedure *procedure,
gboolean success = TRUE; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *buffer_name; const gchar *buffer_name;
gint32 width = 0; gint width = 0;
buffer_name = g_value_get_string (gimp_value_array_index (args, 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *buffer_name; const gchar *buffer_name;
gint32 height = 0; gint height = 0;
buffer_name = g_value_get_string (gimp_value_array_index (args, 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *buffer_name; const gchar *buffer_name;
gint32 bytes = 0; gint bytes = 0;
buffer_name = g_value_get_string (gimp_value_array_index (args, 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *buffer_name; const gchar *buffer_name;
gint32 image_type = 0; gint image_type = 0;
buffer_name = g_value_get_string (gimp_value_array_index (args, 0)); buffer_name = g_value_get_string (gimp_value_array_index (args, 0));
@ -309,11 +309,11 @@ register_buffer_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-buffers", g_param_spec_int ("num-buffers",
"num buffers", "num buffers",
"The number of buffers", "The number of buffers",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_string_array ("buffer-list", gimp_param_spec_string_array ("buffer-list",
"buffer list", "buffer list",
@ -406,11 +406,11 @@ register_buffer_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("width", g_param_spec_int ("width",
"width", "width",
"The buffer width", "The buffer width",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -436,11 +436,11 @@ register_buffer_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("height", g_param_spec_int ("height",
"height", "height",
"The buffer height", "The buffer height",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -466,11 +466,11 @@ register_buffer_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("bytes", g_param_spec_int ("bytes",
"bytes", "bytes",
"The buffer bpp", "The buffer bpp",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpImage *image; GimpImage *image;
gint32 width; gint width;
gint32 height; gint height;
const gchar *name; const gchar *name;
gdouble opacity; gdouble opacity;
GimpRGB color; GimpRGB color;
@ -100,7 +100,7 @@ channel_new_from_component_invoker (GimpProcedure *procedure,
gboolean success = TRUE; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpImage *image; GimpImage *image;
gint32 component; gint component;
const gchar *name; const gchar *name;
GimpChannel *channel = NULL; GimpChannel *channel = NULL;
@ -183,9 +183,9 @@ channel_combine_masks_invoker (GimpProcedure *procedure,
gboolean success = TRUE; gboolean success = TRUE;
GimpChannel *channel1; GimpChannel *channel1;
GimpChannel *channel2; GimpChannel *channel2;
gint32 operation; gint operation;
gint32 offx; gint offx;
gint32 offy; gint offy;
channel1 = gimp_value_get_channel (gimp_value_array_index (args, 0), gimp); channel1 = gimp_value_get_channel (gimp_value_array_index (args, 0), gimp);
channel2 = gimp_value_get_channel (gimp_value_array_index (args, 1), 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, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("width", g_param_spec_int ("width",
"width", "width",
"The channel width", "The channel width",
1, GIMP_MAX_IMAGE_SIZE, 1, 1, GIMP_MAX_IMAGE_SIZE, 1,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("height", g_param_spec_int ("height",
"height", "height",
"The channel height", "The channel height",
1, GIMP_MAX_IMAGE_SIZE, 1, 1, GIMP_MAX_IMAGE_SIZE, 1,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("name", gimp_param_spec_string ("name",
"name", "name",
@ -544,17 +544,17 @@ register_channel_procs (GimpPDB *pdb)
GIMP_CHANNEL_OP_ADD, GIMP_CHANNEL_OP_ADD,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("offx", g_param_spec_int ("offx",
"offx", "offx",
"x offset between upper left corner of channels: (second - first)", "x offset between upper left corner of channels: (second - first)",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("offy", g_param_spec_int ("offy",
"offy", "offy",
"y offset between upper left corner of channels: (second - first)", "y offset between upper left corner of channels: (second - first)",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (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) GError **error)
{ {
GimpValueArray *return_vals; GimpValueArray *return_vals;
gint32 num_paint_methods = 0; gint num_paint_methods = 0;
gchar **paint_methods = NULL; gchar **paint_methods = NULL;
paint_methods = gimp_container_get_name_array (gimp->paint_info_list, paint_methods = gimp_container_get_name_array (gimp->paint_info_list,
@ -192,7 +192,7 @@ context_get_stroke_method_invoker (GimpProcedure *procedure,
GError **error) GError **error)
{ {
GimpValueArray *return_vals; GimpValueArray *return_vals;
gint32 stroke_method = 0; gint stroke_method = 0;
GimpStrokeOptions *options = GimpStrokeOptions *options =
gimp_pdb_context_get_stroke_options (GIMP_PDB_CONTEXT (context)); gimp_pdb_context_get_stroke_options (GIMP_PDB_CONTEXT (context));
@ -216,7 +216,7 @@ context_set_stroke_method_invoker (GimpProcedure *procedure,
GError **error) GError **error)
{ {
gboolean success = TRUE; gboolean success = TRUE;
gint32 stroke_method; gint stroke_method;
stroke_method = g_value_get_enum (gimp_value_array_index (args, 0)); 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) GError **error)
{ {
GimpValueArray *return_vals; GimpValueArray *return_vals;
gint32 paint_mode = 0; gint paint_mode = 0;
paint_mode = gimp_context_get_paint_mode (context); paint_mode = gimp_context_get_paint_mode (context);
@ -415,7 +415,7 @@ context_set_paint_mode_invoker (GimpProcedure *procedure,
GError **error) GError **error)
{ {
gboolean success = TRUE; gboolean success = TRUE;
gint32 paint_mode; gint paint_mode;
paint_mode = g_value_get_enum (gimp_value_array_index (args, 0)); 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) GError **error)
{ {
GimpValueArray *return_vals; GimpValueArray *return_vals;
gint32 cap_style = 0; gint cap_style = 0;
GimpStrokeOptions *options = GimpStrokeOptions *options =
gimp_pdb_context_get_stroke_options (GIMP_PDB_CONTEXT (context)); gimp_pdb_context_get_stroke_options (GIMP_PDB_CONTEXT (context));
@ -566,7 +566,7 @@ context_set_line_cap_style_invoker (GimpProcedure *procedure,
GError **error) GError **error)
{ {
gboolean success = TRUE; gboolean success = TRUE;
gint32 cap_style; gint cap_style;
cap_style = g_value_get_enum (gimp_value_array_index (args, 0)); 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) GError **error)
{ {
GimpValueArray *return_vals; GimpValueArray *return_vals;
gint32 join_style = 0; gint join_style = 0;
GimpStrokeOptions *options = GimpStrokeOptions *options =
gimp_pdb_context_get_stroke_options (GIMP_PDB_CONTEXT (context)); gimp_pdb_context_get_stroke_options (GIMP_PDB_CONTEXT (context));
@ -617,7 +617,7 @@ context_set_line_join_style_invoker (GimpProcedure *procedure,
GError **error) GError **error)
{ {
gboolean success = TRUE; gboolean success = TRUE;
gint32 join_style; gint join_style;
join_style = g_value_get_enum (gimp_value_array_index (args, 0)); 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) GError **error)
{ {
GimpValueArray *return_vals; GimpValueArray *return_vals;
gint32 num_dashes = 0; gint num_dashes = 0;
gdouble *dashes = NULL; gdouble *dashes = NULL;
GimpStrokeOptions *options = GimpStrokeOptions *options =
@ -773,7 +773,7 @@ context_set_line_dash_pattern_invoker (GimpProcedure *procedure,
GError **error) GError **error)
{ {
gboolean success = TRUE; gboolean success = TRUE;
gint32 num_dashes; gint num_dashes;
const gdouble *dashes; const gdouble *dashes;
num_dashes = g_value_get_int (gimp_value_array_index (args, 0)); 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; gboolean success = TRUE;
GimpValueArray *return_vals; 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 */ /* all options should have the same value, so pick a random one */
GimpPaintOptions *options = GimpPaintOptions *options =
@ -1661,7 +1661,7 @@ context_set_gradient_blend_color_space_invoker (GimpProcedure *procedure
GError **error) GError **error)
{ {
gboolean success = TRUE; gboolean success = TRUE;
gint32 blend_color_space; gint blend_color_space;
blend_color_space = g_value_get_enum (gimp_value_array_index (args, 0)); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
gint32 repeat_mode = 0; gint repeat_mode = 0;
/* all options should have the same value, so pick a random one */ /* all options should have the same value, so pick a random one */
GimpPaintOptions *options = GimpPaintOptions *options =
@ -1724,7 +1724,7 @@ context_set_gradient_repeat_mode_invoker (GimpProcedure *procedure,
GError **error) GError **error)
{ {
gboolean success = TRUE; gboolean success = TRUE;
gint32 repeat_mode; gint repeat_mode;
repeat_mode = g_value_get_enum (gimp_value_array_index (args, 0)); 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) GError **error)
{ {
GimpValueArray *return_vals; GimpValueArray *return_vals;
gint32 sample_criterion = 0; gint sample_criterion = 0;
g_object_get (context, g_object_get (context,
"sample-criterion", &sample_criterion, "sample-criterion", &sample_criterion,
@ -2135,7 +2135,7 @@ context_set_sample_criterion_invoker (GimpProcedure *procedure,
GError **error) GError **error)
{ {
gboolean success = TRUE; gboolean success = TRUE;
gint32 sample_criterion; gint sample_criterion;
sample_criterion = g_value_get_enum (gimp_value_array_index (args, 0)); 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) GError **error)
{ {
GimpValueArray *return_vals; GimpValueArray *return_vals;
gint32 sample_threshold = 0; gint sample_threshold = 0;
gdouble threshold; gdouble threshold;
@ -2229,7 +2229,7 @@ context_set_sample_threshold_int_invoker (GimpProcedure *procedure,
GError **error) GError **error)
{ {
gboolean success = TRUE; gboolean success = TRUE;
gint32 sample_threshold; gint sample_threshold;
sample_threshold = g_value_get_int (gimp_value_array_index (args, 0)); 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) GError **error)
{ {
GimpValueArray *return_vals; GimpValueArray *return_vals;
gint32 metric = 0; gint metric = 0;
g_object_get (context, g_object_get (context,
"distance-metric", &metric, "distance-metric", &metric,
@ -2364,7 +2364,7 @@ context_set_distance_metric_invoker (GimpProcedure *procedure,
GError **error) GError **error)
{ {
gboolean success = TRUE; gboolean success = TRUE;
gint32 metric; gint metric;
metric = g_value_get_enum (gimp_value_array_index (args, 0)); metric = g_value_get_enum (gimp_value_array_index (args, 0));
@ -2388,7 +2388,7 @@ context_get_interpolation_invoker (GimpProcedure *procedure,
GError **error) GError **error)
{ {
GimpValueArray *return_vals; GimpValueArray *return_vals;
gint32 interpolation = 0; gint interpolation = 0;
g_object_get (context, g_object_get (context,
"interpolation", &interpolation, "interpolation", &interpolation,
@ -2409,7 +2409,7 @@ context_set_interpolation_invoker (GimpProcedure *procedure,
GError **error) GError **error)
{ {
gboolean success = TRUE; gboolean success = TRUE;
gint32 interpolation; gint interpolation;
interpolation = g_value_get_enum (gimp_value_array_index (args, 0)); interpolation = g_value_get_enum (gimp_value_array_index (args, 0));
@ -2433,7 +2433,7 @@ context_get_transform_direction_invoker (GimpProcedure *procedure,
GError **error) GError **error)
{ {
GimpValueArray *return_vals; GimpValueArray *return_vals;
gint32 transform_direction = 0; gint transform_direction = 0;
g_object_get (context, g_object_get (context,
"transform-direction", &transform_direction, "transform-direction", &transform_direction,
@ -2454,7 +2454,7 @@ context_set_transform_direction_invoker (GimpProcedure *procedure,
GError **error) GError **error)
{ {
gboolean success = TRUE; gboolean success = TRUE;
gint32 transform_direction; gint transform_direction;
transform_direction = g_value_get_enum (gimp_value_array_index (args, 0)); 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) GError **error)
{ {
GimpValueArray *return_vals; GimpValueArray *return_vals;
gint32 transform_resize = 0; gint transform_resize = 0;
g_object_get (context, g_object_get (context,
"transform-resize", &transform_resize, "transform-resize", &transform_resize,
@ -2499,7 +2499,7 @@ context_set_transform_resize_invoker (GimpProcedure *procedure,
GError **error) GError **error)
{ {
gboolean success = TRUE; gboolean success = TRUE;
gint32 transform_resize; gint transform_resize;
transform_resize = g_value_get_enum (gimp_value_array_index (args, 0)); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
gint32 type = 0; gint type = 0;
GimpPaintOptions *options = GimpPaintOptions *options =
gimp_pdb_context_get_paint_options (GIMP_PDB_CONTEXT (context), gimp_pdb_context_get_paint_options (GIMP_PDB_CONTEXT (context),
@ -2870,7 +2870,7 @@ context_set_ink_blob_type_invoker (GimpProcedure *procedure,
GError **error) GError **error)
{ {
gboolean success = TRUE; gboolean success = TRUE;
gint32 type; gint type;
type = g_value_get_enum (gimp_value_array_index (args, 0)); type = g_value_get_enum (gimp_value_array_index (args, 0));
@ -3092,11 +3092,11 @@ register_context_procs (GimpPDB *pdb)
"2007", "2007",
NULL); NULL);
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-paint-methods", g_param_spec_int ("num-paint-methods",
"num paint methods", "num paint methods",
"The number of the available paint methods", "The number of the available paint methods",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_string_array ("paint-methods", gimp_param_spec_string_array ("paint-methods",
"paint methods", "paint methods",
@ -3737,11 +3737,11 @@ register_context_procs (GimpPDB *pdb)
"2015", "2015",
NULL); NULL);
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-dashes", g_param_spec_int ("num-dashes",
"num dashes", "num dashes",
"The number of dashes in the dash_pattern array", "The number of dashes in the dash_pattern array",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_float_array ("dashes", gimp_param_spec_float_array ("dashes",
"dashes", "dashes",
@ -3769,11 +3769,11 @@ register_context_procs (GimpPDB *pdb)
"2015", "2015",
NULL); NULL);
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("num-dashes", g_param_spec_int ("num-dashes",
"num dashes", "num dashes",
"The number of dashes in the dash_pattern array", "The number of dashes in the dash_pattern array",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("dashes", gimp_param_spec_float_array ("dashes",
"dashes", "dashes",
@ -4972,11 +4972,11 @@ register_context_procs (GimpPDB *pdb)
"2011", "2011",
NULL); NULL);
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("sample-threshold", g_param_spec_int ("sample-threshold",
"sample threshold", "sample threshold",
"The sample threshold setting", "The sample threshold setting",
0, 255, 0, 0, 255, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -4995,11 +4995,11 @@ register_context_procs (GimpPDB *pdb)
"2011", "2011",
NULL); NULL);
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("sample-threshold", g_param_spec_int ("sample-threshold",
"sample threshold", "sample threshold",
"The sample threshold setting", "The sample threshold setting",
0, 255, 0, 0, 255, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpObject *display; GimpObject *display;
gint32 window = 0; gint window = 0;
display = gimp_value_get_display (gimp_value_array_index (args, 0), gimp); display = gimp_value_get_display (gimp_value_array_index (args, 0), gimp);
@ -307,11 +307,11 @@ register_display_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("window", g_param_spec_int ("window",
"window", "window",
"The native window handle or 0", "The native window handle or 0",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpDrawable *drawable; GimpDrawable *drawable;
gint32 type = 0; gint type = 0;
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpDrawable *drawable; GimpDrawable *drawable;
gint32 type_with_alpha = 0; gint type_with_alpha = 0;
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp);
@ -304,7 +304,7 @@ drawable_bpp_invoker (GimpProcedure *procedure,
gboolean success = TRUE; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpDrawable *drawable; GimpDrawable *drawable;
gint32 bpp = 0; gint bpp = 0;
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp);
@ -335,7 +335,7 @@ drawable_width_invoker (GimpProcedure *procedure,
gboolean success = TRUE; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpDrawable *drawable; GimpDrawable *drawable;
gint32 width = 0; gint width = 0;
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp);
@ -364,7 +364,7 @@ drawable_height_invoker (GimpProcedure *procedure,
gboolean success = TRUE; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpDrawable *drawable; GimpDrawable *drawable;
gint32 height = 0; gint height = 0;
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp);
@ -393,8 +393,8 @@ drawable_offsets_invoker (GimpProcedure *procedure,
gboolean success = TRUE; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpDrawable *drawable; GimpDrawable *drawable;
gint32 offset_x = 0; gint offset_x = 0;
gint32 offset_y = 0; gint offset_y = 0;
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); 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; GimpValueArray *return_vals;
GimpDrawable *drawable; GimpDrawable *drawable;
gboolean non_empty = FALSE; gboolean non_empty = FALSE;
gint32 x1 = 0; gint x1 = 0;
gint32 y1 = 0; gint y1 = 0;
gint32 x2 = 0; gint x2 = 0;
gint32 y2 = 0; gint y2 = 0;
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); 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; GimpValueArray *return_vals;
GimpDrawable *drawable; GimpDrawable *drawable;
gboolean non_empty = FALSE; gboolean non_empty = FALSE;
gint32 x = 0; gint x = 0;
gint32 y = 0; gint y = 0;
gint32 width = 0; gint width = 0;
gint32 height = 0; gint height = 0;
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp);
@ -572,10 +572,10 @@ drawable_update_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
GimpDrawable *drawable; GimpDrawable *drawable;
gint32 x; gint x;
gint32 y; gint y;
gint32 width; gint width;
gint32 height; gint height;
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp);
x = g_value_get_int (gimp_value_array_index (args, 1)); x = g_value_get_int (gimp_value_array_index (args, 1));
@ -603,9 +603,9 @@ drawable_get_pixel_invoker (GimpProcedure *procedure,
gboolean success = TRUE; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpDrawable *drawable; GimpDrawable *drawable;
gint32 x_coord; gint x_coord;
gint32 y_coord; gint y_coord;
gint32 num_channels = 0; gint num_channels = 0;
guint8 *pixel = NULL; guint8 *pixel = NULL;
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); 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; gboolean success = TRUE;
GimpDrawable *drawable; GimpDrawable *drawable;
gint32 x_coord; gint x_coord;
gint32 y_coord; gint y_coord;
gint32 num_channels; gint num_channels;
const guint8 *pixel; const guint8 *pixel;
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp);
@ -696,7 +696,7 @@ drawable_fill_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
GimpDrawable *drawable; GimpDrawable *drawable;
gint32 fill_type; gint fill_type;
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp);
fill_type = g_value_get_enum (gimp_value_array_index (args, 1)); fill_type = g_value_get_enum (gimp_value_array_index (args, 1));
@ -728,9 +728,9 @@ drawable_offset_invoker (GimpProcedure *procedure,
gboolean success = TRUE; gboolean success = TRUE;
GimpDrawable *drawable; GimpDrawable *drawable;
gboolean wrap_around; gboolean wrap_around;
gint32 fill_type; gint fill_type;
gint32 offset_x; gint offset_x;
gint32 offset_y; gint offset_y;
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp);
wrap_around = g_value_get_boolean (gimp_value_array_index (args, 1)); wrap_around = g_value_get_boolean (gimp_value_array_index (args, 1));
@ -764,12 +764,12 @@ drawable_thumbnail_invoker (GimpProcedure *procedure,
gboolean success = TRUE; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpDrawable *drawable; GimpDrawable *drawable;
gint32 width; gint width;
gint32 height; gint height;
gint32 actual_width = 0; gint actual_width = 0;
gint32 actual_height = 0; gint actual_height = 0;
gint32 bpp = 0; gint bpp = 0;
gint32 thumbnail_data_count = 0; gint thumbnail_data_count = 0;
guint8 *thumbnail_data = NULL; guint8 *thumbnail_data = NULL;
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpDrawable *drawable; GimpDrawable *drawable;
gint32 src_x; gint src_x;
gint32 src_y; gint src_y;
gint32 src_width; gint src_width;
gint32 src_height; gint src_height;
gint32 dest_width; gint dest_width;
gint32 dest_height; gint dest_height;
gint32 width = 0; gint width = 0;
gint32 height = 0; gint height = 0;
gint32 bpp = 0; gint bpp = 0;
gint32 thumbnail_data_count = 0; gint thumbnail_data_count = 0;
guint8 *thumbnail_data = NULL; guint8 *thumbnail_data = NULL;
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); 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; gboolean success = TRUE;
GimpDrawable *drawable; GimpDrawable *drawable;
gint32 mode; gint mode;
GimpDrawable *mask; GimpDrawable *mask;
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp);
@ -1237,11 +1237,11 @@ register_drawable_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("bpp", g_param_spec_int ("bpp",
"bpp", "bpp",
"Bytes per pixel", "Bytes per pixel",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -1266,11 +1266,11 @@ register_drawable_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("width", g_param_spec_int ("width",
"width", "width",
"Width of drawable", "Width of drawable",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -1295,11 +1295,11 @@ register_drawable_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("height", g_param_spec_int ("height",
"height", "height",
"Height of drawable", "Height of drawable",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -1324,17 +1324,17 @@ register_drawable_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("offset-x", g_param_spec_int ("offset-x",
"offset x", "offset x",
"x offset of drawable", "x offset of drawable",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("offset-y", g_param_spec_int ("offset-y",
"offset y", "offset y",
"y offset of drawable", "y offset of drawable",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -1366,29 +1366,29 @@ register_drawable_procs (GimpPDB *pdb)
FALSE, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("x1", g_param_spec_int ("x1",
"x1", "x1",
"x coordinate of the upper left corner of selection bounds", "x coordinate of the upper left corner of selection bounds",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("y1", g_param_spec_int ("y1",
"y1", "y1",
"y coordinate of the upper left corner of selection bounds", "y coordinate of the upper left corner of selection bounds",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("x2", g_param_spec_int ("x2",
"x2", "x2",
"x coordinate of the lower right corner of selection bounds", "x coordinate of the lower right corner of selection bounds",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("y2", g_param_spec_int ("y2",
"y2", "y2",
"y coordinate of the lower right corner of selection bounds", "y coordinate of the lower right corner of selection bounds",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -1420,29 +1420,29 @@ register_drawable_procs (GimpPDB *pdb)
FALSE, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("x", g_param_spec_int ("x",
"x", "x",
"x coordinate of the upper left corner of the intersection", "x coordinate of the upper left corner of the intersection",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("y", g_param_spec_int ("y",
"y", "y",
"y coordinate of the upper left corner of the intersection", "y coordinate of the upper left corner of the intersection",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("width", g_param_spec_int ("width",
"width", "width",
"width of the intersection", "width of the intersection",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("height", g_param_spec_int ("height",
"height", "height",
"height of the intersection", "height of the intersection",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -1519,29 +1519,29 @@ register_drawable_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("x", g_param_spec_int ("x",
"x", "x",
"x coordinate of upper left corner of update region", "x coordinate of upper left corner of update region",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("y", g_param_spec_int ("y",
"y", "y",
"y coordinate of upper left corner of update region", "y coordinate of upper left corner of update region",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("width", g_param_spec_int ("width",
"width", "width",
"Width of update region", "Width of update region",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("height", g_param_spec_int ("height",
"height", "height",
"Height of update region", "Height of update region",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -1566,23 +1566,23 @@ register_drawable_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("x-coord", g_param_spec_int ("x-coord",
"x coord", "x coord",
"The x coordinate", "The x coordinate",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("y-coord", g_param_spec_int ("y-coord",
"y coord", "y coord",
"The y coordinate", "The y coordinate",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-channels", g_param_spec_int ("num-channels",
"num channels", "num channels",
"The number of channels for the pixel", "The number of channels for the pixel",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE)); GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int8_array ("pixel", gimp_param_spec_int8_array ("pixel",
"pixel", "pixel",
@ -1612,23 +1612,23 @@ register_drawable_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("x-coord", g_param_spec_int ("x-coord",
"x coord", "x coord",
"The x coordinate", "The x coordinate",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("y-coord", g_param_spec_int ("y-coord",
"y coord", "y coord",
"The y coordinate", "The y coordinate",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("num-channels", g_param_spec_int ("num-channels",
"num channels", "num channels",
"The number of channels for the pixel", "The number of channels for the pixel",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE)); GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int8_array ("pixel", gimp_param_spec_int8_array ("pixel",
"pixel", "pixel",
@ -1702,17 +1702,17 @@ register_drawable_procs (GimpPDB *pdb)
GIMP_OFFSET_BACKGROUND, GIMP_OFFSET_BACKGROUND,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("offset-x", g_param_spec_int ("offset-x",
"offset x", "offset x",
"offset by this amount in X direction", "offset by this amount in X direction",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("offset-y", g_param_spec_int ("offset-y",
"offset y", "offset y",
"offset by this amount in Y direction", "offset by this amount in Y direction",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -1737,41 +1737,41 @@ register_drawable_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("width", g_param_spec_int ("width",
"width", "width",
"The requested thumbnail width", "The requested thumbnail width",
1, 1024, 1, 1, 1024, 1,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("height", g_param_spec_int ("height",
"height", "height",
"The requested thumbnail height", "The requested thumbnail height",
1, 1024, 1, 1, 1024, 1,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("actual-width", g_param_spec_int ("actual-width",
"actual width", "actual width",
"The previews width", "The previews width",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("actual-height", g_param_spec_int ("actual-height",
"actual height", "actual height",
"The previews height", "The previews height",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("bpp", g_param_spec_int ("bpp",
"bpp", "bpp",
"The previews bpp", "The previews bpp",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("thumbnail-data-count", g_param_spec_int ("thumbnail-data-count",
"thumbnail data count", "thumbnail data count",
"The number of bytes in thumbnail data", "The number of bytes in thumbnail data",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int8_array ("thumbnail-data", gimp_param_spec_int8_array ("thumbnail-data",
"thumbnail data", "thumbnail data",
@ -1801,65 +1801,65 @@ register_drawable_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("src-x", g_param_spec_int ("src-x",
"src x", "src x",
"The x coordinate of the area", "The x coordinate of the area",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("src-y", g_param_spec_int ("src-y",
"src y", "src y",
"The y coordinate of the area", "The y coordinate of the area",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("src-width", g_param_spec_int ("src-width",
"src width", "src width",
"The width of the area", "The width of the area",
1, G_MAXINT32, 1, 1, G_MAXINT32, 1,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("src-height", g_param_spec_int ("src-height",
"src height", "src height",
"The height of the area", "The height of the area",
1, G_MAXINT32, 1, 1, G_MAXINT32, 1,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("dest-width", g_param_spec_int ("dest-width",
"dest width", "dest width",
"The thumbnail width", "The thumbnail width",
1, 1024, 1, 1, 1024, 1,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("dest-height", g_param_spec_int ("dest-height",
"dest height", "dest height",
"The thumbnail height", "The thumbnail height",
1, 1024, 1, 1, 1024, 1,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("width", g_param_spec_int ("width",
"width", "width",
"The previews width", "The previews width",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("height", g_param_spec_int ("height",
"height", "height",
"The previews height", "The previews height",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("bpp", g_param_spec_int ("bpp",
"bpp", "bpp",
"The previews bpp", "The previews bpp",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("thumbnail-data-count", g_param_spec_int ("thumbnail-data-count",
"thumbnail data count", "thumbnail data count",
"The number of bytes in thumbnail data", "The number of bytes in thumbnail data",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int8_array ("thumbnail-data", gimp_param_spec_int8_array ("thumbnail-data",
"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; gboolean success = TRUE;
GimpDrawable *drawable; GimpDrawable *drawable;
gint32 transfer_mode; gint transfer_mode;
gboolean preserve_lum; gboolean preserve_lum;
gdouble cyan_red; gdouble cyan_red;
gdouble magenta_green; gdouble magenta_green;
@ -204,8 +204,8 @@ drawable_curves_explicit_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
GimpDrawable *drawable; GimpDrawable *drawable;
gint32 channel; gint channel;
gint32 num_values; gint num_values;
const gdouble *values; const gdouble *values;
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); 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; gboolean success = TRUE;
GimpDrawable *drawable; GimpDrawable *drawable;
gint32 channel; gint channel;
gint32 num_points; gint num_points;
const gdouble *points; const gdouble *points;
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp);
@ -301,7 +301,7 @@ drawable_desaturate_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
GimpDrawable *drawable; GimpDrawable *drawable;
gint32 desaturate_mode; gint desaturate_mode;
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp);
desaturate_mode = g_value_get_enum (gimp_value_array_index (args, 1)); desaturate_mode = g_value_get_enum (gimp_value_array_index (args, 1));
@ -373,7 +373,7 @@ drawable_histogram_invoker (GimpProcedure *procedure,
gboolean success = TRUE; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpDrawable *drawable; GimpDrawable *drawable;
gint32 channel; gint channel;
gdouble start_range; gdouble start_range;
gdouble end_range; gdouble end_range;
gdouble mean = 0.0; gdouble mean = 0.0;
@ -463,7 +463,7 @@ drawable_hue_saturation_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
GimpDrawable *drawable; GimpDrawable *drawable;
gint32 hue_range; gint hue_range;
gdouble hue_offset; gdouble hue_offset;
gdouble lightness; gdouble lightness;
gdouble saturation; gdouble saturation;
@ -553,7 +553,7 @@ drawable_levels_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
GimpDrawable *drawable; GimpDrawable *drawable;
gint32 channel; gint channel;
gdouble low_input; gdouble low_input;
gdouble high_input; gdouble high_input;
gboolean clamp_input; gboolean clamp_input;
@ -649,7 +649,7 @@ drawable_posterize_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
GimpDrawable *drawable; GimpDrawable *drawable;
gint32 levels; gint levels;
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp);
levels = g_value_get_int (gimp_value_array_index (args, 1)); levels = g_value_get_int (gimp_value_array_index (args, 1));
@ -689,7 +689,7 @@ drawable_threshold_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
GimpDrawable *drawable; GimpDrawable *drawable;
gint32 channel; gint channel;
gdouble low_threshold; gdouble low_threshold;
gdouble high_threshold; gdouble high_threshold;
@ -888,11 +888,11 @@ register_drawable_color_procs (GimpPDB *pdb)
GIMP_HISTOGRAM_VALUE, GIMP_HISTOGRAM_VALUE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("num-values", g_param_spec_int ("num-values",
"num values", "num values",
"The number of values in the new curve", "The number of values in the new curve",
256, 2096, 256, 256, 2096, 256,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("values", gimp_param_spec_float_array ("values",
"values", "values",
@ -929,11 +929,11 @@ register_drawable_color_procs (GimpPDB *pdb)
GIMP_HISTOGRAM_VALUE, GIMP_HISTOGRAM_VALUE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("num-points", g_param_spec_int ("num-points",
"num points", "num points",
"The number of values in the control point array", "The number of values in the control point array",
4, 2048, 4, 4, 2048, 4,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("points", gimp_param_spec_float_array ("points",
"points", "points",
@ -1278,11 +1278,11 @@ register_drawable_color_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("levels", g_param_spec_int ("levels",
"levels", "levels",
"Levels of posterization", "Levels of posterization",
2, 255, 2, 2, 255, 2,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (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; gboolean success = TRUE;
GimpDrawable *drawable; GimpDrawable *drawable;
gint32 fill_type; gint fill_type;
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp);
fill_type = g_value_get_enum (gimp_value_array_index (args, 1)); 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; gboolean success = TRUE;
GimpDrawable *drawable; GimpDrawable *drawable;
gint32 fill_type; gint fill_type;
gdouble x; gdouble x;
gdouble y; gdouble y;
@ -196,10 +196,10 @@ drawable_edit_gradient_fill_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
GimpDrawable *drawable; GimpDrawable *drawable;
gint32 gradient_type; gint gradient_type;
gdouble offset; gdouble offset;
gboolean supersample; gboolean supersample;
gint32 supersample_max_depth; gint supersample_max_depth;
gdouble supersample_threshold; gdouble supersample_threshold;
gboolean dither; gboolean dither;
gdouble x1; gdouble x1;
@ -518,11 +518,11 @@ register_drawable_edit_procs (GimpPDB *pdb)
FALSE, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("supersample-max-depth", g_param_spec_int ("supersample-max-depth",
"supersample max depth", "supersample max depth",
"Maximum recursion levels for supersampling", "Maximum recursion levels for supersampling",
1, 9, 1, 1, 9, 1,
GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE)); GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
g_param_spec_double ("supersample-threshold", g_param_spec_double ("supersample-threshold",
"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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *filter; const gchar *filter;
gint32 num_dynamics = 0; gint num_dynamics = 0;
gchar **dynamics_list = NULL; gchar **dynamics_list = NULL;
filter = g_value_get_string (gimp_value_array_index (args, 0)); filter = g_value_get_string (gimp_value_array_index (args, 0));
@ -129,11 +129,11 @@ register_dynamics_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-dynamics", g_param_spec_int ("num-dynamics",
"num dynamics", "num dynamics",
"The number of available paint dynamics", "The number of available paint dynamics",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_string_array ("dynamics-list", gimp_param_spec_string_array ("dynamics-list",
"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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
gint32 run_mode; gint run_mode;
GimpImage *image; GimpImage *image;
const gchar *filename; const gchar *filename;
GimpLayer *layer = NULL; GimpLayer *layer = NULL;
@ -195,10 +195,10 @@ file_load_layers_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
gint32 run_mode; gint run_mode;
GimpImage *image; GimpImage *image;
const gchar *filename; const gchar *filename;
gint32 num_layers = 0; gint num_layers = 0;
gint32 *layer_ids = NULL; gint32 *layer_ids = NULL;
run_mode = g_value_get_enum (gimp_value_array_index (args, 0)); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *filename; const gchar *filename;
gint32 width = 0; gint width = 0;
gint32 height = 0; gint height = 0;
gint32 thumb_data_count = 0; gint thumb_data_count = 0;
guint8 *thumb_data = NULL; guint8 *thumb_data = NULL;
filename = g_value_get_string (gimp_value_array_index (args, 0)); 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; gboolean success = TRUE;
const gchar *procedure_name; const gchar *procedure_name;
gint32 priority; gint priority;
procedure_name = g_value_get_string (gimp_value_array_index (args, 0)); procedure_name = g_value_get_string (gimp_value_array_index (args, 0));
priority = g_value_get_int (gimp_value_array_index (args, 1)); priority = g_value_get_int (gimp_value_array_index (args, 1));
@ -781,11 +781,11 @@ register_fileops_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-layers", g_param_spec_int ("num-layers",
"num layers", "num layers",
"The number of loaded layers", "The number of loaded layers",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32_array ("layer-ids", gimp_param_spec_int32_array ("layer-ids",
"layer ids", "layer ids",
@ -866,23 +866,23 @@ register_fileops_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("width", g_param_spec_int ("width",
"width", "width",
"The width of the thumbnail", "The width of the thumbnail",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("height", g_param_spec_int ("height",
"height", "height",
"The height of the thumbnail", "The height of the thumbnail",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("thumb-data-count", g_param_spec_int ("thumb-data-count",
"thumb data count", "thumb data count",
"The number of bytes in thumbnail data", "The number of bytes in thumbnail data",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int8_array ("thumb-data", gimp_param_spec_int8_array ("thumb-data",
"thumb data", "thumb data",
@ -1064,11 +1064,11 @@ register_fileops_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("priority", g_param_spec_int ("priority",
"priority", "priority",
"The procedure priority.", "The procedure priority.",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *filter; const gchar *filter;
gint32 num_fonts = 0; gint num_fonts = 0;
gchar **font_list = NULL; gchar **font_list = NULL;
filter = g_value_get_string (gimp_value_array_index (args, 0)); filter = g_value_get_string (gimp_value_array_index (args, 0));
@ -136,11 +136,11 @@ register_fonts_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-fonts", g_param_spec_int ("num-fonts",
"num fonts", "num fonts",
"The number of available fonts", "The number of available fonts",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_string_array ("font-list", gimp_param_spec_string_array ("font-list",
"font list", "font list",

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

@ -67,7 +67,7 @@ getpid_invoker (GimpProcedure *procedure,
GError **error) GError **error)
{ {
GimpValueArray *return_vals; GimpValueArray *return_vals;
gint32 pid = 0; gint pid = 0;
pid = gimp_get_pid (); pid = gimp_get_pid ();
@ -187,7 +187,7 @@ get_parasite_list_invoker (GimpProcedure *procedure,
GError **error) GError **error)
{ {
GimpValueArray *return_vals; GimpValueArray *return_vals;
gint32 num_parasites = 0; gint num_parasites = 0;
gchar **parasites = NULL; gchar **parasites = NULL;
parasites = gimp_parasite_list (gimp, &num_parasites); parasites = gimp_parasite_list (gimp, &num_parasites);
@ -277,11 +277,11 @@ register_gimp_procs (GimpPDB *pdb)
"2005", "2005",
NULL); NULL);
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("pid", g_param_spec_int ("pid",
"pid", "pid",
"The PID", "The PID",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -398,11 +398,11 @@ register_gimp_procs (GimpPDB *pdb)
"1999", "1999",
NULL); NULL);
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-parasites", g_param_spec_int ("num-parasites",
"num parasites", "num parasites",
"The number of attached parasites", "The number of attached parasites",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_string_array ("parasites", gimp_param_spec_string_array ("parasites",
"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[] = type_mapping[] =
{ {
{ GIMP_TYPE_INT32, GIMP_PDB_INT32 },
{ G_TYPE_INT, GIMP_PDB_INT32 }, { G_TYPE_INT, GIMP_PDB_INT32 },
{ G_TYPE_UINT, GIMP_PDB_INT32 }, { G_TYPE_UINT, GIMP_PDB_INT32 },
{ G_TYPE_ENUM, 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); 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 * old plug-ins, silently copy stuff into integers when enums
* and booleans are passed * and booleans are passed
*/ */
@ -410,14 +410,11 @@ gimp_pdb_execute_procedure_by_name (GimpPDB *pdb,
&& &&
(value_type == G_TYPE_INT || value_type == G_TYPE_INT
value_type == GIMP_TYPE_INT32)
&& &&
(arg_type == G_TYPE_INT || (arg_type == G_TYPE_BOOLEAN ||
arg_type == GIMP_TYPE_INT32 ||
arg_type == G_TYPE_BOOLEAN ||
g_type_is_a (arg_type, G_TYPE_ENUM))) g_type_is_a (arg_type, G_TYPE_ENUM)))
{ {
arg_type = value_type; 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *name; const gchar *name;
gint32 num_segments = 0; gint num_segments = 0;
name = g_value_get_string (gimp_value_array_index (args, 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *name; const gchar *name;
gint32 num_samples; gint num_samples;
gboolean reverse; gboolean reverse;
gint32 num_color_samples = 0; gint num_color_samples = 0;
gdouble *color_samples = NULL; gdouble *color_samples = NULL;
name = g_value_get_string (gimp_value_array_index (args, 0)); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *name; const gchar *name;
gint32 num_samples; gint num_samples;
const gdouble *positions; const gdouble *positions;
gboolean reverse; gboolean reverse;
gint32 num_color_samples = 0; gint num_color_samples = 0;
gdouble *color_samples = NULL; gdouble *color_samples = NULL;
name = g_value_get_string (gimp_value_array_index (args, 0)); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *name; const gchar *name;
gint32 segment; gint segment;
GimpRGB color = { 0.0, 0.0, 0.0, 1.0 }; GimpRGB color = { 0.0, 0.0, 0.0, 1.0 };
gdouble opacity = 0.0; gdouble opacity = 0.0;
@ -511,7 +511,7 @@ gradient_segment_set_left_color_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
const gchar *name; const gchar *name;
gint32 segment; gint segment;
GimpRGB color; GimpRGB color;
gdouble opacity; gdouble opacity;
@ -552,7 +552,7 @@ gradient_segment_get_right_color_invoker (GimpProcedure *procedure,
gboolean success = TRUE; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *name; const gchar *name;
gint32 segment; gint segment;
GimpRGB color = { 0.0, 0.0, 0.0, 1.0 }; GimpRGB color = { 0.0, 0.0, 0.0, 1.0 };
gdouble opacity = 0.0; gdouble opacity = 0.0;
@ -598,7 +598,7 @@ gradient_segment_set_right_color_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
const gchar *name; const gchar *name;
gint32 segment; gint segment;
GimpRGB color; GimpRGB color;
gdouble opacity; gdouble opacity;
@ -639,7 +639,7 @@ gradient_segment_get_left_pos_invoker (GimpProcedure *procedure,
gboolean success = TRUE; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *name; const gchar *name;
gint32 segment; gint segment;
gdouble pos = 0.0; gdouble pos = 0.0;
name = g_value_get_string (gimp_value_array_index (args, 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *name; const gchar *name;
gint32 segment; gint segment;
gdouble pos; gdouble pos;
gdouble final_pos = 0.0; gdouble final_pos = 0.0;
@ -725,7 +725,7 @@ gradient_segment_get_middle_pos_invoker (GimpProcedure *procedure,
gboolean success = TRUE; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *name; const gchar *name;
gint32 segment; gint segment;
gdouble pos = 0.0; gdouble pos = 0.0;
name = g_value_get_string (gimp_value_array_index (args, 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *name; const gchar *name;
gint32 segment; gint segment;
gdouble pos; gdouble pos;
gdouble final_pos = 0.0; gdouble final_pos = 0.0;
@ -812,7 +812,7 @@ gradient_segment_get_right_pos_invoker (GimpProcedure *procedure,
gboolean success = TRUE; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *name; const gchar *name;
gint32 segment; gint segment;
gdouble pos = 0.0; gdouble pos = 0.0;
name = g_value_get_string (gimp_value_array_index (args, 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *name; const gchar *name;
gint32 segment; gint segment;
gdouble pos; gdouble pos;
gdouble final_pos = 0.0; gdouble final_pos = 0.0;
@ -899,8 +899,8 @@ gradient_segment_get_blending_function_invoker (GimpProcedure *procedure
gboolean success = TRUE; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *name; const gchar *name;
gint32 segment; gint segment;
gint32 blend_func = 0; gint blend_func = 0;
name = g_value_get_string (gimp_value_array_index (args, 0)); name = g_value_get_string (gimp_value_array_index (args, 0));
segment = g_value_get_int (gimp_value_array_index (args, 1)); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *name; const gchar *name;
gint32 segment; gint segment;
gint32 coloring_type = 0; gint coloring_type = 0;
name = g_value_get_string (gimp_value_array_index (args, 0)); name = g_value_get_string (gimp_value_array_index (args, 0));
segment = g_value_get_int (gimp_value_array_index (args, 1)); 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; gboolean success = TRUE;
const gchar *name; const gchar *name;
gint32 start_segment; gint start_segment;
gint32 end_segment; gint end_segment;
gint32 blending_function; gint blending_function;
name = g_value_get_string (gimp_value_array_index (args, 0)); name = g_value_get_string (gimp_value_array_index (args, 0));
start_segment = g_value_get_int (gimp_value_array_index (args, 1)); 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; gboolean success = TRUE;
const gchar *name; const gchar *name;
gint32 start_segment; gint start_segment;
gint32 end_segment; gint end_segment;
gint32 coloring_type; gint coloring_type;
name = g_value_get_string (gimp_value_array_index (args, 0)); name = g_value_get_string (gimp_value_array_index (args, 0));
start_segment = g_value_get_int (gimp_value_array_index (args, 1)); 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; gboolean success = TRUE;
const gchar *name; const gchar *name;
gint32 start_segment; gint start_segment;
gint32 end_segment; gint end_segment;
name = g_value_get_string (gimp_value_array_index (args, 0)); name = g_value_get_string (gimp_value_array_index (args, 0));
start_segment = g_value_get_int (gimp_value_array_index (args, 1)); 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; gboolean success = TRUE;
const gchar *name; const gchar *name;
gint32 start_segment; gint start_segment;
gint32 end_segment; gint end_segment;
gint32 replicate_times; gint replicate_times;
name = g_value_get_string (gimp_value_array_index (args, 0)); name = g_value_get_string (gimp_value_array_index (args, 0));
start_segment = g_value_get_int (gimp_value_array_index (args, 1)); 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; gboolean success = TRUE;
const gchar *name; const gchar *name;
gint32 start_segment; gint start_segment;
gint32 end_segment; gint end_segment;
name = g_value_get_string (gimp_value_array_index (args, 0)); name = g_value_get_string (gimp_value_array_index (args, 0));
start_segment = g_value_get_int (gimp_value_array_index (args, 1)); 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; gboolean success = TRUE;
const gchar *name; const gchar *name;
gint32 start_segment; gint start_segment;
gint32 end_segment; gint end_segment;
gint32 split_parts; gint split_parts;
name = g_value_get_string (gimp_value_array_index (args, 0)); name = g_value_get_string (gimp_value_array_index (args, 0));
start_segment = g_value_get_int (gimp_value_array_index (args, 1)); 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; gboolean success = TRUE;
const gchar *name; const gchar *name;
gint32 start_segment; gint start_segment;
gint32 end_segment; gint end_segment;
name = g_value_get_string (gimp_value_array_index (args, 0)); name = g_value_get_string (gimp_value_array_index (args, 0));
start_segment = g_value_get_int (gimp_value_array_index (args, 1)); 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; gboolean success = TRUE;
const gchar *name; const gchar *name;
gint32 start_segment; gint start_segment;
gint32 end_segment; gint end_segment;
name = g_value_get_string (gimp_value_array_index (args, 0)); name = g_value_get_string (gimp_value_array_index (args, 0));
start_segment = g_value_get_int (gimp_value_array_index (args, 1)); 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; gboolean success = TRUE;
const gchar *name; const gchar *name;
gint32 start_segment; gint start_segment;
gint32 end_segment; gint end_segment;
name = g_value_get_string (gimp_value_array_index (args, 0)); name = g_value_get_string (gimp_value_array_index (args, 0));
start_segment = g_value_get_int (gimp_value_array_index (args, 1)); 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; gboolean success = TRUE;
const gchar *name; const gchar *name;
gint32 start_segment; gint start_segment;
gint32 end_segment; gint end_segment;
name = g_value_get_string (gimp_value_array_index (args, 0)); name = g_value_get_string (gimp_value_array_index (args, 0));
start_segment = g_value_get_int (gimp_value_array_index (args, 1)); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *name; const gchar *name;
gint32 start_segment; gint start_segment;
gint32 end_segment; gint end_segment;
gdouble delta; gdouble delta;
gboolean control_compress; gboolean control_compress;
gdouble final_delta = 0.0; gdouble final_delta = 0.0;
@ -1626,11 +1626,11 @@ register_gradient_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-segments", g_param_spec_int ("num-segments",
"num segments", "num segments",
"Number of segments", "Number of segments",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -1656,11 +1656,11 @@ register_gradient_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("num-samples", g_param_spec_int ("num-samples",
"num samples", "num samples",
"The number of samples to take", "The number of samples to take",
2, G_MAXINT32, 2, 2, G_MAXINT32, 2,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("reverse", g_param_spec_boolean ("reverse",
"reverse", "reverse",
@ -1668,11 +1668,11 @@ register_gradient_procs (GimpPDB *pdb)
FALSE, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-color-samples", g_param_spec_int ("num-color-samples",
"num color samples", "num color samples",
"Length of the color_samples array (4 * num_samples)", "Length of the color_samples array (4 * num_samples)",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_float_array ("color-samples", gimp_param_spec_float_array ("color-samples",
"color samples", "color samples",
@ -1703,11 +1703,11 @@ register_gradient_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("num-samples", g_param_spec_int ("num-samples",
"num samples", "num samples",
"The number of samples to take", "The number of samples to take",
1, G_MAXINT32, 1, 1, G_MAXINT32, 1,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("positions", gimp_param_spec_float_array ("positions",
"positions", "positions",
@ -1720,11 +1720,11 @@ register_gradient_procs (GimpPDB *pdb)
FALSE, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-color-samples", g_param_spec_int ("num-color-samples",
"num color samples", "num color samples",
"Length of the color_samples array (4 * num_samples)", "Length of the color_samples array (4 * num_samples)",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_float_array ("color-samples", gimp_param_spec_float_array ("color-samples",
"color samples", "color samples",
@ -1755,11 +1755,11 @@ register_gradient_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("segment", g_param_spec_int ("segment",
"segment", "segment",
"The index of the segment within the gradient", "The index of the segment within the gradient",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_rgb ("color", gimp_param_spec_rgb ("color",
"color", "color",
@ -1798,11 +1798,11 @@ register_gradient_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("segment", g_param_spec_int ("segment",
"segment", "segment",
"The index of the segment within the gradient", "The index of the segment within the gradient",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_rgb ("color", gimp_param_spec_rgb ("color",
"color", "color",
@ -1841,11 +1841,11 @@ register_gradient_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("segment", g_param_spec_int ("segment",
"segment", "segment",
"The index of the segment within the gradient", "The index of the segment within the gradient",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_rgb ("color", gimp_param_spec_rgb ("color",
"color", "color",
@ -1884,11 +1884,11 @@ register_gradient_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("segment", g_param_spec_int ("segment",
"segment", "segment",
"The index of the segment within the gradient", "The index of the segment within the gradient",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_rgb ("color", gimp_param_spec_rgb ("color",
"color", "color",
@ -1927,11 +1927,11 @@ register_gradient_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("segment", g_param_spec_int ("segment",
"segment", "segment",
"The index of the segment within the gradient", "The index of the segment within the gradient",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
g_param_spec_double ("pos", g_param_spec_double ("pos",
"pos", "pos",
@ -1964,11 +1964,11 @@ register_gradient_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("segment", g_param_spec_int ("segment",
"segment", "segment",
"The index of the segment within the gradient", "The index of the segment within the gradient",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
g_param_spec_double ("pos", g_param_spec_double ("pos",
"pos", "pos",
@ -2006,11 +2006,11 @@ register_gradient_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("segment", g_param_spec_int ("segment",
"segment", "segment",
"The index of the segment within the gradient", "The index of the segment within the gradient",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
g_param_spec_double ("pos", g_param_spec_double ("pos",
"pos", "pos",
@ -2043,11 +2043,11 @@ register_gradient_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("segment", g_param_spec_int ("segment",
"segment", "segment",
"The index of the segment within the gradient", "The index of the segment within the gradient",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
g_param_spec_double ("pos", g_param_spec_double ("pos",
"pos", "pos",
@ -2085,11 +2085,11 @@ register_gradient_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("segment", g_param_spec_int ("segment",
"segment", "segment",
"The index of the segment within the gradient", "The index of the segment within the gradient",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
g_param_spec_double ("pos", g_param_spec_double ("pos",
"pos", "pos",
@ -2122,11 +2122,11 @@ register_gradient_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("segment", g_param_spec_int ("segment",
"segment", "segment",
"The index of the segment within the gradient", "The index of the segment within the gradient",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
g_param_spec_double ("pos", g_param_spec_double ("pos",
"pos", "pos",
@ -2164,11 +2164,11 @@ register_gradient_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("segment", g_param_spec_int ("segment",
"segment", "segment",
"The index of the segment within the gradient", "The index of the segment within the gradient",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
g_param_spec_enum ("blend-func", g_param_spec_enum ("blend-func",
"blend func", "blend func",
@ -2201,11 +2201,11 @@ register_gradient_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("segment", g_param_spec_int ("segment",
"segment", "segment",
"The index of the segment within the gradient", "The index of the segment within the gradient",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
g_param_spec_enum ("coloring-type", g_param_spec_enum ("coloring-type",
"coloring type", "coloring type",
@ -2238,17 +2238,17 @@ register_gradient_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("start-segment", g_param_spec_int ("start-segment",
"start segment", "start segment",
"The index of the first segment to operate on", "The index of the first segment to operate on",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("end-segment", g_param_spec_int ("end-segment",
"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.", "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, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
g_param_spec_enum ("blending-function", g_param_spec_enum ("blending-function",
"blending function", "blending function",
@ -2281,17 +2281,17 @@ register_gradient_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("start-segment", g_param_spec_int ("start-segment",
"start segment", "start segment",
"The index of the first segment to operate on", "The index of the first segment to operate on",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("end-segment", g_param_spec_int ("end-segment",
"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.", "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, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
g_param_spec_enum ("coloring-type", g_param_spec_enum ("coloring-type",
"coloring type", "coloring type",
@ -2324,17 +2324,17 @@ register_gradient_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("start-segment", g_param_spec_int ("start-segment",
"start segment", "start segment",
"The index of the first segment to operate on", "The index of the first segment to operate on",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("end-segment", g_param_spec_int ("end-segment",
"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.", "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, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -2360,23 +2360,23 @@ register_gradient_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("start-segment", g_param_spec_int ("start-segment",
"start segment", "start segment",
"The index of the first segment to operate on", "The index of the first segment to operate on",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("end-segment", g_param_spec_int ("end-segment",
"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.", "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, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("replicate-times", g_param_spec_int ("replicate-times",
"replicate times", "replicate times",
"The number of times to replicate", "The number of times to replicate",
2, 20, 2, 2, 20, 2,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -2402,17 +2402,17 @@ register_gradient_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("start-segment", g_param_spec_int ("start-segment",
"start segment", "start segment",
"The index of the first segment to operate on", "The index of the first segment to operate on",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("end-segment", g_param_spec_int ("end-segment",
"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.", "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, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -2438,23 +2438,23 @@ register_gradient_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("start-segment", g_param_spec_int ("start-segment",
"start segment", "start segment",
"The index of the first segment to operate on", "The index of the first segment to operate on",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("end-segment", g_param_spec_int ("end-segment",
"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.", "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, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("split-parts", g_param_spec_int ("split-parts",
"split parts", "split parts",
"The number of uniform divisions to split each segment to", "The number of uniform divisions to split each segment to",
2, 1024, 2, 2, 1024, 2,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -2480,17 +2480,17 @@ register_gradient_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("start-segment", g_param_spec_int ("start-segment",
"start segment", "start segment",
"The index of the first segment to operate on", "The index of the first segment to operate on",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("end-segment", g_param_spec_int ("end-segment",
"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.", "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, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -2516,17 +2516,17 @@ register_gradient_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("start-segment", g_param_spec_int ("start-segment",
"start segment", "start segment",
"The index of the first segment to operate on", "The index of the first segment to operate on",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("end-segment", g_param_spec_int ("end-segment",
"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.", "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, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -2552,17 +2552,17 @@ register_gradient_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("start-segment", g_param_spec_int ("start-segment",
"start segment", "start segment",
"The index of the first segment to operate on", "The index of the first segment to operate on",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("end-segment", g_param_spec_int ("end-segment",
"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.", "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, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -2588,17 +2588,17 @@ register_gradient_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("start-segment", g_param_spec_int ("start-segment",
"start segment", "start segment",
"The index of the first segment to operate on", "The index of the first segment to operate on",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("end-segment", g_param_spec_int ("end-segment",
"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.", "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, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -2624,17 +2624,17 @@ register_gradient_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("start-segment", g_param_spec_int ("start-segment",
"start segment", "start segment",
"The index of the first segment to operate on", "The index of the first segment to operate on",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("end-segment", g_param_spec_int ("end-segment",
"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.", "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, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
g_param_spec_double ("delta", g_param_spec_double ("delta",
"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 *gradient_callback;
const gchar *popup_title; const gchar *popup_title;
const gchar *initial_gradient; const gchar *initial_gradient;
gint32 sample_size; gint sample_size;
gradient_callback = g_value_get_string (gimp_value_array_index (args, 0)); gradient_callback = g_value_get_string (gimp_value_array_index (args, 0));
popup_title = g_value_get_string (gimp_value_array_index (args, 1)); popup_title = g_value_get_string (gimp_value_array_index (args, 1));
@ -171,11 +171,11 @@ register_gradient_select_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("sample-size", g_param_spec_int ("sample-size",
"sample size", "sample size",
"Size of the sample to return when the gradient is changed", "Size of the sample to return when the gradient is changed",
1, 10000, 1, 1, 10000, 1,
GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE)); GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *filter; const gchar *filter;
gint32 num_gradients = 0; gint num_gradients = 0;
gchar **gradient_list = NULL; gchar **gradient_list = NULL;
filter = g_value_get_string (gimp_value_array_index (args, 0)); filter = g_value_get_string (gimp_value_array_index (args, 0));
@ -133,11 +133,11 @@ register_gradients_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-gradients", g_param_spec_int ("num-gradients",
"num gradients", "num gradients",
"The number of loaded gradients", "The number of loaded gradients",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_string_array ("gradient-list", gimp_param_spec_string_array ("gradient-list",
"gradient list", "gradient list",

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

@ -109,7 +109,7 @@ image_list_invoker (GimpProcedure *procedure,
GError **error) GError **error)
{ {
GimpValueArray *return_vals; GimpValueArray *return_vals;
gint32 num_images = 0; gint num_images = 0;
gint32 *image_ids = NULL; gint32 *image_ids = NULL;
GList *list = gimp_get_image_iter (gimp); GList *list = gimp_get_image_iter (gimp);
@ -144,9 +144,9 @@ image_new_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
gint32 width; gint width;
gint32 height; gint height;
gint32 type; gint type;
GimpImage *image = NULL; GimpImage *image = NULL;
width = g_value_get_int (gimp_value_array_index (args, 0)); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
gint32 width; gint width;
gint32 height; gint height;
gint32 type; gint type;
gint32 precision; gint precision;
GimpImage *image = NULL; GimpImage *image = NULL;
width = g_value_get_int (gimp_value_array_index (args, 0)); width = g_value_get_int (gimp_value_array_index (args, 0));
@ -282,7 +282,7 @@ image_base_type_invoker (GimpProcedure *procedure,
gboolean success = TRUE; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpImage *image; GimpImage *image;
gint32 base_type = 0; gint base_type = 0;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpImage *image; GimpImage *image;
gint32 precision = 0; gint precision = 0;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpImage *image; GimpImage *image;
gint32 mode = 0; gint mode = 0;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
@ -369,7 +369,7 @@ image_width_invoker (GimpProcedure *procedure,
gboolean success = TRUE; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpImage *image; GimpImage *image;
gint32 width = 0; gint width = 0;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
@ -398,7 +398,7 @@ image_height_invoker (GimpProcedure *procedure,
gboolean success = TRUE; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpImage *image; GimpImage *image;
gint32 height = 0; gint height = 0;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpImage *image; GimpImage *image;
gint32 num_layers = 0; gint num_layers = 0;
gint32 *layer_ids = NULL; gint32 *layer_ids = NULL;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpImage *image; GimpImage *image;
gint32 num_channels = 0; gint num_channels = 0;
gint32 *channel_ids = NULL; gint32 *channel_ids = NULL;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpImage *image; GimpImage *image;
gint32 num_vectors = 0; gint num_vectors = 0;
gint32 *vector_ids = NULL; gint32 *vector_ids = NULL;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpImage *image; GimpImage *image;
gint32 x; gint x;
gint32 y; gint y;
GimpLayer *layer = NULL; GimpLayer *layer = NULL;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
@ -777,7 +777,7 @@ image_insert_layer_invoker (GimpProcedure *procedure,
GimpImage *image; GimpImage *image;
GimpLayer *layer; GimpLayer *layer;
GimpLayer *parent; GimpLayer *parent;
gint32 position; gint position;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
layer = gimp_value_get_layer (gimp_value_array_index (args, 1), 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; GimpImage *image;
GimpChannel *channel; GimpChannel *channel;
GimpChannel *parent; GimpChannel *parent;
gint32 position; gint position;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
channel = gimp_value_get_channel (gimp_value_array_index (args, 1), 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; GimpImage *image;
GimpVectors *vectors; GimpVectors *vectors;
GimpVectors *parent; GimpVectors *parent;
gint32 position; gint position;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
vectors = gimp_value_get_vectors (gimp_value_array_index (args, 1), 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; GimpValueArray *return_vals;
GimpImage *image; GimpImage *image;
GimpItem *item; GimpItem *item;
gint32 position = 0; gint position = 0;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
item = gimp_value_get_item (gimp_value_array_index (args, 1), 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; GimpImage *image;
GimpItem *item; GimpItem *item;
GimpItem *parent; GimpItem *parent;
gint32 position; gint position;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
item = gimp_value_get_item (gimp_value_array_index (args, 1), 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpImage *image; GimpImage *image;
gint32 merge_type; gint merge_type;
GimpLayer *layer = NULL; GimpLayer *layer = NULL;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); 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; GimpValueArray *return_vals;
GimpImage *image; GimpImage *image;
GimpLayer *merge_layer; GimpLayer *merge_layer;
gint32 merge_type; gint merge_type;
GimpLayer *layer = NULL; GimpLayer *layer = NULL;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpImage *image; GimpImage *image;
gint32 num_bytes = 0; gint num_bytes = 0;
guint8 *colormap = NULL; guint8 *colormap = NULL;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); 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; gboolean success = TRUE;
GimpImage *image; GimpImage *image;
gint32 num_bytes; gint num_bytes;
const guint8 *colormap; const guint8 *colormap;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
@ -1636,12 +1636,12 @@ image_thumbnail_invoker (GimpProcedure *procedure,
gboolean success = TRUE; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpImage *image; GimpImage *image;
gint32 width; gint width;
gint32 height; gint height;
gint32 actual_width = 0; gint actual_width = 0;
gint32 actual_height = 0; gint actual_height = 0;
gint32 bpp = 0; gint bpp = 0;
gint32 thumbnail_data_count = 0; gint thumbnail_data_count = 0;
guint8 *thumbnail_data = NULL; guint8 *thumbnail_data = NULL;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpImage *image; GimpImage *image;
gint32 component; gint component;
gboolean active = FALSE; gboolean active = FALSE;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); 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; gboolean success = TRUE;
GimpImage *image; GimpImage *image;
gint32 component; gint component;
gboolean active; gboolean active;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpImage *image; GimpImage *image;
gint32 component; gint component;
gboolean visible = FALSE; gboolean visible = FALSE;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); 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; gboolean success = TRUE;
GimpImage *image; GimpImage *image;
gint32 component; gint component;
gboolean visible; gboolean visible;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpImage *image; GimpImage *image;
gint32 tattoo_state = 0; gint tattoo_state = 0;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); 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; gboolean success = TRUE;
GimpImage *image; GimpImage *image;
gint32 tattoo_state; gint tattoo_state;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
tattoo_state = g_value_get_uint (gimp_value_array_index (args, 1)); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpImage *image; GimpImage *image;
gint32 tattoo; gint tattoo;
GimpLayer *layer = NULL; GimpLayer *layer = NULL;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpImage *image; GimpImage *image;
gint32 tattoo; gint tattoo;
GimpChannel *channel = NULL; GimpChannel *channel = NULL;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpImage *image; GimpImage *image;
gint32 tattoo; gint tattoo;
GimpVectors *vectors = NULL; GimpVectors *vectors = NULL;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpImage *image; GimpImage *image;
gint32 num_parasites = 0; gint num_parasites = 0;
gchar **parasites = NULL; gchar **parasites = NULL;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
@ -2807,11 +2807,11 @@ register_image_procs (GimpPDB *pdb)
"1995-1996", "1995-1996",
NULL); NULL);
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-images", g_param_spec_int ("num-images",
"num images", "num images",
"The number of images currently open", "The number of images currently open",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32_array ("image-ids", gimp_param_spec_int32_array ("image-ids",
"image ids", "image ids",
@ -2837,17 +2837,17 @@ register_image_procs (GimpPDB *pdb)
"1995-1996", "1995-1996",
NULL); NULL);
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("width", g_param_spec_int ("width",
"width", "width",
"The width of the image", "The width of the image",
1, GIMP_MAX_IMAGE_SIZE, 1, 1, GIMP_MAX_IMAGE_SIZE, 1,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("height", g_param_spec_int ("height",
"height", "height",
"The height of the image", "The height of the image",
1, GIMP_MAX_IMAGE_SIZE, 1, 1, GIMP_MAX_IMAGE_SIZE, 1,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
g_param_spec_enum ("type", g_param_spec_enum ("type",
"type", "type",
@ -2879,17 +2879,17 @@ register_image_procs (GimpPDB *pdb)
"2012", "2012",
NULL); NULL);
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("width", g_param_spec_int ("width",
"width", "width",
"The width of the image", "The width of the image",
1, GIMP_MAX_IMAGE_SIZE, 1, 1, GIMP_MAX_IMAGE_SIZE, 1,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("height", g_param_spec_int ("height",
"height", "height",
"The height of the image", "The height of the image",
1, GIMP_MAX_IMAGE_SIZE, 1, 1, GIMP_MAX_IMAGE_SIZE, 1,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
g_param_spec_enum ("type", g_param_spec_enum ("type",
"type", "type",
@ -3076,11 +3076,11 @@ register_image_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("width", g_param_spec_int ("width",
"width", "width",
"The image's width", "The image's width",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -3105,11 +3105,11 @@ register_image_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("height", g_param_spec_int ("height",
"height", "height",
"The image's height", "The image's height",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -3134,11 +3134,11 @@ register_image_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-layers", g_param_spec_int ("num-layers",
"num layers", "num layers",
"The number of layers contained in the image", "The number of layers contained in the image",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32_array ("layer-ids", gimp_param_spec_int32_array ("layer-ids",
"layer ids", "layer ids",
@ -3168,11 +3168,11 @@ register_image_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-channels", g_param_spec_int ("num-channels",
"num channels", "num channels",
"The number of channels contained in the image", "The number of channels contained in the image",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32_array ("channel-ids", gimp_param_spec_int32_array ("channel-ids",
"channel ids", "channel ids",
@ -3202,11 +3202,11 @@ register_image_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-vectors", g_param_spec_int ("num-vectors",
"num vectors", "num vectors",
"The number of vectors contained in the image", "The number of vectors contained in the image",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32_array ("vector-ids", gimp_param_spec_int32_array ("vector-ids",
"vector ids", "vector ids",
@ -3412,17 +3412,17 @@ register_image_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("x", g_param_spec_int ("x",
"x", "x",
"The x coordinate for the pick", "The x coordinate for the pick",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("y", g_param_spec_int ("y",
"y", "y",
"The y coordinate for the pick", "The y coordinate for the pick",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_layer_id ("layer", gimp_param_spec_layer_id ("layer",
"layer", "layer",
@ -3465,11 +3465,11 @@ register_image_procs (GimpPDB *pdb)
pdb->gimp, TRUE, pdb->gimp, TRUE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("position", g_param_spec_int ("position",
"position", "position",
"The layer position", "The layer position",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -3585,11 +3585,11 @@ register_image_procs (GimpPDB *pdb)
pdb->gimp, TRUE, pdb->gimp, TRUE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("position", g_param_spec_int ("position",
"position", "position",
"The channel position", "The channel position",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -3705,11 +3705,11 @@ register_image_procs (GimpPDB *pdb)
pdb->gimp, TRUE, pdb->gimp, TRUE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("position", g_param_spec_int ("position",
"position", "position",
"The vectors position", "The vectors position",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -3819,11 +3819,11 @@ register_image_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("position", g_param_spec_int ("position",
"position", "position",
"The position of the item in its level in the item tree", "The position of the item in its level in the item tree",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -3976,11 +3976,11 @@ register_image_procs (GimpPDB *pdb)
pdb->gimp, TRUE, pdb->gimp, TRUE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("position", g_param_spec_int ("position",
"position", "position",
"The new position of the item", "The new position of the item",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -4116,11 +4116,11 @@ register_image_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-bytes", g_param_spec_int ("num-bytes",
"num bytes", "num bytes",
"Number of bytes in the colormap array", "Number of bytes in the colormap array",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int8_array ("colormap", gimp_param_spec_int8_array ("colormap",
"colormap", "colormap",
@ -4150,11 +4150,11 @@ register_image_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("num-bytes", g_param_spec_int ("num-bytes",
"num bytes", "num bytes",
"Number of bytes in the colormap array", "Number of bytes in the colormap array",
0, 768, 0, 0, 768, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int8_array ("colormap", gimp_param_spec_int8_array ("colormap",
"colormap", "colormap",
@ -4296,41 +4296,41 @@ register_image_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("width", g_param_spec_int ("width",
"width", "width",
"The requested thumbnail width", "The requested thumbnail width",
1, 1024, 1, 1, 1024, 1,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("height", g_param_spec_int ("height",
"height", "height",
"The requested thumbnail height", "The requested thumbnail height",
1, 1024, 1, 1, 1024, 1,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("actual-width", g_param_spec_int ("actual-width",
"actual width", "actual width",
"The previews width", "The previews width",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("actual-height", g_param_spec_int ("actual-height",
"actual height", "actual height",
"The previews height", "The previews height",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("bpp", g_param_spec_int ("bpp",
"bpp", "bpp",
"The previews bpp", "The previews bpp",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("thumbnail-data-count", g_param_spec_int ("thumbnail-data-count",
"thumbnail data count", "thumbnail data count",
"The number of bytes in thumbnail data", "The number of bytes in thumbnail data",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int8_array ("thumbnail-data", gimp_param_spec_int8_array ("thumbnail-data",
"thumbnail data", "thumbnail data",
@ -5413,11 +5413,11 @@ register_image_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-parasites", g_param_spec_int ("num-parasites",
"num parasites", "num parasites",
"The number of attached parasites", "The number of attached parasites",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_string_array ("parasites", gimp_param_spec_string_array ("parasites",
"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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpImage *image; GimpImage *image;
gint32 num_bytes = 0; gint num_bytes = 0;
guint8 *profile_data = NULL; guint8 *profile_data = NULL;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpImage *image; GimpImage *image;
gint32 num_bytes = 0; gint num_bytes = 0;
guint8 *profile_data = NULL; guint8 *profile_data = NULL;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); 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; gboolean success = TRUE;
GimpImage *image; GimpImage *image;
gint32 num_bytes; gint num_bytes;
const guint8 *color_profile; const guint8 *color_profile;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); 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; gboolean success = TRUE;
GimpImage *image; GimpImage *image;
gint32 num_bytes; gint num_bytes;
const guint8 *color_profile; const guint8 *color_profile;
gint32 intent; gint intent;
gboolean bpc; gboolean bpc;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); 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; gboolean success = TRUE;
GimpImage *image; GimpImage *image;
const gchar *uri; const gchar *uri;
gint32 intent; gint intent;
gboolean bpc; gboolean bpc;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); 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, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-bytes", g_param_spec_int ("num-bytes",
"num bytes", "num bytes",
"Number of bytes in the color_profile array", "Number of bytes in the color_profile array",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int8_array ("profile-data", gimp_param_spec_int8_array ("profile-data",
"profile data", "profile data",
@ -384,11 +384,11 @@ register_image_color_profile_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-bytes", g_param_spec_int ("num-bytes",
"num bytes", "num bytes",
"Number of bytes in the color_profile array", "Number of bytes in the color_profile array",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int8_array ("profile-data", gimp_param_spec_int8_array ("profile-data",
"profile data", "profile data",
@ -418,11 +418,11 @@ register_image_color_profile_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("num-bytes", g_param_spec_int ("num-bytes",
"num bytes", "num bytes",
"Number of bytes in the color_profile array", "Number of bytes in the color_profile array",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int8_array ("color-profile", gimp_param_spec_int8_array ("color-profile",
"color profile", "color profile",
@ -482,11 +482,11 @@ register_image_color_profile_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("num-bytes", g_param_spec_int ("num-bytes",
"num bytes", "num bytes",
"Number of bytes in the color_profile array", "Number of bytes in the color_profile array",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int8_array ("color-profile", gimp_param_spec_int8_array ("color-profile",
"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; gboolean success = TRUE;
GimpImage *image; GimpImage *image;
gint32 dither_type; gint dither_type;
gint32 palette_type; gint palette_type;
gint32 num_cols; gint num_cols;
gboolean alpha_dither; gboolean alpha_dither;
gboolean remove_unused; gboolean remove_unused;
const gchar *palette; const gchar *palette;
@ -194,9 +194,9 @@ image_convert_set_dither_matrix_invoker (GimpProcedure *procedure,
GError **error) GError **error)
{ {
gboolean success = TRUE; gboolean success = TRUE;
gint32 width; gint width;
gint32 height; gint height;
gint32 matrix_length; gint matrix_length;
const guint8 *matrix; const guint8 *matrix;
width = g_value_get_int (gimp_value_array_index (args, 0)); width = g_value_get_int (gimp_value_array_index (args, 0));
@ -233,7 +233,7 @@ image_convert_precision_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
GimpImage *image; GimpImage *image;
gint32 precision; gint precision;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
precision = g_value_get_enum (gimp_value_array_index (args, 1)); 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_CONVERT_PALETTE_GENERATE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("num-cols", g_param_spec_int ("num-cols",
"num cols", "num cols",
"The number of colors to quantize to, ignored unless (palette_type == GIMP_CONVERT_PALETTE_GENERATE)", "The number of colors to quantize to, ignored unless (palette_type == GIMP_CONVERT_PALETTE_GENERATE)",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("alpha-dither", g_param_spec_boolean ("alpha-dither",
"alpha dither", "alpha dither",
@ -388,23 +388,23 @@ register_image_convert_procs (GimpPDB *pdb)
"2006", "2006",
NULL); NULL);
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("width", g_param_spec_int ("width",
"width", "width",
"Width of the matrix (0 to reset to default matrix)", "Width of the matrix (0 to reset to default matrix)",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("height", g_param_spec_int ("height",
"height", "height",
"Height of the matrix (0 to reset to default matrix)", "Height of the matrix (0 to reset to default matrix)",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("matrix-length", g_param_spec_int ("matrix-length",
"matrix length", "matrix length",
"The length of 'matrix'", "The length of 'matrix'",
1, 1024, 1, 1, 1024, 1,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int8_array ("matrix", gimp_param_spec_int8_array ("matrix",
"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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpImage *image; GimpImage *image;
gint32 style = 0; gint style = 0;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); 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; gboolean success = TRUE;
GimpImage *image; GimpImage *image;
gint32 style; gint style;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
style = g_value_get_enum (gimp_value_array_index (args, 1)); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpImage *image; GimpImage *image;
gint32 yposition; gint yposition;
gint32 guide = 0; gint guide = 0;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
yposition = g_value_get_int (gimp_value_array_index (args, 1)); yposition = g_value_get_int (gimp_value_array_index (args, 1));
@ -93,8 +93,8 @@ image_add_vguide_invoker (GimpProcedure *procedure,
gboolean success = TRUE; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpImage *image; GimpImage *image;
gint32 xposition; gint xposition;
gint32 guide = 0; gint guide = 0;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
xposition = g_value_get_int (gimp_value_array_index (args, 1)); xposition = g_value_get_int (gimp_value_array_index (args, 1));
@ -131,7 +131,7 @@ image_delete_guide_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
GimpImage *image; GimpImage *image;
gint32 guide; gint guide;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
guide = g_value_get_uint (gimp_value_array_index (args, 1)); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpImage *image; GimpImage *image;
gint32 guide; gint guide;
gint32 next_guide = 0; gint next_guide = 0;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
guide = g_value_get_uint (gimp_value_array_index (args, 1)); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpImage *image; GimpImage *image;
gint32 guide; gint guide;
gint32 orientation = 0; gint orientation = 0;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
guide = g_value_get_uint (gimp_value_array_index (args, 1)); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpImage *image; GimpImage *image;
gint32 guide; gint guide;
gint32 position = 0; gint position = 0;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
guide = g_value_get_uint (gimp_value_array_index (args, 1)); guide = g_value_get_uint (gimp_value_array_index (args, 1));
@ -289,11 +289,11 @@ register_image_guides_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("yposition", g_param_spec_int ("yposition",
"yposition", "yposition",
"The guide's y-offset from top of image", "The guide's y-offset from top of image",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
g_param_spec_uint ("guide", g_param_spec_uint ("guide",
"guide", "guide",
@ -324,11 +324,11 @@ register_image_guides_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("xposition", g_param_spec_int ("xposition",
"xposition", "xposition",
"The guide's x-offset from left of image", "The guide's x-offset from left of image",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
g_param_spec_uint ("guide", g_param_spec_uint ("guide",
"guide", "guide",
@ -467,11 +467,11 @@ register_image_guides_procs (GimpPDB *pdb)
1, G_MAXUINT32, 1, 1, G_MAXUINT32, 1,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("position", g_param_spec_int ("position",
"position", "position",
"The guide's position relative to top or left of image", "The guide's position relative to top or left of image",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpImage *image; GimpImage *image;
gint32 position_x; gint position_x;
gint32 position_y; gint position_y;
gint32 sample_point = 0; gint sample_point = 0;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
position_x = g_value_get_int (gimp_value_array_index (args, 1)); 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; gboolean success = TRUE;
GimpImage *image; GimpImage *image;
gint32 sample_point; gint sample_point;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
sample_point = g_value_get_uint (gimp_value_array_index (args, 1)); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpImage *image; GimpImage *image;
gint32 sample_point; gint sample_point;
gint32 next_sample_point = 0; gint next_sample_point = 0;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
sample_point = g_value_get_uint (gimp_value_array_index (args, 1)); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpImage *image; GimpImage *image;
gint32 sample_point; gint sample_point;
gint32 position_x = 0; gint position_x = 0;
gint32 position_y = 0; gint position_y = 0;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
sample_point = g_value_get_uint (gimp_value_array_index (args, 1)); 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, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("position-x", g_param_spec_int ("position-x",
"position x", "position x",
"The guide'sample points x-offset from left of image", "The guide'sample points x-offset from left of image",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("position-y", g_param_spec_int ("position-y",
"position y", "position y",
"The guide'sample points y-offset from top of image", "The guide'sample points y-offset from top of image",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
g_param_spec_uint ("sample-point", g_param_spec_uint ("sample-point",
"sample point", "sample point",
@ -334,17 +334,17 @@ register_image_sample_points_procs (GimpPDB *pdb)
1, G_MAXUINT32, 1, 1, G_MAXUINT32, 1,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("position-x", g_param_spec_int ("position-x",
"position x", "position x",
"The sample points's position relative to top of image", "The sample points's position relative to top of image",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("position-y", g_param_spec_int ("position-y",
"position y", "position y",
"The sample points's position relative to top of image", "The sample points's position relative to top of image",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (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; gboolean success = TRUE;
GimpImage *image; GimpImage *image;
gint32 operation; gint operation;
GimpDrawable *drawable; GimpDrawable *drawable;
GimpRGB color; GimpRGB color;
@ -103,7 +103,7 @@ image_select_contiguous_color_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
GimpImage *image; GimpImage *image;
gint32 operation; gint operation;
GimpDrawable *drawable; GimpDrawable *drawable;
gdouble x; gdouble x;
gdouble y; gdouble y;
@ -154,7 +154,7 @@ image_select_rectangle_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
GimpImage *image; GimpImage *image;
gint32 operation; gint operation;
gdouble x; gdouble x;
gdouble y; gdouble y;
gdouble width; gdouble width;
@ -195,7 +195,7 @@ image_select_round_rectangle_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
GimpImage *image; GimpImage *image;
gint32 operation; gint operation;
gdouble x; gdouble x;
gdouble y; gdouble y;
gdouble width; gdouble width;
@ -243,7 +243,7 @@ image_select_ellipse_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
GimpImage *image; GimpImage *image;
gint32 operation; gint operation;
gdouble x; gdouble x;
gdouble y; gdouble y;
gdouble width; gdouble width;
@ -285,8 +285,8 @@ image_select_polygon_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
GimpImage *image; GimpImage *image;
gint32 operation; gint operation;
gint32 num_segs; gint num_segs;
const gdouble *segs; const gdouble *segs;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); 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; gboolean success = TRUE;
GimpImage *image; GimpImage *image;
gint32 operation; gint operation;
GimpItem *item; GimpItem *item;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); 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_CHANNEL_OP_ADD,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("num-segs", g_param_spec_int ("num-segs",
"num segs", "num segs",
"Number of points (count 1 coordinate as two points)", "Number of points (count 1 coordinate as two points)",
2, G_MAXINT32, 2, 2, G_MAXINT32, 2,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("segs", gimp_param_spec_float_array ("segs",
"segs", "segs",

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

@ -54,10 +54,10 @@ image_resize_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
GimpImage *image; GimpImage *image;
gint32 new_width; gint new_width;
gint32 new_height; gint new_height;
gint32 offx; gint offx;
gint32 offy; gint offy;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
new_width = g_value_get_int (gimp_value_array_index (args, 1)); new_width = g_value_get_int (gimp_value_array_index (args, 1));
@ -107,8 +107,8 @@ image_scale_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
GimpImage *image; GimpImage *image;
gint32 new_width; gint new_width;
gint32 new_height; gint new_height;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
new_width = g_value_get_int (gimp_value_array_index (args, 1)); new_width = g_value_get_int (gimp_value_array_index (args, 1));
@ -143,10 +143,10 @@ image_crop_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
GimpImage *image; GimpImage *image;
gint32 new_width; gint new_width;
gint32 new_height; gint new_height;
gint32 offx; gint offx;
gint32 offy; gint offy;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
new_width = g_value_get_int (gimp_value_array_index (args, 1)); new_width = g_value_get_int (gimp_value_array_index (args, 1));
@ -181,7 +181,7 @@ image_flip_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
GimpImage *image; GimpImage *image;
gint32 flip_type; gint flip_type;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
flip_type = g_value_get_enum (gimp_value_array_index (args, 1)); flip_type = g_value_get_enum (gimp_value_array_index (args, 1));
@ -205,7 +205,7 @@ image_rotate_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
GimpImage *image; GimpImage *image;
gint32 rotate_type; gint rotate_type;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
rotate_type = g_value_get_enum (gimp_value_array_index (args, 1)); 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, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("new-width", g_param_spec_int ("new-width",
"new width", "new width",
"New image width", "New image width",
1, GIMP_MAX_IMAGE_SIZE, 1, 1, GIMP_MAX_IMAGE_SIZE, 1,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("new-height", g_param_spec_int ("new-height",
"new height", "new height",
"New image height", "New image height",
1, GIMP_MAX_IMAGE_SIZE, 1, 1, GIMP_MAX_IMAGE_SIZE, 1,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("offx", g_param_spec_int ("offx",
"offx", "offx",
"x offset between upper left corner of old and new images: (new - old)", "x offset between upper left corner of old and new images: (new - old)",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("offy", g_param_spec_int ("offy",
"offy", "offy",
"y offset between upper left corner of old and new images: (new - old)", "y offset between upper left corner of old and new images: (new - old)",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -321,17 +321,17 @@ register_image_transform_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("new-width", g_param_spec_int ("new-width",
"new width", "new width",
"New image width", "New image width",
1, GIMP_MAX_IMAGE_SIZE, 1, 1, GIMP_MAX_IMAGE_SIZE, 1,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("new-height", g_param_spec_int ("new-height",
"new height", "new height",
"New image height", "New image height",
1, GIMP_MAX_IMAGE_SIZE, 1, 1, GIMP_MAX_IMAGE_SIZE, 1,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -356,29 +356,29 @@ register_image_transform_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("new-width", g_param_spec_int ("new-width",
"new width", "new width",
"New image width: (0 < new_width <= width)", "New image width: (0 < new_width <= width)",
1, GIMP_MAX_IMAGE_SIZE, 1, 1, GIMP_MAX_IMAGE_SIZE, 1,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("new-height", g_param_spec_int ("new-height",
"new height", "new height",
"New image height: (0 < new_height <= height)", "New image height: (0 < new_height <= height)",
1, GIMP_MAX_IMAGE_SIZE, 1, 1, GIMP_MAX_IMAGE_SIZE, 1,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("offx", g_param_spec_int ("offx",
"offx", "offx",
"X offset: (0 <= offx <= (width - new_width))", "X offset: (0 <= offx <= (width - new_width))",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("offy", g_param_spec_int ("offy",
"offy", "offy",
"Y offset: (0 <= offy <= (height - new_height))", "Y offset: (0 <= offy <= (height - new_height))",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpItem *item; GimpItem *item;
gint32 num_children = 0; gint num_children = 0;
gint32 *child_ids = NULL; gint32 *child_ids = NULL;
item = gimp_value_get_item (gimp_value_array_index (args, 0), gimp); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpItem *item; GimpItem *item;
gint32 color_tag = 0; gint color_tag = 0;
item = gimp_value_get_item (gimp_value_array_index (args, 0), gimp); 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; gboolean success = TRUE;
GimpItem *item; GimpItem *item;
gint32 color_tag; gint color_tag;
item = gimp_value_get_item (gimp_value_array_index (args, 0), gimp); item = gimp_value_get_item (gimp_value_array_index (args, 0), gimp);
color_tag = g_value_get_enum (gimp_value_array_index (args, 1)); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpItem *item; GimpItem *item;
gint32 tattoo = 0; gint tattoo = 0;
item = gimp_value_get_item (gimp_value_array_index (args, 0), gimp); 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; gboolean success = TRUE;
GimpItem *item; GimpItem *item;
gint32 tattoo; gint tattoo;
item = gimp_value_get_item (gimp_value_array_index (args, 0), gimp); item = gimp_value_get_item (gimp_value_array_index (args, 0), gimp);
tattoo = g_value_get_uint (gimp_value_array_index (args, 1)); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpItem *item; GimpItem *item;
gint32 num_parasites = 0; gint num_parasites = 0;
gchar **parasites = NULL; gchar **parasites = NULL;
item = gimp_value_get_item (gimp_value_array_index (args, 0), gimp); item = gimp_value_get_item (gimp_value_array_index (args, 0), gimp);
@ -1360,11 +1360,11 @@ register_item_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-children", g_param_spec_int ("num-children",
"num children", "num children",
"The item's number of children", "The item's number of children",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32_array ("child-ids", gimp_param_spec_int32_array ("child-ids",
"child ids", "child ids",
@ -1955,11 +1955,11 @@ register_item_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-parasites", g_param_spec_int ("num-parasites",
"num parasites", "num parasites",
"The number of attached parasites", "The number of attached parasites",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_string_array ("parasites", gimp_param_spec_string_array ("parasites",
"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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpItem *item; GimpItem *item;
gint32 flip_type; gint flip_type;
gboolean auto_center; gboolean auto_center;
gdouble axis; gdouble axis;
@ -401,7 +401,7 @@ item_transform_rotate_simple_invoker (GimpProcedure *procedure,
gboolean success = TRUE; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpItem *item; GimpItem *item;
gint32 rotate_type; gint rotate_type;
gboolean auto_center; gboolean auto_center;
gdouble center_x; gdouble center_x;
gdouble center_y; gdouble center_y;
@ -701,7 +701,7 @@ item_transform_shear_invoker (GimpProcedure *procedure,
gboolean success = TRUE; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpItem *item; GimpItem *item;
gint32 shear_type; gint shear_type;
gdouble magnitude; gdouble magnitude;
item = gimp_value_get_item (gimp_value_array_index (args, 0), gimp); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpImage *image; GimpImage *image;
gint32 width; gint width;
gint32 height; gint height;
gint32 type; gint type;
const gchar *name; const gchar *name;
gdouble opacity; gdouble opacity;
gint32 mode; gint mode;
GimpLayer *layer = NULL; GimpLayer *layer = NULL;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
@ -389,8 +389,8 @@ layer_scale_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
GimpLayer *layer; GimpLayer *layer;
gint32 new_width; gint new_width;
gint32 new_height; gint new_height;
gboolean local_origin; gboolean local_origin;
layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp); layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp);
@ -436,10 +436,10 @@ layer_resize_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
GimpLayer *layer; GimpLayer *layer;
gint32 new_width; gint new_width;
gint32 new_height; gint new_height;
gint32 offx; gint offx;
gint32 offy; gint offy;
layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp); layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp);
new_width = g_value_get_int (gimp_value_array_index (args, 1)); 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; gboolean success = TRUE;
GimpLayer *layer; GimpLayer *layer;
gint32 offx; gint offx;
gint32 offy; gint offy;
layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp); layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp);
offx = g_value_get_int (gimp_value_array_index (args, 1)); offx = g_value_get_int (gimp_value_array_index (args, 1));
@ -546,7 +546,7 @@ layer_create_mask_invoker (GimpProcedure *procedure,
gboolean success = TRUE; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpLayer *layer; GimpLayer *layer;
gint32 mask_type; gint mask_type;
GimpLayerMask *mask = NULL; GimpLayerMask *mask = NULL;
layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp); 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; gboolean success = TRUE;
GimpLayer *layer; GimpLayer *layer;
gint32 mode; gint mode;
layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp); layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp);
mode = g_value_get_enum (gimp_value_array_index (args, 1)); mode = g_value_get_enum (gimp_value_array_index (args, 1));
@ -1030,7 +1030,7 @@ layer_get_mode_invoker (GimpProcedure *procedure,
gboolean success = TRUE; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpLayer *layer; GimpLayer *layer;
gint32 mode = 0; gint mode = 0;
layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp); 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; gboolean success = TRUE;
GimpLayer *layer; GimpLayer *layer;
gint32 mode; gint mode;
layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp); layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp);
mode = g_value_get_enum (gimp_value_array_index (args, 1)); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpLayer *layer; GimpLayer *layer;
gint32 blend_space = 0; gint blend_space = 0;
layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp); 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; gboolean success = TRUE;
GimpLayer *layer; GimpLayer *layer;
gint32 blend_space; gint blend_space;
layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp); layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp);
blend_space = g_value_get_enum (gimp_value_array_index (args, 1)); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpLayer *layer; GimpLayer *layer;
gint32 composite_space = 0; gint composite_space = 0;
layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp); 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; gboolean success = TRUE;
GimpLayer *layer; GimpLayer *layer;
gint32 composite_space; gint composite_space;
layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp); layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp);
composite_space = g_value_get_enum (gimp_value_array_index (args, 1)); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpLayer *layer; GimpLayer *layer;
gint32 composite_mode = 0; gint composite_mode = 0;
layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp); 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; gboolean success = TRUE;
GimpLayer *layer; GimpLayer *layer;
gint32 composite_mode; gint composite_mode;
layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp); layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp);
composite_mode = g_value_get_enum (gimp_value_array_index (args, 1)); composite_mode = g_value_get_enum (gimp_value_array_index (args, 1));
@ -1272,17 +1272,17 @@ register_layer_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("width", g_param_spec_int ("width",
"width", "width",
"The layer width", "The layer width",
1, GIMP_MAX_IMAGE_SIZE, 1, 1, GIMP_MAX_IMAGE_SIZE, 1,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("height", g_param_spec_int ("height",
"height", "height",
"The layer height", "The layer height",
1, GIMP_MAX_IMAGE_SIZE, 1, 1, GIMP_MAX_IMAGE_SIZE, 1,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
g_param_spec_enum ("type", g_param_spec_enum ("type",
"type", "type",
@ -1528,17 +1528,17 @@ register_layer_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("new-width", g_param_spec_int ("new-width",
"new width", "new width",
"New layer width", "New layer width",
1, GIMP_MAX_IMAGE_SIZE, 1, 1, GIMP_MAX_IMAGE_SIZE, 1,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("new-height", g_param_spec_int ("new-height",
"new height", "new height",
"New layer height", "New layer height",
1, GIMP_MAX_IMAGE_SIZE, 1, 1, GIMP_MAX_IMAGE_SIZE, 1,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("local-origin", g_param_spec_boolean ("local-origin",
"local origin", "local origin",
@ -1569,29 +1569,29 @@ register_layer_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("new-width", g_param_spec_int ("new-width",
"new width", "new width",
"New layer width", "New layer width",
1, GIMP_MAX_IMAGE_SIZE, 1, 1, GIMP_MAX_IMAGE_SIZE, 1,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("new-height", g_param_spec_int ("new-height",
"new height", "new height",
"New layer height", "New layer height",
1, GIMP_MAX_IMAGE_SIZE, 1, 1, GIMP_MAX_IMAGE_SIZE, 1,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("offx", g_param_spec_int ("offx",
"offx", "offx",
"x offset between upper left corner of old and new layers: (old - new)", "x offset between upper left corner of old and new layers: (old - new)",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("offy", g_param_spec_int ("offy",
"offy", "offy",
"y offset between upper left corner of old and new layers: (old - new)", "y offset between upper left corner of old and new layers: (old - new)",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -1639,17 +1639,17 @@ register_layer_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("offx", g_param_spec_int ("offx",
"offx", "offx",
"Offset in x direction", "Offset in x direction",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("offy", g_param_spec_int ("offy",
"offy", "offy",
"Offset in y direction", "Offset in y direction",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (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) GError **error)
{ {
GimpValueArray *return_vals; GimpValueArray *return_vals;
gint32 handler = 0; gint handler = 0;
handler = gimp->message_handler; handler = gimp->message_handler;
@ -96,7 +96,7 @@ message_set_handler_invoker (GimpProcedure *procedure,
GError **error) GError **error)
{ {
gboolean success = TRUE; gboolean success = TRUE;
gint32 handler; gint handler;
handler = g_value_get_enum (gimp_value_array_index (args, 0)); 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; gboolean success = TRUE;
GimpDrawable *drawable; GimpDrawable *drawable;
gdouble pressure; gdouble pressure;
gint32 num_strokes; gint num_strokes;
const gdouble *strokes; const gdouble *strokes;
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp);
@ -159,7 +159,7 @@ airbrush_default_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
GimpDrawable *drawable; GimpDrawable *drawable;
gint32 num_strokes; gint num_strokes;
const gdouble *strokes; const gdouble *strokes;
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp);
@ -203,10 +203,10 @@ clone_invoker (GimpProcedure *procedure,
gboolean success = TRUE; gboolean success = TRUE;
GimpDrawable *drawable; GimpDrawable *drawable;
GimpDrawable *src_drawable; GimpDrawable *src_drawable;
gint32 clone_type; gint clone_type;
gdouble src_x; gdouble src_x;
gdouble src_y; gdouble src_y;
gint32 num_strokes; gint num_strokes;
const gdouble *strokes; const gdouble *strokes;
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp);
@ -260,7 +260,7 @@ clone_default_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
GimpDrawable *drawable; GimpDrawable *drawable;
gint32 num_strokes; gint num_strokes;
const gdouble *strokes; const gdouble *strokes;
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp);
@ -304,8 +304,8 @@ convolve_invoker (GimpProcedure *procedure,
gboolean success = TRUE; gboolean success = TRUE;
GimpDrawable *drawable; GimpDrawable *drawable;
gdouble pressure; gdouble pressure;
gint32 convolve_type; gint convolve_type;
gint32 num_strokes; gint num_strokes;
const gdouble *strokes; const gdouble *strokes;
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp);
@ -355,7 +355,7 @@ convolve_default_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
GimpDrawable *drawable; GimpDrawable *drawable;
gint32 num_strokes; gint num_strokes;
const gdouble *strokes; const gdouble *strokes;
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp);
@ -399,9 +399,9 @@ dodgeburn_invoker (GimpProcedure *procedure,
gboolean success = TRUE; gboolean success = TRUE;
GimpDrawable *drawable; GimpDrawable *drawable;
gdouble exposure; gdouble exposure;
gint32 dodgeburn_type; gint dodgeburn_type;
gint32 dodgeburn_mode; gint dodgeburn_mode;
gint32 num_strokes; gint num_strokes;
const gdouble *strokes; const gdouble *strokes;
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp);
@ -453,7 +453,7 @@ dodgeburn_default_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
GimpDrawable *drawable; GimpDrawable *drawable;
gint32 num_strokes; gint num_strokes;
const gdouble *strokes; const gdouble *strokes;
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp);
@ -496,10 +496,10 @@ eraser_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
GimpDrawable *drawable; GimpDrawable *drawable;
gint32 num_strokes; gint num_strokes;
const gdouble *strokes; const gdouble *strokes;
gint32 hardness; gint hardness;
gint32 method; gint method;
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp);
num_strokes = g_value_get_int (gimp_value_array_index (args, 1)); num_strokes = g_value_get_int (gimp_value_array_index (args, 1));
@ -548,7 +548,7 @@ eraser_default_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
GimpDrawable *drawable; GimpDrawable *drawable;
gint32 num_strokes; gint num_strokes;
const gdouble *strokes; const gdouble *strokes;
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp);
@ -594,7 +594,7 @@ heal_invoker (GimpProcedure *procedure,
GimpDrawable *src_drawable; GimpDrawable *src_drawable;
gdouble src_x; gdouble src_x;
gdouble src_y; gdouble src_y;
gint32 num_strokes; gint num_strokes;
const gdouble *strokes; const gdouble *strokes;
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp);
@ -643,7 +643,7 @@ heal_default_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
GimpDrawable *drawable; GimpDrawable *drawable;
gint32 num_strokes; gint num_strokes;
const gdouble *strokes; const gdouble *strokes;
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp);
@ -687,9 +687,9 @@ paintbrush_invoker (GimpProcedure *procedure,
gboolean success = TRUE; gboolean success = TRUE;
GimpDrawable *drawable; GimpDrawable *drawable;
gdouble fade_out; gdouble fade_out;
gint32 num_strokes; gint num_strokes;
const gdouble *strokes; const gdouble *strokes;
gint32 method; gint method;
gdouble gradient_length; gdouble gradient_length;
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp);
@ -771,7 +771,7 @@ paintbrush_default_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
GimpDrawable *drawable; GimpDrawable *drawable;
gint32 num_strokes; gint num_strokes;
const gdouble *strokes; const gdouble *strokes;
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp);
@ -814,7 +814,7 @@ pencil_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
GimpDrawable *drawable; GimpDrawable *drawable;
gint32 num_strokes; gint num_strokes;
const gdouble *strokes; const gdouble *strokes;
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp);
@ -858,7 +858,7 @@ smudge_invoker (GimpProcedure *procedure,
gboolean success = TRUE; gboolean success = TRUE;
GimpDrawable *drawable; GimpDrawable *drawable;
gdouble pressure; gdouble pressure;
gint32 num_strokes; gint num_strokes;
const gdouble *strokes; const gdouble *strokes;
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp);
@ -906,7 +906,7 @@ smudge_default_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
GimpDrawable *drawable; GimpDrawable *drawable;
gint32 num_strokes; gint num_strokes;
const gdouble *strokes; const gdouble *strokes;
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); 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, 0, 100, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("num-strokes", g_param_spec_int ("num-strokes",
"num strokes", "num strokes",
"Number of stroke control points (count each coordinate as 2 points)", "Number of stroke control points (count each coordinate as 2 points)",
2, G_MAXINT32, 2, 2, G_MAXINT32, 2,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes", gimp_param_spec_float_array ("strokes",
"strokes", "strokes",
@ -1005,11 +1005,11 @@ register_paint_tools_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("num-strokes", g_param_spec_int ("num-strokes",
"num strokes", "num strokes",
"Number of stroke control points (count each coordinate as 2 points)", "Number of stroke control points (count each coordinate as 2 points)",
2, G_MAXINT32, 2, 2, G_MAXINT32, 2,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes", gimp_param_spec_float_array ("strokes",
"strokes", "strokes",
@ -1064,11 +1064,11 @@ register_paint_tools_procs (GimpPDB *pdb)
-G_MAXDOUBLE, G_MAXDOUBLE, 0, -G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("num-strokes", g_param_spec_int ("num-strokes",
"num strokes", "num strokes",
"Number of stroke control points (count each coordinate as 2 points)", "Number of stroke control points (count each coordinate as 2 points)",
2, G_MAXINT32, 2, 2, G_MAXINT32, 2,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes", gimp_param_spec_float_array ("strokes",
"strokes", "strokes",
@ -1098,11 +1098,11 @@ register_paint_tools_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("num-strokes", g_param_spec_int ("num-strokes",
"num strokes", "num strokes",
"Number of stroke control points (count each coordinate as 2 points)", "Number of stroke control points (count each coordinate as 2 points)",
2, G_MAXINT32, 2, 2, G_MAXINT32, 2,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes", gimp_param_spec_float_array ("strokes",
"strokes", "strokes",
@ -1145,11 +1145,11 @@ register_paint_tools_procs (GimpPDB *pdb)
GIMP_CONVOLVE_BLUR, GIMP_CONVOLVE_BLUR,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("num-strokes", g_param_spec_int ("num-strokes",
"num strokes", "num strokes",
"Number of stroke control points (count each coordinate as 2 points)", "Number of stroke control points (count each coordinate as 2 points)",
2, G_MAXINT32, 2, 2, G_MAXINT32, 2,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes", gimp_param_spec_float_array ("strokes",
"strokes", "strokes",
@ -1179,11 +1179,11 @@ register_paint_tools_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("num-strokes", g_param_spec_int ("num-strokes",
"num strokes", "num strokes",
"Number of stroke control points (count each coordinate as 2 points)", "Number of stroke control points (count each coordinate as 2 points)",
2, G_MAXINT32, 2, 2, G_MAXINT32, 2,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes", gimp_param_spec_float_array ("strokes",
"strokes", "strokes",
@ -1233,11 +1233,11 @@ register_paint_tools_procs (GimpPDB *pdb)
GIMP_TRANSFER_SHADOWS, GIMP_TRANSFER_SHADOWS,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("num-strokes", g_param_spec_int ("num-strokes",
"num strokes", "num strokes",
"Number of stroke control points (count each coordinate as 2 points)", "Number of stroke control points (count each coordinate as 2 points)",
2, G_MAXINT32, 2, 2, G_MAXINT32, 2,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes", gimp_param_spec_float_array ("strokes",
"strokes", "strokes",
@ -1267,11 +1267,11 @@ register_paint_tools_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("num-strokes", g_param_spec_int ("num-strokes",
"num strokes", "num strokes",
"Number of stroke control points (count each coordinate as 2 points)", "Number of stroke control points (count each coordinate as 2 points)",
2, G_MAXINT32, 2, 2, G_MAXINT32, 2,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes", gimp_param_spec_float_array ("strokes",
"strokes", "strokes",
@ -1301,11 +1301,11 @@ register_paint_tools_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("num-strokes", g_param_spec_int ("num-strokes",
"num strokes", "num strokes",
"Number of stroke control points (count each coordinate as 2 points)", "Number of stroke control points (count each coordinate as 2 points)",
2, G_MAXINT32, 2, 2, G_MAXINT32, 2,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes", gimp_param_spec_float_array ("strokes",
"strokes", "strokes",
@ -1349,11 +1349,11 @@ register_paint_tools_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("num-strokes", g_param_spec_int ("num-strokes",
"num strokes", "num strokes",
"Number of stroke control points (count each coordinate as 2 points)", "Number of stroke control points (count each coordinate as 2 points)",
2, G_MAXINT32, 2, 2, G_MAXINT32, 2,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes", gimp_param_spec_float_array ("strokes",
"strokes", "strokes",
@ -1401,11 +1401,11 @@ register_paint_tools_procs (GimpPDB *pdb)
-G_MAXDOUBLE, G_MAXDOUBLE, 0, -G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("num-strokes", g_param_spec_int ("num-strokes",
"num strokes", "num strokes",
"Number of stroke control points (count each coordinate as 2 points)", "Number of stroke control points (count each coordinate as 2 points)",
2, G_MAXINT32, 2, 2, G_MAXINT32, 2,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes", gimp_param_spec_float_array ("strokes",
"strokes", "strokes",
@ -1435,11 +1435,11 @@ register_paint_tools_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("num-strokes", g_param_spec_int ("num-strokes",
"num strokes", "num strokes",
"Number of stroke control points (count each coordinate as 2 points)", "Number of stroke control points (count each coordinate as 2 points)",
2, G_MAXINT32, 2, 2, G_MAXINT32, 2,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes", gimp_param_spec_float_array ("strokes",
"strokes", "strokes",
@ -1475,11 +1475,11 @@ register_paint_tools_procs (GimpPDB *pdb)
0, G_MAXDOUBLE, 0, 0, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("num-strokes", g_param_spec_int ("num-strokes",
"num strokes", "num strokes",
"Number of stroke control points (count each coordinate as 2 points)", "Number of stroke control points (count each coordinate as 2 points)",
2, G_MAXINT32, 2, 2, G_MAXINT32, 2,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes", gimp_param_spec_float_array ("strokes",
"strokes", "strokes",
@ -1522,11 +1522,11 @@ register_paint_tools_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("num-strokes", g_param_spec_int ("num-strokes",
"num strokes", "num strokes",
"Number of stroke control points (count each coordinate as 2 points)", "Number of stroke control points (count each coordinate as 2 points)",
2, G_MAXINT32, 2, 2, G_MAXINT32, 2,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes", gimp_param_spec_float_array ("strokes",
"strokes", "strokes",
@ -1556,11 +1556,11 @@ register_paint_tools_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("num-strokes", g_param_spec_int ("num-strokes",
"num strokes", "num strokes",
"Number of stroke control points (count each coordinate as 2 points)", "Number of stroke control points (count each coordinate as 2 points)",
2, G_MAXINT32, 2, 2, G_MAXINT32, 2,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes", gimp_param_spec_float_array ("strokes",
"strokes", "strokes",
@ -1596,11 +1596,11 @@ register_paint_tools_procs (GimpPDB *pdb)
0, 100, 0, 0, 100, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("num-strokes", g_param_spec_int ("num-strokes",
"num strokes", "num strokes",
"Number of stroke control points (count each coordinate as 2 points)", "Number of stroke control points (count each coordinate as 2 points)",
2, G_MAXINT32, 2, 2, G_MAXINT32, 2,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes", gimp_param_spec_float_array ("strokes",
"strokes", "strokes",
@ -1630,11 +1630,11 @@ register_paint_tools_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("num-strokes", g_param_spec_int ("num-strokes",
"num strokes", "num strokes",
"Number of stroke control points (count each coordinate as 2 points)", "Number of stroke control points (count each coordinate as 2 points)",
2, G_MAXINT32, 2, 2, G_MAXINT32, 2,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes", gimp_param_spec_float_array ("strokes",
"strokes", "strokes",

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

@ -235,7 +235,7 @@ palette_get_info_invoker (GimpProcedure *procedure,
gboolean success = TRUE; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *name; const gchar *name;
gint32 num_colors = 0; gint num_colors = 0;
name = g_value_get_string (gimp_value_array_index (args, 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *name; const gchar *name;
gint32 num_colors = 0; gint num_colors = 0;
GimpRGB *colors = NULL; GimpRGB *colors = NULL;
name = g_value_get_string (gimp_value_array_index (args, 0)); name = g_value_get_string (gimp_value_array_index (args, 0));
@ -320,7 +320,7 @@ palette_get_columns_invoker (GimpProcedure *procedure,
gboolean success = TRUE; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *name; const gchar *name;
gint32 num_columns = 0; gint num_columns = 0;
name = g_value_get_string (gimp_value_array_index (args, 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; gboolean success = TRUE;
const gchar *name; const gchar *name;
gint32 columns; gint columns;
name = g_value_get_string (gimp_value_array_index (args, 0)); name = g_value_get_string (gimp_value_array_index (args, 0));
columns = g_value_get_int (gimp_value_array_index (args, 1)); 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 *name;
const gchar *entry_name; const gchar *entry_name;
GimpRGB color; GimpRGB color;
gint32 entry_num = 0; gint entry_num = 0;
name = g_value_get_string (gimp_value_array_index (args, 0)); name = g_value_get_string (gimp_value_array_index (args, 0));
entry_name = g_value_get_string (gimp_value_array_index (args, 1)); 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; gboolean success = TRUE;
const gchar *name; const gchar *name;
gint32 entry_num; gint entry_num;
name = g_value_get_string (gimp_value_array_index (args, 0)); name = g_value_get_string (gimp_value_array_index (args, 0));
entry_num = g_value_get_int (gimp_value_array_index (args, 1)); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *name; const gchar *name;
gint32 entry_num; gint entry_num;
GimpRGB color = { 0.0, 0.0, 0.0, 1.0 }; GimpRGB color = { 0.0, 0.0, 0.0, 1.0 };
name = g_value_get_string (gimp_value_array_index (args, 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; gboolean success = TRUE;
const gchar *name; const gchar *name;
gint32 entry_num; gint entry_num;
GimpRGB color; GimpRGB color;
name = g_value_get_string (gimp_value_array_index (args, 0)); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *name; const gchar *name;
gint32 entry_num; gint entry_num;
gchar *entry_name = NULL; gchar *entry_name = NULL;
name = g_value_get_string (gimp_value_array_index (args, 0)); 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; gboolean success = TRUE;
const gchar *name; const gchar *name;
gint32 entry_num; gint entry_num;
const gchar *entry_name; const gchar *entry_name;
name = g_value_get_string (gimp_value_array_index (args, 0)); name = g_value_get_string (gimp_value_array_index (args, 0));
@ -780,11 +780,11 @@ register_palette_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-colors", g_param_spec_int ("num-colors",
"num colors", "num colors",
"The number of colors in the palette", "The number of colors in the palette",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -810,11 +810,11 @@ register_palette_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-colors", g_param_spec_int ("num-colors",
"num colors", "num colors",
"Length of the colors array", "Length of the colors array",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_rgb_array ("colors", gimp_param_spec_rgb_array ("colors",
"colors", "colors",
@ -845,11 +845,11 @@ register_palette_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-columns", g_param_spec_int ("num-columns",
"num columns", "num columns",
"The number of columns used to display this palette", "The number of columns used to display this palette",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -875,11 +875,11 @@ register_palette_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("columns", g_param_spec_int ("columns",
"columns", "columns",
"The new number of columns", "The new number of columns",
0, 64, 0, 0, 64, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -919,11 +919,11 @@ register_palette_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("entry-num", g_param_spec_int ("entry-num",
"entry num", "entry num",
"The index of the added entry", "The index of the added entry",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -949,11 +949,11 @@ register_palette_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("entry-num", g_param_spec_int ("entry-num",
"entry num", "entry num",
"The index of the added entry", "The index of the added entry",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -979,11 +979,11 @@ register_palette_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("entry-num", g_param_spec_int ("entry-num",
"entry num", "entry num",
"The entry to retrieve", "The entry to retrieve",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_rgb ("color", gimp_param_spec_rgb ("color",
"color", "color",
@ -1016,11 +1016,11 @@ register_palette_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("entry-num", g_param_spec_int ("entry-num",
"entry num", "entry num",
"The entry to retrieve", "The entry to retrieve",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_rgb ("color", gimp_param_spec_rgb ("color",
"color", "color",
@ -1053,11 +1053,11 @@ register_palette_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("entry-num", g_param_spec_int ("entry-num",
"entry num", "entry num",
"The entry to retrieve", "The entry to retrieve",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_string ("entry-name", gimp_param_spec_string ("entry-name",
"entry name", "entry name",
@ -1090,11 +1090,11 @@ register_palette_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("entry-num", g_param_spec_int ("entry-num",
"entry num", "entry num",
"The entry to retrieve", "The entry to retrieve",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("entry-name", gimp_param_spec_string ("entry-name",
"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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *filter; const gchar *filter;
gint32 num_palettes = 0; gint num_palettes = 0;
gchar **palette_list = NULL; gchar **palette_list = NULL;
filter = g_value_get_string (gimp_value_array_index (args, 0)); filter = g_value_get_string (gimp_value_array_index (args, 0));
@ -133,11 +133,11 @@ register_palettes_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-palettes", g_param_spec_int ("num-palettes",
"num palettes", "num palettes",
"The number of palettes in the list", "The number of palettes in the list",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_string_array ("palette-list", gimp_param_spec_string_array ("palette-list",
"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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *name; const gchar *name;
gint32 width = 0; gint width = 0;
gint32 height = 0; gint height = 0;
gint32 bpp = 0; gint bpp = 0;
name = g_value_get_string (gimp_value_array_index (args, 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *name; const gchar *name;
gint32 width = 0; gint width = 0;
gint32 height = 0; gint height = 0;
gint32 bpp = 0; gint bpp = 0;
gint32 num_color_bytes = 0; gint num_color_bytes = 0;
guint8 *color_bytes = NULL; guint8 *color_bytes = NULL;
name = g_value_get_string (gimp_value_array_index (args, 0)); name = g_value_get_string (gimp_value_array_index (args, 0));
@ -177,23 +177,23 @@ register_pattern_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("width", g_param_spec_int ("width",
"width", "width",
"The pattern width", "The pattern width",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("height", g_param_spec_int ("height",
"height", "height",
"The pattern height", "The pattern height",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("bpp", g_param_spec_int ("bpp",
"bpp", "bpp",
"The pattern bpp", "The pattern bpp",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -219,29 +219,29 @@ register_pattern_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("width", g_param_spec_int ("width",
"width", "width",
"The pattern width", "The pattern width",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("height", g_param_spec_int ("height",
"height", "height",
"The pattern height", "The pattern height",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("bpp", g_param_spec_int ("bpp",
"bpp", "bpp",
"The pattern bpp", "The pattern bpp",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-color-bytes", g_param_spec_int ("num-color-bytes",
"num color bytes", "num color bytes",
"Number of pattern bytes", "Number of pattern bytes",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int8_array ("color-bytes", gimp_param_spec_int8_array ("color-bytes",
"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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *filter; const gchar *filter;
gint32 num_patterns = 0; gint num_patterns = 0;
gchar **pattern_list = NULL; gchar **pattern_list = NULL;
filter = g_value_get_string (gimp_value_array_index (args, 0)); filter = g_value_get_string (gimp_value_array_index (args, 0));
@ -134,11 +134,11 @@ register_patterns_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-patterns", g_param_spec_int ("num-patterns",
"num patterns", "num patterns",
"The number of patterns in the pattern list", "The number of patterns in the pattern list",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_string_array ("pattern-list", gimp_param_spec_string_array ("pattern-list",
"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 *copyright;
const gchar *date; const gchar *date;
const gchar *proc_type; const gchar *proc_type;
gint32 num_matches = 0; gint num_matches = 0;
gchar **procedure_names = NULL; gchar **procedure_names = NULL;
name = g_value_get_string (gimp_value_array_index (args, 0)); 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 *authors = NULL;
gchar *copyright = NULL; gchar *copyright = NULL;
gchar *date = NULL; gchar *date = NULL;
gint32 proc_type = 0; gint proc_type = 0;
gint32 num_args = 0; gint num_args = 0;
gint32 num_values = 0; gint num_values = 0;
procedure_name = g_value_get_string (gimp_value_array_index (args, 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *procedure_name; const gchar *procedure_name;
gint32 arg_num; gint arg_num;
GParamSpec *param_spec = NULL; GParamSpec *param_spec = NULL;
procedure_name = g_value_get_string (gimp_value_array_index (args, 0)); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *procedure_name; const gchar *procedure_name;
gint32 val_num; gint val_num;
GParamSpec *param_spec = NULL; GParamSpec *param_spec = NULL;
procedure_name = g_value_get_string (gimp_value_array_index (args, 0)); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *identifier; const gchar *identifier;
gint32 bytes = 0; gint bytes = 0;
guint8 *data = NULL; guint8 *data = NULL;
identifier = g_value_get_string (gimp_value_array_index (args, 0)); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *identifier; const gchar *identifier;
gint32 bytes = 0; gint bytes = 0;
identifier = g_value_get_string (gimp_value_array_index (args, 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; gboolean success = TRUE;
const gchar *identifier; const gchar *identifier;
gint32 bytes; gint bytes;
const guint8 *data; const guint8 *data;
identifier = g_value_get_string (gimp_value_array_index (args, 0)); identifier = g_value_get_string (gimp_value_array_index (args, 0));
@ -577,11 +577,11 @@ register_pdb_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-matches", g_param_spec_int ("num-matches",
"num matches", "num matches",
"The number of matching procedures", "The number of matching procedures",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_string_array ("procedure-names", gimp_param_spec_string_array ("procedure-names",
"procedure names", "procedure names",
@ -684,17 +684,17 @@ register_pdb_procs (GimpPDB *pdb)
GIMP_INTERNAL, GIMP_INTERNAL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-args", g_param_spec_int ("num-args",
"num args", "num args",
"The number of input arguments", "The number of input arguments",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-values", g_param_spec_int ("num-values",
"num values", "num values",
"The number of return values", "The number of return values",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -720,11 +720,11 @@ register_pdb_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("arg-num", g_param_spec_int ("arg-num",
"arg num", "arg num",
"The argument number", "The argument number",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
g_param_spec_param ("param-spec", g_param_spec_param ("param-spec",
"param spec", "param spec",
@ -756,11 +756,11 @@ register_pdb_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("val-num", g_param_spec_int ("val-num",
"val num", "val num",
"The return value number", "The return value number",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
g_param_spec_param ("param-spec", g_param_spec_param ("param-spec",
"param spec", "param spec",
@ -792,11 +792,11 @@ register_pdb_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("bytes", g_param_spec_int ("bytes",
"bytes", "bytes",
"The number of bytes in the data", "The number of bytes in the data",
1, G_MAXINT32, 1, 1, G_MAXINT32, 1,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int8_array ("data", gimp_param_spec_int8_array ("data",
"data", "data",
@ -827,11 +827,11 @@ register_pdb_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("bytes", g_param_spec_int ("bytes",
"bytes", "bytes",
"The number of bytes in the data", "The number of bytes in the data",
1, G_MAXINT32, 1, 1, G_MAXINT32, 1,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -857,11 +857,11 @@ register_pdb_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("bytes", g_param_spec_int ("bytes",
"bytes", "bytes",
"The number of bytes in the data", "The number of bytes in the data",
1, G_MAXINT32, 1, 1, G_MAXINT32, 1,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int8_array ("data", gimp_param_spec_int8_array ("data",
"data", "data",

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

@ -56,7 +56,7 @@ plugins_query_invoker (GimpProcedure *procedure,
{ {
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *search_string; const gchar *search_string;
gint32 num_plugins = 0; gint num_plugins = 0;
gchar **menu_path = NULL; gchar **menu_path = NULL;
gchar **plugin_accelerator = NULL; gchar **plugin_accelerator = NULL;
gchar **plugin_location = NULL; gchar **plugin_location = NULL;
@ -240,8 +240,8 @@ plugin_icon_register_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
const gchar *procedure_name; const gchar *procedure_name;
gint32 icon_type; gint icon_type;
gint32 icon_data_length; gint icon_data_length;
const guint8 *icon_data; const guint8 *icon_data;
procedure_name = g_value_get_string (gimp_value_array_index (args, 0)); 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) GError **error)
{ {
gboolean success = TRUE; gboolean success = TRUE;
gint32 handler; gint handler;
handler = g_value_get_enum (gimp_value_array_index (args, 0)); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
gint32 handler = 0; gint handler = 0;
GimpPlugIn *plug_in = gimp->plug_in_manager->current_plug_in; GimpPlugIn *plug_in = gimp->plug_in_manager->current_plug_in;
@ -371,66 +371,66 @@ register_plug_in_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE)); GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-plugins", g_param_spec_int ("num-plugins",
"num plugins", "num plugins",
"The number of plug-ins", "The number of plug-ins",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_string_array ("menu-path", gimp_param_spec_string_array ("menu-path",
"menu path", "menu path",
"The menu path of the plug-in", "The menu path of the plug-in",
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-plugins", g_param_spec_int ("num-plugins",
"num plugins", "num plugins",
"The number of plug-ins", "The number of plug-ins",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_string_array ("plugin-accelerator", gimp_param_spec_string_array ("plugin-accelerator",
"plugin accelerator", "plugin accelerator",
"String representing keyboard accelerator (could be empty string)", "String representing keyboard accelerator (could be empty string)",
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-plugins", g_param_spec_int ("num-plugins",
"num plugins", "num plugins",
"The number of plug-ins", "The number of plug-ins",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_string_array ("plugin-location", gimp_param_spec_string_array ("plugin-location",
"plugin location", "plugin location",
"Location of the plug-in program", "Location of the plug-in program",
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-plugins", g_param_spec_int ("num-plugins",
"num plugins", "num plugins",
"The number of plug-ins", "The number of plug-ins",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_string_array ("plugin-image-type", gimp_param_spec_string_array ("plugin-image-type",
"plugin image type", "plugin image type",
"Type of image that this plug-in will work on", "Type of image that this plug-in will work on",
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-plugins", g_param_spec_int ("num-plugins",
"num plugins", "num plugins",
"The number of plug-ins", "The number of plug-ins",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32_array ("plugin-install-time", gimp_param_spec_int32_array ("plugin-install-time",
"plugin install time", "plugin install time",
"Time that the plug-in was installed", "Time that the plug-in was installed",
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-plugins", g_param_spec_int ("num-plugins",
"num plugins", "num plugins",
"The number of plug-ins", "The number of plug-ins",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_string_array ("plugin-real-name", gimp_param_spec_string_array ("plugin-real-name",
"plugin real name", "plugin real name",
@ -592,11 +592,11 @@ register_plug_in_procs (GimpPDB *pdb)
GIMP_ICON_TYPE_ICON_NAME, GIMP_ICON_TYPE_ICON_NAME,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("icon-data-length", g_param_spec_int ("icon-data-length",
"icon data length", "icon data length",
"The length of 'icon-data'", "The length of 'icon-data'",
1, G_MAXINT32, 1, 1, G_MAXINT32, 1,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int8_array ("icon-data", gimp_param_spec_int8_array ("icon-data",
"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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
gint32 window = 0; gint window = 0;
GimpPlugIn *plug_in = gimp->plug_in_manager->current_plug_in; GimpPlugIn *plug_in = gimp->plug_in_manager->current_plug_in;
@ -420,11 +420,11 @@ register_progress_procs (GimpPDB *pdb)
"2004", "2004",
NULL); NULL);
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("window", g_param_spec_int ("window",
"window", "window",
"The progress bar's toplevel window", "The progress bar's toplevel window",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (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; GimpValueArray *return_vals;
GimpImage *image; GimpImage *image;
gboolean non_empty = FALSE; gboolean non_empty = FALSE;
gint32 x1 = 0; gint x1 = 0;
gint32 y1 = 0; gint y1 = 0;
gint32 x2 = 0; gint x2 = 0;
gint32 y2 = 0; gint y2 = 0;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
@ -103,9 +103,9 @@ selection_value_invoker (GimpProcedure *procedure,
gboolean success = TRUE; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpImage *image; GimpImage *image;
gint32 x; gint x;
gint32 y; gint y;
gint32 value = 0; gint value = 0;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
x = g_value_get_int (gimp_value_array_index (args, 1)); x = g_value_get_int (gimp_value_array_index (args, 1));
@ -169,8 +169,8 @@ selection_translate_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
GimpImage *image; GimpImage *image;
gint32 offx; gint offx;
gint32 offy; gint offy;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
offx = g_value_get_int (gimp_value_array_index (args, 1)); offx = g_value_get_int (gimp_value_array_index (args, 1));
@ -197,8 +197,8 @@ selection_float_invoker (GimpProcedure *procedure,
gboolean success = TRUE; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpDrawable *drawable; GimpDrawable *drawable;
gint32 offx; gint offx;
gint32 offy; gint offy;
GimpLayer *layer = NULL; GimpLayer *layer = NULL;
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp);
@ -356,7 +356,7 @@ selection_border_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
GimpImage *image; GimpImage *image;
gint32 radius; gint radius;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
radius = g_value_get_int (gimp_value_array_index (args, 1)); radius = g_value_get_int (gimp_value_array_index (args, 1));
@ -384,7 +384,7 @@ selection_grow_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
GimpImage *image; GimpImage *image;
gint32 steps; gint steps;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
steps = g_value_get_int (gimp_value_array_index (args, 1)); steps = g_value_get_int (gimp_value_array_index (args, 1));
@ -409,7 +409,7 @@ selection_shrink_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
GimpImage *image; GimpImage *image;
gint32 steps; gint steps;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
steps = g_value_get_int (gimp_value_array_index (args, 1)); steps = g_value_get_int (gimp_value_array_index (args, 1));
@ -519,29 +519,29 @@ register_selection_procs (GimpPDB *pdb)
FALSE, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("x1", g_param_spec_int ("x1",
"x1", "x1",
"x coordinate of upper left corner of selection bounds", "x coordinate of upper left corner of selection bounds",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("y1", g_param_spec_int ("y1",
"y1", "y1",
"y coordinate of upper left corner of selection bounds", "y coordinate of upper left corner of selection bounds",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("x2", g_param_spec_int ("x2",
"x2", "x2",
"x coordinate of lower right corner of selection bounds", "x coordinate of lower right corner of selection bounds",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("y2", g_param_spec_int ("y2",
"y2", "y2",
"y coordinate of lower right corner of selection bounds", "y coordinate of lower right corner of selection bounds",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -566,23 +566,23 @@ register_selection_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("x", g_param_spec_int ("x",
"x", "x",
"x coordinate of value", "x coordinate of value",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("y", g_param_spec_int ("y",
"y", "y",
"y coordinate of value", "y coordinate of value",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("value", g_param_spec_int ("value",
"value", "value",
"Value of the selection", "Value of the selection",
0, 255, 0, 0, 255, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -636,17 +636,17 @@ register_selection_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("offx", g_param_spec_int ("offx",
"offx", "offx",
"x offset for translation", "x offset for translation",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("offy", g_param_spec_int ("offy",
"offy", "offy",
"y offset for translation", "y offset for translation",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -671,17 +671,17 @@ register_selection_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("offx", g_param_spec_int ("offx",
"offx", "offx",
"x offset for translation", "x offset for translation",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("offy", g_param_spec_int ("offy",
"offy", "offy",
"y offset for translation", "y offset for translation",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_layer_id ("layer", gimp_param_spec_layer_id ("layer",
"layer", "layer",
@ -833,11 +833,11 @@ register_selection_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("radius", g_param_spec_int ("radius",
"radius", "radius",
"Radius of border (in pixels)", "Radius of border (in pixels)",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -862,11 +862,11 @@ register_selection_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("steps", g_param_spec_int ("steps",
"steps", "steps",
"Steps of grow (in pixels)", "Steps of grow (in pixels)",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -891,11 +891,11 @@ register_selection_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("steps", g_param_spec_int ("steps",
"steps", "steps",
"Steps of shrink (in pixels)", "Steps of shrink (in pixels)",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpLayer *layer; GimpLayer *layer;
gint32 style = 0; gint style = 0;
layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp); 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; gboolean success = TRUE;
GimpLayer *layer; GimpLayer *layer;
gint32 style; gint style;
layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp); layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp);
style = g_value_get_enum (gimp_value_array_index (args, 1)); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpLayer *layer; GimpLayer *layer;
gint32 direction = 0; gint direction = 0;
layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp); 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; gboolean success = TRUE;
GimpLayer *layer; GimpLayer *layer;
gint32 direction; gint direction;
layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp); layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp);
direction = g_value_get_enum (gimp_value_array_index (args, 1)); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpLayer *layer; GimpLayer *layer;
gint32 justify = 0; gint justify = 0;
layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp); 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; gboolean success = TRUE;
GimpLayer *layer; GimpLayer *layer;
gint32 justify; gint justify;
layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp); layer = gimp_value_get_layer (gimp_value_array_index (args, 0), gimp);
justify = g_value_get_enum (gimp_value_array_index (args, 1)); 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 x;
gdouble y; gdouble y;
const gchar *text; const gchar *text;
gint32 border; gint border;
gboolean antialias; gboolean antialias;
gdouble size; gdouble size;
const gchar *fontname; const gchar *fontname;
@ -114,10 +114,10 @@ text_get_extents_fontname_invoker (GimpProcedure *procedure,
const gchar *text; const gchar *text;
gdouble size; gdouble size;
const gchar *fontname; const gchar *fontname;
gint32 width = 0; gint width = 0;
gint32 height = 0; gint height = 0;
gint32 ascent = 0; gint ascent = 0;
gint32 descent = 0; gint descent = 0;
text = g_value_get_string (gimp_value_array_index (args, 0)); text = g_value_get_string (gimp_value_array_index (args, 0));
size = g_value_get_double (gimp_value_array_index (args, 1)); size = g_value_get_double (gimp_value_array_index (args, 1));
@ -200,11 +200,11 @@ register_text_tool_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("border", g_param_spec_int ("border",
"border", "border",
"The size of the border", "The size of the border",
-1, G_MAXINT32, -1, -1, G_MAXINT32, -1,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("antialias", g_param_spec_boolean ("antialias",
"antialias", "antialias",
@ -282,29 +282,29 @@ register_text_tool_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("width", g_param_spec_int ("width",
"width", "width",
"The width of the specified font", "The width of the specified font",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("height", g_param_spec_int ("height",
"height", "height",
"The height of the specified font", "The height of the specified font",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("ascent", g_param_spec_int ("ascent",
"ascent", "ascent",
"The ascent of the specified font", "The ascent of the specified font",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("descent", g_param_spec_int ("descent",
"descent", "descent",
"The descent of the specified font", "The descent of the specified font",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (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) GError **error)
{ {
GimpValueArray *return_vals; GimpValueArray *return_vals;
gint32 num_units = 0; gint num_units = 0;
num_units = _gimp_unit_get_number_of_units (gimp); 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) GError **error)
{ {
GimpValueArray *return_vals; GimpValueArray *return_vals;
gint32 num_units = 0; gint num_units = 0;
num_units = _gimp_unit_get_number_of_built_in_units (gimp); num_units = _gimp_unit_get_number_of_built_in_units (gimp);
@ -87,7 +87,7 @@ unit_new_invoker (GimpProcedure *procedure,
GimpValueArray *return_vals; GimpValueArray *return_vals;
const gchar *identifier; const gchar *identifier;
gdouble factor; gdouble factor;
gint32 digits; gint digits;
const gchar *symbol; const gchar *symbol;
const gchar *abbreviation; const gchar *abbreviation;
const gchar *singular; const gchar *singular;
@ -239,7 +239,7 @@ unit_get_digits_invoker (GimpProcedure *procedure,
gboolean success = TRUE; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpUnit unit_id; GimpUnit unit_id;
gint32 digits = 0; gint digits = 0;
unit_id = g_value_get_int (gimp_value_array_index (args, 0)); unit_id = g_value_get_int (gimp_value_array_index (args, 0));
@ -393,11 +393,11 @@ register_unit_procs (GimpPDB *pdb)
"1999", "1999",
NULL); NULL);
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-units", g_param_spec_int ("num-units",
"num units", "num units",
"The number of units", "The number of units",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -416,11 +416,11 @@ register_unit_procs (GimpPDB *pdb)
"1999", "1999",
NULL); NULL);
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-units", g_param_spec_int ("num-units",
"num units", "num units",
"The number of built-in units", "The number of built-in units",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -452,11 +452,11 @@ register_unit_procs (GimpPDB *pdb)
-G_MAXDOUBLE, G_MAXDOUBLE, 0, -G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("digits", g_param_spec_int ("digits",
"digits", "digits",
"The new unit's digits", "The new unit's digits",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("symbol", gimp_param_spec_string ("symbol",
"symbol", "symbol",
@ -644,11 +644,11 @@ register_unit_procs (GimpPDB *pdb)
GIMP_UNIT_PIXEL, GIMP_UNIT_PIXEL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("digits", g_param_spec_int ("digits",
"digits", "digits",
"The unit's number of digits", "The unit's number of digits",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpVectors *vectors; GimpVectors *vectors;
gint32 num_strokes = 0; gint num_strokes = 0;
gint32 *stroke_ids = NULL; gint32 *stroke_ids = NULL;
vectors = gimp_value_get_vectors (gimp_value_array_index (args, 0), gimp); 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; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpVectors *vectors; GimpVectors *vectors;
gint32 stroke_id; gint stroke_id;
gdouble precision; gdouble precision;
gdouble length = 0.0; gdouble length = 0.0;
@ -257,7 +257,7 @@ vectors_stroke_get_point_at_dist_invoker (GimpProcedure *procedure,
gboolean success = TRUE; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpVectors *vectors; GimpVectors *vectors;
gint32 stroke_id; gint stroke_id;
gdouble dist; gdouble dist;
gdouble precision; gdouble precision;
gdouble x_point = 0.0; gdouble x_point = 0.0;
@ -311,7 +311,7 @@ vectors_remove_stroke_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
GimpVectors *vectors; GimpVectors *vectors;
gint32 stroke_id; gint stroke_id;
vectors = gimp_value_get_vectors (gimp_value_array_index (args, 0), gimp); vectors = gimp_value_get_vectors (gimp_value_array_index (args, 0), gimp);
stroke_id = g_value_get_int (gimp_value_array_index (args, 1)); 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; gboolean success = TRUE;
GimpVectors *vectors; GimpVectors *vectors;
gint32 stroke_id; gint stroke_id;
vectors = gimp_value_get_vectors (gimp_value_array_index (args, 0), gimp); vectors = gimp_value_get_vectors (gimp_value_array_index (args, 0), gimp);
stroke_id = g_value_get_int (gimp_value_array_index (args, 1)); 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; gboolean success = TRUE;
GimpVectors *vectors; GimpVectors *vectors;
gint32 stroke_id; gint stroke_id;
gint32 off_x; gint off_x;
gint32 off_y; gint off_y;
vectors = gimp_value_get_vectors (gimp_value_array_index (args, 0), gimp); vectors = gimp_value_get_vectors (gimp_value_array_index (args, 0), gimp);
stroke_id = g_value_get_int (gimp_value_array_index (args, 1)); 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; gboolean success = TRUE;
GimpVectors *vectors; GimpVectors *vectors;
gint32 stroke_id; gint stroke_id;
gdouble scale_x; gdouble scale_x;
gdouble scale_y; gdouble scale_y;
@ -477,7 +477,7 @@ vectors_stroke_rotate_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
GimpVectors *vectors; GimpVectors *vectors;
gint32 stroke_id; gint stroke_id;
gdouble center_x; gdouble center_x;
gdouble center_y; gdouble center_y;
gdouble angle; gdouble angle;
@ -524,8 +524,8 @@ vectors_stroke_flip_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
GimpVectors *vectors; GimpVectors *vectors;
gint32 stroke_id; gint stroke_id;
gint32 flip_type; gint flip_type;
gdouble axis; gdouble axis;
vectors = gimp_value_get_vectors (gimp_value_array_index (args, 0), gimp); 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; gboolean success = TRUE;
GimpVectors *vectors; GimpVectors *vectors;
gint32 stroke_id; gint stroke_id;
gdouble x1; gdouble x1;
gdouble y1; gdouble y1;
gdouble x2; gdouble x2;
@ -619,9 +619,9 @@ vectors_stroke_get_points_invoker (GimpProcedure *procedure,
gboolean success = TRUE; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpVectors *vectors; GimpVectors *vectors;
gint32 stroke_id; gint stroke_id;
gint32 type = 0; gint type = 0;
gint32 num_points = 0; gint num_points = 0;
gdouble *controlpoints = NULL; gdouble *controlpoints = NULL;
gboolean closed = FALSE; gboolean closed = FALSE;
@ -687,11 +687,11 @@ vectors_stroke_new_from_points_invoker (GimpProcedure *procedure,
gboolean success = TRUE; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpVectors *vectors; GimpVectors *vectors;
gint32 type; gint type;
gint32 num_points; gint num_points;
const gdouble *controlpoints; const gdouble *controlpoints;
gboolean closed; gboolean closed;
gint32 stroke_id = 0; gint stroke_id = 0;
vectors = gimp_value_get_vectors (gimp_value_array_index (args, 0), gimp); vectors = gimp_value_get_vectors (gimp_value_array_index (args, 0), gimp);
type = g_value_get_enum (gimp_value_array_index (args, 1)); type = g_value_get_enum (gimp_value_array_index (args, 1));
@ -759,9 +759,9 @@ vectors_stroke_interpolate_invoker (GimpProcedure *procedure,
gboolean success = TRUE; gboolean success = TRUE;
GimpValueArray *return_vals; GimpValueArray *return_vals;
GimpVectors *vectors; GimpVectors *vectors;
gint32 stroke_id; gint stroke_id;
gdouble precision; gdouble precision;
gint32 num_coords = 0; gint num_coords = 0;
gdouble *coords = NULL; gdouble *coords = NULL;
gboolean closed = FALSE; gboolean closed = FALSE;
@ -826,7 +826,7 @@ vectors_bezier_stroke_new_moveto_invoker (GimpProcedure *procedure,
GimpVectors *vectors; GimpVectors *vectors;
gdouble x0; gdouble x0;
gdouble y0; gdouble y0;
gint32 stroke_id = 0; gint stroke_id = 0;
vectors = gimp_value_get_vectors (gimp_value_array_index (args, 0), gimp); vectors = gimp_value_get_vectors (gimp_value_array_index (args, 0), gimp);
x0 = g_value_get_double (gimp_value_array_index (args, 1)); 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; gboolean success = TRUE;
GimpVectors *vectors; GimpVectors *vectors;
gint32 stroke_id; gint stroke_id;
gdouble x0; gdouble x0;
gdouble y0; gdouble y0;
@ -927,7 +927,7 @@ vectors_bezier_stroke_conicto_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
GimpVectors *vectors; GimpVectors *vectors;
gint32 stroke_id; gint stroke_id;
gdouble x0; gdouble x0;
gdouble y0; gdouble y0;
gdouble x1; gdouble x1;
@ -983,7 +983,7 @@ vectors_bezier_stroke_cubicto_invoker (GimpProcedure *procedure,
{ {
gboolean success = TRUE; gboolean success = TRUE;
GimpVectors *vectors; GimpVectors *vectors;
gint32 stroke_id; gint stroke_id;
gdouble x0; gdouble x0;
gdouble y0; gdouble y0;
gdouble x1; gdouble x1;
@ -1053,7 +1053,7 @@ vectors_bezier_stroke_new_ellipse_invoker (GimpProcedure *procedure,
gdouble radius_x; gdouble radius_x;
gdouble radius_y; gdouble radius_y;
gdouble angle; gdouble angle;
gint32 stroke_id = 0; gint stroke_id = 0;
vectors = gimp_value_get_vectors (gimp_value_array_index (args, 0), gimp); vectors = gimp_value_get_vectors (gimp_value_array_index (args, 0), gimp);
x0 = g_value_get_double (gimp_value_array_index (args, 1)); 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; const gchar *filename;
gboolean merge; gboolean merge;
gboolean scale; gboolean scale;
gint32 num_vectors = 0; gint num_vectors = 0;
gint32 *vectors_ids = NULL; gint32 *vectors_ids = NULL;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); 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; GimpValueArray *return_vals;
GimpImage *image; GimpImage *image;
const gchar *string; const gchar *string;
gint32 length; gint length;
gboolean merge; gboolean merge;
gboolean scale; gboolean scale;
gint32 num_vectors = 0; gint num_vectors = 0;
gint32 *vectors_ids = NULL; gint32 *vectors_ids = NULL;
image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
@ -1418,11 +1418,11 @@ register_vectors_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-strokes", g_param_spec_int ("num-strokes",
"num strokes", "num strokes",
"The number of strokes returned.", "The number of strokes returned.",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32_array ("stroke-ids", gimp_param_spec_int32_array ("stroke-ids",
"stroke ids", "stroke ids",
@ -1452,11 +1452,11 @@ register_vectors_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("stroke-id", g_param_spec_int ("stroke-id",
"stroke id", "stroke id",
"The stroke ID", "The stroke ID",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
g_param_spec_double ("precision", g_param_spec_double ("precision",
"precision", "precision",
@ -1493,11 +1493,11 @@ register_vectors_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("stroke-id", g_param_spec_int ("stroke-id",
"stroke id", "stroke id",
"The stroke ID", "The stroke ID",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
g_param_spec_double ("dist", g_param_spec_double ("dist",
"dist", "dist",
@ -1558,11 +1558,11 @@ register_vectors_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("stroke-id", g_param_spec_int ("stroke-id",
"stroke id", "stroke id",
"The stroke ID", "The stroke ID",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -1587,11 +1587,11 @@ register_vectors_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("stroke-id", g_param_spec_int ("stroke-id",
"stroke id", "stroke id",
"The stroke ID", "The stroke ID",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -1616,23 +1616,23 @@ register_vectors_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("stroke-id", g_param_spec_int ("stroke-id",
"stroke id", "stroke id",
"The stroke ID", "The stroke ID",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("off-x", g_param_spec_int ("off-x",
"off x", "off x",
"Offset in x direction", "Offset in x direction",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("off-y", g_param_spec_int ("off-y",
"off y", "off y",
"Offset in y direction", "Offset in y direction",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -1657,11 +1657,11 @@ register_vectors_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("stroke-id", g_param_spec_int ("stroke-id",
"stroke id", "stroke id",
"The stroke ID", "The stroke ID",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
g_param_spec_double ("scale-x", g_param_spec_double ("scale-x",
"scale x", "scale x",
@ -1698,11 +1698,11 @@ register_vectors_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("stroke-id", g_param_spec_int ("stroke-id",
"stroke id", "stroke id",
"The stroke ID", "The stroke ID",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
g_param_spec_double ("center-x", g_param_spec_double ("center-x",
"center x", "center x",
@ -1745,11 +1745,11 @@ register_vectors_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("stroke-id", g_param_spec_int ("stroke-id",
"stroke id", "stroke id",
"The stroke ID", "The stroke ID",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_enum ("flip-type", gimp_param_spec_enum ("flip-type",
"flip type", "flip type",
@ -1789,11 +1789,11 @@ register_vectors_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("stroke-id", g_param_spec_int ("stroke-id",
"stroke id", "stroke id",
"The stroke ID", "The stroke ID",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
g_param_spec_double ("x1", g_param_spec_double ("x1",
"x1", "x1",
@ -1842,11 +1842,11 @@ register_vectors_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("stroke-id", g_param_spec_int ("stroke-id",
"stroke id", "stroke id",
"The stroke ID", "The stroke ID",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
g_param_spec_enum ("type", g_param_spec_enum ("type",
"type", "type",
@ -1855,11 +1855,11 @@ register_vectors_procs (GimpPDB *pdb)
GIMP_VECTORS_STROKE_TYPE_BEZIER, GIMP_VECTORS_STROKE_TYPE_BEZIER,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-points", g_param_spec_int ("num-points",
"num points", "num points",
"The number of floats returned.", "The number of floats returned.",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_float_array ("controlpoints", gimp_param_spec_float_array ("controlpoints",
"controlpoints", "controlpoints",
@ -1902,11 +1902,11 @@ register_vectors_procs (GimpPDB *pdb)
GIMP_VECTORS_STROKE_TYPE_BEZIER, GIMP_VECTORS_STROKE_TYPE_BEZIER,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("num-points", g_param_spec_int ("num-points",
"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).", "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, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("controlpoints", gimp_param_spec_float_array ("controlpoints",
"controlpoints", "controlpoints",
@ -1919,11 +1919,11 @@ register_vectors_procs (GimpPDB *pdb)
FALSE, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("stroke-id", g_param_spec_int ("stroke-id",
"stroke id", "stroke id",
"The stroke ID of the newly created stroke.", "The stroke ID of the newly created stroke.",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -1948,11 +1948,11 @@ register_vectors_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("stroke-id", g_param_spec_int ("stroke-id",
"stroke id", "stroke id",
"The stroke ID", "The stroke ID",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
g_param_spec_double ("precision", g_param_spec_double ("precision",
"precision", "precision",
@ -1960,11 +1960,11 @@ register_vectors_procs (GimpPDB *pdb)
-G_MAXDOUBLE, G_MAXDOUBLE, 0, -G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-coords", g_param_spec_int ("num-coords",
"num coords", "num coords",
"The number of floats returned.", "The number of floats returned.",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_float_array ("coords", gimp_param_spec_float_array ("coords",
"coords", "coords",
@ -2012,11 +2012,11 @@ register_vectors_procs (GimpPDB *pdb)
-G_MAXDOUBLE, G_MAXDOUBLE, 0, -G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("stroke-id", g_param_spec_int ("stroke-id",
"stroke id", "stroke id",
"The resulting stroke", "The resulting stroke",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -2041,11 +2041,11 @@ register_vectors_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("stroke-id", g_param_spec_int ("stroke-id",
"stroke id", "stroke id",
"The stroke ID", "The stroke ID",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
g_param_spec_double ("x0", g_param_spec_double ("x0",
"x0", "x0",
@ -2082,11 +2082,11 @@ register_vectors_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("stroke-id", g_param_spec_int ("stroke-id",
"stroke id", "stroke id",
"The stroke ID", "The stroke ID",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
g_param_spec_double ("x0", g_param_spec_double ("x0",
"x0", "x0",
@ -2135,11 +2135,11 @@ register_vectors_procs (GimpPDB *pdb)
pdb->gimp, FALSE, pdb->gimp, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("stroke-id", g_param_spec_int ("stroke-id",
"stroke id", "stroke id",
"The stroke ID", "The stroke ID",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
g_param_spec_double ("x0", g_param_spec_double ("x0",
"x0", "x0",
@ -2230,11 +2230,11 @@ register_vectors_procs (GimpPDB *pdb)
-G_MAXDOUBLE, G_MAXDOUBLE, 0, -G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("stroke-id", g_param_spec_int ("stroke-id",
"stroke id", "stroke id",
"The resulting stroke", "The resulting stroke",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@ -2278,11 +2278,11 @@ register_vectors_procs (GimpPDB *pdb)
FALSE, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-vectors", g_param_spec_int ("num-vectors",
"num vectors", "num vectors",
"The number of newly created vectors", "The number of newly created vectors",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32_array ("vectors-ids", gimp_param_spec_int32_array ("vectors-ids",
"vectors ids", "vectors ids",
@ -2319,11 +2319,11 @@ register_vectors_procs (GimpPDB *pdb)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("length", g_param_spec_int ("length",
"length", "length",
"Number of bytes in string or -1 if the string is NULL terminated.", "Number of bytes in string or -1 if the string is NULL terminated.",
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("merge", g_param_spec_boolean ("merge",
"merge", "merge",
@ -2337,11 +2337,11 @@ register_vectors_procs (GimpPDB *pdb)
FALSE, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("num-vectors", g_param_spec_int ("num-vectors",
"num vectors", "num vectors",
"The number of newly created vectors", "The number of newly created vectors",
0, G_MAXINT32, 0, 0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32_array ("vectors-ids", gimp_param_spec_int32_array ("vectors-ids",
"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, param_def->meta.m_int.default_val,
flags); 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")) if (! strcmp (param_def->type_name, "GimpParamInt16"))
return gimp_param_spec_int16 (name, nick, blurb, return gimp_param_spec_int16 (name, nick, blurb,
param_def->meta.m_int.min_val, 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, "GimpParamIntStringArray") ||
! strcmp (param_def->type_name, "GimpParamIntColorArray")) ! 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, gimp_message (plug_in->manager->gimp, NULL, GIMP_MESSAGE_ERROR,
"Plug-in \"%s\"\n(%s)\n\n" "Plug-in \"%s\"\n(%s)\n\n"
@ -876,7 +876,7 @@ gimp_plug_in_handle_proc_install (GimpPlugIn *plug_in,
if (pspec) if (pspec)
{ {
if (i == 0 && 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)) ||
! 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) || if (! GIMP_IS_TEMPORARY_PROCEDURE (procedure) ||
GIMP_TEMPORARY_PROCEDURE (procedure)->plug_in != plug_in || GIMP_TEMPORARY_PROCEDURE (procedure)->plug_in != plug_in ||
procedure->num_args != 3 || procedure->num_args != 3 ||
! GIMP_IS_PARAM_SPEC_INT32 (procedure->args[0]) || ! G_IS_PARAM_SPEC_INT (procedure->args[0]) ||
! G_IS_PARAM_SPEC_STRING (procedure->args[1]) || ! G_IS_PARAM_SPEC_STRING (procedure->args[1]) ||
! G_IS_PARAM_SPEC_DOUBLE (procedure->args[2])) ! G_IS_PARAM_SPEC_DOUBLE (procedure->args[2]))
{ {
return FALSE; 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), 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_width (brush),
G_TYPE_INT, gimp_brush_get_height (brush), G_TYPE_INT, gimp_brush_get_height (brush),
GIMP_TYPE_INT32, array->length, G_TYPE_INT, array->length,
GIMP_TYPE_INT8_ARRAY, array, GIMP_TYPE_INT8_ARRAY, array,
G_TYPE_BOOLEAN, closing, G_TYPE_BOOLEAN, closing,
G_TYPE_NONE); G_TYPE_NONE);

2
app/widgets/gimpgradientselect.c
View File

@ -184,7 +184,7 @@ gimp_gradient_select_run_callback (GimpPdbDialog *dialog,
NULL, error, NULL, error,
dialog->callback_name, dialog->callback_name,
G_TYPE_STRING, gimp_object_get_name (object), 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, GIMP_TYPE_FLOAT_ARRAY, array,
G_TYPE_BOOLEAN, closing, G_TYPE_BOOLEAN, closing,
G_TYPE_NONE); 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_width (pattern->mask),
G_TYPE_INT, gimp_temp_buf_get_height (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)), 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, GIMP_TYPE_INT8_ARRAY, array,
G_TYPE_BOOLEAN, closing, G_TYPE_BOOLEAN, closing,
G_TYPE_NONE); 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_READABLE
GIMP_PARAM_WRITABLE GIMP_PARAM_WRITABLE
GIMP_PARAM_READWRITE GIMP_PARAM_READWRITE
gimp_param_spec_int32
gimp_param_spec_int16 gimp_param_spec_int16
gimp_param_spec_string gimp_param_spec_string
gimp_array_new gimp_array_new
@ -347,7 +346,6 @@ GIMP_IS_PARAM_SPEC_ARRAY
GIMP_IS_PARAM_SPEC_FLOAT_ARRAY GIMP_IS_PARAM_SPEC_FLOAT_ARRAY
GIMP_IS_PARAM_SPEC_INT16 GIMP_IS_PARAM_SPEC_INT16
GIMP_IS_PARAM_SPEC_INT16_ARRAY GIMP_IS_PARAM_SPEC_INT16_ARRAY
GIMP_IS_PARAM_SPEC_INT32
GIMP_IS_PARAM_SPEC_INT32_ARRAY GIMP_IS_PARAM_SPEC_INT32_ARRAY
GIMP_IS_PARAM_SPEC_INT8_ARRAY GIMP_IS_PARAM_SPEC_INT8_ARRAY
GIMP_IS_PARAM_SPEC_RGB_ARRAY GIMP_IS_PARAM_SPEC_RGB_ARRAY
@ -357,7 +355,6 @@ GIMP_PARAM_SPEC_ARRAY
GIMP_PARAM_SPEC_FLOAT_ARRAY GIMP_PARAM_SPEC_FLOAT_ARRAY
GIMP_PARAM_SPEC_INT16 GIMP_PARAM_SPEC_INT16
GIMP_PARAM_SPEC_INT16_ARRAY GIMP_PARAM_SPEC_INT16_ARRAY
GIMP_PARAM_SPEC_INT32
GIMP_PARAM_SPEC_INT32_ARRAY GIMP_PARAM_SPEC_INT32_ARRAY
GIMP_PARAM_SPEC_INT8_ARRAY GIMP_PARAM_SPEC_INT8_ARRAY
GIMP_PARAM_SPEC_RGB_ARRAY GIMP_PARAM_SPEC_RGB_ARRAY
@ -367,14 +364,12 @@ GIMP_TYPE_ARRAY
GIMP_TYPE_FLOAT_ARRAY GIMP_TYPE_FLOAT_ARRAY
GIMP_TYPE_INT16 GIMP_TYPE_INT16
GIMP_TYPE_INT16_ARRAY GIMP_TYPE_INT16_ARRAY
GIMP_TYPE_INT32
GIMP_TYPE_INT32_ARRAY GIMP_TYPE_INT32_ARRAY
GIMP_TYPE_INT8_ARRAY GIMP_TYPE_INT8_ARRAY
GIMP_TYPE_PARAM_ARRAY GIMP_TYPE_PARAM_ARRAY
GIMP_TYPE_PARAM_FLOAT_ARRAY GIMP_TYPE_PARAM_FLOAT_ARRAY
GIMP_TYPE_PARAM_INT16 GIMP_TYPE_PARAM_INT16
GIMP_TYPE_PARAM_INT16_ARRAY GIMP_TYPE_PARAM_INT16_ARRAY
GIMP_TYPE_PARAM_INT32
GIMP_TYPE_PARAM_INT32_ARRAY GIMP_TYPE_PARAM_INT32_ARRAY
GIMP_TYPE_PARAM_INT8_ARRAY GIMP_TYPE_PARAM_INT8_ARRAY
GIMP_TYPE_PARAM_RGB_ARRAY GIMP_TYPE_PARAM_RGB_ARRAY
@ -386,7 +381,6 @@ GIMP_VALUE_HOLDS_ARRAY
GIMP_VALUE_HOLDS_FLOAT_ARRAY GIMP_VALUE_HOLDS_FLOAT_ARRAY
GIMP_VALUE_HOLDS_INT16 GIMP_VALUE_HOLDS_INT16
GIMP_VALUE_HOLDS_INT16_ARRAY GIMP_VALUE_HOLDS_INT16_ARRAY
GIMP_VALUE_HOLDS_INT32
GIMP_VALUE_HOLDS_INT32_ARRAY GIMP_VALUE_HOLDS_INT32_ARRAY
GIMP_VALUE_HOLDS_INT8_ARRAY GIMP_VALUE_HOLDS_INT8_ARRAY
GIMP_VALUE_HOLDS_RGB_ARRAY GIMP_VALUE_HOLDS_RGB_ARRAY
@ -397,7 +391,6 @@ GimpParamSpecArray
GimpParamSpecFloatArray GimpParamSpecFloatArray
GimpParamSpecInt16 GimpParamSpecInt16
GimpParamSpecInt16Array GimpParamSpecInt16Array
GimpParamSpecInt32
GimpParamSpecInt32Array GimpParamSpecInt32Array
GimpParamSpecInt8Array GimpParamSpecInt8Array
GimpParamSpecRGBArray GimpParamSpecRGBArray
@ -408,14 +401,12 @@ gimp_float_array_get_type
gimp_int16_array_get_type gimp_int16_array_get_type
gimp_int16_get_type gimp_int16_get_type
gimp_int32_array_get_type gimp_int32_array_get_type
gimp_int32_get_type
gimp_int8_array_get_type gimp_int8_array_get_type
gimp_param_array_get_type gimp_param_array_get_type
gimp_param_float_array_get_type gimp_param_float_array_get_type
gimp_param_int16_array_get_type gimp_param_int16_array_get_type
gimp_param_int16_get_type gimp_param_int16_get_type
gimp_param_int32_array_get_type gimp_param_int32_array_get_type
gimp_param_int32_get_type
gimp_param_int8_array_get_type gimp_param_int8_array_get_type
gimp_param_rgb_array_get_type gimp_param_rgb_array_get_type
gimp_param_string_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_array_get_type
gimp_int16_get_type gimp_int16_get_type
gimp_int32_array_get_type gimp_int32_array_get_type
gimp_int32_get_type
gimp_int8_array_get_type gimp_int8_array_get_type
gimp_memsize_get_type gimp_memsize_get_type
gimp_metadata_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_array_get_type
gimp_param_int16_get_type gimp_param_int16_get_type
gimp_param_int32_array_get_type gimp_param_int32_array_get_type
gimp_param_int32_get_type
gimp_param_int8_array_get_type gimp_param_int8_array_get_type
gimp_param_rgb_array_get_type gimp_param_rgb_array_get_type
gimp_param_string_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[] = GType init_types[] =
{ {
GIMP_TYPE_INT32, GIMP_TYPE_PARAM_INT32, G_TYPE_INT, G_TYPE_PARAM_INT,
GIMP_TYPE_INT16, GIMP_TYPE_PARAM_INT16, GIMP_TYPE_INT16, GIMP_TYPE_PARAM_INT16,
G_TYPE_UCHAR, G_TYPE_PARAM_UCHAR, 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, args = gimp_value_array_new_from_types (NULL,
G_TYPE_STRING, name, G_TYPE_STRING, name,
GIMP_TYPE_INT32, spacing, G_TYPE_INT, spacing,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -767,7 +767,7 @@ gimp_brush_set_spikes (const gchar *name,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
G_TYPE_STRING, name, G_TYPE_STRING, name,
GIMP_TYPE_INT32, spikes_in, G_TYPE_INT, spikes_in,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)

12
libgimp/gimpbrushselect.c
View File

@ -123,12 +123,12 @@ gimp_brush_select_new (const gchar *title,
0, 10000, 0, 0, 10000, 0,
G_PARAM_READWRITE)); G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("mask-len", g_param_spec_int ("mask-len",
"Mask length", "Mask length",
"Length of brush " "Length of brush "
"mask data", "mask data",
0, G_MAXINT, 0, 0, G_MAXINT, 0,
G_PARAM_READWRITE)); G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int8_array ("mask-data", gimp_param_spec_int8_array ("mask-data",
"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, popup_title,
G_TYPE_STRING, initial_brush, G_TYPE_STRING, initial_brush,
G_TYPE_DOUBLE, opacity, G_TYPE_DOUBLE, opacity,
GIMP_TYPE_INT32, spacing, G_TYPE_INT, spacing,
GIMP_TYPE_LAYER_MODE, paint_mode, GIMP_TYPE_LAYER_MODE, paint_mode,
G_TYPE_NONE); G_TYPE_NONE);
@ -155,7 +155,7 @@ gimp_brushes_set_popup (const gchar *brush_callback,
G_TYPE_STRING, brush_callback, G_TYPE_STRING, brush_callback,
G_TYPE_STRING, brush_name, G_TYPE_STRING, brush_name,
G_TYPE_DOUBLE, opacity, G_TYPE_DOUBLE, opacity,
GIMP_TYPE_INT32, spacing, G_TYPE_INT, spacing,
GIMP_TYPE_LAYER_MODE, paint_mode, GIMP_TYPE_LAYER_MODE, paint_mode,
G_TYPE_NONE); 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, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_IMAGE_ID, image_ID, GIMP_TYPE_IMAGE_ID, image_ID,
GIMP_TYPE_INT32, width, G_TYPE_INT, width,
GIMP_TYPE_INT32, height, G_TYPE_INT, height,
G_TYPE_STRING, name, G_TYPE_STRING, name,
G_TYPE_DOUBLE, opacity, G_TYPE_DOUBLE, opacity,
GIMP_TYPE_RGB, color, 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, channel1_ID,
GIMP_TYPE_CHANNEL_ID, channel2_ID, GIMP_TYPE_CHANNEL_ID, channel2_ID,
GIMP_TYPE_CHANNEL_OPS, operation, GIMP_TYPE_CHANNEL_OPS, operation,
GIMP_TYPE_INT32, offx, G_TYPE_INT, offx,
GIMP_TYPE_INT32, offy, G_TYPE_INT, offy,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) 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; gboolean success = TRUE;
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_INT32, num_dashes, G_TYPE_INT, num_dashes,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_FLOAT_ARRAY, NULL,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 1), dashes, num_dashes); 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; gboolean success = TRUE;
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_INT32, sample_threshold, G_TYPE_INT, sample_threshold,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) 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, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE_ID, drawable_ID, GIMP_TYPE_DRAWABLE_ID, drawable_ID,
GIMP_TYPE_INT32, x, G_TYPE_INT, x,
GIMP_TYPE_INT32, y, G_TYPE_INT, y,
GIMP_TYPE_INT32, width, G_TYPE_INT, width,
GIMP_TYPE_INT32, height, G_TYPE_INT, height,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -830,8 +830,8 @@ gimp_drawable_get_pixel (gint32 drawable_ID,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE_ID, drawable_ID, GIMP_TYPE_DRAWABLE_ID, drawable_ID,
GIMP_TYPE_INT32, x_coord, G_TYPE_INT, x_coord,
GIMP_TYPE_INT32, y_coord, G_TYPE_INT, y_coord,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -888,9 +888,9 @@ gimp_drawable_set_pixel (gint32 drawable_ID,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE_ID, drawable_ID, GIMP_TYPE_DRAWABLE_ID, drawable_ID,
GIMP_TYPE_INT32, x_coord, G_TYPE_INT, x_coord,
GIMP_TYPE_INT32, y_coord, G_TYPE_INT, y_coord,
GIMP_TYPE_INT32, num_channels, G_TYPE_INT, num_channels,
GIMP_TYPE_INT8_ARRAY, NULL, GIMP_TYPE_INT8_ARRAY, NULL,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_int8_array (gimp_value_array_index (args, 4), pixel, num_channels); 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, GIMP_TYPE_DRAWABLE_ID, drawable_ID,
G_TYPE_BOOLEAN, wrap_around, G_TYPE_BOOLEAN, wrap_around,
GIMP_TYPE_OFFSET_TYPE, fill_type, GIMP_TYPE_OFFSET_TYPE, fill_type,
GIMP_TYPE_INT32, offset_x, G_TYPE_INT, offset_x,
GIMP_TYPE_INT32, offset_y, G_TYPE_INT, offset_y,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -1055,8 +1055,8 @@ _gimp_drawable_thumbnail (gint32 drawable_ID,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE_ID, drawable_ID, GIMP_TYPE_DRAWABLE_ID, drawable_ID,
GIMP_TYPE_INT32, width, G_TYPE_INT, width,
GIMP_TYPE_INT32, height, G_TYPE_INT, height,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -1137,12 +1137,12 @@ _gimp_drawable_sub_thumbnail (gint32 drawable_ID,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE_ID, drawable_ID, GIMP_TYPE_DRAWABLE_ID, drawable_ID,
GIMP_TYPE_INT32, src_x, G_TYPE_INT, src_x,
GIMP_TYPE_INT32, src_y, G_TYPE_INT, src_y,
GIMP_TYPE_INT32, src_width, G_TYPE_INT, src_width,
GIMP_TYPE_INT32, src_height, G_TYPE_INT, src_height,
GIMP_TYPE_INT32, dest_width, G_TYPE_INT, dest_width,
GIMP_TYPE_INT32, dest_height, G_TYPE_INT, dest_height,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) 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, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE_ID, drawable_ID, GIMP_TYPE_DRAWABLE_ID, drawable_ID,
GIMP_TYPE_HISTOGRAM_CHANNEL, channel, GIMP_TYPE_HISTOGRAM_CHANNEL, channel,
GIMP_TYPE_INT32, num_values, G_TYPE_INT, num_values,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_FLOAT_ARRAY, NULL,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 3), values, num_values); 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, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE_ID, drawable_ID, GIMP_TYPE_DRAWABLE_ID, drawable_ID,
GIMP_TYPE_HISTOGRAM_CHANNEL, channel, GIMP_TYPE_HISTOGRAM_CHANNEL, channel,
GIMP_TYPE_INT32, num_points, G_TYPE_INT, num_points,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_FLOAT_ARRAY, NULL,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 3), points, num_points); 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, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE_ID, drawable_ID, GIMP_TYPE_DRAWABLE_ID, drawable_ID,
GIMP_TYPE_INT32, levels, G_TYPE_INT, levels,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) 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, GIMP_TYPE_GRADIENT_TYPE, gradient_type,
G_TYPE_DOUBLE, offset, G_TYPE_DOUBLE, offset,
G_TYPE_BOOLEAN, supersample, G_TYPE_BOOLEAN, supersample,
GIMP_TYPE_INT32, supersample_max_depth, G_TYPE_INT, supersample_max_depth,
G_TYPE_DOUBLE, supersample_threshold, G_TYPE_DOUBLE, supersample_threshold,
G_TYPE_BOOLEAN, dither, G_TYPE_BOOLEAN, dither,
G_TYPE_DOUBLE, x1, 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, args = gimp_value_array_new_from_types (NULL,
G_TYPE_STRING, procedure_name, G_TYPE_STRING, procedure_name,
GIMP_TYPE_INT32, priority, G_TYPE_INT, priority,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)

9
libgimp/gimpgpcompat.c
View File

@ -46,9 +46,9 @@ _gimp_gp_compat_param_spec (GimpPDBArgType arg_type,
switch (arg_type) switch (arg_type)
{ {
case GIMP_PDB_INT32: case GIMP_PDB_INT32:
pspec = gimp_param_spec_int32 (name, nick, blurb, pspec = g_param_spec_int (name, nick, blurb,
G_MININT32, G_MAXINT32, 0, G_MININT32, G_MAXINT32, 0,
G_PARAM_READWRITE); G_PARAM_READWRITE);
break; break;
case GIMP_PDB_INT16: case GIMP_PDB_INT16:
@ -189,7 +189,7 @@ _gimp_pdb_arg_type_to_gtype (GimpPDBArgType type)
switch (type) switch (type)
{ {
case GIMP_PDB_INT32: case GIMP_PDB_INT32:
return GIMP_TYPE_INT32; return G_TYPE_INT;
case GIMP_PDB_INT16: case GIMP_PDB_INT16:
return GIMP_TYPE_INT16; return GIMP_TYPE_INT16;
@ -279,7 +279,6 @@ _gimp_pdb_gtype_to_arg_type (GType type)
} }
type_mapping[] = type_mapping[] =
{ {
{ GIMP_TYPE_INT32, GIMP_PDB_INT32 },
{ G_TYPE_INT, GIMP_PDB_INT32 }, { G_TYPE_INT, GIMP_PDB_INT32 },
{ G_TYPE_UINT, GIMP_PDB_INT32 }, { G_TYPE_UINT, GIMP_PDB_INT32 },
{ G_TYPE_ENUM, 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); pspec_type = G_PARAM_SPEC_TYPE (pspec);
if (pspec_type == G_TYPE_PARAM_INT || if (pspec_type == G_TYPE_PARAM_INT ||
pspec_type == GIMP_TYPE_PARAM_INT32 ||
pspec_type == GIMP_TYPE_PARAM_INT16) pspec_type == GIMP_TYPE_PARAM_INT16)
{ {
GParamSpecInt *ispec = G_PARAM_SPEC_INT (pspec); GParamSpecInt *ispec = G_PARAM_SPEC_INT (pspec);
@ -192,7 +191,6 @@ _gimp_gp_param_to_value (gpointer gimp,
g_value_init (value, type); g_value_init (value, type);
if (type == G_TYPE_INT || if (type == G_TYPE_INT ||
type == GIMP_TYPE_INT32 ||
type == GIMP_TYPE_INT16 || type == GIMP_TYPE_INT16 ||
type == GIMP_TYPE_UNIT) type == GIMP_TYPE_UNIT)
{ {
@ -386,19 +384,19 @@ _gimp_gp_params_to_value_array (gpointer gimp,
*/ */
type = pspec_type; 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 (g_type_is_a (pspec_type, G_TYPE_ENUM))
{ {
/* if the param spec's type is enum, but an /* 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; type = pspec_type;
} }
else if (g_type_is_a (pspec_type, G_TYPE_BOOLEAN)) else if (g_type_is_a (pspec_type, G_TYPE_BOOLEAN))
{ {
/* if the param spec's type is boolean, but /* 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.
*/ */
type = pspec_type; type = pspec_type;
@ -437,7 +435,6 @@ _gimp_value_to_gp_param (const GValue *value,
param->type_name = (gchar *) g_type_name (type); param->type_name = (gchar *) g_type_name (type);
if (type == G_TYPE_INT || if (type == G_TYPE_INT ||
type == GIMP_TYPE_INT32 ||
type == GIMP_TYPE_INT16 || type == GIMP_TYPE_INT16 ||
type == GIMP_TYPE_UNIT) 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, param_def->meta.m_int.default_val,
flags); 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")) if (! strcmp (param_def->type_name, "GimpParamInt16"))
return gimp_param_spec_int16 (name, nick, blurb, return gimp_param_spec_int16 (name, nick, blurb,
param_def->meta.m_int.min_val, 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, args = gimp_value_array_new_from_types (NULL,
G_TYPE_STRING, name, G_TYPE_STRING, name,
GIMP_TYPE_INT32, num_samples, G_TYPE_INT, num_samples,
G_TYPE_BOOLEAN, reverse, G_TYPE_BOOLEAN, reverse,
G_TYPE_NONE); G_TYPE_NONE);
@ -388,7 +388,7 @@ gimp_gradient_get_custom_samples (const gchar *name,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
G_TYPE_STRING, name, G_TYPE_STRING, name,
GIMP_TYPE_INT32, num_samples, G_TYPE_INT, num_samples,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_FLOAT_ARRAY, NULL,
G_TYPE_BOOLEAN, reverse, G_TYPE_BOOLEAN, reverse,
G_TYPE_NONE); G_TYPE_NONE);
@ -448,7 +448,7 @@ gimp_gradient_segment_get_left_color (const gchar *name,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
G_TYPE_STRING, name, G_TYPE_STRING, name,
GIMP_TYPE_INT32, segment, G_TYPE_INT, segment,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -504,7 +504,7 @@ gimp_gradient_segment_set_left_color (const gchar *name,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
G_TYPE_STRING, name, G_TYPE_STRING, name,
GIMP_TYPE_INT32, segment, G_TYPE_INT, segment,
GIMP_TYPE_RGB, color, GIMP_TYPE_RGB, color,
G_TYPE_DOUBLE, opacity, G_TYPE_DOUBLE, opacity,
G_TYPE_NONE); G_TYPE_NONE);
@ -554,7 +554,7 @@ gimp_gradient_segment_get_right_color (const gchar *name,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
G_TYPE_STRING, name, G_TYPE_STRING, name,
GIMP_TYPE_INT32, segment, G_TYPE_INT, segment,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -610,7 +610,7 @@ gimp_gradient_segment_set_right_color (const gchar *name,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
G_TYPE_STRING, name, G_TYPE_STRING, name,
GIMP_TYPE_INT32, segment, G_TYPE_INT, segment,
GIMP_TYPE_RGB, color, GIMP_TYPE_RGB, color,
G_TYPE_DOUBLE, opacity, G_TYPE_DOUBLE, opacity,
G_TYPE_NONE); G_TYPE_NONE);
@ -658,7 +658,7 @@ gimp_gradient_segment_get_left_pos (const gchar *name,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
G_TYPE_STRING, name, G_TYPE_STRING, name,
GIMP_TYPE_INT32, segment, G_TYPE_INT, segment,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -714,7 +714,7 @@ gimp_gradient_segment_set_left_pos (const gchar *name,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
G_TYPE_STRING, name, G_TYPE_STRING, name,
GIMP_TYPE_INT32, segment, G_TYPE_INT, segment,
G_TYPE_DOUBLE, pos, G_TYPE_DOUBLE, pos,
G_TYPE_NONE); G_TYPE_NONE);
@ -766,7 +766,7 @@ gimp_gradient_segment_get_middle_pos (const gchar *name,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
G_TYPE_STRING, name, G_TYPE_STRING, name,
GIMP_TYPE_INT32, segment, G_TYPE_INT, segment,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -821,7 +821,7 @@ gimp_gradient_segment_set_middle_pos (const gchar *name,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
G_TYPE_STRING, name, G_TYPE_STRING, name,
GIMP_TYPE_INT32, segment, G_TYPE_INT, segment,
G_TYPE_DOUBLE, pos, G_TYPE_DOUBLE, pos,
G_TYPE_NONE); G_TYPE_NONE);
@ -873,7 +873,7 @@ gimp_gradient_segment_get_right_pos (const gchar *name,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
G_TYPE_STRING, name, G_TYPE_STRING, name,
GIMP_TYPE_INT32, segment, G_TYPE_INT, segment,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -929,7 +929,7 @@ gimp_gradient_segment_set_right_pos (const gchar *name,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
G_TYPE_STRING, name, G_TYPE_STRING, name,
GIMP_TYPE_INT32, segment, G_TYPE_INT, segment,
G_TYPE_DOUBLE, pos, G_TYPE_DOUBLE, pos,
G_TYPE_NONE); G_TYPE_NONE);
@ -981,7 +981,7 @@ gimp_gradient_segment_get_blending_function (const gchar *name,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
G_TYPE_STRING, name, G_TYPE_STRING, name,
GIMP_TYPE_INT32, segment, G_TYPE_INT, segment,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -1032,7 +1032,7 @@ gimp_gradient_segment_get_coloring_type (const gchar *name,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
G_TYPE_STRING, name, G_TYPE_STRING, name,
GIMP_TYPE_INT32, segment, G_TYPE_INT, segment,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -1085,8 +1085,8 @@ gimp_gradient_segment_range_set_blending_function (const gchar *name
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
G_TYPE_STRING, name, G_TYPE_STRING, name,
GIMP_TYPE_INT32, start_segment, G_TYPE_INT, start_segment,
GIMP_TYPE_INT32, end_segment, G_TYPE_INT, end_segment,
GIMP_TYPE_GRADIENT_SEGMENT_TYPE, blending_function, GIMP_TYPE_GRADIENT_SEGMENT_TYPE, blending_function,
G_TYPE_NONE); 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, args = gimp_value_array_new_from_types (NULL,
G_TYPE_STRING, name, G_TYPE_STRING, name,
GIMP_TYPE_INT32, start_segment, G_TYPE_INT, start_segment,
GIMP_TYPE_INT32, end_segment, G_TYPE_INT, end_segment,
GIMP_TYPE_GRADIENT_SEGMENT_COLOR, coloring_type, GIMP_TYPE_GRADIENT_SEGMENT_COLOR, coloring_type,
G_TYPE_NONE); G_TYPE_NONE);
@ -1182,8 +1182,8 @@ gimp_gradient_segment_range_flip (const gchar *name,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
G_TYPE_STRING, name, G_TYPE_STRING, name,
GIMP_TYPE_INT32, start_segment, G_TYPE_INT, start_segment,
GIMP_TYPE_INT32, end_segment, G_TYPE_INT, end_segment,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -1232,9 +1232,9 @@ gimp_gradient_segment_range_replicate (const gchar *name,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
G_TYPE_STRING, name, G_TYPE_STRING, name,
GIMP_TYPE_INT32, start_segment, G_TYPE_INT, start_segment,
GIMP_TYPE_INT32, end_segment, G_TYPE_INT, end_segment,
GIMP_TYPE_INT32, replicate_times, G_TYPE_INT, replicate_times,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -1280,8 +1280,8 @@ gimp_gradient_segment_range_split_midpoint (const gchar *name,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
G_TYPE_STRING, name, G_TYPE_STRING, name,
GIMP_TYPE_INT32, start_segment, G_TYPE_INT, start_segment,
GIMP_TYPE_INT32, end_segment, G_TYPE_INT, end_segment,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -1329,9 +1329,9 @@ gimp_gradient_segment_range_split_uniform (const gchar *name,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
G_TYPE_STRING, name, G_TYPE_STRING, name,
GIMP_TYPE_INT32, start_segment, G_TYPE_INT, start_segment,
GIMP_TYPE_INT32, end_segment, G_TYPE_INT, end_segment,
GIMP_TYPE_INT32, split_parts, G_TYPE_INT, split_parts,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -1376,8 +1376,8 @@ gimp_gradient_segment_range_delete (const gchar *name,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
G_TYPE_STRING, name, G_TYPE_STRING, name,
GIMP_TYPE_INT32, start_segment, G_TYPE_INT, start_segment,
GIMP_TYPE_INT32, end_segment, G_TYPE_INT, end_segment,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -1423,8 +1423,8 @@ gimp_gradient_segment_range_redistribute_handles (const gchar *name,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
G_TYPE_STRING, name, G_TYPE_STRING, name,
GIMP_TYPE_INT32, start_segment, G_TYPE_INT, start_segment,
GIMP_TYPE_INT32, end_segment, G_TYPE_INT, end_segment,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -1471,8 +1471,8 @@ gimp_gradient_segment_range_blend_colors (const gchar *name,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
G_TYPE_STRING, name, G_TYPE_STRING, name,
GIMP_TYPE_INT32, start_segment, G_TYPE_INT, start_segment,
GIMP_TYPE_INT32, end_segment, G_TYPE_INT, end_segment,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -1519,8 +1519,8 @@ gimp_gradient_segment_range_blend_opacity (const gchar *name,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
G_TYPE_STRING, name, G_TYPE_STRING, name,
GIMP_TYPE_INT32, start_segment, G_TYPE_INT, start_segment,
GIMP_TYPE_INT32, end_segment, G_TYPE_INT, end_segment,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -1571,8 +1571,8 @@ gimp_gradient_segment_range_move (const gchar *name,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
G_TYPE_STRING, name, G_TYPE_STRING, name,
GIMP_TYPE_INT32, start_segment, G_TYPE_INT, start_segment,
GIMP_TYPE_INT32, end_segment, G_TYPE_INT, end_segment,
G_TYPE_DOUBLE, delta, G_TYPE_DOUBLE, delta,
G_TYPE_BOOLEAN, control_compress, G_TYPE_BOOLEAN, control_compress,
G_TYPE_NONE); G_TYPE_NONE);

10
libgimp/gimpgradientselect.c
View File

@ -86,11 +86,11 @@ gimp_gradient_select_new (const gchar *title,
NULL, NULL,
G_PARAM_READWRITE)); G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("gradient-width", g_param_spec_int ("gradient-width",
"Gradient width", "Gradient width",
"The gradient width", "The gradient width",
0, G_MAXINT, 0, 0, G_MAXINT, 0,
G_PARAM_READWRITE)); G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("gradient-data", gimp_param_spec_float_array ("gradient-data",
"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, gradient_callback,
G_TYPE_STRING, popup_title, G_TYPE_STRING, popup_title,
G_TYPE_STRING, initial_gradient, G_TYPE_STRING, initial_gradient,
GIMP_TYPE_INT32, sample_size, G_TYPE_INT, sample_size,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)

34
libgimp/gimpimage_pdb.c
View File

@ -154,8 +154,8 @@ gimp_image_new (gint width,
gint32 image_ID = -1; gint32 image_ID = -1;
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_INT32, width, G_TYPE_INT, width,
GIMP_TYPE_INT32, height, G_TYPE_INT, height,
GIMP_TYPE_IMAGE_BASE_TYPE, type, GIMP_TYPE_IMAGE_BASE_TYPE, type,
G_TYPE_NONE); G_TYPE_NONE);
@ -207,8 +207,8 @@ gimp_image_new_with_precision (gint width,
gint32 image_ID = -1; gint32 image_ID = -1;
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_INT32, width, G_TYPE_INT, width,
GIMP_TYPE_INT32, height, G_TYPE_INT, height,
GIMP_TYPE_IMAGE_BASE_TYPE, type, GIMP_TYPE_IMAGE_BASE_TYPE, type,
GIMP_TYPE_PRECISION, precision, GIMP_TYPE_PRECISION, precision,
G_TYPE_NONE); G_TYPE_NONE);
@ -932,8 +932,8 @@ gimp_image_pick_correlate_layer (gint32 image_ID,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_IMAGE_ID, image_ID, GIMP_TYPE_IMAGE_ID, image_ID,
GIMP_TYPE_INT32, x, G_TYPE_INT, x,
GIMP_TYPE_INT32, y, G_TYPE_INT, y,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -991,7 +991,7 @@ gimp_image_insert_layer (gint32 image_ID,
GIMP_TYPE_IMAGE_ID, image_ID, GIMP_TYPE_IMAGE_ID, image_ID,
GIMP_TYPE_LAYER_ID, layer_ID, GIMP_TYPE_LAYER_ID, layer_ID,
GIMP_TYPE_LAYER_ID, parent_ID, GIMP_TYPE_LAYER_ID, parent_ID,
GIMP_TYPE_INT32, position, G_TYPE_INT, position,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -1178,7 +1178,7 @@ gimp_image_insert_channel (gint32 image_ID,
GIMP_TYPE_IMAGE_ID, image_ID, GIMP_TYPE_IMAGE_ID, image_ID,
GIMP_TYPE_CHANNEL_ID, channel_ID, GIMP_TYPE_CHANNEL_ID, channel_ID,
GIMP_TYPE_CHANNEL_ID, parent_ID, GIMP_TYPE_CHANNEL_ID, parent_ID,
GIMP_TYPE_INT32, position, G_TYPE_INT, position,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -1363,7 +1363,7 @@ gimp_image_insert_vectors (gint32 image_ID,
GIMP_TYPE_IMAGE_ID, image_ID, GIMP_TYPE_IMAGE_ID, image_ID,
GIMP_TYPE_VECTORS_ID, vectors_ID, GIMP_TYPE_VECTORS_ID, vectors_ID,
GIMP_TYPE_VECTORS_ID, parent_ID, GIMP_TYPE_VECTORS_ID, parent_ID,
GIMP_TYPE_INT32, position, G_TYPE_INT, position,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -1771,7 +1771,7 @@ gimp_image_reorder_item (gint32 image_ID,
GIMP_TYPE_IMAGE_ID, image_ID, GIMP_TYPE_IMAGE_ID, image_ID,
GIMP_TYPE_ITEM_ID, item_ID, GIMP_TYPE_ITEM_ID, item_ID,
GIMP_TYPE_ITEM_ID, parent_ID, GIMP_TYPE_ITEM_ID, parent_ID,
GIMP_TYPE_INT32, position, G_TYPE_INT, position,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -2010,7 +2010,7 @@ _gimp_image_set_colormap (gint32 image_ID,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_IMAGE_ID, image_ID, GIMP_TYPE_IMAGE_ID, image_ID,
GIMP_TYPE_INT32, num_bytes, G_TYPE_INT, num_bytes,
GIMP_TYPE_INT8_ARRAY, NULL, GIMP_TYPE_INT8_ARRAY, NULL,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_int8_array (gimp_value_array_index (args, 2), colormap, num_bytes); 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, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_IMAGE_ID, image_ID, GIMP_TYPE_IMAGE_ID, image_ID,
GIMP_TYPE_INT32, width, G_TYPE_INT, width,
GIMP_TYPE_INT32, height, G_TYPE_INT, height,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -3314,7 +3314,7 @@ gimp_image_set_tattoo_state (gint32 image_ID,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_IMAGE_ID, image_ID, GIMP_TYPE_IMAGE_ID, image_ID,
GIMP_TYPE_INT32, tattoo_state, G_TYPE_INT, tattoo_state,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -3356,7 +3356,7 @@ gimp_image_get_layer_by_tattoo (gint32 image_ID,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_IMAGE_ID, image_ID, GIMP_TYPE_IMAGE_ID, image_ID,
GIMP_TYPE_INT32, tattoo, G_TYPE_INT, tattoo,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -3399,7 +3399,7 @@ gimp_image_get_channel_by_tattoo (gint32 image_ID,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_IMAGE_ID, image_ID, GIMP_TYPE_IMAGE_ID, image_ID,
GIMP_TYPE_INT32, tattoo, G_TYPE_INT, tattoo,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -3444,7 +3444,7 @@ gimp_image_get_vectors_by_tattoo (gint32 image_ID,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_IMAGE_ID, image_ID, GIMP_TYPE_IMAGE_ID, image_ID,
GIMP_TYPE_INT32, tattoo, G_TYPE_INT, tattoo,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) 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, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_IMAGE_ID, image_ID, GIMP_TYPE_IMAGE_ID, image_ID,
GIMP_TYPE_INT32, num_bytes, G_TYPE_INT, num_bytes,
GIMP_TYPE_INT8_ARRAY, NULL, GIMP_TYPE_INT8_ARRAY, NULL,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_int8_array (gimp_value_array_index (args, 2), color_profile, num_bytes); 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, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_IMAGE_ID, image_ID, GIMP_TYPE_IMAGE_ID, image_ID,
GIMP_TYPE_INT32, num_bytes, G_TYPE_INT, num_bytes,
GIMP_TYPE_INT8_ARRAY, NULL, GIMP_TYPE_INT8_ARRAY, NULL,
GIMP_TYPE_COLOR_RENDERING_INTENT, intent, GIMP_TYPE_COLOR_RENDERING_INTENT, intent,
G_TYPE_BOOLEAN, bpc, 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_IMAGE_ID, image_ID,
GIMP_TYPE_CONVERT_DITHER_TYPE, dither_type, GIMP_TYPE_CONVERT_DITHER_TYPE, dither_type,
GIMP_TYPE_CONVERT_PALETTE_TYPE, palette_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, alpha_dither,
G_TYPE_BOOLEAN, remove_unused, G_TYPE_BOOLEAN, remove_unused,
G_TYPE_STRING, palette, G_TYPE_STRING, palette,
@ -210,9 +210,9 @@ gimp_image_convert_set_dither_matrix (gint width,
gboolean success = TRUE; gboolean success = TRUE;
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_INT32, width, G_TYPE_INT, width,
GIMP_TYPE_INT32, height, G_TYPE_INT, height,
GIMP_TYPE_INT32, matrix_length, G_TYPE_INT, matrix_length,
GIMP_TYPE_INT8_ARRAY, NULL, GIMP_TYPE_INT8_ARRAY, NULL,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_int8_array (gimp_value_array_index (args, 3), matrix, matrix_length); 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, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_IMAGE_ID, image_ID, GIMP_TYPE_IMAGE_ID, image_ID,
GIMP_TYPE_INT32, yposition, G_TYPE_INT, yposition,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -102,7 +102,7 @@ gimp_image_add_vguide (gint32 image_ID,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_IMAGE_ID, image_ID, GIMP_TYPE_IMAGE_ID, image_ID,
GIMP_TYPE_INT32, xposition, G_TYPE_INT, xposition,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -145,7 +145,7 @@ gimp_image_delete_guide (gint32 image_ID,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_IMAGE_ID, image_ID, GIMP_TYPE_IMAGE_ID, image_ID,
GIMP_TYPE_INT32, guide_ID, G_TYPE_INT, guide_ID,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -190,7 +190,7 @@ gimp_image_find_next_guide (gint32 image_ID,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_IMAGE_ID, image_ID, GIMP_TYPE_IMAGE_ID, image_ID,
GIMP_TYPE_INT32, guide_ID, G_TYPE_INT, guide_ID,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -233,7 +233,7 @@ gimp_image_get_guide_orientation (gint32 image_ID,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_IMAGE_ID, image_ID, GIMP_TYPE_IMAGE_ID, image_ID,
GIMP_TYPE_INT32, guide_ID, G_TYPE_INT, guide_ID,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -276,7 +276,7 @@ gimp_image_get_guide_position (gint32 image_ID,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_IMAGE_ID, image_ID, GIMP_TYPE_IMAGE_ID, image_ID,
GIMP_TYPE_INT32, guide_ID, G_TYPE_INT, guide_ID,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) 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, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_IMAGE_ID, image_ID, GIMP_TYPE_IMAGE_ID, image_ID,
GIMP_TYPE_INT32, position_x, G_TYPE_INT, position_x,
GIMP_TYPE_INT32, position_y, G_TYPE_INT, position_y,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -108,7 +108,7 @@ gimp_image_delete_sample_point (gint32 image_ID,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_IMAGE_ID, image_ID, GIMP_TYPE_IMAGE_ID, image_ID,
GIMP_TYPE_INT32, sample_point_ID, G_TYPE_INT, sample_point_ID,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -156,7 +156,7 @@ gimp_image_find_next_sample_point (gint32 image_ID,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_IMAGE_ID, image_ID, GIMP_TYPE_IMAGE_ID, image_ID,
GIMP_TYPE_INT32, sample_point_ID, G_TYPE_INT, sample_point_ID,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -204,7 +204,7 @@ gimp_image_get_sample_point_position (gint32 image_ID,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_IMAGE_ID, image_ID, GIMP_TYPE_IMAGE_ID, image_ID,
GIMP_TYPE_INT32, sample_point_ID, G_TYPE_INT, sample_point_ID,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) 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, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_IMAGE_ID, image_ID, GIMP_TYPE_IMAGE_ID, image_ID,
GIMP_TYPE_CHANNEL_OPS, operation, GIMP_TYPE_CHANNEL_OPS, operation,
GIMP_TYPE_INT32, num_segs, G_TYPE_INT, num_segs,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_FLOAT_ARRAY, NULL,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 3), segs, num_segs); 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, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_IMAGE_ID, image_ID, GIMP_TYPE_IMAGE_ID, image_ID,
GIMP_TYPE_INT32, new_width, G_TYPE_INT, new_width,
GIMP_TYPE_INT32, new_height, G_TYPE_INT, new_height,
GIMP_TYPE_INT32, offx, G_TYPE_INT, offx,
GIMP_TYPE_INT32, offy, G_TYPE_INT, offy,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -161,8 +161,8 @@ gimp_image_scale (gint32 image_ID,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_IMAGE_ID, image_ID, GIMP_TYPE_IMAGE_ID, image_ID,
GIMP_TYPE_INT32, new_width, G_TYPE_INT, new_width,
GIMP_TYPE_INT32, new_height, G_TYPE_INT, new_height,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -214,10 +214,10 @@ gimp_image_crop (gint32 image_ID,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_IMAGE_ID, image_ID, GIMP_TYPE_IMAGE_ID, image_ID,
GIMP_TYPE_INT32, new_width, G_TYPE_INT, new_width,
GIMP_TYPE_INT32, new_height, G_TYPE_INT, new_height,
GIMP_TYPE_INT32, offx, G_TYPE_INT, offx,
GIMP_TYPE_INT32, offy, G_TYPE_INT, offy,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) 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, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_ITEM_ID, item_ID, GIMP_TYPE_ITEM_ID, item_ID,
GIMP_TYPE_INT32, tattoo, G_TYPE_INT, tattoo,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) 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, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_IMAGE_ID, image_ID, GIMP_TYPE_IMAGE_ID, image_ID,
GIMP_TYPE_INT32, width, G_TYPE_INT, width,
GIMP_TYPE_INT32, height, G_TYPE_INT, height,
GIMP_TYPE_IMAGE_TYPE, type, GIMP_TYPE_IMAGE_TYPE, type,
G_TYPE_STRING, name, G_TYPE_STRING, name,
G_TYPE_DOUBLE, opacity, G_TYPE_DOUBLE, opacity,
@ -403,8 +403,8 @@ gimp_layer_scale (gint32 layer_ID,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_LAYER_ID, layer_ID, GIMP_TYPE_LAYER_ID, layer_ID,
GIMP_TYPE_INT32, new_width, G_TYPE_INT, new_width,
GIMP_TYPE_INT32, new_height, G_TYPE_INT, new_height,
G_TYPE_BOOLEAN, local_origin, G_TYPE_BOOLEAN, local_origin,
G_TYPE_NONE); G_TYPE_NONE);
@ -455,10 +455,10 @@ gimp_layer_resize (gint32 layer_ID,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_LAYER_ID, layer_ID, GIMP_TYPE_LAYER_ID, layer_ID,
GIMP_TYPE_INT32, new_width, G_TYPE_INT, new_width,
GIMP_TYPE_INT32, new_height, G_TYPE_INT, new_height,
GIMP_TYPE_INT32, offx, G_TYPE_INT, offx,
GIMP_TYPE_INT32, offy, G_TYPE_INT, offy,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -542,8 +542,8 @@ gimp_layer_set_offsets (gint32 layer_ID,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_LAYER_ID, layer_ID, GIMP_TYPE_LAYER_ID, layer_ID,
GIMP_TYPE_INT32, offx, G_TYPE_INT, offx,
GIMP_TYPE_INT32, offy, G_TYPE_INT, offy,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) 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, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE_ID, drawable_ID, GIMP_TYPE_DRAWABLE_ID, drawable_ID,
G_TYPE_DOUBLE, pressure, G_TYPE_DOUBLE, pressure,
GIMP_TYPE_INT32, num_strokes, G_TYPE_INT, num_strokes,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_FLOAT_ARRAY, NULL,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 3), strokes, num_strokes); 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, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE_ID, drawable_ID, GIMP_TYPE_DRAWABLE_ID, drawable_ID,
GIMP_TYPE_INT32, num_strokes, G_TYPE_INT, num_strokes,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_FLOAT_ARRAY, NULL,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes); 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, GIMP_TYPE_CLONE_TYPE, clone_type,
G_TYPE_DOUBLE, src_x, G_TYPE_DOUBLE, src_x,
G_TYPE_DOUBLE, src_y, G_TYPE_DOUBLE, src_y,
GIMP_TYPE_INT32, num_strokes, G_TYPE_INT, num_strokes,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_FLOAT_ARRAY, NULL,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 6), strokes, num_strokes); 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, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE_ID, drawable_ID, GIMP_TYPE_DRAWABLE_ID, drawable_ID,
GIMP_TYPE_INT32, num_strokes, G_TYPE_INT, num_strokes,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_FLOAT_ARRAY, NULL,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes); 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, GIMP_TYPE_DRAWABLE_ID, drawable_ID,
G_TYPE_DOUBLE, pressure, G_TYPE_DOUBLE, pressure,
GIMP_TYPE_CONVOLVE_TYPE, convolve_type, GIMP_TYPE_CONVOLVE_TYPE, convolve_type,
GIMP_TYPE_INT32, num_strokes, G_TYPE_INT, num_strokes,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_FLOAT_ARRAY, NULL,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 4), strokes, num_strokes); 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, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE_ID, drawable_ID, GIMP_TYPE_DRAWABLE_ID, drawable_ID,
GIMP_TYPE_INT32, num_strokes, G_TYPE_INT, num_strokes,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_FLOAT_ARRAY, NULL,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes); 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, G_TYPE_DOUBLE, exposure,
GIMP_TYPE_DODGE_BURN_TYPE, dodgeburn_type, GIMP_TYPE_DODGE_BURN_TYPE, dodgeburn_type,
GIMP_TYPE_TRANSFER_MODE, dodgeburn_mode, GIMP_TYPE_TRANSFER_MODE, dodgeburn_mode,
GIMP_TYPE_INT32, num_strokes, G_TYPE_INT, num_strokes,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_FLOAT_ARRAY, NULL,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 5), strokes, num_strokes); 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, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE_ID, drawable_ID, GIMP_TYPE_DRAWABLE_ID, drawable_ID,
GIMP_TYPE_INT32, num_strokes, G_TYPE_INT, num_strokes,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_FLOAT_ARRAY, NULL,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes); 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, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE_ID, drawable_ID, GIMP_TYPE_DRAWABLE_ID, drawable_ID,
GIMP_TYPE_INT32, num_strokes, G_TYPE_INT, num_strokes,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_FLOAT_ARRAY, NULL,
GIMP_TYPE_BRUSH_APPLICATION_MODE, hardness, GIMP_TYPE_BRUSH_APPLICATION_MODE, hardness,
GIMP_TYPE_PAINT_APPLICATION_MODE, method, GIMP_TYPE_PAINT_APPLICATION_MODE, method,
@ -541,7 +541,7 @@ gimp_eraser_default (gint32 drawable_ID,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE_ID, drawable_ID, GIMP_TYPE_DRAWABLE_ID, drawable_ID,
GIMP_TYPE_INT32, num_strokes, G_TYPE_INT, num_strokes,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_FLOAT_ARRAY, NULL,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes); 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, GIMP_TYPE_DRAWABLE_ID, src_drawable_ID,
G_TYPE_DOUBLE, src_x, G_TYPE_DOUBLE, src_x,
G_TYPE_DOUBLE, src_y, G_TYPE_DOUBLE, src_y,
GIMP_TYPE_INT32, num_strokes, G_TYPE_INT, num_strokes,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_FLOAT_ARRAY, NULL,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 5), strokes, num_strokes); 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, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE_ID, drawable_ID, GIMP_TYPE_DRAWABLE_ID, drawable_ID,
GIMP_TYPE_INT32, num_strokes, G_TYPE_INT, num_strokes,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_FLOAT_ARRAY, NULL,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes); 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, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE_ID, drawable_ID, GIMP_TYPE_DRAWABLE_ID, drawable_ID,
G_TYPE_DOUBLE, fade_out, G_TYPE_DOUBLE, fade_out,
GIMP_TYPE_INT32, num_strokes, G_TYPE_INT, num_strokes,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_FLOAT_ARRAY, NULL,
GIMP_TYPE_PAINT_APPLICATION_MODE, method, GIMP_TYPE_PAINT_APPLICATION_MODE, method,
G_TYPE_DOUBLE, gradient_length, G_TYPE_DOUBLE, gradient_length,
@ -775,7 +775,7 @@ gimp_paintbrush_default (gint32 drawable_ID,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE_ID, drawable_ID, GIMP_TYPE_DRAWABLE_ID, drawable_ID,
GIMP_TYPE_INT32, num_strokes, G_TYPE_INT, num_strokes,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_FLOAT_ARRAY, NULL,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes); 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, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE_ID, drawable_ID, GIMP_TYPE_DRAWABLE_ID, drawable_ID,
GIMP_TYPE_INT32, num_strokes, G_TYPE_INT, num_strokes,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_FLOAT_ARRAY, NULL,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes); 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, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE_ID, drawable_ID, GIMP_TYPE_DRAWABLE_ID, drawable_ID,
G_TYPE_DOUBLE, pressure, G_TYPE_DOUBLE, pressure,
GIMP_TYPE_INT32, num_strokes, G_TYPE_INT, num_strokes,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_FLOAT_ARRAY, NULL,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 3), strokes, num_strokes); 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, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE_ID, drawable_ID, GIMP_TYPE_DRAWABLE_ID, drawable_ID,
GIMP_TYPE_INT32, num_strokes, G_TYPE_INT, num_strokes,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_FLOAT_ARRAY, NULL,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes); 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, args = gimp_value_array_new_from_types (NULL,
G_TYPE_STRING, name, G_TYPE_STRING, name,
GIMP_TYPE_INT32, columns, G_TYPE_INT, columns,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -508,7 +508,7 @@ gimp_palette_delete_entry (const gchar *name,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
G_TYPE_STRING, name, G_TYPE_STRING, name,
GIMP_TYPE_INT32, entry_num, G_TYPE_INT, entry_num,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -555,7 +555,7 @@ gimp_palette_entry_get_color (const gchar *name,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
G_TYPE_STRING, name, G_TYPE_STRING, name,
GIMP_TYPE_INT32, entry_num, G_TYPE_INT, entry_num,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -605,7 +605,7 @@ gimp_palette_entry_set_color (const gchar *name,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
G_TYPE_STRING, name, G_TYPE_STRING, name,
GIMP_TYPE_INT32, entry_num, G_TYPE_INT, entry_num,
GIMP_TYPE_RGB, color, GIMP_TYPE_RGB, color,
G_TYPE_NONE); G_TYPE_NONE);
@ -653,7 +653,7 @@ gimp_palette_entry_get_name (const gchar *name,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
G_TYPE_STRING, name, G_TYPE_STRING, name,
GIMP_TYPE_INT32, entry_num, G_TYPE_INT, entry_num,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -705,7 +705,7 @@ gimp_palette_entry_set_name (const gchar *name,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
G_TYPE_STRING, name, G_TYPE_STRING, name,
GIMP_TYPE_INT32, entry_num, G_TYPE_INT, entry_num,
G_TYPE_STRING, entry_name, G_TYPE_STRING, entry_name,
G_TYPE_NONE); G_TYPE_NONE);

12
libgimp/gimppatternselect.c
View File

@ -105,12 +105,12 @@ gimp_pattern_select_new (const gchar *title,
0, 10000, 0, 0, 10000, 0,
G_PARAM_READWRITE)); G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("mask-len", g_param_spec_int ("mask-len",
"Mask length", "Mask length",
"Length of pattern " "Length of pattern "
"mask data", "mask data",
0, G_MAXINT, 0, 0, G_MAXINT, 0,
G_PARAM_READWRITE)); G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int8_array ("mask-data", gimp_param_spec_int8_array ("mask-data",
"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, args = gimp_value_array_new_from_types (NULL,
G_TYPE_STRING, procedure_name, G_TYPE_STRING, procedure_name,
GIMP_TYPE_INT32, arg_num, G_TYPE_INT, arg_num,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -381,7 +381,7 @@ _gimp_pdb_proc_return_value (const gchar *procedure_name,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
G_TYPE_STRING, procedure_name, G_TYPE_STRING, procedure_name,
GIMP_TYPE_INT32, val_num, G_TYPE_INT, val_num,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -522,7 +522,7 @@ _gimp_pdb_set_data (const gchar *identifier,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
G_TYPE_STRING, identifier, G_TYPE_STRING, identifier,
GIMP_TYPE_INT32, bytes, G_TYPE_INT, bytes,
GIMP_TYPE_INT8_ARRAY, NULL, GIMP_TYPE_INT8_ARRAY, NULL,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_int8_array (gimp_value_array_index (args, 2), data, bytes); 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, args = gimp_value_array_new_from_types (NULL,
G_TYPE_STRING, procedure_name, G_TYPE_STRING, procedure_name,
GIMP_TYPE_ICON_TYPE, icon_type, GIMP_TYPE_ICON_TYPE, icon_type,
GIMP_TYPE_INT32, icon_data_length, G_TYPE_INT, icon_data_length,
GIMP_TYPE_INT8_ARRAY, NULL, GIMP_TYPE_INT8_ARRAY, NULL,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_int8_array (gimp_value_array_index (args, 3), icon_data, icon_data_length); 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, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_IMAGE_ID, image_ID, GIMP_TYPE_IMAGE_ID, image_ID,
GIMP_TYPE_INT32, x, G_TYPE_INT, x,
GIMP_TYPE_INT32, y, G_TYPE_INT, y,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -218,8 +218,8 @@ gimp_selection_translate (gint32 image_ID,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_IMAGE_ID, image_ID, GIMP_TYPE_IMAGE_ID, image_ID,
GIMP_TYPE_INT32, offx, G_TYPE_INT, offx,
GIMP_TYPE_INT32, offy, G_TYPE_INT, offy,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -267,8 +267,8 @@ _gimp_selection_float (gint32 drawable_ID,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE_ID, drawable_ID, GIMP_TYPE_DRAWABLE_ID, drawable_ID,
GIMP_TYPE_INT32, offx, G_TYPE_INT, offx,
GIMP_TYPE_INT32, offy, G_TYPE_INT, offy,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -512,7 +512,7 @@ gimp_selection_border (gint32 image_ID,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_IMAGE_ID, image_ID, GIMP_TYPE_IMAGE_ID, image_ID,
GIMP_TYPE_INT32, radius, G_TYPE_INT, radius,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -554,7 +554,7 @@ gimp_selection_grow (gint32 image_ID,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_IMAGE_ID, image_ID, GIMP_TYPE_IMAGE_ID, image_ID,
GIMP_TYPE_INT32, steps, G_TYPE_INT, steps,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -597,7 +597,7 @@ gimp_selection_shrink (gint32 image_ID,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_IMAGE_ID, image_ID, GIMP_TYPE_IMAGE_ID, image_ID,
GIMP_TYPE_INT32, steps, G_TYPE_INT, steps,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) 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, x,
G_TYPE_DOUBLE, y, G_TYPE_DOUBLE, y,
G_TYPE_STRING, text, G_TYPE_STRING, text,
GIMP_TYPE_INT32, border, G_TYPE_INT, border,
G_TYPE_BOOLEAN, antialias, G_TYPE_BOOLEAN, antialias,
G_TYPE_DOUBLE, size, G_TYPE_DOUBLE, size,
GIMP_TYPE_SIZE_TYPE, size_type, 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, args = gimp_value_array_new_from_types (NULL,
G_TYPE_STRING, identifier, G_TYPE_STRING, identifier,
G_TYPE_DOUBLE, factor, G_TYPE_DOUBLE, factor,
GIMP_TYPE_INT32, digits, G_TYPE_INT, digits,
G_TYPE_STRING, symbol, G_TYPE_STRING, symbol,
G_TYPE_STRING, abbreviation, G_TYPE_STRING, abbreviation,
G_TYPE_STRING, singular, 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, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_VECTORS_ID, vectors_ID, GIMP_TYPE_VECTORS_ID, vectors_ID,
GIMP_TYPE_INT32, stroke_id, G_TYPE_INT, stroke_id,
G_TYPE_DOUBLE, precision, G_TYPE_DOUBLE, precision,
G_TYPE_NONE); 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, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_VECTORS_ID, vectors_ID, GIMP_TYPE_VECTORS_ID, vectors_ID,
GIMP_TYPE_INT32, stroke_id, G_TYPE_INT, stroke_id,
G_TYPE_DOUBLE, dist, G_TYPE_DOUBLE, dist,
G_TYPE_DOUBLE, precision, G_TYPE_DOUBLE, precision,
G_TYPE_NONE); G_TYPE_NONE);
@ -363,7 +363,7 @@ gimp_vectors_remove_stroke (gint32 vectors_ID,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_VECTORS_ID, vectors_ID, GIMP_TYPE_VECTORS_ID, vectors_ID,
GIMP_TYPE_INT32, stroke_id, G_TYPE_INT, stroke_id,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -406,7 +406,7 @@ gimp_vectors_stroke_close (gint32 vectors_ID,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_VECTORS_ID, vectors_ID, GIMP_TYPE_VECTORS_ID, vectors_ID,
GIMP_TYPE_INT32, stroke_id, G_TYPE_INT, stroke_id,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -453,9 +453,9 @@ gimp_vectors_stroke_translate (gint32 vectors_ID,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_VECTORS_ID, vectors_ID, GIMP_TYPE_VECTORS_ID, vectors_ID,
GIMP_TYPE_INT32, stroke_id, G_TYPE_INT, stroke_id,
GIMP_TYPE_INT32, off_x, G_TYPE_INT, off_x,
GIMP_TYPE_INT32, off_y, G_TYPE_INT, off_y,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -502,7 +502,7 @@ gimp_vectors_stroke_scale (gint32 vectors_ID,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_VECTORS_ID, vectors_ID, 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_x,
G_TYPE_DOUBLE, scale_y, G_TYPE_DOUBLE, scale_y,
G_TYPE_NONE); G_TYPE_NONE);
@ -553,7 +553,7 @@ gimp_vectors_stroke_rotate (gint32 vectors_ID,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_VECTORS_ID, vectors_ID, 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_x,
G_TYPE_DOUBLE, center_y, G_TYPE_DOUBLE, center_y,
G_TYPE_DOUBLE, angle, G_TYPE_DOUBLE, angle,
@ -603,7 +603,7 @@ gimp_vectors_stroke_flip (gint32 vectors_ID,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_VECTORS_ID, vectors_ID, GIMP_TYPE_VECTORS_ID, vectors_ID,
GIMP_TYPE_INT32, stroke_id, G_TYPE_INT, stroke_id,
GIMP_TYPE_ORIENTATION_TYPE, flip_type, GIMP_TYPE_ORIENTATION_TYPE, flip_type,
G_TYPE_DOUBLE, axis, G_TYPE_DOUBLE, axis,
G_TYPE_NONE); G_TYPE_NONE);
@ -658,7 +658,7 @@ gimp_vectors_stroke_flip_free (gint32 vectors_ID,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_VECTORS_ID, vectors_ID, GIMP_TYPE_VECTORS_ID, vectors_ID,
GIMP_TYPE_INT32, stroke_id, G_TYPE_INT, stroke_id,
G_TYPE_DOUBLE, x1, G_TYPE_DOUBLE, x1,
G_TYPE_DOUBLE, y1, G_TYPE_DOUBLE, y1,
G_TYPE_DOUBLE, x2, G_TYPE_DOUBLE, x2,
@ -714,7 +714,7 @@ gimp_vectors_stroke_get_points (gint32 vectors_ID,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_VECTORS_ID, vectors_ID, GIMP_TYPE_VECTORS_ID, vectors_ID,
GIMP_TYPE_INT32, stroke_id, G_TYPE_INT, stroke_id,
G_TYPE_NONE); G_TYPE_NONE);
if (pdb) if (pdb)
@ -779,7 +779,7 @@ gimp_vectors_stroke_new_from_points (gint32 vectors_ID,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_VECTORS_ID, vectors_ID, GIMP_TYPE_VECTORS_ID, vectors_ID,
GIMP_TYPE_VECTORS_STROKE_TYPE, type, GIMP_TYPE_VECTORS_STROKE_TYPE, type,
GIMP_TYPE_INT32, num_points, G_TYPE_INT, num_points,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_FLOAT_ARRAY, NULL,
G_TYPE_BOOLEAN, closed, G_TYPE_BOOLEAN, closed,
G_TYPE_NONE); G_TYPE_NONE);
@ -834,7 +834,7 @@ gimp_vectors_stroke_interpolate (gint32 vectors_ID,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_VECTORS_ID, vectors_ID, GIMP_TYPE_VECTORS_ID, vectors_ID,
GIMP_TYPE_INT32, stroke_id, G_TYPE_INT, stroke_id,
G_TYPE_DOUBLE, precision, G_TYPE_DOUBLE, precision,
G_TYPE_NONE); G_TYPE_NONE);
@ -936,7 +936,7 @@ gimp_vectors_bezier_stroke_lineto (gint32 vectors_ID,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_VECTORS_ID, vectors_ID, GIMP_TYPE_VECTORS_ID, vectors_ID,
GIMP_TYPE_INT32, stroke_id, G_TYPE_INT, stroke_id,
G_TYPE_DOUBLE, x0, G_TYPE_DOUBLE, x0,
G_TYPE_DOUBLE, y0, G_TYPE_DOUBLE, y0,
G_TYPE_NONE); G_TYPE_NONE);
@ -991,7 +991,7 @@ gimp_vectors_bezier_stroke_conicto (gint32 vectors_ID,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_VECTORS_ID, vectors_ID, GIMP_TYPE_VECTORS_ID, vectors_ID,
GIMP_TYPE_INT32, stroke_id, G_TYPE_INT, stroke_id,
G_TYPE_DOUBLE, x0, G_TYPE_DOUBLE, x0,
G_TYPE_DOUBLE, y0, G_TYPE_DOUBLE, y0,
G_TYPE_DOUBLE, x1, G_TYPE_DOUBLE, x1,
@ -1050,7 +1050,7 @@ gimp_vectors_bezier_stroke_cubicto (gint32 vectors_ID,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_VECTORS_ID, vectors_ID, GIMP_TYPE_VECTORS_ID, vectors_ID,
GIMP_TYPE_INT32, stroke_id, G_TYPE_INT, stroke_id,
G_TYPE_DOUBLE, x0, G_TYPE_DOUBLE, x0,
G_TYPE_DOUBLE, y0, G_TYPE_DOUBLE, y0,
G_TYPE_DOUBLE, x1, G_TYPE_DOUBLE, x1,
@ -1231,7 +1231,7 @@ gimp_vectors_import_from_string (gint32 image_ID,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_IMAGE_ID, image_ID, GIMP_TYPE_IMAGE_ID, image_ID,
G_TYPE_STRING, string, G_TYPE_STRING, string,
GIMP_TYPE_INT32, length, G_TYPE_INT, length,
G_TYPE_BOOLEAN, merge, G_TYPE_BOOLEAN, merge,
G_TYPE_BOOLEAN, scale, G_TYPE_BOOLEAN, scale,
G_TYPE_NONE); G_TYPE_NONE);

3
libgimpbase/gimpbase.def
View File

@ -69,7 +69,6 @@ EXPORTS
gimp_int16_array_get_type gimp_int16_array_get_type
gimp_int16_get_type gimp_int16_get_type
gimp_int32_array_get_type gimp_int32_array_get_type
gimp_int32_get_type
gimp_int8_array_get_type gimp_int8_array_get_type
gimp_int8_get_type gimp_int8_get_type
gimp_interpolation_type_get_type gimp_interpolation_type_get_type
@ -113,7 +112,6 @@ EXPORTS
gimp_param_int16_array_get_type gimp_param_int16_array_get_type
gimp_param_int16_get_type gimp_param_int16_get_type
gimp_param_int32_array_get_type gimp_param_int32_array_get_type
gimp_param_int32_get_type
gimp_param_int8_array_get_type gimp_param_int8_array_get_type
gimp_param_memsize_get_type gimp_param_memsize_get_type
gimp_param_parasite_get_type gimp_param_parasite_get_type
@ -122,7 +120,6 @@ EXPORTS
gimp_param_spec_float_array gimp_param_spec_float_array
gimp_param_spec_int16 gimp_param_spec_int16
gimp_param_spec_int16_array gimp_param_spec_int16_array
gimp_param_spec_int32
gimp_param_spec_int32_array gimp_param_spec_int32_array
gimp_param_spec_int8_array gimp_param_spec_int8_array
gimp_param_spec_memsize gimp_param_spec_memsize

110
libgimpbase/gimpparamspecs.c
View File

@ -25,116 +25,6 @@
#include "gimpbase.h" #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 * GIMP_TYPE_INT16
*/ */

37
libgimpbase/gimpparamspecs.h
View File

@ -74,43 +74,6 @@ G_BEGIN_DECLS
GIMP_PARAM_STATIC_STRINGS) 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 * 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; $default = exists $arg->{default} ? $arg->{default} : defined $typeinfo[0] ? $typeinfo[0] : 0;
$pspec = <<CODE; $pspec = <<CODE;
gimp_param_spec_int32 ("$name", g_param_spec_int ("$name",
"$nick", "$nick",
"$blurb", "$blurb",
$min, $max, $default, $min, $max, $default,
$flags) $flags)
CODE CODE
} }
elsif ($pdbtype eq 'int16') { elsif ($pdbtype eq 'int16') {

28
pdb/pdb.pl
View File

@ -18,9 +18,9 @@ package Gimp::CodeGen::pdb;
%arg_types = ( %arg_types = (
int32 => { name => 'INT32', int32 => { name => 'INT32',
gtype => 'GIMP_TYPE_INT32', gtype => 'G_TYPE_INT',
type => 'gint32 ', type => 'gint ',
const_type => 'gint32 ', const_type => 'gint ',
init_value => '0', init_value => '0',
get_value_func => '$var = g_value_get_int ($value)', get_value_func => '$var = g_value_get_int ($value)',
dup_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 # Special cases
enum => { name => 'INT32', enum => { name => 'INT32',
gtype => 'G_TYPE_ENUM', gtype => 'G_TYPE_ENUM',
type => 'gint32 ', type => 'gint ',
const_type => 'gint32 ', const_type => 'gint ',
init_value => '0', init_value => '0',
get_value_func => '$var = g_value_get_enum ($value)', get_value_func => '$var = g_value_get_enum ($value)',
dup_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)' }, take_value_func => 'g_value_set_boolean ($value, $var)' },
tattoo => { name => 'INT32', tattoo => { name => 'INT32',
gtype => 'GIMP_TYPE_INT32', gtype => 'G_TYPE_INT',
type => 'gint32 ', type => 'gint ',
const_type => 'gint32 ', const_type => 'gint ',
init_value => '0', init_value => '0',
get_value_func => '$var = g_value_get_uint ($value)', get_value_func => '$var = g_value_get_uint ($value)',
dup_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)' }, take_value_func => 'g_value_set_uint ($value, $var)' },
guide => { name => 'INT32', guide => { name => 'INT32',
gtype => 'GIMP_TYPE_INT32', gtype => 'G_TYPE_INT',
type => 'gint32 ', type => 'gint ',
const_type => 'gint32 ', const_type => 'gint ',
id => 1, id => 1,
init_value => '0', init_value => '0',
get_value_func => '$var = g_value_get_uint ($value)', 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)' }, take_value_func => 'g_value_set_uint ($value, $var)' },
sample_point => { name => 'INT32', sample_point => { name => 'INT32',
gtype => 'GIMP_TYPE_INT32', gtype => 'G_TYPE_INT',
type => 'gint32 ', type => 'gint ',
const_type => 'gint32 ', const_type => 'gint ',
id => 1, id => 1,
init_value => '0', init_value => '0',
get_value_func => '$var = g_value_get_uint ($value)', 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, FALSE,
G_PARAM_READWRITE)); G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("num-colors", g_param_spec_int ("num-colors",
"Num colors", "Num colors",
"Length of 'map' " "Length of 'map' "
"argument", "argument",
1, 256, 1, 1, 256, 1,
G_PARAM_READWRITE)); G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int8_array ("map", gimp_param_spec_int8_array ("map",
"Map", "Map",

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

@ -239,12 +239,12 @@ gih_create_procedure (GimpPlugIn *plug_in,
1, 1000, 1, 1, 1000, 1,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("dimension", g_param_spec_int ("dimension",
"Dimension", "Dimension",
"Dimension of the " "Dimension of the "
"brush pipe", "brush pipe",
1, 4, 1, 1, 4, 1,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int8_array ("rank", gimp_param_spec_int8_array ("rank",
"Rank", "Rank",
@ -252,12 +252,12 @@ gih_create_procedure (GimpPlugIn *plug_in,
"dimensions", "dimensions",
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("dimension", g_param_spec_int ("dimension",
"Dimension", "Dimension",
"Dimension of the " "Dimension of the "
"brush pipe", "brush pipe",
1, 4, 1, 1, 4, 1,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int8_array ("sel", gimp_param_spec_int8_array ("sel",
"Sel", "Sel",

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

@ -299,12 +299,12 @@ film_create_procedure (GimpPlugIn *plug_in,
TRUE, TRUE,
G_PARAM_READWRITE)); G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("num-images", g_param_spec_int ("num-images",
"Num images", "Num images",
"Number of images to " "Number of images to "
"be used for film", "be used for film",
1, MAX_FILM_PICTURES, 1, 1, MAX_FILM_PICTURES, 1,
G_PARAM_READWRITE)); G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32_array ("image-ids", gimp_param_spec_int32_array ("image-ids",
"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, GIMP_RUN_INTERACTIVE,
G_PARAM_READWRITE)); G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("num-domain-names", g_param_spec_int ("num-domain-names",
"Num domain names", "Num domain names",
"Num domain names", "Num domain names",
0, G_MAXINT, 0, 0, G_MAXINT, 0,
G_PARAM_READWRITE)); G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_string_array ("domain-names", gimp_param_spec_string_array ("domain-names",
"Domain names", "Domain names",
"Domain names", "Domain names",
G_PARAM_READWRITE)); G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("num-domain-uris", g_param_spec_int ("num-domain-uris",
"Num domain URIs", "Num domain URIs",
"Num domain URIs", "Num domain URIs",
0, G_MAXINT, 0, 0, G_MAXINT, 0,
G_PARAM_READWRITE)); G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_string_array ("domain-uris", gimp_param_spec_string_array ("domain-uris",
"Domain URIs", "Domain URIs",

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

@ -137,22 +137,22 @@ help_create_procedure (GimpPlugIn *plug_in,
"1999-2008"); "1999-2008");
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("num-domain-names", g_param_spec_int ("num-domain-names",
"Num Domain Names", "Num Domain Names",
"Num domain names", "Num domain names",
0, G_MAXINT, 0, 0, G_MAXINT, 0,
G_PARAM_READWRITE)); G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_string_array ("domain-names", gimp_param_spec_string_array ("domain-names",
"Domain Names", "Domain Names",
"Domain names", "Domain names",
G_PARAM_READWRITE)); G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("num-domain-uris", g_param_spec_int ("num-domain-uris",
"Num Domain URIs", "Num Domain URIs",
"Num domain URIs", "Num domain URIs",
0, G_MAXINT, 0, 0, G_MAXINT, 0,
G_PARAM_READWRITE)); G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_string_array ("domain-uris", gimp_param_spec_string_array ("domain-uris",
"Domain URIs", "Domain URIs",