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

libgimp, plug-ins: use the new macros everwhere 

Except for gimp_param_spec_string() which is on its way back to the
core.
This commit is contained in:
Michael Natterer 2019-08-19 10:02:07 +02:00
parent 471285bda9
commit 9cabc8c8d0
35 changed files with 1071 additions and 1244 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

110
libgimp/gimpbrushselect.c
View File

@ -85,63 +85,59 @@ gimp_brush_select_new (const gchar *title,
(GDestroyNotify) (GDestroyNotify)
gimp_brush_data_free); gimp_brush_data_free);
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_STRING (procedure, "brush-name",
g_param_spec_string ("brush-name", "Brush name",
"Brush name", "The brush name",
"The brush name", NULL,
NULL, G_PARAM_READWRITE);
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_DOUBLE (procedure, "opacity",
g_param_spec_double ("opacity", "Opacity",
"Opacity", NULL,
NULL, 0.0, 1.0, 1.0,
0.0, 1.0, 1.0, G_PARAM_READWRITE);
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_INT (procedure, "spacing",
g_param_spec_int ("spacing", "Spacing",
"Spacing", NULL,
NULL, -1, 1000, 20,
-1, 1000, 20, G_PARAM_READWRITE);
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_ENUM (procedure, "paint-mode",
g_param_spec_enum ("paint-mode", "Paint mode",
"Paint mode", NULL,
NULL, GIMP_TYPE_LAYER_MODE,
GIMP_TYPE_LAYER_MODE, GIMP_LAYER_MODE_NORMAL,
GIMP_LAYER_MODE_NORMAL, G_PARAM_READWRITE);
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_INT (procedure, "mask-width",
g_param_spec_int ("mask-width", "Brush width",
"Brush width", NULL,
NULL, 0, 10000, 0,
0, 10000, 0, G_PARAM_READWRITE);
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_INT (procedure, "mask-height",
g_param_spec_int ("mask-height", "Brush height",
"Brush height", NULL,
NULL, 0, 10000, 0,
0, 10000, 0, G_PARAM_READWRITE);
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_INT (procedure, "mask-len",
g_param_spec_int ("mask-len", "Mask length",
"Mask length", "Length of brush mask data",
"Length of brush " 0, G_MAXINT, 0,
"mask data", G_PARAM_READWRITE);
0, G_MAXINT, 0,
G_PARAM_READWRITE)); GIMP_PROC_ARG_UINT8_ARRAY (procedure, "mask-data",
gimp_procedure_add_argument (procedure, "Mask data",
gimp_param_spec_uint8_array ("mask-data", "The brush mask data",
"Mask data", G_PARAM_READWRITE);
"The brush mask "
"data", GIMP_PROC_ARG_BOOLEAN (procedure, "closing",
G_PARAM_READWRITE)); "Closing",
gimp_procedure_add_argument (procedure, "If the dialog was closing",
g_param_spec_boolean ("closing", FALSE,
"Closing", G_PARAM_READWRITE);
"If the dialog was "
"cloaing",
FALSE,
G_PARAM_READWRITE));
gimp_plug_in_add_temp_procedure (plug_in, procedure); gimp_plug_in_add_temp_procedure (plug_in, procedure);
g_object_unref (procedure); g_object_unref (procedure);

13
libgimp/gimpfileprocedure.c
View File

@ -69,13 +69,12 @@ gimp_file_procedure_constructed (GObject *object)
G_OBJECT_CLASS (parent_class)->constructed (object); G_OBJECT_CLASS (parent_class)->constructed (object);
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_ENUM (procedure, "run-mode",
g_param_spec_enum ("run-mode", "Run mode",
"Run mode", "The run mode",
"The run mode", GIMP_TYPE_RUN_MODE,
GIMP_TYPE_RUN_MODE, GIMP_RUN_NONINTERACTIVE,
GIMP_RUN_NONINTERACTIVE, G_PARAM_READWRITE);
G_PARAM_READWRITE));
} }
static void static void

24
libgimp/gimpfontselect.c
View File

@ -76,19 +76,17 @@ gimp_font_select_new (const gchar *title,
(GDestroyNotify) (GDestroyNotify)
gimp_font_data_free); gimp_font_data_free);
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_STRING (procedure, "font-name",
g_param_spec_string ("font-name", "Font name",
"Font name", "The font name",
"The font name", NULL,
NULL, G_PARAM_READWRITE);
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_BOOLEAN (procedure, "closing",
g_param_spec_boolean ("closing", "Closing",
"Closing", "If the dialog was closing",
"If the dialog was " FALSE,
"closing", G_PARAM_READWRITE);
FALSE,
G_PARAM_READWRITE));
gimp_plug_in_add_temp_procedure (plug_in, procedure); gimp_plug_in_add_temp_procedure (plug_in, procedure);
g_object_unref (procedure); g_object_unref (procedure);

47
libgimp/gimpgradientselect.c
View File

@ -79,31 +79,28 @@ gimp_gradient_select_new (const gchar *title,
(GDestroyNotify) (GDestroyNotify)
gimp_gradient_data_free); gimp_gradient_data_free);
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_STRING (procedure, "gradient-name",
g_param_spec_string ("gradient-name", "Gradient name",
"Gradient name", "The gradient name",
"The gradient name", NULL,
NULL, G_PARAM_READWRITE);
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_INT (procedure, "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_PROC_ARG_FLOAT_ARRAY (procedure, "gradient-data",
gimp_param_spec_float_array ("gradient-data", "Gradient data",
"Gradient data", "The gradient data",
"The gradient " G_PARAM_READWRITE);
"data",
G_PARAM_READWRITE)); GIMP_PROC_ARG_BOOLEAN (procedure, "closing",
gimp_procedure_add_argument (procedure, "Closing",
g_param_spec_boolean ("closing", "If the dialog was closing",
"Closing", FALSE,
"If the dialog was " G_PARAM_READWRITE);
"closing",
FALSE,
G_PARAM_READWRITE));
gimp_plug_in_add_temp_procedure (plug_in, procedure); gimp_plug_in_add_temp_procedure (plug_in, procedure);
g_object_unref (procedure); g_object_unref (procedure);

37
libgimp/gimpimageprocedure.c
View File

@ -74,25 +74,24 @@ gimp_image_procedure_constructed (GObject *object)
G_OBJECT_CLASS (parent_class)->constructed (object); G_OBJECT_CLASS (parent_class)->constructed (object);
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_ENUM (procedure, "run-mode",
g_param_spec_enum ("run-mode", "Run mode",
"Run mode", "The run mode",
"The run mode", GIMP_TYPE_RUN_MODE,
GIMP_TYPE_RUN_MODE, GIMP_RUN_NONINTERACTIVE,
GIMP_RUN_NONINTERACTIVE, G_PARAM_READWRITE);
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_IMAGE (procedure, "image",
gimp_param_spec_image_id ("image", "Image",
"Image", "The input image",
"The input image", FALSE,
FALSE, G_PARAM_READWRITE);
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_DRAWABLE (procedure, "drawable",
gimp_param_spec_drawable_id ("drawable", "Drawable",
"Drawable", "The input drawable",
"The input drawable", FALSE,
FALSE, G_PARAM_READWRITE);
G_PARAM_READWRITE));
} }
static void static void

11
libgimp/gimploadprocedure.c
View File

@ -96,12 +96,11 @@ gimp_load_procedure_constructed (GObject *object)
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, GIMP_PROC_VAL_IMAGE (procedure, "image",
gimp_param_spec_image_id ("image", "Image",
"Image", "Output image",
"Output image", FALSE,
FALSE, GIMP_PARAM_READWRITE);
GIMP_PARAM_READWRITE));
} }
static void static void

36
libgimp/gimppaletteselect.c
View File

