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

62
libgimp/gimpbrushselect.c
View File

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

5
libgimp/gimpfileprocedure.c
View File

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

14
libgimp/gimpfontselect.c
View File

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

29
libgimp/gimpgradientselect.c
View File

@ -79,31 +79,28 @@ gimp_gradient_select_new (const gchar *title,
(GDestroyNotify)
gimp_gradient_data_free);
gimp_procedure_add_argument (procedure,
g_param_spec_string ("gradient-name",
GIMP_PROC_ARG_STRING (procedure, "gradient-name",
"Gradient name",
"The gradient name",
NULL,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_int ("gradient-width",
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "gradient-width",
"Gradient width",
"The gradient width",
0, G_MAXINT, 0,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("gradient-data",
G_PARAM_READWRITE);
GIMP_PROC_ARG_FLOAT_ARRAY (procedure, "gradient-data",
"Gradient data",
"The gradient "
"data",
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("closing",
"The gradient data",
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "closing",
"Closing",
"If the dialog was "
"closing",
"If the dialog was closing",
FALSE,
G_PARAM_READWRITE));
G_PARAM_READWRITE);
gimp_plug_in_add_temp_procedure (plug_in, procedure);
g_object_unref (procedure);

17
libgimp/gimpimageprocedure.c
View File

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

5
libgimp/gimploadprocedure.c
View File

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

20
libgimp/gimppaletteselect.c
View File

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

50
libgimp/gimppatternselect.c
View File

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

28
libgimp/gimpprogress.c
View File

@ -106,32 +106,30 @@ gimp_progress_install_vtable (const GimpProgressVtable *vtable,
(GDestroyNotify)
gimp_progress_data_free);
gimp_procedure_add_argument (procedure,
g_param_spec_enum ("command",
GIMP_PROC_ARG_ENUM (procedure, "command",
"Command",
"The progress command",
GIMP_TYPE_PROGRESS_COMMAND,
GIMP_PROGRESS_COMMAND_START,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_string ("text",
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "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));
G_PARAM_READWRITE);
gimp_procedure_add_return_value (procedure,
g_param_spec_double ("value",
GIMP_PROC_ARG_DOUBLE (procedure, "value",
"Vakue",
"The progress value",
0.0, 1.0, 0.0,
G_PARAM_READWRITE));
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);
g_object_unref (procedure);

12
libgimp/gimpsaveprocedure.c
View File

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

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

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

6
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),
TRUE);
gimp_procedure_add_argument (procedure,
g_param_spec_int ("spacing",
GIMP_PROC_ARG_INT (procedure, "spacing",
"Spacing",
"Spacing of the brush",
1, 1000, 10,
GIMP_PARAM_READWRITE));
GIMP_PARAM_READWRITE);
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("description",
"Description",

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

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

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

59
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),
"png");
gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("interlace",
GIMP_PROC_ARG_BOOLEAN (procedure, "interlace",
"Interlace",
"Use Adam7 interlacing?",
FALSE,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_int ("compression",
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "compression",
"Compression",
"Deflate Compression "
"factor (0..9)",
"Deflate Compression factor (0..9)",
0, 9, 9,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("bkgd",
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "bkgd",
"bKGD",
"Write bKGD chunk?",
TRUE,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("gama",
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "gama",
"gAMA",
"Write gAMA chunk?",
FALSE,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("offs",
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "offs",
"oFFs",
"Write oFFs chunk?",
FALSE,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("phys",
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "phys",
"pHYs",
"Write pHYs chunk?",
TRUE,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("time",
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "time",
"tIME",
"Write tIME chunk?",
TRUE,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("comment",
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "comment",
"Comment",
"Write comment?",
TRUE,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("save-trans",
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "save-trans",
"Save trans",
"Preserve color of "
"transparent pixels?",
"Preserve color of transparent pixels?",
TRUE,
G_PARAM_READWRITE));
G_PARAM_READWRITE);
}
return procedure;

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

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

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

@ -237,71 +237,64 @@ film_create_procedure (GimpPlugIn *plug_in,
"Peter Kirchgessner (peter@kirchgessner.net)",
"1997");
gimp_procedure_add_argument (procedure,
g_param_spec_int ("film-height",
GIMP_PROC_ARG_INT (procedure, "film-height",
"Film height",
"Height of film (0: fit "
"to images)",
"Height of film (0: fit to images)",
0, GIMP_MAX_IMAGE_SIZE, 0,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_rgb ("film-color",
G_PARAM_READWRITE);
GIMP_PROC_ARG_RGB (procedure, "film-color",
"Film color",
"Color of the film",
TRUE, NULL,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_int ("number-start",
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_procedure_add_argument (procedure,
g_param_spec_string ("number-font",
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "number-font",
"Number font",
"Font for drawing numbers",
NULL,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_rgb ("number-color",
G_PARAM_READWRITE);
GIMP_PROC_ARG_RGB (procedure, "number-color",
"Number color",
"Color for numbers",
TRUE, NULL,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("at-top",
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "at-top",
"At top",
"Draw numbers at top",
TRUE,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("at-bottom",
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "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));
G_PARAM_READWRITE);
gimp_procedure_add_return_value (procedure,
gimp_param_spec_image_id ("new-image",
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));
G_PARAM_READWRITE);
}
return procedure;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

10
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),
"sgi,rgb,rgba,bw,icon");
gimp_procedure_add_argument (procedure,
g_param_spec_int ("compression",
GIMP_PROC_ARG_INT (procedure, "compression",
"Compression",
"Compression level "
"(0 = none, "
"1 = RLE, "
"2 = ARLE)",
"Compression level (0 = none, 1 = RLE, 2 = ARLE)",
0, 2, 1,
G_PARAM_STATIC_STRINGS));
G_PARAM_STATIC_STRINGS);
}
return procedure;

28
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),
"tif,tiff");
gimp_procedure_add_argument (procedure,
g_param_spec_int ("compression",
GIMP_PROC_ARG_INT (procedure, "compression",
"Compression",
"Compression type: "
"{ NONE (0), "
"LZW (1), "
"PACKBITS (2), "
"DEFLATE (3), "
"JPEG (4), "
"CCITT G3 Fax (5), "
"Compression type: { NONE (0), LZW (1), PACKBITS (2), "
"DEFLATE (3), JPEG (4), CCITT G3 Fax (5), "
"CCITT G4 Fax (6) }",
0, 6, 0,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("save-transp-pixels",
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "save-transp-pixels",
"Save transp pixels",
"Keep the color data "
"masked by an alpha "
"channel intact "
"(do not store "
"premultiplied "
"components)",
"Keep the color data masked by an alpha channel "
"intact (do not store premultiplied components)",
TRUE,
G_PARAM_READWRITE));
G_PARAM_READWRITE);
}
return procedure;

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

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

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

@ -132,35 +132,34 @@ help_browser_create_procedure (GimpPlugIn *plug_in,
"Henrik Brix Andersen",
"1999-2008");
gimp_procedure_add_argument (procedure,
g_param_spec_enum ("run-mode",
GIMP_PROC_ARG_ENUM (procedure, "run-mode",
"Run mode",
"The run mode",
GIMP_TYPE_RUN_MODE,
GIMP_RUN_INTERACTIVE,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_int ("num-domain-names",
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "num-domain-names",
"Num domain names",
"Num domain names",
0, G_MAXINT, 0,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string_array ("domain-names",
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING_ARRAY (procedure, "domain-names",
"Domain names",
"Domain names",
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_int ("num-domain-uris",
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "num-domain-uris",
"Num domain URIs",
"Num domain URIs",
0, G_MAXINT, 0,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string_array ("domain-uris",
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING_ARRAY (procedure, "domain-uris",
"Domain URIs",
"Domain URIs",
G_PARAM_READWRITE));
G_PARAM_READWRITE);
}
return procedure;
@ -217,24 +216,23 @@ temp_proc_install (GimpPlugIn *plug_in)
"Henrik Brix Andersen",
"1999-2008");
gimp_procedure_add_argument (procedure,
g_param_spec_string ("help-domain",
GIMP_PROC_ARG_STRING (procedure, "help-domain",
"Help domain",
"Help domain to use",
NULL,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_string ("help-locales",
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "help-locales",
"Help locales",
"Language to use",
NULL,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_string ("help-id",
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "help-id",
"Help ID",
"Help ID to open",
NULL,
G_PARAM_READWRITE));
G_PARAM_READWRITE);
gimp_plug_in_add_temp_procedure (plug_in, procedure);
g_object_unref (procedure);

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

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

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

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

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

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

72
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,
FALSE, NULL));
gimp_procedure_add_argument (procedure,
g_param_spec_enum ("run-mode",
GIMP_PROC_ARG_ENUM (procedure, "run-mode",
"Run mode",
"The run mode",
GIMP_TYPE_RUN_MODE,
GIMP_RUN_NONINTERACTIVE,
G_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_int ("shoot-type",
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "shoot-type",
"Shoot type",
"The shoot type "
"{ SHOOT-WINDOW (0), "
"SHOOT-ROOT (1), "
"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));
G_PARAM_READWRITE);
gimp_procedure_add_return_value (procedure,
gimp_param_spec_image_id ("image",
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));
G_PARAM_READWRITE);
}
return procedure;

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

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