@ -77,25 +77,23 @@ gimp_palette_select_new (const gchar *title,
(GDestroyNotify) (GDestroyNotify)
gimp_palette_data_free); gimp_palette_data_free);
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_STRING (procedure, "palette-name",
g_param_spec_string ("palette-name", "Palette name",
"Palette name", "The palette name",
"The palette name", NULL,
NULL, G_PARAM_READWRITE);
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_INT (procedure, "num-colors",
g_param_spec_int ("num-colors", "Num colors",
"Num colors", "Number of colors",
"Number of colors", 0, G_MAXINT, 0,
0, G_MAXINT, 0, G_PARAM_READWRITE);
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_BOOLEAN (procedure, "closing",
g_param_spec_boolean ("closing", "Closing",
"Closing", "If the dialog was closing",
"If the dialog was " FALSE,
"closing", G_PARAM_READWRITE);
FALSE,
G_PARAM_READWRITE));
gimp_plug_in_add_temp_procedure (plug_in, procedure); gimp_plug_in_add_temp_procedure (plug_in, procedure);
g_object_unref (procedure); g_object_unref (procedure);

84
libgimp/gimppatternselect.c
View File

@ -80,50 +80,46 @@ gimp_pattern_select_new (const gchar *title,
(GDestroyNotify) (GDestroyNotify)
gimp_pattern_data_free); gimp_pattern_data_free);
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_STRING (procedure, "pattern-name",
g_param_spec_string ("pattern-name", "Pattern name",
"Pattern name", "The pattern name",
"The pattern name", NULL,
NULL, G_PARAM_READWRITE);
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_INT (procedure, "mask-width",
g_param_spec_int ("mask-width", "Mask width",
"Mask width", "Pattern width",
"Pattern width", 0, 10000, 0,
0, 10000, 0, G_PARAM_READWRITE);
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_INT (procedure, "mask-height",
g_param_spec_int ("mask-height", "Mask height",
"Mask height", "Pattern height",
"Pattern height", 0, 10000, 0,
0, 10000, 0, G_PARAM_READWRITE);
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_INT (procedure, "mask-bpp",
g_param_spec_int ("mask-bpp", "Mask bpp",
"Mask bpp", "Pattern bytes per pixel",
"Pattern bytes per pixel", 0, 10000, 0,
0, 10000, 0, G_PARAM_READWRITE);
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_INT (procedure, "mask-len",
g_param_spec_int ("mask-len", "Mask length",
"Mask length", "Length of pattern mask data",
"Length of pattern " 0, G_MAXINT, 0,
"mask data", G_PARAM_READWRITE);
0, G_MAXINT, 0,
G_PARAM_READWRITE)); GIMP_PROC_ARG_UINT8_ARRAY (procedure, "mask-data",
gimp_procedure_add_argument (procedure, "Mask data",
gimp_param_spec_uint8_array ("mask-data", "The pattern mask data",
"Mask data", G_PARAM_READWRITE);
"The pattern mask "
"data", GIMP_PROC_ARG_BOOLEAN (procedure, "closing",
G_PARAM_READWRITE)); "Closing",
gimp_procedure_add_argument (procedure, "If the dialog was cloaing",
g_param_spec_boolean ("closing", FALSE,
"Closing", G_PARAM_READWRITE);
"If the dialog was "
"cloaing",
FALSE,
G_PARAM_READWRITE));
gimp_plug_in_add_temp_procedure (plug_in, procedure); gimp_plug_in_add_temp_procedure (plug_in, procedure);
g_object_unref (procedure); g_object_unref (procedure);

48
libgimp/gimpprogress.c
View File

@ -106,32 +106,30 @@ gimp_progress_install_vtable (const GimpProgressVtable *vtable,
(GDestroyNotify) (GDestroyNotify)
gimp_progress_data_free); gimp_progress_data_free);
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_ENUM (procedure, "command",
g_param_spec_enum ("command", "Command",
"Command", "The progress command",
"The progress command", GIMP_TYPE_PROGRESS_COMMAND,
GIMP_TYPE_PROGRESS_COMMAND, GIMP_PROGRESS_COMMAND_START,
GIMP_PROGRESS_COMMAND_START, G_PARAM_READWRITE);
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_string ("text",
"Text",
"The progress text",
NULL,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("value",
"Vakue",
"The progress value",
0.0, 1.0, 0.0,
G_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, GIMP_PROC_ARG_STRING (procedure, "text",
g_param_spec_double ("value", "Text",
"Vakue", "The progress text",
"The progress value", NULL,
0.0, 1.0, 0.0, G_PARAM_READWRITE);
G_PARAM_READWRITE));
GIMP_PROC_ARG_DOUBLE (procedure, "value",
"Vakue",
"The progress value",
0.0, 1.0, 0.0,
G_PARAM_READWRITE);
GIMP_PROC_VAL_DOUBLE (procedure, "value",
"Vakue",
"The progress value",
0.0, 1.0, 0.0,
G_PARAM_READWRITE);
gimp_plug_in_add_temp_procedure (plug_in, procedure); gimp_plug_in_add_temp_procedure (plug_in, procedure);
g_object_unref (procedure); g_object_unref (procedure);

26
libgimp/gimpsaveprocedure.c
View File

@ -76,19 +76,19 @@ gimp_save_procedure_constructed (GObject *object)
G_OBJECT_CLASS (parent_class)->constructed (object); G_OBJECT_CLASS (parent_class)->constructed (object);
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_IMAGE (procedure, "image",
gimp_param_spec_image_id ("image", "Image",
"Image", "The image to save",
"The image to save", FALSE,
FALSE, G_PARAM_READWRITE);
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_DRAWABLE (procedure, "drawable",
gimp_param_spec_drawable_id ("drawable", "Drawable",
"Drawable", "The drawable "
"The drawable " "to save",
"to save", FALSE,
FALSE, G_PARAM_READWRITE);
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("uri", gimp_param_spec_string ("uri",
"URI", "URI",

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

@ -141,19 +141,16 @@ remap_create_procedure (GimpPlugIn *plug_in,
"Mukund Sivaraman <muks@mukund.org>", "Mukund Sivaraman <muks@mukund.org>",
"June 2006"); "June 2006");
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_INT (procedure, "num-colors",
g_param_spec_int ("num-colors", "Num colors",
"Num colors", "Length of 'map' argument",
"Length of 'map' " 1, 256, 1,
"argument", G_PARAM_READWRITE);
1, 256, 1,
G_PARAM_READWRITE)); GIMP_PROC_ARG_UINT8_ARRAY (procedure, "map",
gimp_procedure_add_argument (procedure, "Map",
gimp_param_spec_uint8_array ("map", "Remap array for the colormap",
"Map", G_PARAM_READWRITE);
"Remap array "
"for the colormap",
G_PARAM_READWRITE));
} }
else if (! strcmp (name, PLUG_IN_PROC_SWAP)) else if (! strcmp (name, PLUG_IN_PROC_SWAP))
{ {
@ -178,20 +175,17 @@ remap_create_procedure (GimpPlugIn *plug_in,
"Mukund Sivaraman <muks@mukund.org>", "Mukund Sivaraman <muks@mukund.org>",
"June 2006"); "June 2006");
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_UCHAR (procedure, "index1",
g_param_spec_uchar ("index1", "Index 1",
"Index 1", "First index in the colormap",
"First index in the " 0, 255, 0,
"colormap", G_PARAM_READWRITE);
0, 255, 0,
G_PARAM_READWRITE)); GIMP_PROC_ARG_UCHAR (procedure, "index2",
gimp_procedure_add_argument (procedure, "Index 2",
g_param_spec_uchar ("index2", "Second (other) index in the colormap",
"Index 2", 0, 255, 0,
"First (other) index " G_PARAM_READWRITE);
"in the colormap",
0, 255, 0,
G_PARAM_READWRITE));
} }
return procedure; return procedure;

12
plug-ins/common/file-gbr.c
View File

@ -155,12 +155,12 @@ gbr_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_handles_uri (GIMP_FILE_PROCEDURE (procedure), gimp_file_procedure_set_handles_uri (GIMP_FILE_PROCEDURE (procedure),
TRUE); TRUE);
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_INT (procedure, "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 ("description", gimp_param_spec_string ("description",
"Description", "Description",

48
plug-ins/common/file-gif-load.c
View File

@ -216,33 +216,29 @@ gif_create_procedure (GimpPlugIn *plug_in,
FALSE, TRUE, FALSE, FALSE, TRUE, FALSE,
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_INT (procedure, "thumb-size",
g_param_spec_int ("thumb-size", "Thumb Size",
"Thumb Size", "Preferred thumbnail size",
"Preferred thumbnail size", 16, 2014, 256,
16, 2014, 256, GIMP_PARAM_READWRITE);
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, GIMP_PROC_VAL_IMAGE (procedure, "image",
gimp_param_spec_image_id ("image", "Image",
"Image", "Thumbnail image",
"Thumbnail image", FALSE,
FALSE, GIMP_PARAM_READWRITE);
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, GIMP_PROC_VAL_INT (procedure, "image-width",
g_param_spec_int ("image-width", "Image width",
"Image width", "Width of the full-sized image",
"Width of the " 1, GIMP_MAX_IMAGE_SIZE, 1,
"full-sized image", GIMP_PARAM_READWRITE);
1, GIMP_MAX_IMAGE_SIZE, 1,
GIMP_PARAM_READWRITE)); GIMP_PROC_VAL_INT (procedure, "image-height",
gimp_procedure_add_return_value (procedure, "Image height",
g_param_spec_int ("image-height", "Height of the full-sized image",
"Image height", 1, GIMP_MAX_IMAGE_SIZE, 1,
"Height of the " GIMP_PARAM_READWRITE);
"full-sized image",
1, GIMP_MAX_IMAGE_SIZE, 1,
GIMP_PARAM_READWRITE));
} }
return procedure; return procedure;

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

@ -198,12 +198,12 @@ gih_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_handles_uri (GIMP_FILE_PROCEDURE (procedure), gimp_file_procedure_set_handles_uri (GIMP_FILE_PROCEDURE (procedure),
TRUE); TRUE);
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_INT (procedure, "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 ("description", gimp_param_spec_string ("description",
"Description", "Description",
@ -212,55 +212,51 @@ gih_create_procedure (GimpPlugIn *plug_in,
FALSE, TRUE, FALSE, FALSE, TRUE, FALSE,
"GIMP Gihtern", "GIMP Gihtern",
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_INT (procedure, "cell-width",
g_param_spec_int ("cell-width", "Cell width",
"Cell width", "Width of the brush cells",
"Width of the brush cells", 1, 1000, 10,
1, 1000, 10, GIMP_PARAM_READWRITE);
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_INT (procedure, "cell-height",
g_param_spec_int ("cell-height", "Cell height",
"Cell height", "Height of the brush cells",
"Height of the brush cells", 1, 1000, 10,
1, 1000, 10, GIMP_PARAM_READWRITE);
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_INT (procedure, "display-cols",
g_param_spec_int ("display-cols", "Display columns",
"Display columns", "Display column number",
"Display column number", 1, 1000, 1,
1, 1000, 1, GIMP_PARAM_READWRITE);
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_INT (procedure, "display-rows",
g_param_spec_int ("display-rows", "Display rows",
"Display rows", "Display row number",
"Display row number", 1, 1000, 1,
1, 1000, 1, GIMP_PARAM_READWRITE);
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_INT (procedure, "dimension",
g_param_spec_int ("dimension", "Dimension",
"Dimension", "Dimension of the brush pipe",
"Dimension of the " 1, 4, 1,
"brush pipe", GIMP_PARAM_READWRITE);
1, 4, 1,
GIMP_PARAM_READWRITE)); GIMP_PROC_ARG_UINT8_ARRAY (procedure, "rank",
gimp_procedure_add_argument (procedure, "Rank",
gimp_param_spec_uint8_array ("rank", "Ranks of the dimensions",
"Rank", GIMP_PARAM_READWRITE);
"Ranks of the "
"dimensions", GIMP_PROC_ARG_INT (procedure, "dimension",
GIMP_PARAM_READWRITE)); "Dimension",
gimp_procedure_add_argument (procedure, "Dimension of the brush pipe",
g_param_spec_int ("dimension", 1, 4, 1,
"Dimension", GIMP_PARAM_READWRITE);
"Dimension of the "
"brush pipe", GIMP_PROC_ARG_STRING_ARRAY (procedure, "sel",
1, 4, 1, "Sel",
GIMP_PARAM_READWRITE)); "Selection modes",
gimp_procedure_add_argument (procedure, GIMP_PARAM_READWRITE);
gimp_param_spec_string_array ("sel",
"Sel",
"Selection modes",
GIMP_PARAM_READWRITE));
} }
return procedure; return procedure;

109
plug-ins/common/file-png.c
View File

@ -326,62 +326,59 @@ png_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"png"); "png");
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_BOOLEAN (procedure, "interlace",
g_param_spec_boolean ("interlace", "Interlace",
"Interlace", "Use Adam7 interlacing?",
"Use Adam7 interlacing?", FALSE,
FALSE, G_PARAM_READWRITE);
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_INT (procedure, "compression",
g_param_spec_int ("compression", "Compression",
"Compression", "Deflate Compression factor (0..9)",
"Deflate Compression " 0, 9, 9,
"factor (0..9)", G_PARAM_READWRITE);
0, 9, 9,
G_PARAM_READWRITE)); GIMP_PROC_ARG_BOOLEAN (procedure, "bkgd",
gimp_procedure_add_argument (procedure, "bKGD",
g_param_spec_boolean ("bkgd", "Write bKGD chunk?",
"bKGD", TRUE,
"Write bKGD chunk?", G_PARAM_READWRITE);
TRUE,
G_PARAM_READWRITE)); GIMP_PROC_ARG_BOOLEAN (procedure, "gama",
gimp_procedure_add_argument (procedure, "gAMA",
g_param_spec_boolean ("gama", "Write gAMA chunk?",
"gAMA", FALSE,
"Write gAMA chunk?", G_PARAM_READWRITE);
FALSE,
G_PARAM_READWRITE)); GIMP_PROC_ARG_BOOLEAN (procedure, "offs",
gimp_procedure_add_argument (procedure, "oFFs",
g_param_spec_boolean ("offs", "Write oFFs chunk?",
"oFFs", FALSE,
"Write oFFs chunk?", G_PARAM_READWRITE);
FALSE,
G_PARAM_READWRITE)); GIMP_PROC_ARG_BOOLEAN (procedure, "phys",
gimp_procedure_add_argument (procedure, "pHYs",
g_param_spec_boolean ("phys", "Write pHYs chunk?",
"pHYs", TRUE,
"Write pHYs chunk?", G_PARAM_READWRITE);
TRUE,
G_PARAM_READWRITE)); GIMP_PROC_ARG_BOOLEAN (procedure, "time",
gimp_procedure_add_argument (procedure, "tIME",
g_param_spec_boolean ("time", "Write tIME chunk?",
"tIME", TRUE,
"Write tIME chunk?", G_PARAM_READWRITE);
TRUE,
G_PARAM_READWRITE)); GIMP_PROC_ARG_BOOLEAN (procedure, "comment",
gimp_procedure_add_argument (procedure, "Comment",
g_param_spec_boolean ("comment", "Write comment?",
"Comment", TRUE,
"Write comment?", G_PARAM_READWRITE);
TRUE,
G_PARAM_READWRITE)); GIMP_PROC_ARG_BOOLEAN (procedure, "save-trans",
gimp_procedure_add_argument (procedure, "Save trans",
g_param_spec_boolean ("save-trans", "Preserve color of transparent pixels?",
"Save trans", TRUE,
"Preserve color of " G_PARAM_READWRITE);
"transparent pixels?",
TRUE,
G_PARAM_READWRITE));
} }
return procedure; return procedure;

267
plug-ins/common/file-ps.c
View File

@ -410,64 +410,53 @@ ps_create_procedure (GimpPlugIn *plug_in,
gimp_load_procedure_set_thumbnail_loader (GIMP_LOAD_PROCEDURE (procedure), gimp_load_procedure_set_thumbnail_loader (GIMP_LOAD_PROCEDURE (procedure),
LOAD_PS_THUMB_PROC); LOAD_PS_THUMB_PROC);
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_INT (procedure, "resolution",
g_param_spec_int ("resolution", "Resolution",
"Resolution", "Resolution to interpret image (dpi)",
"Resolution to interpret " MIN_RESOLUTION, MAX_RESOLUTION, 100,
"image (dpi)", GIMP_PARAM_READWRITE);
MIN_RESOLUTION,
MAX_RESOLUTION, GIMP_PROC_ARG_INT (procedure, "width",
100, "Width",
GIMP_PARAM_READWRITE)); "Desired width",
gimp_procedure_add_argument (procedure, 1, GIMP_MAX_IMAGE_SIZE, 826,
g_param_spec_int ("width", GIMP_PARAM_READWRITE);
"Width",
"Desired width", GIMP_PROC_ARG_INT (procedure, "height",
1, GIMP_MAX_IMAGE_SIZE, "Height",
826, "Desired height",
GIMP_PARAM_READWRITE)); 1, GIMP_MAX_IMAGE_SIZE, 1170,
gimp_procedure_add_argument (procedure, GIMP_PARAM_READWRITE);
g_param_spec_int ("height",
"Height", GIMP_PROC_ARG_BOOLEAN (procedure, "check-bbox",
"Desired height", "Check bbox",
1, GIMP_MAX_IMAGE_SIZE, "FALSE: Use width/height, TRUE: Use BoundingBox",
1170, TRUE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE);
gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("check-bbox", GIMP_PROC_ARG_STRING (procedure, "pages",
"Check bbox", "Pages",
"FALSE: Use width/height, " "Pages to load (e.g.: 1,3,5-7)",
"TRUE: Use BoundingBox", "1",
TRUE, GIMP_PARAM_READWRITE);
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_INT (procedure, "coloring",
g_param_spec_string ("pages", "Coloring",
"Pages", "4: b/w, 5: grey, 6: color image, 7: automatic",
"Pages to load " 4, 7, 6,
"(e.g.: 1,3,5-7)", GIMP_PARAM_READWRITE);
"1",
GIMP_PARAM_READWRITE)); GIMP_PROC_ARG_INT (procedure, "text-alpha-bits",
gimp_procedure_add_argument (procedure, "Text alpha bits",
g_param_spec_int ("coloring", "1, 2 or 4",
"Coloring", 1, 4, 1,
"4: b/w, " GIMP_PARAM_READWRITE);
"5: grey, "
"6: color image, " GIMP_PROC_ARG_INT (procedure, "graphoc-alpha-bits",
"7: automatic", "Graphic alpha bits",
4, 7, 6, "1, 2 or 4",
GIMP_PARAM_READWRITE)); 1, 4, 1,
gimp_procedure_add_argument (procedure, GIMP_PARAM_READWRITE);
g_param_spec_int ("text-alpha-bits",
"Text alpha bits",
"1, 2 or 4",
1, 4, 1,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_int ("graphoc-alpha-bits",
"Graphic alpha bits",
"1, 2 or 4",
1, 4, 1,
GIMP_PARAM_READWRITE));
} }
else if (! strcmp (name, LOAD_PS_THUMB_PROC)) else if (! strcmp (name, LOAD_PS_THUMB_PROC))
{ {
@ -492,19 +481,17 @@ ps_create_procedure (GimpPlugIn *plug_in,
FALSE, TRUE, FALSE, FALSE, TRUE, FALSE,
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_INT (procedure, "thumb-size",
g_param_spec_int ("thumb-size", "Thumb Size",
"Thumb Size", "Preferred thumbnail size",
"Preferred thumbnail size", 16, 2014, 256,
16, 2014, 256, GIMP_PARAM_READWRITE);
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, GIMP_PROC_VAL_IMAGE (procedure, "image",
gimp_param_spec_image_id ("image", "Image",
"Image", "Thumbnail image",
"Thumbnail image", FALSE,
FALSE, GIMP_PARAM_READWRITE);
GIMP_PARAM_READWRITE));
} }
else if (! strcmp (name, SAVE_PS_PROC) || else if (! strcmp (name, SAVE_PS_PROC) ||
! strcmp (name, SAVE_EPS_PROC)) ! strcmp (name, SAVE_EPS_PROC))
@ -557,84 +544,68 @@ ps_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_handles_uri (GIMP_FILE_PROCEDURE (procedure), gimp_file_procedure_set_handles_uri (GIMP_FILE_PROCEDURE (procedure),
TRUE); TRUE);
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_DOUBLE (procedure, "width",
g_param_spec_double ("width", "Width",
"Width", "Width of the image in PostScript file "
"Width of the image in " "(0: use input image size)",
"PostScript file " 0, GIMP_MAX_IMAGE_SIZE, 0,
"(0: use input image " G_PARAM_READWRITE);
"size)",
0, GIMP_MAX_IMAGE_SIZE, 0, GIMP_PROC_ARG_DOUBLE (procedure, "height",
G_PARAM_READWRITE)); "Height",
gimp_procedure_add_argument (procedure, "Height of the image in PostScript file "
g_param_spec_double ("height", "(0: use input image size)",
"Height", 0, GIMP_MAX_IMAGE_SIZE, 0,
"Height of the image in " G_PARAM_READWRITE);
"PostScript file "
"(0: use input image " GIMP_PROC_ARG_DOUBLE (procedure, "x-offset",
"size)", "X offset",
0, GIMP_MAX_IMAGE_SIZE, 0, "X-offset to image from lower left corner",
G_PARAM_READWRITE)); -GIMP_MAX_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE, 0,
gimp_procedure_add_argument (procedure, G_PARAM_READWRITE);
g_param_spec_double ("x-offset",
"X offset", GIMP_PROC_ARG_DOUBLE (procedure, "y-offset",
"X-offset to image " "Y offset",
"from lower left corner", "Y-offset to image from lower left corner",
-GIMP_MAX_IMAGE_SIZE, -GIMP_MAX_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE, 0,
GIMP_MAX_IMAGE_SIZE, 0, G_PARAM_READWRITE);
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_INT (procedure, "unit",
g_param_spec_double ("y-offset", "Unit",
"Y offset", "Unit for width/height/offset. "
"Y-offset to image " "0: inches, 1: millimeters",
"from lower left corner", 0, 1, 0,
-GIMP_MAX_IMAGE_SIZE, G_PARAM_READWRITE);
GIMP_MAX_IMAGE_SIZE, 0,
G_PARAM_READWRITE)); GIMP_PROC_ARG_BOOLEAN (procedure, "keep-ratio",
gimp_procedure_add_argument (procedure, "Keep ratio",
g_param_spec_int ("unit", "FALSE: use width/height, TRUE: keep aspect ratio",
"Unit", TRUE,
"Unit for " G_PARAM_READWRITE);
"width/height/offset. "
"0: inches, " GIMP_PROC_ARG_INT (procedure, "rotation",
"1: millimeters", "Rotation",
0, 1, 0, "0, 90, 180, 270",
G_PARAM_READWRITE)); 0, 270, 0,
gimp_procedure_add_argument (procedure, G_PARAM_READWRITE);
g_param_spec_boolean ("keep-ratio",
"Keep ratio", GIMP_PROC_ARG_BOOLEAN (procedure, "eps-flag",
"FALSE: use width/height, " "EPG flag",
"TRUE: keep aspect ratio", "FALSE: PostScript, TRUE: Encapsulated PostScript",
TRUE, FALSE,
G_PARAM_READWRITE)); G_PARAM_READWRITE);
gimp_procedure_add_argument (procedure,
g_param_spec_int ("rotation", GIMP_PROC_ARG_INT (procedure, "preview",
"Rotation", "Preview",
"0, 90, 180, 270", "0: no preview, >0: max. size of preview",
0, 270, 0, 0, GIMP_MAX_IMAGE_SIZE, 0,
G_PARAM_READWRITE)); G_PARAM_READWRITE);
gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("eps-flag", GIMP_PROC_ARG_INT (procedure, "level",
"EPG flag", "Level",
"FALSE: PostScript, " "1: PostScript Level 1, 2: PostScript Level 2",
"TRUE: Encapsulated " 1, 2, 2,
"PostScript", G_PARAM_READWRITE);
FALSE,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_int ("preview",
"Preview",
"0: no preview, "
">0: max. size of preview",
0, GIMP_MAX_IMAGE_SIZE, 0,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_int ("level",
"Level",
"1: PostScript Level 1, "
"2: PostScript Level 2",
1, 2, 2,
G_PARAM_READWRITE));
} }
return procedure; return procedure;

116
plug-ins/common/file-svg.c
View File

@ -172,45 +172,34 @@ svg_create_procedure (GimpPlugIn *plug_in,
gimp_load_procedure_set_thumbnail_loader (GIMP_LOAD_PROCEDURE (procedure), gimp_load_procedure_set_thumbnail_loader (GIMP_LOAD_PROCEDURE (procedure),
LOAD_THUMB_PROC); LOAD_THUMB_PROC);
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_DOUBLE (procedure, "resolution",
g_param_spec_double ("resolution", "Resolution",
"Resolution", "Resolution to use for rendering the SVG",
"Resolution to use for " GIMP_MIN_RESOLUTION, GIMP_MAX_RESOLUTION, 90,
"rendering the SVG", GIMP_PARAM_READWRITE);
GIMP_MIN_RESOLUTION,
GIMP_MAX_RESOLUTION, GIMP_PROC_ARG_INT (procedure, "width",
90, "Width",
GIMP_PARAM_READWRITE)); "Width (in pixels) to load the SVG in. "
gimp_procedure_add_argument (procedure, "(0 for original width, a negative width to "
g_param_spec_int ("width", "specify a maximum width)",
"Width", -GIMP_MAX_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE, 0,
"Width (in pixels) to load " GIMP_PARAM_READWRITE);
"the SVG in. "
"(0 for original width, " GIMP_PROC_ARG_INT (procedure, "height",
"a negative width to " "Height",
"specify a maximum width)", "Height (in pixels) to load the SVG in. "
-GIMP_MAX_IMAGE_SIZE, "(0 for original heght, a negative width to "
GIMP_MAX_IMAGE_SIZE, 0, "specify a maximum height)",
GIMP_PARAM_READWRITE)); -GIMP_MAX_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE, 0,
gimp_procedure_add_argument (procedure, GIMP_PARAM_READWRITE);
g_param_spec_int ("height",
"Height", GIMP_PROC_ARG_INT (procedure, "paths",
"Height (in pixels) to load " "Paths",
"the SVG in. " "(0) don't import paths, (1) paths individually, "
"(0 for original heght, " "(2) paths merged",
"a negative width to " 0, 2, 0,
"specify a maximum height)", GIMP_PARAM_READWRITE);
-GIMP_MAX_IMAGE_SIZE,
GIMP_MAX_IMAGE_SIZE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_int ("paths",
"Paths",
"(0) don't import paths, "
"(1) paths individually, "
"(2) paths merged",
0, 2, 0,
GIMP_PARAM_READWRITE));
} }
else if (! strcmp (name, LOAD_THUMB_PROC)) else if (! strcmp (name, LOAD_THUMB_PROC))
{ {
@ -235,33 +224,30 @@ svg_create_procedure (GimpPlugIn *plug_in,
FALSE, TRUE, FALSE, FALSE, TRUE, FALSE,
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_int ("thumb-size",
"Thumb Size",
"Preferred thumbnail size",
16, 2014, 256,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, GIMP_PROC_ARG_INT (procedure, "thumb-size",
gimp_param_spec_image_id ("image", "Thumb Size",
"Image", "Preferred thumbnail size",
"Thumbnail image", 16, 2014, 256,
FALSE, GIMP_PARAM_READWRITE);
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, GIMP_PROC_VAL_IMAGE (procedure, "image",
g_param_spec_int ("image-width", "Image",
"Image width", "Thumbnail image",
"Width of the " FALSE,
"full-sized image", GIMP_PARAM_READWRITE);
1, GIMP_MAX_IMAGE_SIZE, 1,
GIMP_PARAM_READWRITE)); GIMP_PROC_VAL_INT (procedure, "image-width",
gimp_procedure_add_return_value (procedure, "Image width",
g_param_spec_int ("image-height", "Width of the full-sized image",
"Image height", 1, GIMP_MAX_IMAGE_SIZE, 1,
"Height of the " GIMP_PARAM_READWRITE);
"full-sized image",
1, GIMP_MAX_IMAGE_SIZE, 1, GIMP_PROC_VAL_INT (procedure, "image-height",
GIMP_PARAM_READWRITE)); "Image height",
"Height of the full-sized image",
1, GIMP_MAX_IMAGE_SIZE, 1,
GIMP_PARAM_READWRITE);
} }
return procedure; return procedure;

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

@ -237,71 +237,64 @@ film_create_procedure (GimpPlugIn *plug_in,
"Peter Kirchgessner (peter@kirchgessner.net)", "Peter Kirchgessner (peter@kirchgessner.net)",
"1997"); "1997");
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_INT (procedure, "film-height",
g_param_spec_int ("film-height", "Film height",
"Film height", "Height of film (0: fit to images)",
"Height of film (0: fit " 0, GIMP_MAX_IMAGE_SIZE, 0,
"to images)", G_PARAM_READWRITE);
0, GIMP_MAX_IMAGE_SIZE, 0,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_rgb ("film-color",
"Film color",
"Color of the film",
TRUE, NULL,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_int ("number-start",
"Number start",
"Start index for numbering",
G_MININT, G_MAXINT, 1,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_string ("number-font",
"Number font",
"Font for drawing numbers",
NULL,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_rgb ("number-color",
"Number color",
"Color for numbers",
TRUE, NULL,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("at-top",
"At top",
"Draw numbers at top",
TRUE,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("at-bottom",
"At bottom",
"Draw numbers at bottom",
TRUE,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_int ("num-images",
"Num images",
"Number of images to "
"be used for film",
1, MAX_FILM_PICTURES, 1,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32_array ("image-ids",
"Image IDs",
"num-images "
"image IDs to "
"be used for "
"film",
G_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, GIMP_PROC_ARG_RGB (procedure, "film-color",
gimp_param_spec_image_id ("new-image", "Film color",
"New image", "Color of the film",
"Outout image", TRUE, NULL,
FALSE, G_PARAM_READWRITE);
G_PARAM_READWRITE));
GIMP_PROC_ARG_INT (procedure, "number-start",
"Number start",
"Start index for numbering",
G_MININT, G_MAXINT, 1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "number-font",
"Number font",
"Font for drawing numbers",
NULL,
G_PARAM_READWRITE);
GIMP_PROC_ARG_RGB (procedure, "number-color",
"Number color",
"Color for numbers",
TRUE, NULL,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "at-top",
"At top",
"Draw numbers at top",
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "at-bottom",
"At bottom",
"Draw numbers at bottom",
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "num-images",
"Num images",
"Number of images to be used for film",
1, MAX_FILM_PICTURES, 1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT32_ARRAY (procedure, "image-ids",
"Image IDs",
"num-images image IDs to be used for film",
G_PARAM_READWRITE);
GIMP_PROC_VAL_IMAGE (procedure, "new-image",
"New image",
"Outout image",
FALSE,
G_PARAM_READWRITE);
} }
return procedure; return procedure;

62
plug-ins/common/mail.c
View File

@ -214,39 +214,35 @@ mail_create_procedure (GimpPlugIn *plug_in,
"Spencer Kimball and Peter Mattis", "Spencer Kimball and Peter Mattis",
"1995-1997"); "1995-1997");
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_STRING (procedure, "filename",
g_param_spec_string ("filename", "Filename",
"Filename", "The name of the file to save the image in",
"The name of the file " NULL,
"to save the image in", G_PARAM_READWRITE);
NULL,
G_PARAM_READWRITE)); GIMP_PROC_ARG_STRING (procedure, "to-address",
gimp_procedure_add_argument (procedure, "To address",
g_param_spec_string ("to-address", "The email address to send to",
"To address", NULL,
"The email address " G_PARAM_READWRITE);
"to send to",
NULL, GIMP_PROC_ARG_STRING (procedure, "from-address",
G_PARAM_READWRITE)); "From address",
gimp_procedure_add_argument (procedure, "The email address for the From: field",
g_param_spec_string ("from-address", NULL,
"From address", G_PARAM_READWRITE);
"The email address "
"for the From: field", GIMP_PROC_ARG_STRING (procedure, "subject",
NULL, "Subject",
G_PARAM_READWRITE)); "The subject",
gimp_procedure_add_argument (procedure, NULL,
g_param_spec_string ("subject", G_PARAM_READWRITE);
"Subject",
"The subject", GIMP_PROC_ARG_STRING (procedure, "comment",
NULL, "Comment",
G_PARAM_READWRITE)); "The comment",
gimp_procedure_add_argument (procedure, NULL,
g_param_spec_string ("comment", G_PARAM_READWRITE);
"Comment",
"The comment",
NULL,
G_PARAM_READWRITE));
} }
return procedure; return procedure;

13
plug-ins/common/plugin-browser.c
View File

@ -184,13 +184,12 @@ browser_create_procedure (GimpPlugIn *plug_in,
"Andy Thomas", "Andy Thomas",
"1999"); "1999");
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_ENUM (procedure, "run-mode",
g_param_spec_enum ("run-mode", "Run mode",
"Run mode", "The run mode",
"The run mode", GIMP_TYPE_RUN_MODE,
GIMP_TYPE_RUN_MODE, GIMP_RUN_INTERACTIVE,
GIMP_RUN_INTERACTIVE, G_PARAM_READWRITE);
G_PARAM_READWRITE));
} }
return procedure; return procedure;

13
plug-ins/common/procedure-browser.c
View File

@ -132,13 +132,12 @@ browser_create_procedure (GimpPlugIn *plug_in,
"Thomas Noel", "Thomas Noel",
"23th june 1997"); "23th june 1997");
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_ENUM (procedure, "run-mode",
g_param_spec_enum ("run-mode", "Run mode",
"Run mode", "The run mode",
"The run mode", GIMP_TYPE_RUN_MODE,
GIMP_TYPE_RUN_MODE, GIMP_RUN_INTERACTIVE,
GIMP_RUN_INTERACTIVE, G_PARAM_READWRITE);
G_PARAM_READWRITE));
} }
return procedure; return procedure;

13
plug-ins/common/unit-editor.c
View File

@ -191,13 +191,12 @@ editor_create_procedure (GimpPlugIn *plug_in,
"Michael Natterer <mitch@gimp.org>", "Michael Natterer <mitch@gimp.org>",
"2000"); "2000");
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_ENUM (procedure, "run-mode",
g_param_spec_enum ("run-mode", "Run mode",
"Run mode", "The run mode",
"The run mode", GIMP_TYPE_RUN_MODE,
GIMP_TYPE_RUN_MODE, GIMP_RUN_INTERACTIVE,
GIMP_RUN_INTERACTIVE, G_PARAM_READWRITE);
G_PARAM_READWRITE));
} }
return procedure; return procedure;

48
plug-ins/file-ico/ico.c
View File

@ -164,33 +164,29 @@ ico_create_procedure (GimpPlugIn *plug_in,
FALSE, TRUE, FALSE, FALSE, TRUE, FALSE,
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_INT (procedure, "thumb-size",
g_param_spec_int ("thumb-size", "Thumb Size",
"Thumb Size", "Preferred thumbnail size",
"Preferred thumbnail size", 16, 2014, 256,
16, 2014, 256, GIMP_PARAM_READWRITE);
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, GIMP_PROC_VAL_IMAGE (procedure, "image",
gimp_param_spec_image_id ("image", "Image",
"Image", "Thumbnail image",
"Thumbnail image", FALSE,
FALSE, GIMP_PARAM_READWRITE);
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, GIMP_PROC_VAL_INT (procedure, "image-width",
g_param_spec_int ("image-width", "Image width",
"Image width", "Width of the full-sized image",
"Width of the " 1, GIMP_MAX_IMAGE_SIZE, 1,
"full-sized image", GIMP_PARAM_READWRITE);
1, GIMP_MAX_IMAGE_SIZE, 1,
GIMP_PARAM_READWRITE)); GIMP_PROC_VAL_INT (procedure, "image-height",
gimp_procedure_add_return_value (procedure, "Image height",
g_param_spec_int ("image-height", "Height of the full-sized image",
"Image height", 1, GIMP_MAX_IMAGE_SIZE, 1,
"Height of the " GIMP_PARAM_READWRITE);
"full-sized image",
1, GIMP_MAX_IMAGE_SIZE, 1,
GIMP_PARAM_READWRITE));
} }
else if (! strcmp (name, SAVE_PROC)) else if (! strcmp (name, SAVE_PROC))
{ {

48
plug-ins/file-psd/psd.c
View File

@ -194,33 +194,29 @@ psd_create_procedure (GimpPlugIn *plug_in,
FALSE, TRUE, FALSE, FALSE, TRUE, FALSE,
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_INT (procedure, "thumb-size",
g_param_spec_int ("thumb-size", "Thumb Size",
"Thumb Size", "Preferred thumbnail size",
"Preferred thumbnail size", 16, 2014, 256,
16, 2014, 256, GIMP_PARAM_READWRITE);
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, GIMP_PROC_VAL_IMAGE (procedure, "image",
gimp_param_spec_image_id ("image", "Image",
"Image", "Thumbnail image",
"Thumbnail image", FALSE,
FALSE, GIMP_PARAM_READWRITE);
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, GIMP_PROC_VAL_INT (procedure, "image-width",
g_param_spec_int ("image-width", "Image width",
"Image width", "Width of the full-sized image",
"Width of the " 1, GIMP_MAX_IMAGE_SIZE, 1,
"full-sized image", GIMP_PARAM_READWRITE);
1, GIMP_MAX_IMAGE_SIZE, 1,
GIMP_PARAM_READWRITE)); GIMP_PROC_VAL_INT (procedure, "image-height",
gimp_procedure_add_return_value (procedure, "Image height",
g_param_spec_int ("image-height", "Height of the full-sized image",
"Image height", 1, GIMP_MAX_IMAGE_SIZE, 1,
"Height of the " GIMP_PARAM_READWRITE);
"full-sized image",
1, GIMP_MAX_IMAGE_SIZE, 1,
GIMP_PARAM_READWRITE));
} }
else if (! strcmp (name, SAVE_PROC)) else if (! strcmp (name, SAVE_PROC))
{ {

49
plug-ins/file-raw/file-darktable.c
View File

@ -247,33 +247,30 @@ darktable_create_procedure (GimpPlugIn *plug_in,
FALSE, TRUE, FALSE, FALSE, TRUE, FALSE,
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_int ("thumb-size",
"Thumb Size",
"Preferred thumbnail size",
16, 2014, 256,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, GIMP_PROC_ARG_INT (procedure, "thumb-size",
gimp_param_spec_image_id ("image", "Thumb Size",
"Image", "Preferred thumbnail size",
"Thumbnail image", 16, 2014, 256,
FALSE, GIMP_PARAM_READWRITE);
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, GIMP_PROC_VAL_IMAGE (procedure, "image",
g_param_spec_int ("image-width", "Image",
"Image width", "Thumbnail image",
"Width of the " FALSE,
"full-sized image", GIMP_PARAM_READWRITE);
1, GIMP_MAX_IMAGE_SIZE, 1,
GIMP_PARAM_READWRITE)); GIMP_PROC_VAL_INT (procedure, "image-width",
gimp_procedure_add_return_value (procedure, "Image width",
g_param_spec_int ("image-height", "Width of the full-sized image",
"Image height", 1, GIMP_MAX_IMAGE_SIZE, 1,
"Height of the " GIMP_PARAM_READWRITE);
"full-sized image",
1, GIMP_MAX_IMAGE_SIZE, 1, GIMP_PROC_VAL_INT (procedure, "image-height",
GIMP_PARAM_READWRITE)); "Image height",
"Height of the full-sized image",
1, GIMP_MAX_IMAGE_SIZE, 1,
GIMP_PARAM_READWRITE);
} }
else else
{ {

22
plug-ins/file-raw/file-rawtherapee.c
View File

@ -198,19 +198,17 @@ rawtherapee_create_procedure (GimpPlugIn *plug_in,
FALSE, TRUE, FALSE, FALSE, TRUE, FALSE,
NULL, NULL,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_INT (procedure, "thumb-size",
g_param_spec_int ("thumb-size", "Thumb Size",
"Thumb Size", "Preferred thumbnail size",
"Preferred thumbnail size", 16, 2014, 256,
16, 2014, 256, GIMP_PARAM_READWRITE);
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, GIMP_PROC_VAL_IMAGE (procedure, "image",
gimp_param_spec_image_id ("image", "Image",
"Image", "Thumbnail image",
"Thumbnail image", FALSE,
FALSE, GIMP_PARAM_READWRITE);
GIMP_PARAM_READWRITE));
} }
else else
{ {

14
plug-ins/file-sgi/sgi.c
View File

@ -181,15 +181,11 @@ sgi_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"sgi,rgb,rgba,bw,icon"); "sgi,rgb,rgba,bw,icon");
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_INT (procedure, "compression",
g_param_spec_int ("compression", "Compression",
"Compression", "Compression level (0 = none, 1 = RLE, 2 = ARLE)",
"Compression level " 0, 2, 1,
"(0 = none, " G_PARAM_STATIC_STRINGS);
"1 = RLE, "
"2 = ARLE)",
0, 2, 1,
G_PARAM_STATIC_STRINGS));
} }
return procedure; return procedure;

38
plug-ins/file-tiff/file-tiff.c
View File

@ -205,30 +205,20 @@ tiff_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"tif,tiff"); "tif,tiff");
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_INT (procedure, "compression",
g_param_spec_int ("compression", "Compression",
"Compression", "Compression type: { NONE (0), LZW (1), PACKBITS (2), "
"Compression type: " "DEFLATE (3), JPEG (4), CCITT G3 Fax (5), "
"{ NONE (0), " "CCITT G4 Fax (6) }",
"LZW (1), " 0, 6, 0,
"PACKBITS (2), " G_PARAM_READWRITE);
"DEFLATE (3), "
"JPEG (4), " GIMP_PROC_ARG_BOOLEAN (procedure, "save-transp-pixels",
"CCITT G3 Fax (5), " "Save transp pixels",
"CCITT G4 Fax (6) }", "Keep the color data masked by an alpha channel "
0, 6, 0, "intact (do not store premultiplied components)",
G_PARAM_READWRITE)); TRUE,
gimp_procedure_add_argument (procedure, G_PARAM_READWRITE);
g_param_spec_boolean ("save-transp-pixels",
"Save transp pixels",
"Keep the color data "
"masked by an alpha "
"channel intact "
"(do not store "
"premultiplied "
"components)",
TRUE,
G_PARAM_READWRITE));
} }
return procedure; return procedure;

260
plug-ins/fractal-explorer/fractal-explorer.c
View File

@ -246,150 +246,122 @@ explorer_create_procedure (GimpPlugIn *plug_in,
"www.multimania.com/cotting)", "www.multimania.com/cotting)",
"December, 1998"); "December, 1998");
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_INT (procedure, "fractal-type",
g_param_spec_int ("fractal-type", "Fractal type",
"Fractal type", "0: Mandelbrot; 1: Julia; 2: Barnsley 1; "
"0: Mandelbrot; " "3: Barnsley 2; 4: Barnsley 3; 5: Spider; "
"1: Julia; " "6: ManOWar; 7: Lambda; 8: Sierpinski",
"2: Barnsley 1; " 0, 8, 0,
"3: Barnsley 2; " G_PARAM_READWRITE);
"4: Barnsley 3; "
"5: Spider; " GIMP_PROC_ARG_DOUBLE (procedure, "xmin",
"6: ManOWar; " "X min",
"7: Lambda; " "xmin fractal image delimiter",
"8: Sierpinski", -G_MAXDOUBLE, G_MAXDOUBLE, 0,
0, 8, 0, G_PARAM_READWRITE);
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_DOUBLE (procedure, "xmax",
g_param_spec_double ("xmin", "X max",
"X min", "xmax fractal image delimiter",
"xmin fractal image " -G_MAXDOUBLE, G_MAXDOUBLE, 0,
"delimiter", G_PARAM_READWRITE);
-G_MAXDOUBLE,
G_MAXDOUBLE, 0, GIMP_PROC_ARG_DOUBLE (procedure, "ymin",
G_PARAM_READWRITE)); "Y min",
gimp_procedure_add_argument (procedure, "ymin fractal image delimiter",
g_param_spec_double ("xmax", -G_MAXDOUBLE, G_MAXDOUBLE, 0,
"X max", G_PARAM_READWRITE);
"xmax fractal image "
"delimiter", GIMP_PROC_ARG_DOUBLE (procedure, "ymax",
-G_MAXDOUBLE, "Y max",
G_MAXDOUBLE, 0, "ymax fractal image delimiter",
G_PARAM_READWRITE)); -G_MAXDOUBLE, G_MAXDOUBLE, 0,
gimp_procedure_add_argument (procedure, G_PARAM_READWRITE);
g_param_spec_double ("ymin",
"Y min", GIMP_PROC_ARG_DOUBLE (procedure, "iter",
"ymin fractal image " "Iter",
"delimiter", "Iteration value",
-G_MAXDOUBLE, -G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_MAXDOUBLE, 0, G_PARAM_READWRITE);
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_DOUBLE (procedure, "cx",
g_param_spec_double ("ymax", "CX",
"Y max", "cx value (only Julia)",
"ymax fractal image " -G_MAXDOUBLE, G_MAXDOUBLE, 0,
"delimiter", G_PARAM_READWRITE);
-G_MAXDOUBLE,
G_MAXDOUBLE, 0, GIMP_PROC_ARG_DOUBLE (procedure, "cy",
G_PARAM_READWRITE)); "CY",
gimp_procedure_add_argument (procedure, "cy value (only Julia)",
g_param_spec_double ("iter", -G_MAXDOUBLE, G_MAXDOUBLE, 0,
"Iter", G_PARAM_READWRITE);
"Iteration value",
-G_MAXDOUBLE, GIMP_PROC_ARG_INT (procedure, "color-mode",
G_MAXDOUBLE, 0, "Color mode",
G_PARAM_READWRITE)); "0: Apply colormap as specified by the parameters "
gimp_procedure_add_argument (procedure, "below; 1: Apply active gradient to final image",
g_param_spec_double ("cx", 0, 1, 0,
"CX", G_PARAM_READWRITE);
"cx value (only Julia)",
-G_MAXDOUBLE, GIMP_PROC_ARG_DOUBLE (procedure, "red-stretch",
G_MAXDOUBLE, 0, "Red stretch",
G_PARAM_READWRITE)); "Red stretching factor",
gimp_procedure_add_argument (procedure, -G_MAXDOUBLE, G_MAXDOUBLE, 0,
g_param_spec_double ("cy", G_PARAM_READWRITE);
"CY",
"cy value (only Julia)", GIMP_PROC_ARG_DOUBLE (procedure, "green-stretch",
-G_MAXDOUBLE, "Green stretch",
G_MAXDOUBLE, 0, "Green stretching factor",
G_PARAM_READWRITE)); -G_MAXDOUBLE, G_MAXDOUBLE, 0,
gimp_procedure_add_argument (procedure, G_PARAM_READWRITE);
g_param_spec_int ("color-mode",
"Color mode", GIMP_PROC_ARG_DOUBLE (procedure, "blues-tretch",
"0: Apply colormap as " "Blue stretch",
"specified by the " "Blue stretching factor",
"parameters below; " -G_MAXDOUBLE,G_MAXDOUBLE, 0,
"1: Apply active gradient " G_PARAM_READWRITE);
"to final image",
0, 1, 0, GIMP_PROC_ARG_INT (procedure, "red-mode",
G_PARAM_READWRITE)); "Red mode",
gimp_procedure_add_argument (procedure, "Red application mode (0:SIN; 1:COS; 2:NONE)",
g_param_spec_double ("red-stretch", 0, 2, 0,
"Red stretch", G_PARAM_READWRITE);
"Red stretching factor",
-G_MAXDOUBLE, GIMP_PROC_ARG_INT (procedure, "green-mode",
G_MAXDOUBLE, 0, "Green mode",
G_PARAM_READWRITE)); "Green application mode (0:SIN; 1:COS; 2:NONE)",
gimp_procedure_add_argument (procedure, 0, 2, 0,
g_param_spec_double ("green-stretch", G_PARAM_READWRITE);
"Green stretch",
"Green stretching factor", GIMP_PROC_ARG_INT (procedure, "blue-mode",
-G_MAXDOUBLE, "Blue mode",
G_MAXDOUBLE, 0, "Blue application mode (0:SIN; 1:COS; 2:NONE)",
G_PARAM_READWRITE)); 0, 2, 0,
gimp_procedure_add_argument (procedure, G_PARAM_READWRITE);
g_param_spec_double ("blues-tretch",
"Blue stretch", GIMP_PROC_ARG_BOOLEAN (procedure, "red-invert",
"Blue stretching factor", "Red invert",
-G_MAXDOUBLE, "Red inversion mode",
G_MAXDOUBLE, 0, FALSE,
G_PARAM_READWRITE)); G_PARAM_READWRITE);
gimp_procedure_add_argument (procedure,
g_param_spec_int ("red-mode", GIMP_PROC_ARG_BOOLEAN (procedure, "green-invert",
"Red mode", "Green invert",
"Red application mode " "Green inversion mode",
"(0:SIN;1:COS;2:NONE)", FALSE,
0, 2, 0, G_PARAM_READWRITE);
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_BOOLEAN (procedure, "blue-invert",
g_param_spec_int ("green-mode", "Blue invert",
"Green mode", "Blue inversion mode",
"Green application mode " FALSE,
"(0:SIN;1:COS;2:NONE)", G_PARAM_READWRITE);
0, 2, 0,
G_PARAM_READWRITE)); GIMP_PROC_ARG_INT (procedure, "n-colors",
gimp_procedure_add_argument (procedure, "N volors",
g_param_spec_int ("blue-mode", "Number of Colors for mapping",
"Blue mode", 2, 8192, 512,
"Blue application mode " G_PARAM_READWRITE);
"(0:SIN;1:COS;2:NONE)",
0, 2, 0,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("red-invert",
"Red invert",
"Red inversion mode",
FALSE,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("green-invert",
"Green invert",
"Green inversion mode",
FALSE,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("blue-invert",
"Blue invert",
"Blue inversion mode",
FALSE,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_int ("n-colors",
"N volors",
"Number of Colors "
"for mapping",
2, 8192, 512,
G_PARAM_READWRITE));
} }
return procedure; return procedure;

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

@ -132,35 +132,34 @@ help_browser_create_procedure (GimpPlugIn *plug_in,
"Henrik Brix Andersen", "Henrik Brix Andersen",
"1999-2008"); "1999-2008");
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_ENUM (procedure, "run-mode",
g_param_spec_enum ("run-mode", "Run mode",
"Run mode", "The run mode",
"The run mode", GIMP_TYPE_RUN_MODE,
GIMP_TYPE_RUN_MODE, GIMP_RUN_INTERACTIVE,
GIMP_RUN_INTERACTIVE, G_PARAM_READWRITE);
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_INT (procedure, "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_PROC_ARG_STRING_ARRAY (procedure, "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_PROC_ARG_INT (procedure, "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_PROC_ARG_STRING_ARRAY (procedure, "domain-uris",
gimp_param_spec_string_array ("domain-uris", "Domain URIs",
"Domain URIs", "Domain URIs",
"Domain URIs", G_PARAM_READWRITE);
G_PARAM_READWRITE));
} }
return procedure; return procedure;
@ -217,24 +216,23 @@ temp_proc_install (GimpPlugIn *plug_in)
"Henrik Brix Andersen", "Henrik Brix Andersen",
"1999-2008"); "1999-2008");
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_STRING (procedure, "help-domain",
g_param_spec_string ("help-domain", "Help domain",
"Help domain", "Help domain to use",
"Help domain to use", NULL,
NULL, G_PARAM_READWRITE);
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_STRING (procedure, "help-locales",
g_param_spec_string ("help-locales", "Help locales",
"Help locales", "Language to use",
"Language to use", NULL,
NULL, G_PARAM_READWRITE);
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_STRING (procedure, "help-id",
g_param_spec_string ("help-id", "Help ID",
"Help ID", "Help ID to open",
"Help ID to open", NULL,
NULL, G_PARAM_READWRITE);
G_PARAM_READWRITE));
gimp_plug_in_add_temp_procedure (plug_in, procedure); gimp_plug_in_add_temp_procedure (plug_in, procedure);
g_object_unref (procedure); g_object_unref (procedure);

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

@ -136,28 +136,27 @@ help_create_procedure (GimpPlugIn *plug_in,
"Sven Neumann, Michael Natterer & Henrik Brix Andersen", "Sven Neumann, Michael Natterer & Henrik Brix Andersen",
"1999-2008"); "1999-2008");
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_INT (procedure, "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_PROC_ARG_STRING_ARRAY (procedure, "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_PROC_ARG_INT (procedure, "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_PROC_ARG_STRING_ARRAY (procedure, "domain-uris",
gimp_param_spec_string_array ("domain-uris", "Domain URIs",
"Domain URIs", "Domain URIs",
"Domain URIs", G_PARAM_READWRITE);
G_PARAM_READWRITE));
} }
return procedure; return procedure;
@ -225,33 +224,33 @@ help_temp_proc_install (GimpPlugIn *plug_in)
"Sven Neumann <sven@gimp.org>, " "Sven Neumann <sven@gimp.org>, "
"Michael Natterer <mitch@gimp.org>" "Michael Natterer <mitch@gimp.org>"
"Henrik Brix Andersen <brix@gimp.org", "Henrik Brix Andersen <brix@gimp.org",
"Sven Neumann, Michael Natterer & Henrik Brix Andersen", "Sven Neumann, Michael Natterer & "
"Henrik Brix Andersen",
"1999-2008"); "1999-2008");
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_STRING (procedure, "help-proc",
g_param_spec_string ("help-proc", "The procedure of the browser to use",
"The procedure of the browser to use", "The procedure of the browser to use",
"The procedure of the browser to use", NULL,
NULL, G_PARAM_READWRITE);
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_STRING (procedure, "help-domain",
g_param_spec_string ("help-domain", "Help domain to use",
"Help domain to use", "Help domain to use",
"Help domain to use", NULL,
NULL, G_PARAM_READWRITE);
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_STRING (procedure, "help-locales",
g_param_spec_string ("help-locales", "Language to use",
"Language to use", "Language to use",
"Language to use", NULL,
NULL, G_PARAM_READWRITE);
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_STRING (procedure, "help-id",
g_param_spec_string ("help-id", "Help ID to open",
"Help ID to open", "Help ID to open",
"Help ID to open", NULL,
NULL, G_PARAM_READWRITE);
G_PARAM_READWRITE));
gimp_plug_in_add_temp_procedure (plug_in, procedure); gimp_plug_in_add_temp_procedure (plug_in, procedure);
g_object_unref (procedure); g_object_unref (procedure);

68
plug-ins/pagecurl/pagecurl.c
View File

@ -234,43 +234,39 @@ pagecurl_create_procedure (GimpPlugIn *plug_in,
"Federico Mena Quintero and Simon Budig", "Federico Mena Quintero and Simon Budig",
PLUG_IN_VERSION); PLUG_IN_VERSION);
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_INT (procedure, "colors",
g_param_spec_int ("colors", "Colors",
"Colors", "FG- and BG-Color (0), Current gradient (1), "
"FG- and BG-Color (0), Current gradient (1), Current gradient reversed (2)", "Current gradient reversed (2)",
CURL_COLORS_FG_BG, CURL_COLORS_FG_BG, CURL_COLORS_LAST, CURL_COLORS_FG_BG,
CURL_COLORS_LAST, G_PARAM_READWRITE);
CURL_COLORS_FG_BG,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_int ("edge",
"Edge",
"Edge to curl (1-4, clockwise, starting in the lower right edge)",
CURL_EDGE_LOWER_RIGHT,
CURL_EDGE_UPPER_RIGHT,
CURL_EDGE_LOWER_RIGHT,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_int ("orientation",
"Orientation",
"Vertical (0), Horizontal (1)",
CURL_ORIENTATION_VERTICAL,
CURL_ORIENTATION_HORIZONTAL,
CURL_ORIENTATION_VERTICAL,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("shade",
"Shade",
"Shade the region under the curl",
TRUE,
G_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, GIMP_PROC_ARG_INT (procedure, "edge",
gimp_param_spec_layer_id ("curl-layer", "Edge",
"Curl layer", "Edge to curl (1-4, clockwise, starting in the "
"The new layer with the curl.", "lower right edge)",
FALSE, CURL_EDGE_LOWER_RIGHT, CURL_EDGE_UPPER_RIGHT,
G_PARAM_READWRITE)); CURL_EDGE_LOWER_RIGHT,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "orientation",
"Orientation",
"Vertical (0), Horizontal (1)",
CURL_ORIENTATION_VERTICAL, CURL_ORIENTATION_HORIZONTAL,
CURL_ORIENTATION_VERTICAL,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "shade",
"Shade",
"Shade the region under the curl",
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_VAL_LAYER (procedure, "curl-layer",
"Curl layer",
"The new layer with the curl.",
FALSE,
G_PARAM_READWRITE);
} }
return procedure; return procedure;

11
plug-ins/print/print.c
View File

@ -533,12 +533,11 @@ print_temp_proc_install (gint32 image_ID)
"Sven Neumann", "Sven Neumann",
"2008"); "2008");
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_IMAGE (procedure, "image",
gimp_param_spec_image_id ("image", "Image",
"Image", "The image to notify about",
"The image to save", FALSE,
FALSE, G_PARAM_READWRITE);
G_PARAM_READWRITE));
gimp_plug_in_add_temp_procedure (plug_in, procedure); gimp_plug_in_add_temp_procedure (plug_in, procedure);
g_object_unref (procedure); g_object_unref (procedure);

92
plug-ins/screenshot/screenshot.c
View File

@ -179,57 +179,49 @@ screenshot_create_procedure (GimpPlugIn *plug_in,
gdk_pixbuf_new_from_inline (-1, screenshot_icon, gdk_pixbuf_new_from_inline (-1, screenshot_icon,
FALSE, NULL)); FALSE, NULL));
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_ENUM (procedure, "run-mode",
g_param_spec_enum ("run-mode", "Run mode",
"Run mode", "The run mode",
"The run mode", GIMP_TYPE_RUN_MODE,
GIMP_TYPE_RUN_MODE, GIMP_RUN_NONINTERACTIVE,
GIMP_RUN_NONINTERACTIVE, G_PARAM_READWRITE);
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_int ("shoot-type",
"Shoot type",
"The shoot type "
"{ SHOOT-WINDOW (0), "
"SHOOT-ROOT (1), "
"SHOOT-REGION (2) }",
0, 2, 0,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_int ("x1",
"X1",
"Region left x coord "
"for SHOOT-WINDOW",
G_MININT, G_MAXINT, 0,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_int ("y1",
"Y1",
"Region top y coord "
"for SHOOT-WINDOW",
G_MININT, G_MAXINT, 0,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_int ("x2",
"X2",
"Region right x coord "
"for SHOOT-WINDOW",
G_MININT, G_MAXINT, 0,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_int ("y2",
"Y2",
"Region bottom y coord "
"for SHOOT-WINDOW",
G_MININT, G_MAXINT, 0,
G_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, GIMP_PROC_ARG_INT (procedure, "shoot-type",
gimp_param_spec_image_id ("image", "Shoot type",
"Image", "The shoot type { SHOOT-WINDOW (0), SHOOT-ROOT (1), "
"Output image", "SHOOT-REGION (2) }",
FALSE, 0, 2, 0,
G_PARAM_READWRITE)); G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "x1",
"X1",
"Region left x coord for SHOOT-WINDOW",
G_MININT, G_MAXINT, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "y1",
"Y1",
"Region top y coord for SHOOT-WINDOW",
G_MININT, G_MAXINT, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "x2",
"X2",
"Region right x coord for SHOOT-WINDOW",
G_MININT, G_MAXINT, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "y2",
"Y2",
"Region bottom y coord for SHOOT-WINDOW",
G_MININT, G_MAXINT, 0,
G_PARAM_READWRITE);
GIMP_PROC_VAL_IMAGE (procedure, "image",
"Image",
"Output image",
FALSE,
G_PARAM_READWRITE);
} }
return procedure; return procedure;

116
plug-ins/script-fu/script-fu.c
View File

@ -148,13 +148,12 @@ script_fu_create_procedure (GimpPlugIn *plug_in,
"Spencer Kimball & Peter Mattis", "Spencer Kimball & Peter Mattis",
"1997"); "1997");
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_ENUM (procedure, "run-mode",
g_param_spec_enum ("run-mode", "Run mode",
"Run mode", "The run mode",
"The run mode", GIMP_TYPE_RUN_MODE,
GIMP_TYPE_RUN_MODE, GIMP_RUN_INTERACTIVE,
GIMP_RUN_INTERACTIVE, G_PARAM_READWRITE);
G_PARAM_READWRITE));
} }
else if (! strcmp (name, "plug-in-script-fu-text-console")) else if (! strcmp (name, "plug-in-script-fu-text-console"))
{ {
@ -172,13 +171,12 @@ script_fu_create_procedure (GimpPlugIn *plug_in,
"Spencer Kimball & Peter Mattis", "Spencer Kimball & Peter Mattis",
"1997"); "1997");
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_ENUM (procedure, "run-mode",
g_param_spec_enum ("run-mode", "Run mode",
"Run mode", "The run mode",
"The run mode", GIMP_TYPE_RUN_MODE,
GIMP_TYPE_RUN_MODE, GIMP_RUN_INTERACTIVE,
GIMP_RUN_INTERACTIVE, G_PARAM_READWRITE);
G_PARAM_READWRITE));
} }
else if (! strcmp (name, "plug-in-script-fu-server")) else if (! strcmp (name, "plug-in-script-fu-server"))
{ {
@ -207,34 +205,30 @@ script_fu_create_procedure (GimpPlugIn *plug_in,
"Spencer Kimball & Peter Mattis", "Spencer Kimball & Peter Mattis",
"1997"); "1997");
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_ENUM (procedure, "run-mode",
g_param_spec_enum ("run-mode", "Run mode",
"Run mode", "The run mode",
"The run mode", GIMP_TYPE_RUN_MODE,
GIMP_TYPE_RUN_MODE, GIMP_RUN_INTERACTIVE,
GIMP_RUN_INTERACTIVE, G_PARAM_READWRITE);
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_STRING (procedure, "ip",
g_param_spec_string ("ip", "IP",
"IP", "The IP on which to listen for requests",
"The IP on which to " NULL,
"listen for requests", G_PARAM_READWRITE);
NULL,
G_PARAM_READWRITE)); GIMP_PROC_ARG_INT (procedure, "port",
gimp_procedure_add_argument (procedure, "Port",
g_param_spec_int ("port", "The port on which to listen for requests",
"Port", 0, G_MAXINT, 0,
"The port on which to " G_PARAM_READWRITE);
"listen for requests",
0, G_MAXINT, 0, GIMP_PROC_ARG_STRING (procedure, "logfile",
G_PARAM_READWRITE)); "Log File",
gimp_procedure_add_argument (procedure, "The file to log activity to",
g_param_spec_string ("logfile", NULL,
"Log File", G_PARAM_READWRITE);
"The file to log "
"activity to",
NULL,
G_PARAM_READWRITE));
} }
else if (! strcmp (name, "plug-in-script-fu-eval")) else if (! strcmp (name, "plug-in-script-fu-eval"))
{ {
@ -251,19 +245,18 @@ script_fu_create_procedure (GimpPlugIn *plug_in,
"Manish Singh", "Manish Singh",
"1998"); "1998");
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_ENUM (procedure, "run-mode",
g_param_spec_enum ("run-mode", "Run mode",
"Run mode", "The run mode",
"The run mode", GIMP_TYPE_RUN_MODE,
GIMP_TYPE_RUN_MODE, GIMP_RUN_INTERACTIVE,
GIMP_RUN_INTERACTIVE, G_PARAM_READWRITE);
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_STRING (procedure, "code",
g_param_spec_string ("code", "Code",
"Code", "The code to run",
"The code to run", NULL,
NULL, G_PARAM_READWRITE);
G_PARAM_READWRITE));
} }
return procedure; return procedure;
@ -437,13 +430,12 @@ script_fu_extension_init (GimpPlugIn *plug_in)
"Spencer Kimball & Peter Mattis", "Spencer Kimball & Peter Mattis",
"1997"); "1997");
gimp_procedure_add_argument (procedure, GIMP_PROC_ARG_ENUM (procedure, "run-mode",
g_param_spec_enum ("run-mode", "Run mode",
"Run mode", "The run mode",
"The run mode", GIMP_TYPE_RUN_MODE,
GIMP_TYPE_RUN_MODE, GIMP_RUN_INTERACTIVE,
GIMP_RUN_INTERACTIVE, G_PARAM_READWRITE);
G_PARAM_READWRITE));
gimp_plug_in_add_temp_procedure (plug_in, procedure); gimp_plug_in_add_temp_procedure (plug_in, procedure);
g_object_unref (procedure); g_object_unref (procedure);