procyberian/gimp
2
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/gimp.git synced 2025-07-04 09:53:25 +00:00
Code Issues 1 Projects 1 Releases Packages Wiki Activity Actions

plug-ins: Port argument macros to functions

Browse source 
With the new API introduced int d1c4457f,
we next need to port all plug-ins using
the argument macros to functions.
This will allow us to remove the macros
as part of the 3.0 API clean-up.
This commit is contained in:
Alx Sa 2024-06-12 16:53:12 +00:00
parent 0de33a0462
commit 4bf5dc7b97
103 changed files with 4185 additions and 4183 deletions
Download patch file Download diff file Expand all files Collapse all files

4
libgimp/gimpbatchprocedure.c
View file

@ -97,14 +97,14 @@ gimp_batch_procedure_constructed (GObject *object)
G_OBJECT_CLASS (parent_class)->constructed (object);
GIMP_PROC_ARG_ENUM (procedure, "run-mode",
gimp_procedure_add_enum_argument (procedure, "run-mode",
"Run mode",
"The run mode",
GIMP_TYPE_RUN_MODE,
GIMP_RUN_NONINTERACTIVE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "script",
gimp_procedure_add_string_argument (procedure, "script",
"Batch commands in the target language",
"Batch commands in the target language, which will be run by the interpreter",
"",

4
libgimp/gimpdrawablechooser.c
View file

@ -513,10 +513,10 @@ gimp_drawable_chooser_clicked (GimpDrawableChooser *chooser)
(GimpRunFunc) gimp_temp_callback_run,
g_object_ref (chooser),
(GDestroyNotify) g_object_unref);
GIMP_PROC_ARG_DRAWABLE (callback_procedure, "drawable",
gimp_procedure_add_drawable_argument (callback_procedure, "drawable",
"Drawable", "The selected drawable",
TRUE, G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (callback_procedure, "closing",
gimp_procedure_add_boolean_argument (callback_procedure, "closing",
"Closing", "If the dialog was closing",
FALSE, G_PARAM_READWRITE);

18
libgimp/gimpexportprocedure.c
View file

@ -214,13 +214,13 @@ gimp_export_procedure_constructed (GObject *object)
G_OBJECT_CLASS (parent_class)->constructed (object);
GIMP_PROC_ARG_IMAGE (procedure, "image",
gimp_procedure_add_image_argument (procedure, "image",
"Image",
"The image to export",
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_FILE (procedure, "file",
gimp_procedure_add_file_argument (procedure, "file",
"File",
"The file to export to",
GIMP_PARAM_READWRITE);
@ -458,43 +458,43 @@ gimp_export_procedure_add_metadata (GimpExportProcedure *export_procedure)
return;
if (export_procedure->priv->supports_exif)
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-exif",
gimp_procedure_add_boolean_aux_argument (procedure, "save-exif",
_("Save _Exif"),
_("Save Exif (Exchangeable image file format) metadata"),
gimp_export_exif (),
G_PARAM_READWRITE);
if (export_procedure->priv->supports_iptc)
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-iptc",
gimp_procedure_add_boolean_aux_argument (procedure, "save-iptc",
_("Save _IPTC"),
_("Save IPTC (International Press Telecommunications Council) metadata"),
gimp_export_iptc (),
G_PARAM_READWRITE);
if (export_procedure->priv->supports_xmp)
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-xmp",
gimp_procedure_add_boolean_aux_argument (procedure, "save-xmp",
_("Save _XMP"),
_("Save XMP (Extensible Metadata Platform) metadata"),
gimp_export_xmp (),
G_PARAM_READWRITE);
if (export_procedure->priv->supports_profile)
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-color-profile",
gimp_procedure_add_boolean_aux_argument (procedure, "save-color-profile",
_("Save color _profile"),
_("Save the ICC color profile as metadata"),
gimp_export_color_profile (),
G_PARAM_READWRITE);
if (export_procedure->priv->supports_thumbnail)
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-thumbnail",
gimp_procedure_add_boolean_aux_argument (procedure, "save-thumbnail",
_("Save _thumbnail"),
_("Save a smaller representation of the image as metadata"),
gimp_export_thumbnail (),
G_PARAM_READWRITE);
if (export_procedure->priv->supports_comment)
{
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-comment",
gimp_procedure_add_boolean_aux_argument (procedure, "save-comment",
_("Save c_omment"),
_("Save a comment as metadata"),
gimp_export_comment (),
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_STRING (procedure, "gimp-comment",
gimp_procedure_add_string_aux_argument (procedure, "gimp-comment",
_("Comment"),
_("Image comment"),
gimp_get_default_comment (),

2
libgimp/gimpfileprocedure.c
View file

@ -76,7 +76,7 @@ gimp_file_procedure_constructed (GObject *object)
G_OBJECT_CLASS (parent_class)->constructed (object);
GIMP_PROC_ARG_ENUM (procedure, "run-mode",
gimp_procedure_add_enum_argument (procedure, "run-mode",
"Run mode",
"The run mode",
GIMP_TYPE_RUN_MODE,

8
libgimp/gimpimageprocedure.c
View file

@ -105,26 +105,26 @@ gimp_image_procedure_constructed (GObject *object)
G_OBJECT_CLASS (parent_class)->constructed (object);
GIMP_PROC_ARG_ENUM (procedure, "run-mode",
gimp_procedure_add_enum_argument (procedure, "run-mode",
"Run mode",
"The run mode",
GIMP_TYPE_RUN_MODE,
GIMP_RUN_NONINTERACTIVE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_IMAGE (procedure, "image",
gimp_procedure_add_image_argument (procedure, "image",
"Image",
"The input image",
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "num-drawables",
gimp_procedure_add_int_argument (procedure, "num-drawables",
"Number of drawables",
"Number of input drawables",
0, G_MAXINT, 1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_OBJECT_ARRAY (procedure, "drawables",
gimp_procedure_add_object_array_argument (procedure, "drawables",
"Drawables",
"The input drawables",
GIMP_TYPE_DRAWABLE,

4
libgimp/gimploadprocedure.c
View file

@ -113,12 +113,12 @@ gimp_load_procedure_constructed (GObject *object)
G_OBJECT_CLASS (parent_class)->constructed (object);
GIMP_PROC_ARG_FILE (procedure, "file",
gimp_procedure_add_file_argument (procedure, "file",
"File",
"The file to load",
GIMP_PARAM_READWRITE);
GIMP_PROC_VAL_IMAGE (procedure, "image",
gimp_procedure_add_image_return_value (procedure, "image",
"Image",
"Output image",
TRUE,

3
libgimp/gimpprocedureconfig.c
View file

@ -815,7 +815,8 @@ _gimp_procedure_config_end_run (GimpProcedureConfig *config,
* but must take care of their default values itself. The easiest way
* to do this is by simply using [func@export_comment], [func@export_exif] etc.
* as default values for these arguments when adding them using
* GIMP_PROC_ARG_BOOLEAN() or GIMP_PROC_AUX_ARG_BOOLEAN().
* gimp_procedure_add_boolean_argument() or
* gimp_procedure_add_boolean_aux_argument().
*
* Returns: (transfer none) (nullable): The metadata to be used
* for this export, or %NULL if @original_image doesn't have

8
libgimp/gimpprogress.c
View file

@ -107,26 +107,26 @@ gimp_progress_install_vtable (const GimpProgressVtable *vtable,
(GDestroyNotify)
gimp_progress_data_free);
GIMP_PROC_ARG_ENUM (procedure, "command",
gimp_procedure_add_enum_argument (procedure, "command",
"Command",
"The progress command",
GIMP_TYPE_PROGRESS_COMMAND,
GIMP_PROGRESS_COMMAND_START,
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "text",
gimp_procedure_add_string_argument (procedure, "text",
"Text",
"The progress text",
NULL,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "value",
gimp_procedure_add_double_argument (procedure, "value",
"Value",
"The progress value",
0.0, 1.0, 0.0,
G_PARAM_READWRITE);
GIMP_PROC_VAL_DOUBLE (procedure, "value",
gimp_procedure_add_double_return_value (procedure, "value",
"Value",
"The progress value",
0.0, 1.0, 0.0,

30
libgimp/gimpresourceselect.c
View file

@ -113,7 +113,7 @@ static void
create_callback_PDB_procedure_params (GimpProcedure *procedure,
GType resource_type)
{
GIMP_PROC_ARG_RESOURCE (procedure, "resource",
gimp_procedure_add_resource_argument (procedure, "resource",
"Resource",
"The resource",
G_PARAM_READWRITE);
@ -125,58 +125,58 @@ create_callback_PDB_procedure_params (GimpProcedure *procedure,
}
else if (g_type_is_a (resource_type, GIMP_TYPE_GRADIENT))
{
GIMP_PROC_ARG_INT (procedure, "gradient-width",
gimp_procedure_add_int_argument (procedure, "gradient-width",
"Gradient width",
"The gradient width",
0, G_MAXINT, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_FLOAT_ARRAY (procedure, "gradient-data",
gimp_procedure_add_float_array_argument (procedure, "gradient-data",
"Gradient data",
"The gradient data",
G_PARAM_READWRITE);
}
else if (g_type_is_a (resource_type, GIMP_TYPE_BRUSH))
{
GIMP_PROC_ARG_DOUBLE (procedure, "opacity",
gimp_procedure_add_double_argument (procedure, "opacity",
"Opacity",
NULL,
0.0, 100.0, 100.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "spacing",
gimp_procedure_add_int_argument (procedure, "spacing",
"Spacing",
NULL,
-1, 1000, 20,
G_PARAM_READWRITE);
GIMP_PROC_ARG_ENUM (procedure, "paint-mode",
gimp_procedure_add_enum_argument (procedure, "paint-mode",
"Paint mode",
NULL,
GIMP_TYPE_LAYER_MODE,
GIMP_LAYER_MODE_NORMAL,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "mask-width",
gimp_procedure_add_int_argument (procedure, "mask-width",
"Brush width",
NULL,
0, 10000, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "mask-height",
gimp_procedure_add_int_argument (procedure, "mask-height",
"Brush height",
NULL,
0, 10000, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BYTES (procedure, "mask-data",
gimp_procedure_add_bytes_argument (procedure, "mask-data",
"Mask data",
"The brush mask data",
G_PARAM_READWRITE);
}
else if (g_type_is_a (resource_type, GIMP_TYPE_PALETTE))
{
GIMP_PROC_ARG_INT (procedure, "num-colors",
gimp_procedure_add_int_argument (procedure, "num-colors",
"Num colors",
"Number of colors",
0, G_MAXINT, 0,
@ -184,25 +184,25 @@ create_callback_PDB_procedure_params (GimpProcedure *procedure,
}
else if (g_type_is_a (resource_type, GIMP_TYPE_PATTERN))
{
GIMP_PROC_ARG_INT (procedure, "mask-width",
gimp_procedure_add_int_argument (procedure, "mask-width",
"Mask width",
"Pattern width",
0, 10000, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "mask-height",
gimp_procedure_add_int_argument (procedure, "mask-height",
"Mask height",
"Pattern height",
0, 10000, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "mask-bpp",
gimp_procedure_add_int_argument (procedure, "mask-bpp",
"Mask bpp",
"Pattern bytes per pixel",
0, 10000, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BYTES (procedure, "mask-data",
gimp_procedure_add_bytes_argument (procedure, "mask-data",
"Mask data",
"The pattern mask data",
G_PARAM_READWRITE);
@ -212,7 +212,7 @@ create_callback_PDB_procedure_params (GimpProcedure *procedure,
g_warning ("%s: unhandled resource type", G_STRFUNC);
}
GIMP_PROC_ARG_BOOLEAN (procedure, "closing",
gimp_procedure_add_boolean_argument (procedure, "closing",
"Closing",
"If the dialog was closing",
FALSE,

14
libgimp/gimpthumbnailprocedure.c
View file

@ -82,43 +82,43 @@ gimp_thumbnail_procedure_constructed (GObject *object)
G_OBJECT_CLASS (parent_class)->constructed (object);
GIMP_PROC_ARG_FILE (procedure, "file",
gimp_procedure_add_file_argument (procedure, "file",
"File",
"The file to load the thumbnail from",
GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "thumb-size",
gimp_procedure_add_int_argument (procedure, "thumb-size",
"Thumb Size",
"Preferred thumbnail size",
16, 2014, 256,
GIMP_PARAM_READWRITE);
GIMP_PROC_VAL_IMAGE (procedure, "image",
gimp_procedure_add_image_return_value (procedure, "image",
"Image",
"Thumbnail image",
TRUE,
GIMP_PARAM_READWRITE);
GIMP_PROC_VAL_INT (procedure, "image-width",
gimp_procedure_add_int_return_value (procedure, "image-width",
"Image width",
"Width of the full-sized image (0 for unknown)",
0, GIMP_MAX_IMAGE_SIZE, 0,
GIMP_PARAM_READWRITE);
GIMP_PROC_VAL_INT (procedure, "image-height",
gimp_procedure_add_int_return_value (procedure, "image-height",
"Image height",
"Height of the full-sized image (0 for unknown)",
0, GIMP_MAX_IMAGE_SIZE, 0,
GIMP_PARAM_READWRITE);
GIMP_PROC_VAL_ENUM (procedure, "image-type",
gimp_procedure_add_enum_return_value (procedure, "image-type",
"Image type",
"Type of the image",
GIMP_TYPE_IMAGE_TYPE,
GIMP_RGB_IMAGE,
GIMP_PARAM_READWRITE);
GIMP_PROC_VAL_INT (procedure, "num-layers",
gimp_procedure_add_int_return_value (procedure, "num-layers",
"Num layers",
"Number of layers in the image",
1, G_MAXINT, 1,

12
libgimp/gimpvectorloadprocedure.c
View file

@ -107,26 +107,26 @@ gimp_vector_load_procedure_constructed (GObject *object)
G_OBJECT_CLASS (parent_class)->constructed (object);
GIMP_PROC_ARG_INT (procedure, "width",
gimp_procedure_add_int_argument (procedure, "width",
_("_Width (pixels)"),
"Width (in pixels) to load the image in. "
"(0 for the corresponding width per native ratio)",
0, GIMP_MAX_IMAGE_SIZE, 0,
GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "height",
gimp_procedure_add_int_argument (procedure, "height",
_("_Height (pixels)"),
"Height (in pixels) to load the image in. "
"(0 for the corresponding height per native ratio)",
0, GIMP_MAX_IMAGE_SIZE, 0,
GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "keep-ratio",
gimp_procedure_add_boolean_argument (procedure, "keep-ratio",
_("_Keep aspect ratio"),
_("Force dimensions with aspect ratio"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "prefer-native-dimensions",
gimp_procedure_add_boolean_argument (procedure, "prefer-native-dimensions",
_("_Prefer native dimensions"),
_("Load and use dimensions from source file"),
FALSE,
@ -135,13 +135,13 @@ gimp_vector_load_procedure_constructed (GObject *object)
/* Note: the "pixel-density" is saved in pixels per inch. "physical-unit"
* property is only there for display.
*/
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "pixel-density",
gimp_procedure_add_double_aux_argument (procedure, "pixel-density",
_("Resolu_tion"),
_("Pixel Density: number of pixels per physical unit"),
GIMP_MIN_RESOLUTION, GIMP_MAX_RESOLUTION,
GIMP_VECTOR_LOAD_DEFAULT_PIXEL_DENSITY,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_INT (procedure, "physical-unit",
gimp_procedure_add_int_aux_argument (procedure, "physical-unit",
_("Unit"),
_("Physical unit"),
GIMP_UNIT_INCH, GIMP_UNIT_PICA, GIMP_UNIT_INCH,

18
plug-ins/common/align-layers.c
View file

@ -188,7 +188,7 @@ align_layers_create_procedure (GimpPlugIn *plug_in,
"Shuji Narazaki",
"1997");
GIMP_PROC_ARG_INT (procedure, "horizontal-style",
gimp_procedure_add_int_argument (procedure, "horizontal-style",
_("_Horizontal style"),
_("(None = 0, Collect = 1, "
"Fill left to right = 2, Fill right to left = 3, "
@ -196,14 +196,14 @@ align_layers_create_procedure (GimpPlugIn *plug_in,
H_NONE, SNAP2HGRID, H_NONE,
GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "horizontal-base",
gimp_procedure_add_int_argument (procedure, "horizontal-base",
_("Hori_zontal base"),
_("(Left edge = 0, Center = 1, "
"Right edge = 2)"),
H_BASE_LEFT, H_BASE_RIGHT, H_BASE_LEFT,
GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "vertical-style",
gimp_procedure_add_int_argument (procedure, "vertical-style",
_("_Vertical style"),
_("(None = 0, Collect = 1, "
"Fill left to right = 2, Fill right to left = 3, "
@ -211,27 +211,27 @@ align_layers_create_procedure (GimpPlugIn *plug_in,
V_NONE, SNAP2VGRID, V_NONE,
GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "vertical-base",
gimp_procedure_add_int_argument (procedure, "vertical-base",
_("Ver_tical base"),
_("(Left edge = 0, Center = 1, "
"Right edge = 2)"),
V_BASE_TOP, V_BASE_BOTTOM, V_BASE_TOP,
GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "grid-size",
gimp_procedure_add_int_argument (procedure, "grid-size",
_("_Grid"),
_("Grid"),
1, 200, 10,
GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure,
gimp_procedure_add_boolean_argument (procedure,
"ignore-bottom-layer",
_("Ignore the _bottom layer even if visible"),
_("Ignore the bottom layer even if visible"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure,
gimp_procedure_add_boolean_argument (procedure,
"use-bottom-layer",
_("_Use the (invisible) bottom layer as the base"),
_("Use the (invisible) bottom layer as the base"),
@ -244,12 +244,12 @@ align_layers_create_procedure (GimpPlugIn *plug_in,
* them.
*/
/*
GIMP_PROC_ARG_BOOLEAN (procedure,
gimp_procedure_add_boolean_argument (procedure,
"link-after-alignment",
"Link the visible layers after alignment",
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure,
gimp_procedure_add_boolean_argument (procedure,
"use-bottom",
"use the bottom layer as the base of alignment",
TRUE,

4
plug-ins/common/animation-optimize.c
View file

@ -295,9 +295,9 @@ optimize_create_procedure (GimpPlugIn *plug_in,
"Adam D. Moss <adam@gimp.org>",
"1997-2003");
GIMP_PROC_VAL_IMAGE (procedure, "result",
gimp_procedure_add_image_return_value (procedure, "result",
"Result",
"Resultimg image",
"Resulting image",
FALSE,
G_PARAM_READWRITE);
}

2
plug-ins/common/animation-play.c
View file

@ -341,7 +341,7 @@ play_create_procedure (GimpPlugIn *plug_in,
"Adam D. Moss <adam@gimp.org>",
"1997, 1998...");
GIMP_PROC_AUX_ARG_BYTES (procedure, "settings-data",
gimp_procedure_add_bytes_aux_argument (procedure, "settings-data",
"Settings data",
"TODO: eventually we must implement proper args for every settings",
GIMP_PARAM_READWRITE);

8
plug-ins/common/blinds.c
View file

@ -150,19 +150,19 @@ blinds_create_procedure (GimpPlugIn *plug_in,
"Andy Thomas",
"1997");
GIMP_PROC_ARG_INT (procedure, "angle-displacement",
gimp_procedure_add_int_argument (procedure, "angle-displacement",
_("_Displacement"),
_("Angle of Displacement"),
0, 90, 30,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "num-segments",
gimp_procedure_add_int_argument (procedure, "num-segments",
_("_Number of segments"),
_("Number of segments in blinds"),
1, MAX_FANS, 3,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "orientation",
gimp_procedure_add_int_argument (procedure, "orientation",
_("Orientation"),
_("The orientation"),
GIMP_ORIENTATION_HORIZONTAL,
@ -170,7 +170,7 @@ blinds_create_procedure (GimpPlugIn *plug_in,
GIMP_ORIENTATION_HORIZONTAL,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "bg-transparent",
gimp_procedure_add_boolean_argument (procedure, "bg-transparent",
_("_Transparent"),
_("Background transparent"),
FALSE,

8
plug-ins/common/border-average.c
View file

@ -137,23 +137,23 @@ border_average_create_procedure (GimpPlugIn *plug_in,
"Internet Access AG",
"1998");
GIMP_PROC_ARG_INT (procedure, "thickness",
gimp_procedure_add_int_argument (procedure, "thickness",
_("_Thickness"),
_("Border size to take in count"),
0, G_MAXINT, 3,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_UNIT (procedure, "thickness-unit",
gimp_procedure_add_unit_aux_argument (procedure, "thickness-unit",
_("Thickness unit of measure"),
_("Border size unit of measure"),
TRUE, TRUE, GIMP_UNIT_PIXEL,
GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "bucket-exponent",
gimp_procedure_add_int_argument (procedure, "bucket-exponent",
_("Bucket Si_ze"),
_("Bits for bucket size (default=4: 16 Levels)"),
0, G_MAXINT, 4,
G_PARAM_READWRITE);
GIMP_PROC_VAL_COLOR (procedure, "borderaverage",
gimp_procedure_add_color_return_value (procedure, "borderaverage",
_("The average color of the specified border."),
_("The average color of the specified border."),
TRUE, default_return_color,

11
plug-ins/common/busy-dialog.c
View file

@ -136,32 +136,33 @@ busy_dialog_create_procedure (GimpPlugIn *plug_in,
"Ell",
"2018");
GIMP_PROC_ARG_ENUM (procedure, "run-mode",
gimp_procedure_add_enum_argument (procedure, "run-mode",
"Run mode",
"The run mode",
GIMP_TYPE_RUN_MODE,
GIMP_RUN_INTERACTIVE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "read-fd",
gimp_procedure_add_int_argument (procedure, "read-fd",
"The read file descriptor",
"The read file descriptor",
G_MININT, G_MAXINT, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "write-fd",
gimp_procedure_add_int_argument (procedure, "write-fd",
"The write file descriptor",
"The write file descriptor",
G_MININT, G_MAXINT, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "message",
gimp_procedure_add_string_argument (procedure, "message",
"The message",
"The message",
NULL,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "cancelable",
gimp_procedure_add_boolean_argument (procedure, "cancelable",
"Whether the dialog is cancelable",
"Whether the dialog is cancelable",
FALSE,

12
plug-ins/common/checkerboard.c
View file

@ -133,19 +133,19 @@ checkerboard_create_procedure (GimpPlugIn *plug_in,
"Brent Burton & the Edward Blevins",
"1997");
GIMP_PROC_ARG_BOOLEAN (procedure, "psychobily",
gimp_procedure_add_boolean_argument (procedure, "psychobilly",
_("_Psychobilly"),
_("Render a psychobilly checkerboard"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "check-size",
gimp_procedure_add_int_argument (procedure, "check-size",
_("_Size"),
_("Size of the checks"),
1, GIMP_MAX_IMAGE_SIZE, 10,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_UNIT (procedure, "check-size-unit",
gimp_procedure_add_unit_aux_argument (procedure, "check-size-unit",
_("Check size unit of measure"),
_("Check size unit of measure"),
TRUE, TRUE, GIMP_UNIT_PIXEL,
@ -267,7 +267,7 @@ do_checkerboard_pattern (GObject *config,
if (config)
g_object_get (config,
"check-size", &size,
"psychobily", &mode,
"psychobilly", &mode,
NULL);
color = gimp_context_get_background ();
@ -511,7 +511,7 @@ checkerboard_dialog (GimpProcedure *procedure,
1.0, size);
toggle = gimp_procedure_dialog_get_widget (GIMP_PROCEDURE_DIALOG (dialog),
"psychobily",
"psychobilly",
GTK_TYPE_CHECK_BUTTON);
gtk_widget_set_margin_bottom (toggle, 12);
@ -528,7 +528,7 @@ checkerboard_dialog (GimpProcedure *procedure,
preview);
gimp_procedure_dialog_fill (GIMP_PROCEDURE_DIALOG (dialog),
"preview", "check-size", "psychobily",
"preview", "check-size", "psychobilly",
NULL);
gtk_widget_show (dialog);

4
plug-ins/common/cml-explorer.c
View file

@ -532,13 +532,13 @@ explorer_create_procedure (GimpPlugIn *plug_in,
"Shuji Narazaki",
"1997");
GIMP_PROC_ARG_FILE (procedure, "parameter-file",
gimp_procedure_add_file_argument (procedure, "parameter-file",
_("Parameter File"),
_("The parameter file from which CML_explorer makes an image. "
"This argument is only used in non-interactive runs."),
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BYTES (procedure, "settings-data",
gimp_procedure_add_bytes_aux_argument (procedure, "settings-data",
"Settings data",
"TODO: eventually we must implement proper args for every settings",
GIMP_PARAM_READWRITE);

6
plug-ins/common/colormap-remap.c
View file

@ -195,7 +195,7 @@ remap_create_procedure (GimpPlugIn *plug_in,
"Mukund Sivaraman <muks@mukund.org>",
"June 2006");
GIMP_PROC_ARG_BYTES (procedure, "map",
gimp_procedure_add_bytes_argument (procedure, "map",
_("Map"),
_("Remap array for the colormap"),
G_PARAM_READWRITE);
@ -228,13 +228,13 @@ remap_create_procedure (GimpPlugIn *plug_in,
"Mukund Sivaraman <muks@mukund.org>",
"June 2006");
GIMP_PROC_ARG_INT (procedure, "index1",
gimp_procedure_add_int_argument (procedure, "index1",
_("Index 1"),
_("First index in the colormap"),
0, 255, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "index2",
gimp_procedure_add_int_argument (procedure, "index2",
_("Index 2"),
_("Second (other) index in the colormap"),
0, 255, 0,

20
plug-ins/common/compose.c
View file

@ -414,25 +414,25 @@ compose_create_procedure (GimpPlugIn *plug_in,
"Peter Kirchgessner (peter@kirchgessner.net)",
"1997");
GIMP_PROC_ARG_IMAGE (procedure, "image-2",
gimp_procedure_add_image_argument (procedure, "image-2",
_("Image 2"),
_("Second input image"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_IMAGE (procedure, "image-3",
gimp_procedure_add_image_argument (procedure, "image-3",
_("Image 3"),
_("Third input image"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_IMAGE (procedure, "image-4",
gimp_procedure_add_image_argument (procedure, "image-4",
_("Image 4"),
_("Fourth input image"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "compose-type",
gimp_procedure_add_choice_argument (procedure, "compose-type",
_("Color _model"),
type_desc->str,
gimp_choice_new_with_values ("rgb", 0, _("RGB"), NULL,
@ -450,7 +450,7 @@ compose_create_procedure (GimpPlugIn *plug_in,
"rgb",
G_PARAM_READWRITE);
GIMP_PROC_VAL_IMAGE (procedure, "new-image",
gimp_procedure_add_image_return_value (procedure, "new-image",
_("New image"),
_("Output image"),
FALSE,
@ -477,25 +477,25 @@ compose_create_procedure (GimpPlugIn *plug_in,
"Peter Kirchgessner (peter@kirchgessner.net)",
"1998");
GIMP_PROC_ARG_DRAWABLE (procedure, "drawable-2",
gimp_procedure_add_drawable_argument (procedure, "drawable-2",
_("Drawable 2"),
_("Second input drawable"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DRAWABLE (procedure, "drawable-3",
gimp_procedure_add_drawable_argument (procedure, "drawable-3",
_("Drawable 3"),
_("Third input drawable"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DRAWABLE (procedure, "drawable-4",
gimp_procedure_add_drawable_argument (procedure, "drawable-4",
_("Drawable 4"),
_("Fourth input drawable"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "compose-type",
gimp_procedure_add_choice_argument (procedure, "compose-type",
_("Color _model"),
type_desc->str,
gimp_choice_new_with_values ("rgb", 0, _("RGB"), NULL,
@ -513,7 +513,7 @@ compose_create_procedure (GimpPlugIn *plug_in,
"rgb",
G_PARAM_READWRITE);
GIMP_PROC_VAL_IMAGE (procedure, "new-image",
gimp_procedure_add_image_return_value (procedure, "new-image",
_("New image"),
_("Output image"),
FALSE,

8
plug-ins/common/contrast-retinex.c
View file

@ -195,26 +195,26 @@ retinex_create_procedure (GimpPlugIn *plug_in,
"Fabien Pelisson",
"2003");
GIMP_PROC_ARG_INT (procedure, "scale",
gimp_procedure_add_int_argument (procedure, "scale",
_("Scal_e"),
_("Biggest scale value"),
MIN_GAUSSIAN_SCALE, MAX_GAUSSIAN_SCALE, 240,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "nscales",
gimp_procedure_add_int_argument (procedure, "nscales",
_("Scale _division"),
_("Number of scales"),
0, MAX_RETINEX_SCALES, 3,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "scales-mode",
gimp_procedure_add_int_argument (procedure, "scales-mode",
_("Le_vel"),
_("Retinex distribution through scales "
"{ Uniform (0), Low (1), High (2) }"),
RETINEX_UNIFORM, RETINEX_HIGH, RETINEX_UNIFORM,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "cvar",
gimp_procedure_add_double_argument (procedure, "cvar",
_("Dy_namic"),
_("Variance value"),
0, 4, 1.2,

36
plug-ins/common/curve-bend.c
View file

@ -422,111 +422,111 @@ bender_create_procedure (GimpPlugIn *plug_in,
PLUG_IN_COPYRIGHT,
PLUG_IN_VERSION);
GIMP_PROC_ARG_DOUBLE (procedure, "rotation",
gimp_procedure_add_double_argument (procedure, "rotation",
_("Rotat_e"),
_("Direction {angle 0 to 360 degree } "
"of the bend effect"),
0, 360, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "smoothing",
gimp_procedure_add_boolean_argument (procedure, "smoothing",
_("Smoo_thing"),
_("Smoothing"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "antialias",
gimp_procedure_add_boolean_argument (procedure, "antialias",
_("_Antialiasing"),
_("Antialias"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "work-on-copy",
gimp_procedure_add_boolean_argument (procedure, "work-on-copy",
_("Work on cop_y"),
_("Copy the drawable and bend the copy"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "curve-type",
gimp_procedure_add_int_argument (procedure, "curve-type",
_("Curve Type"),
_("{ 0 == smooth (use 17 points), "
"1 == freehand (use 256 val_y) }"),
0, 1, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "curve-border",
gimp_procedure_add_int_argument (procedure, "curve-border",
_("Curve for Border"),
_("Choose the active border line to edit"),
0, 1, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "argc-upper-point-x",
gimp_procedure_add_int_argument (procedure, "argc-upper-point-x",
_("Argc upper point X"),
_("Argc upper point X"),
2, 17, 2,
G_PARAM_READWRITE);
GIMP_PROC_ARG_FLOAT_ARRAY (procedure, "upper-point-x",
gimp_procedure_add_float_array_argument (procedure, "upper-point-x",
_("Upper point X"),
_("Array of 17 x point coords "
"{ 0.0 <= x <= 1.0 or -1 for unused point }"),
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "argc-upper-point-y",
gimp_procedure_add_int_argument (procedure, "argc-upper-point-y",
_("Argc upper point Y"),
_("Argc upper point Y"),
2, 17, 2,
G_PARAM_READWRITE);
GIMP_PROC_ARG_FLOAT_ARRAY (procedure, "upper-point-y",
gimp_procedure_add_float_array_argument (procedure, "upper-point-y",
_("Upper point Y"),
_("Array of 17 y point coords "
"{ 0.0 <= y <= 1.0 or -1 for unused point }"),
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "argc-lower-point-x",
gimp_procedure_add_int_argument (procedure, "argc-lower-point-x",
_("Argc lower point X"),
_("Argc lower point X"),
2, 17, 2,
G_PARAM_READWRITE);
GIMP_PROC_ARG_FLOAT_ARRAY (procedure, "lower-point-x",
gimp_procedure_add_float_array_argument (procedure, "lower-point-x",
_("Lower point X"),
_("Array of 17 x point coords "
"{ 0.0 <= x <= 1.0 or -1 for unused point }"),
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "argc-lower-point-y",
gimp_procedure_add_int_argument (procedure, "argc-lower-point-y",
_("Argc lower point Y"),
_("Argc lower point Y"),
2, 17, 2,
G_PARAM_READWRITE);
GIMP_PROC_ARG_FLOAT_ARRAY (procedure, "lower-point-y",
gimp_procedure_add_float_array_argument (procedure, "lower-point-y",
_("Lower point Y"),
_("Array of 17 y point coords "
"{ 0.0 <= y <= 1.0 or -1 for unused point }"),
G_PARAM_READWRITE);
GIMP_PROC_ARG_BYTES (procedure, "upper-val-y",
gimp_procedure_add_bytes_argument (procedure, "upper-val-y",
_("Upper val Y"),
_("Array of 256 y freehand coords "
"{ 0 <= y <= 255 }"),
G_PARAM_READWRITE);
GIMP_PROC_ARG_BYTES (procedure, "lower-val-y",
gimp_procedure_add_bytes_argument (procedure, "lower-val-y",
_("Lower val Y"),
_("Array of 256 y freehand coords "
"{ 0 <= y <= 255 }"),
G_PARAM_READWRITE);
GIMP_PROC_VAL_LAYER (procedure, "bent-layer",
gimp_procedure_add_layer_return_value (procedure, "bent-layer",
_("Bent layer"),
_("The transformed layer"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BYTES (procedure, "settings-data",
gimp_procedure_add_bytes_aux_argument (procedure, "settings-data",
"Settings data",
"TODO: eventually we must implement proper args for every settings",
GIMP_PARAM_READWRITE);

14
plug-ins/common/decompose.c
View file

@ -294,7 +294,7 @@ decompose_create_procedure (GimpPlugIn *plug_in,
"Peter Kirchgessner, Clarence Risher",
"1997");
GIMP_PROC_ARG_CHOICE (procedure, "decompose-type",
gimp_procedure_add_choice_argument (procedure, "decompose-type",
_("Color _model"),
_("The model to decompose to"),
gimp_choice_new_with_values ("rgb", 0, _("RGB"), NULL,
@ -313,13 +313,13 @@ decompose_create_procedure (GimpPlugIn *plug_in,
"rgb",
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "layers-mode",
gimp_procedure_add_boolean_argument (procedure, "layers-mode",
_("_Decompose to layers"),
_("Create channels as layers in a single image"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "use-registration",
gimp_procedure_add_boolean_argument (procedure, "use-registration",
_("_Foreground as registration color"),
_("When enabled, pixels in the foreground color "
"will appear black in all output images. This "
@ -328,25 +328,25 @@ decompose_create_procedure (GimpPlugIn *plug_in,
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_VAL_IMAGE (procedure, "new-image-1",
gimp_procedure_add_image_return_value (procedure, "new-image-1",
"New image 1",
"Output gray image 1",
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_VAL_IMAGE (procedure, "new-image-2",
gimp_procedure_add_image_return_value (procedure, "new-image-2",
"New image 2",
"Output gray image 2 (N/A for single channel extract)",
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_VAL_IMAGE (procedure, "new-image-3",
gimp_procedure_add_image_return_value (procedure, "new-image-3",
"New image 3",
"Output gray image 3 (N/A for single channel extract)",
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_VAL_IMAGE (procedure, "new-image-4",
gimp_procedure_add_image_return_value (procedure, "new-image-4",
"New image 4",
"Output gray image 4 (N/A for single channel extract)",
TRUE,

16
plug-ins/common/depth-merge.c
View file

@ -219,49 +219,49 @@ merge_create_procedure (GimpPlugIn *plug_in,
"Sean Cier",
PLUG_IN_VERSION);
GIMP_PROC_ARG_DRAWABLE (procedure, "source-1",
gimp_procedure_add_drawable_argument (procedure, "source-1",
_("Source _1"),
_("Source 1"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DRAWABLE (procedure, "depth-map-1",
gimp_procedure_add_drawable_argument (procedure, "depth-map-1",
_("_Depth map 1"),
_("Depth map 1"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DRAWABLE (procedure, "source-2",
gimp_procedure_add_drawable_argument (procedure, "source-2",
_("Source _2"),
_("Source 2"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DRAWABLE (procedure, "depth-map-2",
gimp_procedure_add_drawable_argument (procedure, "depth-map-2",
_("Depth _map 2"),
_("Depth map 2"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "overlap",
gimp_procedure_add_double_argument (procedure, "overlap",
_("O_verlap"),
_("Overlap"),
0, 2, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "offset",
gimp_procedure_add_double_argument (procedure, "offset",
_("O_ffset"),
_("Depth relative offset"),
-1, 1, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "scale-1",
gimp_procedure_add_double_argument (procedure, "scale-1",
_("Sc_ale 1"),
_("Depth relative scale 1"),
-1, 1, 1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "scale-2",
gimp_procedure_add_double_argument (procedure, "scale-2",
_("Scal_e 2"),
_("Depth relative scale 2"),
-1, 1, 1,

8
plug-ins/common/despeckle.c
View file

@ -181,26 +181,26 @@ despeckle_create_procedure (GimpPlugIn *plug_in,
"Copyright 1997-1998 by Michael Sweet",
PLUG_IN_VERSION);
GIMP_PROC_ARG_INT (procedure, "radius",
gimp_procedure_add_int_argument (procedure, "radius",
_("R_adius"),
_("Filter box radius"),
1, MAX_RADIUS, 3,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "type",
gimp_procedure_add_int_argument (procedure, "type",
_("_Filter Type"),
_("Filter type { MEDIAN (0), ADAPTIVE (1), "
"RECURSIVE-MEDIAN (2), RECURSIVE-ADAPTIVE (3) }"),
0, 3, FILTER_ADAPTIVE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "black",
gimp_procedure_add_int_argument (procedure, "black",
_("_Black level"),
_("Black level"),
-1, 255, 7,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "white",
gimp_procedure_add_int_argument (procedure, "white",
_("_White level"),
_("White level"),
0, 256, 248,

4
plug-ins/common/destripe.c
View file

@ -137,13 +137,13 @@ destripe_create_procedure (GimpPlugIn *plug_in,
"Marc Lehmann <pcg@goof.com>",
PLUG_IN_VERSION);
GIMP_PROC_ARG_INT (procedure, "avg-width",
gimp_procedure_add_int_argument (procedure, "avg-width",
_("_Width"),
_("Averaging filter width"),
2, MAX_AVG, 36,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure,
gimp_procedure_add_boolean_argument (procedure,
"create-histogram",
_("Create _histogram"),
_("Output a histogram"),

2
plug-ins/common/file-aa.c
View file

@ -150,7 +150,7 @@ ascii_create_procedure (GimpPlugIn *plug_in,
for (i = 0; aa_formats[i]; i++);
GIMP_PROC_ARG_INT (procedure, "file-type",
gimp_procedure_add_int_argument (procedure, "file-type",
_("_Format"),
_("File type to use"),
0, i, 0,

8
plug-ins/common/file-cel.c
View file

@ -153,7 +153,7 @@ cel_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_magics (GIMP_FILE_PROCEDURE (procedure),
"0,string,KiSS\\040");
GIMP_PROC_ARG_FILE (procedure, "palette-file",
gimp_procedure_add_file_argument (procedure, "palette-file",
_("_Palette file"),
_("KCF file to load palette from"),
G_PARAM_READWRITE);
@ -183,9 +183,9 @@ cel_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"cel");
GIMP_PROC_ARG_FILE (procedure, "palette-file",
"Palette file",
"File to save palette to",
gimp_procedure_add_file_argument (procedure, "palette-file",
_("_Palette file"),
_("File to save palette to"),
G_PARAM_READWRITE);
}

18
plug-ins/common/file-csource.c
View file

@ -139,13 +139,13 @@ csource_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"c");
GIMP_PROC_AUX_ARG_STRING (procedure, "prefixed-name",
gimp_procedure_add_string_aux_argument (procedure, "prefixed-name",
_("_Prefixed name"),
_("Prefixed name"),
"gimp_image",
GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_STRING (procedure, "gimp-comment",
gimp_procedure_add_string_aux_argument (procedure, "gimp-comment",
_("Comme_nt"),
_("Comment"),
gimp_get_default_comment (),
@ -154,43 +154,43 @@ csource_create_procedure (GimpPlugIn *plug_in,
gimp_procedure_set_argument_sync (procedure, "gimp-comment",
GIMP_ARGUMENT_SYNC_PARASITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-comment",
gimp_procedure_add_boolean_aux_argument (procedure, "save-comment",
_("Save comment to _file"),
_("Save comment"),
gimp_export_comment (),
GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "glib-types",
gimp_procedure_add_boolean_aux_argument (procedure, "glib-types",
_("Use GLib types (guint_8*)"),
_("Use GLib types"),
TRUE,
GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-alpha",
gimp_procedure_add_boolean_aux_argument (procedure, "save-alpha",
_("Save alpha channel (RG_BA/RGB)"),
_("Save the alpha channel"),
FALSE,
GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "rgb565",
gimp_procedure_add_boolean_aux_argument (procedure, "rgb565",
_("Save as RGB565 (1_6-bit)"),
_("Use RGB565 encoding"),
FALSE,
GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "use-macros",
gimp_procedure_add_boolean_aux_argument (procedure, "use-macros",
_("_Use macros instead of struct"),
_("Use C macros"),
FALSE,
GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "use-rle",
gimp_procedure_add_boolean_aux_argument (procedure, "use-rle",
_("Use _1 bit Run-Length-Encoding"),
_("Use run-length-encoding"),
FALSE,
GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "opacity",
gimp_procedure_add_double_aux_argument (procedure, "opacity",
_("Opaci_ty"),
_("Opacity"),
0.0, 100.0, 100.0,

4
plug-ins/common/file-gbr.c
View file

@ -146,13 +146,13 @@ gbr_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_handles_remote (GIMP_FILE_PROCEDURE (procedure),
TRUE);
GIMP_PROC_ARG_INT (procedure, "spacing",
gimp_procedure_add_int_argument (procedure, "spacing",
_("Sp_acing"),
_("Spacing of the brush"),
1, 1000, 10,
GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "description",
gimp_procedure_add_string_argument (procedure, "description",
_("_Description"),
_("Short description of the brush"),
_("GIMP Brush"),

20
plug-ins/common/file-gif-export.c
View file

@ -179,33 +179,33 @@ gif_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"gif");
GIMP_PROC_ARG_BOOLEAN (procedure, "interlace",
gimp_procedure_add_boolean_argument (procedure, "interlace",
_("_Interlace"),
_("Try to export as interlaced"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "loop",
gimp_procedure_add_boolean_argument (procedure, "loop",
_("Loop _Forever"),
_("(animated gif) Loop infinitely"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "number-of-repeats",
gimp_procedure_add_int_argument (procedure, "number-of-repeats",
_("_Number of repeats"),
_("(animated gif) Number of repeats "
"(Ignored if 'loop' is TRUE)"),
0, G_MAXSHORT - 1, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "default-delay",
gimp_procedure_add_int_argument (procedure, "default-delay",
_("_Delay between frames when unspecified"),
_("(animated gif) Default delay between frames "
"in milliseconds"),
0, G_MAXINT, 100,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "default-dispose",
gimp_procedure_add_int_argument (procedure, "default-dispose",
_("Frame disposal _when unspecified"),
_("(animated gif) Default disposal type "
"(0=`don't care`, "
@ -214,32 +214,32 @@ gif_create_procedure (GimpPlugIn *plug_in,
0, 2, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "as-animation",
gimp_procedure_add_boolean_argument (procedure, "as-animation",
_("_As animation"),
_("Export GIF as animation?"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "force-delay",
gimp_procedure_add_boolean_argument (procedure, "force-delay",
_("_Use delay entered above for all frames"),
_("(animated gif) Use specified delay for all frames"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "force-dispose",
gimp_procedure_add_boolean_argument (procedure, "force-dispose",
_("Use dis_posal entered above "
"for all frames"),
_("(animated gif) Use specified disposal for all frames"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-comment",
gimp_procedure_add_boolean_aux_argument (procedure, "save-comment",
_("Sa_ve comment"),
_("Save the image comment in the GIF file"),
gimp_export_comment (),
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_STRING (procedure, "gimp-comment",
gimp_procedure_add_string_aux_argument (procedure, "gimp-comment",
_("Commen_t"),
_("Image comment"),
gimp_get_default_comment (),

22
plug-ins/common/file-gih.c
View file

@ -181,60 +181,60 @@ gih_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_handles_remote (GIMP_FILE_PROCEDURE (procedure),
TRUE);
GIMP_PROC_ARG_INT (procedure, "spacing",
gimp_procedure_add_int_argument (procedure, "spacing",
_("Spacing (_percent)"),
_("Spacing of the brush"),
1, 1000, 20,
GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "description",
gimp_procedure_add_string_argument (procedure, "description",
_("_Description"),
_("Short description of the GIH brush pipe"),
"GIMP Brush Pipe",
GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "cell-width",
gimp_procedure_add_int_argument (procedure, "cell-width",
_("Cell _width"),
_("Width of the brush cells in pixels"),
1, 1000, 1,
GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "cell-height",
gimp_procedure_add_int_argument (procedure, "cell-height",
_("Cell _height"),
_("Height of the brush cells in pixels"),
1, 1000, 1,
GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "num-cells",
gimp_procedure_add_int_argument (procedure, "num-cells",
_("_Number of cells"),
_("Number of cells to cut up"),
1, 1000, 1,
GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_BYTES (procedure, "ranks",
gimp_procedure_add_bytes_argument (procedure, "ranks",
_("_Rank"),
_("Ranks of the dimensions"),
GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_STRV (procedure, "selection-modes",
"Selection modes",
gimp_procedure_add_string_array_argument (procedure, "selection-modes",
_("Selection modes"),
_("Selection modes"),
GIMP_PARAM_READWRITE);
/* Auxiliary arguments. Only useful for the GUI, to pass info around. */
GIMP_PROC_AUX_ARG_STRING (procedure, "info-text",
gimp_procedure_add_string_aux_argument (procedure, "info-text",
_("Display as"),
_("Describe how the layers will be split"),
"", GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_INT (procedure, "dimension",
gimp_procedure_add_int_aux_argument (procedure, "dimension",
_("D_imension"),
_("How many dimensions the animated brush has"),
1, 1000, 1,
GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_INT32_ARRAY (procedure, "guides",
gimp_procedure_add_int32_array_aux_argument (procedure, "guides",
"Guides",
"Guides to show how the layers will be split in cells",
GIMP_PARAM_READWRITE);

6
plug-ins/common/file-glob.c
View file

@ -116,20 +116,20 @@ glob_create_procedure (GimpPlugIn *plug_in,
"Sven Neumann",
"2004");
GIMP_PROC_ARG_STRING (procedure, "pattern",
gimp_procedure_add_string_argument (procedure, "pattern",
"Pattern",
"The glob pattern (in UTF-8 encoding)",
NULL,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "filename-encoding",
gimp_procedure_add_boolean_argument (procedure, "filename-encoding",
"Filename encoding",
"FALSE to return UTF-8 strings, TRUE to return "
"strings in filename encoding",
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_VAL_STRV (procedure, "files",
gimp_procedure_add_string_array_return_value (procedure, "files",
"Files",
"The list of matching filenames",
G_PARAM_READWRITE |

32
plug-ins/common/file-heif.c
View file

@ -251,51 +251,51 @@ heif_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"heif,heic");
GIMP_PROC_ARG_INT (procedure, "quality",
gimp_procedure_add_int_argument (procedure, "quality",
_("_Quality"),
_("Quality factor (0 = worst, 100 = best)"),
0, 100, 50,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "lossless",
gimp_procedure_add_boolean_argument (procedure, "lossless",
_("L_ossless"),
_("Use lossless compression"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-color-profile",
gimp_procedure_add_boolean_aux_argument (procedure, "save-color-profile",
_("Save color prof_ile"),
_("Save the image's color profile"),
gimp_export_color_profile (),
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "save-bit-depth",
gimp_procedure_add_int_argument (procedure, "save-bit-depth",
_("_Bit depth"),
_("Bit depth of exported image"),
8, 12, 8,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "pixel-format",
gimp_procedure_add_int_argument (procedure, "pixel-format",
_("_Pixel format"),
_("Format of color sub-sampling"),
HEIFPLUGIN_EXPORT_FORMAT_RGB, HEIFPLUGIN_EXPORT_FORMAT_YUV420,
HEIFPLUGIN_EXPORT_FORMAT_YUV420,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "encoder-speed",
gimp_procedure_add_int_argument (procedure, "encoder-speed",
_("Enco_der speed"),
_("Tradeoff between speed and compression"),
HEIFPLUGIN_ENCODER_SPEED_SLOW, HEIFPLUGIN_ENCODER_SPEED_FASTER,
HEIFPLUGIN_ENCODER_SPEED_BALANCED,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "save-exif",
gimp_procedure_add_boolean_argument (procedure, "save-exif",
_("Save Exi_f"),
_("Toggle saving Exif data"),
gimp_export_exif (),
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "save-xmp",
gimp_procedure_add_boolean_argument (procedure, "save-xmp",
_("Save _XMP"),
_("Toggle saving XMP data"),
gimp_export_xmp (),
@ -361,51 +361,51 @@ heif_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_priority (GIMP_FILE_PROCEDURE (procedure), 100);
GIMP_PROC_ARG_INT (procedure, "quality",
gimp_procedure_add_int_argument (procedure, "quality",
_("_Quality"),
_("Quality factor (0 = worst, 100 = best)"),
0, 100, 50,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "lossless",
gimp_procedure_add_boolean_argument (procedure, "lossless",
_("L_ossless"),
_("Use lossless compression"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-color-profile",
gimp_procedure_add_boolean_aux_argument (procedure, "save-color-profile",
_("Save color prof_ile"),
_("Save the image's color profile"),
gimp_export_color_profile (),
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "save-bit-depth",
gimp_procedure_add_int_argument (procedure, "save-bit-depth",
_("_Bit depth"),
_("Bit depth of exported image"),
8, 12, 8,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "pixel-format",
gimp_procedure_add_int_argument (procedure, "pixel-format",
_("_Pixel format"),
_("Format of color sub-sampling"),
HEIFPLUGIN_EXPORT_FORMAT_RGB, HEIFPLUGIN_EXPORT_FORMAT_YUV420,
HEIFPLUGIN_EXPORT_FORMAT_YUV420,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "encoder-speed",
gimp_procedure_add_int_argument (procedure, "encoder-speed",
_("Enco_der speed"),
_("Tradeoff between speed and compression"),
HEIFPLUGIN_ENCODER_SPEED_SLOW, HEIFPLUGIN_ENCODER_SPEED_FASTER,
HEIFPLUGIN_ENCODER_SPEED_BALANCED,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "save-exif",
gimp_procedure_add_boolean_argument (procedure, "save-exif",
_("Save Exi_f"),
_("Toggle saving Exif data"),
gimp_export_exif (),
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "save-xmp",
gimp_procedure_add_boolean_argument (procedure, "save-xmp",
_("Save _XMP"),
_("Toggle saving XMP data"),
gimp_export_xmp (),

22
plug-ins/common/file-html-table.c
View file

@ -170,40 +170,40 @@ html_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"html,htm");
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "use-caption",
gimp_procedure_add_boolean_aux_argument (procedure, "use-caption",
_("Use c_aption"),
_("Enable if you would like to have the table "
"captioned."),
FALSE,
GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_STRING (procedure, "caption-text",
gimp_procedure_add_string_aux_argument (procedure, "caption-text",
_("Capt_ion"),
_("The text for the table caption."),
"Made with GIMP Table Magic",
GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_STRING (procedure, "cell-content",
gimp_procedure_add_string_aux_argument (procedure, "cell-content",
_("Cell con_tent"),
_("The text to go into each cell."),
"&nbsp;",
GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_STRING (procedure, "cell-width",
gimp_procedure_add_string_aux_argument (procedure, "cell-width",
_("_Width"),
_("The width for each table cell. "
"Can be a number or a percent."),
"",
GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_STRING (procedure, "cell-height",
gimp_procedure_add_string_aux_argument (procedure, "cell-height",
_("_Height"),
_("The height for each table cell. "
"Can be a number or a percent."),
"",
GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "full-document",
gimp_procedure_add_boolean_aux_argument (procedure, "full-document",
_("_Generate full HTML document"),
_("If enabled GTM will output a full HTML "
"document with <HTML>, <BODY>, etc. tags "
@ -211,13 +211,13 @@ html_create_procedure (GimpPlugIn *plug_in,
TRUE,
GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_INT (procedure, "border",
gimp_procedure_add_int_aux_argument (procedure, "border",
_("_Border"),
_("The number of pixels in the table border."),
0, 1000, 2,
GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "span-tags",
gimp_procedure_add_boolean_aux_argument (procedure, "span-tags",
_("_Use cellspan"),
_("If enabled GTM will replace any "
"rectangular sections of identically "
@ -226,7 +226,7 @@ html_create_procedure (GimpPlugIn *plug_in,
FALSE,
GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "compress-td-tags",
gimp_procedure_add_boolean_aux_argument (procedure, "compress-td-tags",
_("Co_mpress TD tags"),
_("Enabling this will cause GTM to "
"leave no whitespace between the TD "
@ -236,13 +236,13 @@ html_create_procedure (GimpPlugIn *plug_in,
FALSE,
GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_INT (procedure, "cell-padding",
gimp_procedure_add_int_aux_argument (procedure, "cell-padding",
_("Cell-pa_dding"),
_("The amount of cell padding."),
0, 1000, 4,
GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_INT (procedure, "cell-spacing",
gimp_procedure_add_int_aux_argument (procedure, "cell-spacing",
_("Cell spaci_ng"),
_("The amount of cell spacing."),
0, 1000, 0,

2
plug-ins/common/file-jp2-load.c
View file

@ -245,7 +245,7 @@ jp2_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"j2k,j2c,jpc");
GIMP_PROC_ARG_INT (procedure, "colorspace",
gimp_procedure_add_int_argument (procedure, "colorspace",
_("Color s_pace"),
_("Color space { UNKNOWN (0), GRAYSCALE (1), RGB (2), "
"CMYK (3), YCbCr (4), xvYCC (5) }"),

16
plug-ins/common/file-jpegxl.c
View file

@ -182,50 +182,50 @@ jpegxl_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"jxl");
GIMP_PROC_ARG_BOOLEAN (procedure, "lossless",
gimp_procedure_add_boolean_argument (procedure, "lossless",
_("L_ossless"),
_("Use lossless compression"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "compression",
gimp_procedure_add_double_argument (procedure, "compression",
_("Co_mpression/maxError"),
_("Max. butteraugli distance, lower = higher quality. Range: 0 .. 15. 1.0 = visually lossless."),
0.1, 15, 1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "save-bit-depth",
gimp_procedure_add_int_argument (procedure, "save-bit-depth",
_("_Bit depth"),
_("Bit depth of exported image"),
8, 16, 8,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "speed",
gimp_procedure_add_int_argument (procedure, "speed",
_("Effort/S_peed"),
_("Encoder effort setting"),
1, 9,
7,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "uses-original-profile",
gimp_procedure_add_boolean_argument (procedure, "uses-original-profile",
_("Save ori_ginal profile"),
_("Store ICC profile to exported JXL file"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "cmyk",
gimp_procedure_add_boolean_argument (procedure, "cmyk",
_("Export as CMY_K"),
_("Create a CMYK JPEG XL image using the soft-proofing color profile"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "save-exif",
gimp_procedure_add_boolean_argument (procedure, "save-exif",
_("Save Exi_f"),
_("Toggle saving Exif data"),
gimp_export_exif (),
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "save-xmp",
gimp_procedure_add_boolean_argument (procedure, "save-xmp",
_("Save _XMP"),
_("Toggle saving XMP data"),
gimp_export_xmp (),

24
plug-ins/common/file-mng.c
View file

@ -272,45 +272,45 @@ mng_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"mng");
GIMP_PROC_ARG_BOOLEAN (procedure, "interlaced",
gimp_procedure_add_boolean_argument (procedure, "interlaced",
_("_Interlace"),
_("Use interlacing"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "png-compression",
gimp_procedure_add_int_argument (procedure, "png-compression",
_("_PNG compression level"),
_("PNG compression level, choose a high compression "
"level for small file size"),
0, 9, 9,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "jpeg-quality",
gimp_procedure_add_double_argument (procedure, "jpeg-quality",
_("JPEG compression _quality"),
_("JPEG quality factor"),
0, 1, 0.75,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "jpeg-smoothing",
gimp_procedure_add_double_argument (procedure, "jpeg-smoothing",
_("_JPEG smoothing factor"),
_("JPEG smoothing factor"),
0, 1, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "loop",
gimp_procedure_add_boolean_argument (procedure, "loop",
_("L_oop"),
_("(ANIMATED MNG) Loop infinitely"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "default-delay",
gimp_procedure_add_int_argument (procedure, "default-delay",
_("Default fra_me delay"),
_("(ANIMATED MNG) Default delay between frames in "
"milliseconds"),
1, G_MAXINT, 100,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "default-chunks",
gimp_procedure_add_int_argument (procedure, "default-chunks",
_("Default chunks t_ype"),
_("(ANIMATED MNG) Default chunks type "
"(0 = PNG + Delta PNG; 1 = JNG + Delta PNG; "
@ -318,32 +318,32 @@ mng_create_procedure (GimpPlugIn *plug_in,
0, 3, CHUNKS_PNG_D,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "default-dispose",
gimp_procedure_add_int_argument (procedure, "default-dispose",
_("De_fault frame disposal"),
_("(ANIMATED MNG) Default dispose type "
"(0 = combine; 1 = replace)"),
0, 1, DISPOSE_COMBINE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "bkgd",
gimp_procedure_add_boolean_argument (procedure, "bkgd",
_("Save _background color"),
_("Write bKGd (background color) chunk"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "gama",
gimp_procedure_add_boolean_argument (procedure, "gama",
_("Save _gamma"),
_("Write gAMA (gamma) chunk"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "phys",
gimp_procedure_add_boolean_argument (procedure, "phys",
_("Sa_ve resolution"),
_("Write pHYs (image resolution) chunk"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "time",
gimp_procedure_add_boolean_argument (procedure, "time",
_("Save creation _time"),
_("Write tIME (creation time) chunk"),
TRUE,

2
plug-ins/common/file-pat.c
View file

@ -131,7 +131,7 @@ pat_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_handles_remote (GIMP_FILE_PROCEDURE (procedure),
TRUE);
GIMP_PROC_ARG_STRING (procedure, "description",
gimp_procedure_add_string_argument (procedure, "description",
_("_Description"),
_("Short description of the pattern"),
_("GIMP Pattern"),

6
plug-ins/common/file-pcx.c
View file

@ -218,7 +218,7 @@ pcx_create_procedure (GimpPlugIn *plug_in,
"Nick Lamb <njl195@zepler.org.uk>",
"January 1997");
GIMP_PROC_ARG_INT (procedure, "override-palette",
gimp_procedure_add_int_argument (procedure, "override-palette",
_("Palette Options"),
_("Use built-in palette (0) or override with "
"black/white (1)"),
@ -249,7 +249,7 @@ pcx_create_procedure (GimpPlugIn *plug_in,
"Alex S.",
"2023");
GIMP_PROC_ARG_INT (procedure, "override-palette",
gimp_procedure_add_int_argument (procedure, "override-palette",
_("Palette Options"),
_("Use built-in palette (0) or override with "
"black/white (1)"),
@ -274,7 +274,7 @@ pcx_create_procedure (GimpPlugIn *plug_in,
gimp_procedure_set_menu_label (procedure, _("ZSoft PCX image"));
gimp_procedure_set_documentation (procedure,
"Exports files in ZSoft PCX file format",
_("Exports files in ZSoft PCX file format"),
"FIXME: write help for pcx_export",
name);
gimp_procedure_set_attribution (procedure,

32
plug-ins/common/file-pdf-export.c
View file

@ -333,50 +333,50 @@ pdf_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"pdf");
GIMP_PROC_ARG_BOOLEAN (procedure, "vectorize",
gimp_procedure_add_boolean_argument (procedure, "vectorize",
_("Convert _bitmaps to vector graphics where possible"),
_("Convert bitmaps to vector graphics where possible"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "ignore-hidden",
gimp_procedure_add_boolean_argument (procedure, "ignore-hidden",
_("O_mit hidden layers and layers with zero opacity"),
_("Non-visible layers will not be exported"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "apply-masks",
gimp_procedure_add_boolean_argument (procedure, "apply-masks",
_("_Apply layer masks"),
_("Apply layer masks before saving (Keeping the mask "
"will not change the output, only the PDF structure)"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "layers-as-pages",
gimp_procedure_add_boolean_argument (procedure, "layers-as-pages",
_("La_yers as pages"),
_("Layers as pages (bottom layers first)."),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "reverse-order",
gimp_procedure_add_boolean_argument (procedure, "reverse-order",
_("Re_verse order"),
_("Reverse the pages order (top layers first)."),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "root-layers-only",
gimp_procedure_add_boolean_argument (procedure, "root-layers-only",
_("Roo_t layers only"),
_("Only the root layers are considered pages"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "convert-text-layers",
gimp_procedure_add_boolean_argument (procedure, "convert-text-layers",
_("Convert te_xt layers to image"),
_("Convert text layers to raster graphics"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "fill-background-color",
gimp_procedure_add_boolean_argument (procedure, "fill-background-color",
_("_Fill transparent areas with background color"),
_("Fill transparent areas with background color if "
"layer has an alpha channel"),
@ -409,53 +409,53 @@ pdf_create_procedure (GimpPlugIn *plug_in,
"Copyright Barak Itkin",
"August 2009");
GIMP_PROC_ARG_ENUM (procedure, "run-mode",
gimp_procedure_add_enum_argument (procedure, "run-mode",
"Run mode",
"The run mode",
GIMP_TYPE_RUN_MODE,
GIMP_RUN_INTERACTIVE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "count",
gimp_procedure_add_int_argument (procedure, "count",
_("Count"),
_("The number of images entered (This will be the "
"number of pages)."),
1, MAX_PAGE_COUNT, 1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT32_ARRAY (procedure, "images",
gimp_procedure_add_int32_array_argument (procedure, "images",
"Images",
"Input image for each page (An image can "
"appear more than once)",
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "vectorize",
gimp_procedure_add_boolean_argument (procedure, "vectorize",
_("Convert _bitmaps to vector graphics where possible"),
_("Convert bitmaps to vector graphics where possible"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "ignore-hidden",
gimp_procedure_add_boolean_argument (procedure, "ignore-hidden",
_("O_mit hidden layers and layers with zero opacity"),
_("Non-visible layers will not be exported"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "apply-masks",
gimp_procedure_add_boolean_argument (procedure, "apply-masks",
_("_Apply layer masks"),
_("Apply layer masks before saving (Keeping the mask "
"will not change the output, only the PDF structure)"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "fill-background-color",
gimp_procedure_add_boolean_argument (procedure, "fill-background-color",
_("_Fill transparent areas with background color"),
_("Fill transparent areas with background color if "
"layer has an alpha channel"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "uri",
gimp_procedure_add_string_argument (procedure, "uri",
_("Save to"),
_("The URI of the file to save to"),
NULL,

18
plug-ins/common/file-pdf-load.c
View file

@ -222,23 +222,23 @@ pdf_create_procedure (GimpPlugIn *plug_in,
gimp_load_procedure_set_thumbnail_loader (GIMP_LOAD_PROCEDURE (procedure),
LOAD_THUMB_PROC);
GIMP_PROC_ARG_STRING (procedure, "password",
gimp_procedure_add_string_argument (procedure, "password",
_("PDF password"),
_("The password to decrypt the encrypted PDF file"),
NULL,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "reverse-order",
gimp_procedure_add_boolean_argument (procedure, "reverse-order",
_("Load in re_verse order"),
_("Load PDF pages in reverse order"),
FALSE,
G_PARAM_READWRITE);
/* FIXME: this should be a GIMP_PROC_ARG_ENUM of type
/* FIXME: this should be a gimp_procedure_add_enum_argument () of type
* GIMP_TYPE_PAGE_SELECTOR_TARGET but it won't work right now (see FIXME
* comment in libgimp/gimpgpparams-body.c:116).
GIMP_PROC_ARG_ENUM (procedure, "target",
gimp_procedure_add_enum_argument (procedure, "target",
_("Open pages as"),
_("Number of pages to load (0 for all)"),
GIMP_TYPE_PAGE_SELECTOR_TARGET,
@ -246,14 +246,14 @@ pdf_create_procedure (GimpPlugIn *plug_in,
G_PARAM_READWRITE);
*/
GIMP_PROC_AUX_ARG_INT (procedure, "target",
gimp_procedure_add_int_aux_argument (procedure, "target",
_("Open pages as"),
_("Number of pages to load (0 for all)"),
GIMP_PAGE_SELECTOR_TARGET_LAYERS, GIMP_PAGE_SELECTOR_TARGET_IMAGES,
GIMP_PAGE_SELECTOR_TARGET_LAYERS,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "n-pages",
gimp_procedure_add_int_argument (procedure, "n-pages",
_("N pages"),
_("Number of pages to load (0 for all)"),
0, G_MAXINT, 0,
@ -266,18 +266,18 @@ pdf_create_procedure (GimpPlugIn *plug_in,
* some settings generally, not sure that the list of page makes sense
* from one PDF document loaded to another (different) one.
*/
GIMP_PROC_ARG_INT32_ARRAY (procedure, "pages",
gimp_procedure_add_int32_array_argument (procedure, "pages",
_("Pages"),
_("The pages to load in the expected order"),
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "antialias",
gimp_procedure_add_boolean_argument (procedure, "antialias",
_("Use _Anti-aliasing"),
_("Render texts with anti-aliasing"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "white-background",
gimp_procedure_add_boolean_argument (procedure, "white-background",
_("_Fill transparent areas with white"),
_("Render all pages as opaque by filling the background in white"),
TRUE,

18
plug-ins/common/file-png.c
View file

@ -234,49 +234,49 @@ png_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"png");
GIMP_PROC_ARG_BOOLEAN (procedure, "interlaced",
gimp_procedure_add_boolean_argument (procedure, "interlaced",
_("_Interlacing (Adam7)"),
_("Use Adam7 interlacing"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "compression",
gimp_procedure_add_int_argument (procedure, "compression",
_("Co_mpression level"),
_("Deflate Compression factor (0..9)"),
0, 9, 9,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "bkgd",
gimp_procedure_add_boolean_argument (procedure, "bkgd",
_("Save _background color"),
_("Write bKGD chunk (PNG metadata)"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "offs",
gimp_procedure_add_boolean_argument (procedure, "offs",
_("Save layer o_ffset"),
_("Write oFFs chunk (PNG metadata)"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "phys",
gimp_procedure_add_boolean_argument (procedure, "phys",
_("Save resol_ution"),
_("Write pHYs chunk (PNG metadata)"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "time",
gimp_procedure_add_boolean_argument (procedure, "time",
_("Save creation _time"),
_("Write tIME chunk (PNG metadata)"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "save-transparent",
gimp_procedure_add_boolean_argument (procedure, "save-transparent",
_("Save color _values from transparent pixels"),
_("Preserve color of completely transparent pixels"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "optimize-palette",
gimp_procedure_add_boolean_argument (procedure, "optimize-palette",
_("_Optimize for smallest possible palette size"),
_("When checked, save as 1, 2, 4, or 8-bit depending"
" on number of colors used. When unchecked, always"
@ -284,7 +284,7 @@ png_create_procedure (GimpPlugIn *plug_in,
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_CHOICE (procedure, "format",
gimp_procedure_add_choice_argument (procedure, "format",
_("_Pixel format"),
_("PNG export format"),
gimp_choice_new_with_values ("auto", PNG_FORMAT_AUTO, _("Automatic"), NULL,

8
plug-ins/common/file-pnm.c
View file

@ -367,7 +367,7 @@ pnm_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"pnm");
GIMP_PROC_ARG_INT (procedure, "raw",
gimp_procedure_add_int_argument (procedure, "raw",
_("Data formatting"),
_("TRUE for raw output, FALSE for ascii output"),
0, 1, 1,
@ -403,7 +403,7 @@ pnm_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"pbm");
GIMP_PROC_ARG_INT (procedure, "raw",
gimp_procedure_add_int_argument (procedure, "raw",
_("Data formatting"),
_("TRUE for raw output, FALSE for ascii output"),
0, 1, 1,
@ -439,7 +439,7 @@ pnm_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"pgm");
GIMP_PROC_ARG_INT (procedure, "raw",
gimp_procedure_add_int_argument (procedure, "raw",
_("Data formatting"),
_("TRUE for raw output, FALSE for ascii output"),
0, 1, 1,
@ -475,7 +475,7 @@ pnm_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"ppm");
GIMP_PROC_ARG_INT (procedure, "raw",
gimp_procedure_add_int_argument (procedure, "raw",
"Data formatting",
_("TRUE for raw output, FALSE for ascii output"),
0, 1, 1,

32
plug-ins/common/file-ps.c
View file

@ -402,19 +402,19 @@ ps_create_procedure (GimpPlugIn *plug_in,
gimp_load_procedure_set_thumbnail_loader (GIMP_LOAD_PROCEDURE (procedure),
LOAD_PS_THUMB_PROC);
GIMP_PROC_ARG_BOOLEAN (procedure, "check-bbox",
gimp_procedure_add_boolean_argument (procedure, "check-bbox",
_("Try _Bounding Box"),
_("FALSE: Use width/height, TRUE: Use BoundingBox"),
TRUE,
GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "pages",
gimp_procedure_add_string_argument (procedure, "pages",
_("_Pages"),
_("Pages to load (e.g.: 1,3,5-7)"),
"1",
GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "coloring",
gimp_procedure_add_choice_argument (procedure, "coloring",
_("Colorin_g"),
_("Import color format"),
gimp_choice_new_with_values ("bw", 4, _("B/W"), NULL,
@ -424,7 +424,7 @@ ps_create_procedure (GimpPlugIn *plug_in,
NULL),
"rgb", G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "text-alpha-bits",
gimp_procedure_add_choice_argument (procedure, "text-alpha-bits",
_("Te_xt anti-aliasing"),
_("Text anti-aliasing strength"),
gimp_choice_new_with_values ("none", 1, _("None"), NULL,
@ -433,7 +433,7 @@ ps_create_procedure (GimpPlugIn *plug_in,
NULL),
"none", G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "graphic-alpha-bits",
gimp_procedure_add_choice_argument (procedure, "graphic-alpha-bits",
_("Gra_phic anti-aliasing"),
_("Graphic anti-aliasing strength"),
gimp_choice_new_with_values ("none", 1, _("None"), NULL,
@ -514,33 +514,33 @@ ps_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_handles_remote (GIMP_FILE_PROCEDURE (procedure),
TRUE);
GIMP_PROC_ARG_DOUBLE (procedure, "width",
gimp_procedure_add_double_argument (procedure, "width",
_("_Width"),
_("Width of the image in PostScript file "
"(0: use input image size)"),
0, GIMP_MAX_IMAGE_SIZE, 287.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "height",
gimp_procedure_add_double_argument (procedure, "height",
_("_Height"),
_("Height of the image in PostScript file "
"(0: use input image size)"),
0, GIMP_MAX_IMAGE_SIZE, 200.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "x-offset",
gimp_procedure_add_double_argument (procedure, "x-offset",
_("_X offset"),
_("X-offset to image from lower left corner"),
-GIMP_MAX_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE, 5.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "y-offset",
gimp_procedure_add_double_argument (procedure, "y-offset",
_("Y o_ffset"),
_("Y-offset to image from lower left corner"),
-GIMP_MAX_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE, 5.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "unit",
gimp_procedure_add_choice_argument (procedure, "unit",
_("_Unit"),
_("Unit of measure for offset values"),
gimp_choice_new_with_values ("inch", 0, _("Inch"), NULL,
@ -548,40 +548,40 @@ ps_create_procedure (GimpPlugIn *plug_in,
NULL),
"inch", G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "keep-ratio",
gimp_procedure_add_boolean_argument (procedure, "keep-ratio",
_("_Keep aspect ratio"),
_("If enabled, aspect ratio will be maintained on export. "
"Otherwise, the width and height values will be used."),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "rotation",
gimp_procedure_add_int_argument (procedure, "rotation",
_("Rotation"),
"0, 90, 180, 270",
0, 270, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "level",
gimp_procedure_add_boolean_argument (procedure, "level",
_("PostScript Level _2"),
_("If enabled, export in PostScript Level 2 format. "
"Otherwise, export in PostScript Level 1 format."),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "eps-flag",
gimp_procedure_add_boolean_argument (procedure, "eps-flag",
_("Encapsula_ted PostScript"),
_("If enabled, export as Encapsulated PostScript. "
"Otherwise, export as PostScript."),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "show-preview",
gimp_procedure_add_boolean_argument (procedure, "show-preview",
_("_Preview"),
_("Show Preview"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "preview",
gimp_procedure_add_int_argument (procedure, "preview",
_("Preview Si_ze"),
_("Maximum size of preview. Set to 0 for no preview."),
0, GIMP_MAX_IMAGE_SIZE, 256,

2
plug-ins/common/file-psp.c
View file

@ -713,7 +713,7 @@ psp_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"psp,tub");
GIMP_PROC_ARG_INT (procedure, "compression",
gimp_procedure_add_int_argument (procedure, "compression",
"_Data Compression",
"Specify 0 for no compression, "
"1 for RLE, and 2 for LZ77",

32
plug-ins/common/file-raw-data.c
View file

@ -349,23 +349,23 @@ raw_create_procedure (GimpPlugIn *plug_in,
/* Properties for image data. */
GIMP_PROC_ARG_INT (procedure, "width",
gimp_procedure_add_int_argument (procedure, "width",
_("_Width"),
_("Image width in number of pixels"),
1, GIMP_MAX_IMAGE_SIZE, PREVIEW_SIZE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "height",
gimp_procedure_add_int_argument (procedure, "height",
_("_Height"),
_("Image height in number of pixels"),
1, GIMP_MAX_IMAGE_SIZE, PREVIEW_SIZE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "offset",
gimp_procedure_add_int_argument (procedure, "offset",
_("O_ffset"),
_("Offset to beginning of image in raw data"),
0, GIMP_MAX_IMAGE_SIZE, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "pixel-format",
gimp_procedure_add_choice_argument (procedure, "pixel-format",
_("Pi_xel format"),
_("The layout of pixel data, such as components and their order"),
gimp_choice_new_with_values ("rgb-8bpp", RAW_RGB_8BPP, _("RGB 8-bit"), NULL,
@ -389,7 +389,7 @@ raw_create_procedure (GimpPlugIn *plug_in,
"indexed-alpha", RAW_INDEXEDA, _("Indexed Alpha"), NULL,
NULL),
"rgb-8bpp", G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "data-type",
gimp_procedure_add_choice_argument (procedure, "data-type",
_("_Data type"),
_("Data type used to represent pixel values"),
gimp_choice_new_with_values ("unsigned", RAW_ENCODING_UNSIGNED, _("Unsigned Integer"), NULL,
@ -397,14 +397,14 @@ raw_create_procedure (GimpPlugIn *plug_in,
"float", RAW_ENCODING_FLOAT, _("Floating Point"), NULL,
NULL),
"unsigned", G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "endianness",
gimp_procedure_add_choice_argument (procedure, "endianness",
_("_Endianness"),
_("Order of sequences of bytes"),
gimp_choice_new_with_values ("little-endian", RAW_LITTLE_ENDIAN, _("Little Endian"), NULL,
"big-endian", RAW_BIG_ENDIAN, _("Big Endian"), NULL,
NULL),
"little-endian", G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "planar-configuration",
gimp_procedure_add_choice_argument (procedure, "planar-configuration",
_("Planar confi_guration"),
_("How color pixel data are stored"),
gimp_choice_new_with_values ("contiguous", RAW_PLANAR_CONTIGUOUS, _("Contiguous"), NULL,
@ -414,20 +414,20 @@ raw_create_procedure (GimpPlugIn *plug_in,
/* Properties for palette data. */
GIMP_PROC_ARG_INT (procedure, "palette-offset",
gimp_procedure_add_int_argument (procedure, "palette-offset",
_("Palette Offse_t"),
_("Offset to beginning of data in the palette file"),
0, GIMP_MAX_IMAGE_SIZE, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "palette-type",
gimp_procedure_add_choice_argument (procedure, "palette-type",
_("Palette's la_yout"),
_("The layout for the palette's color channels"),
gimp_choice_new_with_values ("rgb", RAW_PALETTE_RGB, _("R, G, B (normal)"), NULL,
"bgr", RAW_PALETTE_BGR, _("B, G, R, X (BMP style)"), NULL,
NULL),
"rgb", G_PARAM_READWRITE);
GIMP_PROC_ARG_FILE (procedure, "palette-file",
gimp_procedure_add_file_argument (procedure, "palette-file",
_("_Palette File"),
_("The file containing palette data"),
G_PARAM_READWRITE);
@ -462,7 +462,7 @@ raw_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"hgt");
GIMP_PROC_ARG_CHOICE (procedure, "sample-spacing",
gimp_procedure_add_choice_argument (procedure, "sample-spacing",
_("Sa_mple spacing"),
_("The sample spacing of the data."),
gimp_choice_new_with_values ("auto-detect", HGT_SRTM_AUTO_DETECT, _("Auto-Detect"), NULL,
@ -473,20 +473,20 @@ raw_create_procedure (GimpPlugIn *plug_in,
/* Properties for palette data. */
GIMP_PROC_ARG_INT (procedure, "palette-offset",
gimp_procedure_add_int_argument (procedure, "palette-offset",
_("Palette Offse_t"),
_("Offset to beginning of data in the palette file"),
0, GIMP_MAX_IMAGE_SIZE, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "palette-type",
gimp_procedure_add_choice_argument (procedure, "palette-type",
_("Palette's la_yout"),
_("The layout for the palette's color channels"),
gimp_choice_new_with_values ("rgb", RAW_PALETTE_RGB, _("R, G, B (normal)"), NULL,
"bgr", RAW_PALETTE_BGR, _("B, G, R, X (BMP style)"), NULL,
NULL),
"rgb", G_PARAM_READWRITE);
GIMP_PROC_ARG_FILE (procedure, "palette-file",
gimp_procedure_add_file_argument (procedure, "palette-file",
_("_Palette File"),
_("The file containing palette data"),
G_PARAM_READWRITE);
@ -513,7 +513,7 @@ raw_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"data,raw");
GIMP_PROC_ARG_CHOICE (procedure, "planar-configuration",
gimp_procedure_add_choice_argument (procedure, "planar-configuration",
_("Planar configuration"),
_("How color pixel data are stored"),
gimp_choice_new_with_values ("contiguous", RAW_PLANAR_CONTIGUOUS, _("Contiguous"), NULL,
@ -521,7 +521,7 @@ raw_create_procedure (GimpPlugIn *plug_in,
NULL),
"contiguous", G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "palette-type",
gimp_procedure_add_choice_argument (procedure, "palette-type",
_("Palette's la_yout"),
_("The layout for the palette's color channels"),
gimp_choice_new_with_values ("rgb", RAW_PALETTE_RGB, _("R, G, B (normal)"), NULL,

2
plug-ins/common/file-sunras.c
View file

@ -319,7 +319,7 @@ sunras_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"im1,im8,im24,im32,rs,ras,sun");
GIMP_PROC_ARG_INT (procedure, "rle",
gimp_procedure_add_int_argument (procedure, "rle",
_("Data Formatting"),
_("Use standard (0) or Run-Length Encoded (1) output"),
0, 1, 1,

2
plug-ins/common/file-svg.c
View file

@ -184,7 +184,7 @@ svg_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_magics (GIMP_FILE_PROCEDURE (procedure),
"0,string,<?xml,0,string,<svg");
GIMP_PROC_ARG_CHOICE (procedure, "paths",
gimp_procedure_add_choice_argument (procedure, "paths",
_("_Paths"),
_("Whether and how to import paths so that they can be used with the path tool"),
gimp_choice_new_with_values ("no-import", 0, _("Don't import paths"), NULL,

4
plug-ins/common/file-tga.c
View file

@ -302,13 +302,13 @@ tga_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"tga");
GIMP_PROC_ARG_BOOLEAN (procedure, "rle",
gimp_procedure_add_boolean_argument (procedure, "rle",
_("_Use RLE compression"),
_("Use RLE compression"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "origin",
gimp_procedure_add_int_argument (procedure, "origin",
_("Ori_gin"),
_("Image origin (0 = top-left, 1 = bottom-left)"),
0, 1, ORIGIN_BOTTOM_LEFT,

18
plug-ins/common/file-xbm.c
View file

@ -209,13 +209,13 @@ xbm_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"xbm,icon,bitmap");
GIMP_PROC_ARG_BOOLEAN (procedure, "save-comment",
gimp_procedure_add_boolean_argument (procedure, "save-comment",
_("_Write comment"),
_("Write a comment at the beginning of the file."),
FALSE, /* *NOT* gimp_export_comment() */
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "gimp-comment",
gimp_procedure_add_string_argument (procedure, "gimp-comment",
_("Co_mment"),
_("Image description (maximum 72 bytes)"),
gimp_get_default_comment (),
@ -224,43 +224,43 @@ xbm_create_procedure (GimpPlugIn *plug_in,
gimp_procedure_set_argument_sync (procedure, "gimp-comment",
GIMP_ARGUMENT_SYNC_PARASITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "x10-format",
gimp_procedure_add_boolean_argument (procedure, "x10-format",
_("_X10 format bitmap"),
_("Export in X10 format"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "use-hot-spot",
gimp_procedure_add_boolean_argument (procedure, "use-hot-spot",
_("Write hot spot _values"),
_("Write hotspot information"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "hot-spot-x",
gimp_procedure_add_int_argument (procedure, "hot-spot-x",
_("Hot s_pot X"),
_("X coordinate of hotspot"),
0, GIMP_MAX_IMAGE_SIZE, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "hot-spot-y",
gimp_procedure_add_int_argument (procedure, "hot-spot-y",
_("Hot spot _Y"),
_("Y coordinate of hotspot"),
0, GIMP_MAX_IMAGE_SIZE, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "prefix",
gimp_procedure_add_string_argument (procedure, "prefix",
_("I_dentifier prefix"),
_("Identifier prefix [determined from filename]"),
"bitmap",
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "write-mask",
gimp_procedure_add_boolean_argument (procedure, "write-mask",
_("Write extra mask _file"),
_("Write extra mask file"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "mask-suffix",
gimp_procedure_add_string_argument (procedure, "mask-suffix",
_("Mas_k file extensions"),
_("Suffix of the mask file"),
"-mask",

20
plug-ins/common/file-xmc.c
View file

@ -364,27 +364,27 @@ xmc_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
XCURSOR_EXTENSION);
GIMP_PROC_ARG_INT (procedure, "hot-spot-x",
gimp_procedure_add_int_argument (procedure, "hot-spot-x",
_("Hot spot _X"),
_("X-coordinate of hot spot "
"(use -1, -1 to keep original hot spot)"),
-1, GIMP_MAX_IMAGE_SIZE, -1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "hot-spot-y",
gimp_procedure_add_int_argument (procedure, "hot-spot-y",
_("Hot spot _Y"),
_("Y-coordinate of hot spot "
"(use -1, -1 to keep original hot spot)"),
-1, GIMP_MAX_IMAGE_SIZE, -1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "crop",
gimp_procedure_add_boolean_argument (procedure, "crop",
_("_Auto Crop all frames"),
_("Remove the empty borders of all frames."),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "size",
gimp_procedure_add_choice_argument (procedure, "size",
_("Si_ze where unspecified"),
_("Default frame size if unspecified"),
gimp_choice_new_with_values ("size-12px", 12, ("12px"), NULL,
@ -399,26 +399,26 @@ xmc_create_procedure (GimpPlugIn *plug_in,
"size-32px",
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "size-replace",
gimp_procedure_add_boolean_argument (procedure, "size-replace",
_("_Use default size for all frames"),
_("Use default size for all frames"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "delay",
gimp_procedure_add_int_argument (procedure, "delay",
_("_Delay where unspecified"),
_("Default time span in milliseconds in which "
"each frame is rendered"),
CURSOR_MINIMUM_DELAY, G_MAXINT, CURSOR_DEFAULT_DELAY,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "delay-replace",
gimp_procedure_add_boolean_argument (procedure, "delay-replace",
_("Use default delay for all _frames"),
_("Use default delay for all frames"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "xmc-copyright",
gimp_procedure_add_string_argument (procedure, "xmc-copyright",
_("C_opyright"),
_("Copyright information"),
NULL,
@ -427,7 +427,7 @@ xmc_create_procedure (GimpPlugIn *plug_in,
gimp_procedure_set_argument_sync (procedure, "xmc-copyright",
GIMP_ARGUMENT_SYNC_PARASITE);
GIMP_PROC_ARG_STRING (procedure, "xmc-license",
gimp_procedure_add_string_argument (procedure, "xmc-license",
_("Lice_nse"),
_("License information"),
NULL,
@ -436,7 +436,7 @@ xmc_create_procedure (GimpPlugIn *plug_in,
gimp_procedure_set_argument_sync (procedure, "xmc-license",
GIMP_ARGUMENT_SYNC_PARASITE);
GIMP_PROC_ARG_STRING (procedure, "gimp-comment",
gimp_procedure_add_string_argument (procedure, "gimp-comment",
_("Co_mment"),
_("Optional comment"),
gimp_get_default_comment (),

2
plug-ins/common/file-xpm.c
View file

@ -256,7 +256,7 @@ xpm_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"xpm");
GIMP_PROC_ARG_INT (procedure, "threshold",
gimp_procedure_add_int_argument (procedure, "threshold",
_("_Threshold"),
_("Alpha threshold"),
0, 255, 127,

34
plug-ins/common/film.c
View file

@ -196,42 +196,42 @@ film_create_procedure (GimpPlugIn *plug_in,
"Peter Kirchgessner (peter@kirchgessner.net)",
"1997");
GIMP_PROC_ARG_INT (procedure, "film-height",
gimp_procedure_add_int_argument (procedure, "film-height",
_("Film _height"),
_("Height of film (0: fit to images)"),
0, GIMP_MAX_IMAGE_SIZE, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_COLOR (procedure, "film-color",
gimp_procedure_add_color_argument (procedure, "film-color",
_("_Film color"),
_("Color of the film"),
TRUE, default_film_color,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "number-start",
gimp_procedure_add_int_argument (procedure, "number-start",
_("Start _index"),
_("Start index for numbering"),
0, G_MAXINT, 1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_FONT (procedure, "number-font",
gimp_procedure_add_font_argument (procedure, "number-font",
_("Number _font"),
_("Font for drawing numbers"),
G_PARAM_READWRITE);
GIMP_PROC_ARG_COLOR (procedure, "number-color",
gimp_procedure_add_color_argument (procedure, "number-color",
_("_Number color"),
_("Color for numbers"),
TRUE, default_number_color,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "at-top",
gimp_procedure_add_boolean_argument (procedure, "at-top",
_("At _top"),
_("Draw numbers at top"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "at-bottom",
gimp_procedure_add_boolean_argument (procedure, "at-bottom",
_("At _bottom"),
_("Draw numbers at bottom"),
TRUE,
@ -239,7 +239,7 @@ film_create_procedure (GimpPlugIn *plug_in,
/* Arguments ignored in interactive mode. */
GIMP_PROC_ARG_OBJECT_ARRAY (procedure, "images",
gimp_procedure_add_object_array_argument (procedure, "images",
"Images",
"Images to be used for film",
GIMP_TYPE_IMAGE,
@ -247,43 +247,43 @@ film_create_procedure (GimpPlugIn *plug_in,
/* The more specific settings. */
GIMP_PROC_ARG_DOUBLE (procedure, "picture-height",
gimp_procedure_add_double_argument (procedure, "picture-height",
_("Image _height"),
_("As fraction of the strip height"),
0.0, 1.0, 0.695,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "picture-spacing",
gimp_procedure_add_double_argument (procedure, "picture-spacing",
_("Image s_pacing"),
_("The spacing between 2 images, as fraction of the strip height"),
0.0, 1.0, 0.040,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "hole-offset",
gimp_procedure_add_double_argument (procedure, "hole-offset",
_("Hole offse_t"),
_("The offset from the edge of film, as fraction of the strip height"),
0.0, 1.0, 0.058,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "hole-width",
gimp_procedure_add_double_argument (procedure, "hole-width",
_("Hole _width"),
_("The width of the holes, as fraction of the strip height"),
0.0, 1.0, 0.052,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "hole-height",
gimp_procedure_add_double_argument (procedure, "hole-height",
_("Hole hei_ght"),
_("The height of the holes, as fraction of the strip height"),
0.0, 1.0, 0.081,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "hole-spacing",
gimp_procedure_add_double_argument (procedure, "hole-spacing",
_("Hole _distance"),
_("The distance between holes, as fraction of the strip height"),
0.0, 1.0, 0.081,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "number-height",
gimp_procedure_add_double_argument (procedure, "number-height",
_("_Number height"),
_("The height of drawn numbers, as fraction of the strip height"),
0.0, 1.0, 0.052,
@ -291,7 +291,7 @@ film_create_procedure (GimpPlugIn *plug_in,
/* Auxiliary argument mostly for the GUI. */
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "keep-height",
gimp_procedure_add_boolean_aux_argument (procedure, "keep-height",
_("F_it height to images"),
_("Keep maximum image height"),
TRUE,
@ -299,7 +299,7 @@ film_create_procedure (GimpPlugIn *plug_in,
/* Returned image. */
GIMP_PROC_VAL_IMAGE (procedure, "new-image",
gimp_procedure_add_image_return_value (procedure, "new-image",
"New image",
"Output image",
FALSE,

24
plug-ins/common/grid.c
View file

@ -178,19 +178,19 @@ grid_create_procedure (GimpPlugIn *plug_in,
"Tom Rathborne, TC",
"1997 - 2000");
GIMP_PROC_ARG_INT (procedure, "hwidth",
gimp_procedure_add_int_argument (procedure, "hwidth",
"H width",
"Horizontal width",
0, GIMP_MAX_IMAGE_SIZE, 1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "hspace",
gimp_procedure_add_int_argument (procedure, "hspace",
"H space",
"Horizontal spacing",
1, GIMP_MAX_IMAGE_SIZE, 16,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "hoffset",
gimp_procedure_add_int_argument (procedure, "hoffset",
"H offset",
"Horizontal offset",
0, GIMP_MAX_IMAGE_SIZE, 8,
@ -200,55 +200,55 @@ grid_create_procedure (GimpPlugIn *plug_in,
* the foreground color as default. Future work would be to get the
* foreground/background color from context.
*/
GIMP_PROC_ARG_COLOR (procedure, "hcolor",
gimp_procedure_add_color_argument (procedure, "hcolor",
"H color",
"Horizontal color",
TRUE, default_hcolor,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "vwidth",
gimp_procedure_add_int_argument (procedure, "vwidth",
"V width",
"Vertical width",
0, GIMP_MAX_IMAGE_SIZE, 1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "vspace",
gimp_procedure_add_int_argument (procedure, "vspace",
"V space",
"Vertical spacing",
1, GIMP_MAX_IMAGE_SIZE, 16,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "voffset",
gimp_procedure_add_int_argument (procedure, "voffset",
"V offset",
"Vertical offset",
0, GIMP_MAX_IMAGE_SIZE, 8,
G_PARAM_READWRITE);
GIMP_PROC_ARG_COLOR (procedure, "vcolor",
gimp_procedure_add_color_argument (procedure, "vcolor",
"V color",
"Vertical color",
TRUE, default_vcolor,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "iwidth",
gimp_procedure_add_int_argument (procedure, "iwidth",
"I width",
"Intersection width",
0, GIMP_MAX_IMAGE_SIZE, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "ispace",
gimp_procedure_add_int_argument (procedure, "ispace",
"I space",
"Intersection spacing",
1, GIMP_MAX_IMAGE_SIZE, 2,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "ioffset",
gimp_procedure_add_int_argument (procedure, "ioffset",
"I offset",
"Intersection offset",
0, GIMP_MAX_IMAGE_SIZE, 6,
G_PARAM_READWRITE);
GIMP_PROC_ARG_COLOR (procedure, "icolor",
gimp_procedure_add_color_argument (procedure, "icolor",
"I color",
"Intersection color",
TRUE, default_icolor,

4
plug-ins/common/guillotine.c
View file

@ -125,13 +125,13 @@ guillotine_create_procedure (GimpPlugIn *plug_in,
"Adam D. Moss (adam@foxbox.org)",
"1998");
GIMP_PROC_VAL_INT (procedure, "image-count",
gimp_procedure_add_int_return_value (procedure, "image-count",
"Number of images created",
"Number of images created",
0, G_MAXINT, 0,
G_PARAM_READWRITE);
GIMP_PROC_VAL_OBJECT_ARRAY (procedure, "images",
gimp_procedure_add_object_array_return_value (procedure, "images",
"Output images",
"Output images",
GIMP_TYPE_IMAGE,

6
plug-ins/common/hot.c
View file

@ -266,20 +266,20 @@ hot_create_procedure (GimpPlugIn *plug_in,
"Eric L. Hernes",
"1997");
GIMP_PROC_ARG_INT (procedure, "mode",
gimp_procedure_add_int_argument (procedure, "mode",
_("Mode"),
_("Mode { NTSC (0), PAL (1) }"),
0, 1, MODE_NTSC,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "action",
gimp_procedure_add_int_argument (procedure, "action",
_("Action"),
_("Action { (0) reduce luminance, "
"(1) reduce saturation, or (2) Blacken }"),
0, 2, ACT_LREDUX,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "new-layer",
gimp_procedure_add_boolean_argument (procedure, "new-layer",
_("Create _new layer"),
_("Create a new layer"),
TRUE,

10
plug-ins/common/jigsaw.c
View file

@ -409,32 +409,32 @@ jigsaw_create_procedure (GimpPlugIn *plug_in,
"Nigel Wetten",
"May 2000");
GIMP_PROC_ARG_INT (procedure, "x",
gimp_procedure_add_int_argument (procedure, "x",
_("_Horizontal"),
_("Number of pieces going across"),
MIN_XTILES, MAX_XTILES, 5,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "y",
gimp_procedure_add_int_argument (procedure, "y",
_("_Vertical"),
_("Number of pieces going down"),
MIN_YTILES, MAX_YTILES, 5,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "style",
gimp_procedure_add_int_argument (procedure, "style",
_("Jigsaw Style"),
_("The style/shape of the jigsaw puzzle "
"{ Square (0), Curved (1) }"),
0, 1, BEZIER_1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "blend-lines",
gimp_procedure_add_int_argument (procedure, "blend-lines",
_("_Blend width"),
_("Degree of slope of each piece's edge"),
MIN_BLEND_LINES, MAX_BLEND_LINES, 3,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "blend-amount",
gimp_procedure_add_double_argument (procedure, "blend-amount",
_("Hi_ghlight"),
_("The amount of highlighting on the edges "
"of each piece"),

10
plug-ins/common/mail.c
View file

@ -207,31 +207,31 @@ mail_create_procedure (GimpPlugIn *plug_in,
"Spencer Kimball and Peter Mattis",
"1995-1997");
GIMP_PROC_ARG_STRING (procedure, "filename",
gimp_procedure_add_string_argument (procedure, "filename",
_("File_name"),
_("The name of the file to save the image in"),
NULL,
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "to-address",
gimp_procedure_add_string_argument (procedure, "to-address",
_("_To"),
_("The email address to send to"),
"",
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "from-address",
gimp_procedure_add_string_argument (procedure, "from-address",
_("_From"),
_("The email address for the From: field"),
"",
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "subject",
gimp_procedure_add_string_argument (procedure, "subject",
_("Su_bject"),
_("The subject"),
"",
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "comment",
gimp_procedure_add_string_argument (procedure, "comment",
_("Co_mment"),
_("The comment"),
NULL,

6
plug-ins/common/nl-filter.c
View file

@ -170,19 +170,19 @@ nlfilter_create_procedure (GimpPlugIn *plug_in,
"Graeme W. Gill, Eric L. Hernes",
"1997");
GIMP_PROC_ARG_DOUBLE (procedure, "alpha",
gimp_procedure_add_double_argument (procedure, "alpha",
_("_Alpha"),
_("The amount of the filter to apply"),
0, 1, 0.3,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "radius",
gimp_procedure_add_double_argument (procedure, "radius",
_("Ra_dius"),
_("The filter radius"),
1.0 / 3.0, 1, 1.0 / 3.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "filter",
gimp_procedure_add_int_argument (procedure, "filter",
_("Filter"),
_("The Filter to Run, "
"0 - alpha trimmed mean; "

2
plug-ins/common/plugin-browser.c
View file

@ -186,7 +186,7 @@ browser_create_procedure (GimpPlugIn *plug_in,
"Andy Thomas",
"1999");
GIMP_PROC_ARG_ENUM (procedure, "run-mode",
gimp_procedure_add_enum_argument (procedure, "run-mode",
"Run mode",
"The run mode",
GIMP_TYPE_RUN_MODE,

2
plug-ins/common/procedure-browser.c
View file

@ -135,7 +135,7 @@ browser_create_procedure (GimpPlugIn *plug_in,
"Thomas Noel",
"23th june 1997");
GIMP_PROC_ARG_ENUM (procedure, "run-mode",
gimp_procedure_add_enum_argument (procedure, "run-mode",
"Run mode",
"The run mode",
GIMP_TYPE_RUN_MODE,

6
plug-ins/common/qbist.c
View file

@ -201,7 +201,7 @@ qbist_create_procedure (GimpPlugIn *plug_in,
"Jörn Loviscach, Jens Ch. Restemeier",
PLUG_IN_VERSION);
GIMP_PROC_ARG_BOOLEAN (procedure, "anti-aliasing",
gimp_procedure_add_boolean_argument (procedure, "anti-aliasing",
_("_Anti-aliasing"),
_("Enable anti-aliasing using an oversampling "
"algorithm"),
@ -211,11 +211,11 @@ qbist_create_procedure (GimpPlugIn *plug_in,
/* Saving the pattern as a parasite is a trick allowing to store
* random binary data.
*/
GIMP_PROC_AUX_ARG_PARASITE (procedure, "pattern",
gimp_procedure_add_parasite_aux_argument (procedure, "pattern",
"Qbist pattern", NULL,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_STRING (procedure, "data-path",
gimp_procedure_add_string_aux_argument (procedure, "data-path",
"Path of data file",
_("Any file which will be used as source for pattern generation"),
NULL,

20
plug-ins/common/sample-colorize.c
View file

@ -336,19 +336,19 @@ colorize_create_procedure (GimpPlugIn *plug_in,
"hof@hotbot.com",
"02/2000");
GIMP_PROC_ARG_DRAWABLE (procedure, "sample-drawable",
gimp_procedure_add_drawable_argument (procedure, "sample-drawable",
_("Sample drawable"),
_("Sample drawable (should be of Type RGB or RGBA)"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "hold-inten",
gimp_procedure_add_boolean_argument (procedure, "hold-inten",
_("Hold _intensity"),
_("Hold brightness intensity levels"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "orig-inten",
gimp_procedure_add_boolean_argument (procedure, "orig-inten",
_("Original i_ntensity"),
_("TRUE: hold brightness of original intensity "
"levels, "
@ -356,14 +356,14 @@ colorize_create_procedure (GimpPlugIn *plug_in,
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "rnd-subcolors",
gimp_procedure_add_boolean_argument (procedure, "rnd-subcolors",
_("Us_e subcolors"),
_("TRUE: Use all subcolors of same intensity, "
"FALSE: Use only one color per intensity"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "guess-missing",
gimp_procedure_add_boolean_argument (procedure, "guess-missing",
_("Smooth sam_ples"),
_("TRUE: guess samplecolors for the missing "
"intensity values, "
@ -371,31 +371,31 @@ colorize_create_procedure (GimpPlugIn *plug_in,
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "in-low",
gimp_procedure_add_int_argument (procedure, "in-low",
_("_Low"),
_("Intensity of lowest input"),
0, 254, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "in-high",
gimp_procedure_add_int_argument (procedure, "in-high",
_("_High"),
_("Intensity of highest input"),
1, 255, 255,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "gamma",
gimp_procedure_add_double_argument (procedure, "gamma",
_("Ga_mma"),
_("Gamma adjustment factor, 1.0 is linear"),
0.1, 10.0, 1.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "out-low",
gimp_procedure_add_int_argument (procedure, "out-low",
_("Lo_w"),
_("Lowest sample color intensity"),
0, 254, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "out-high",
gimp_procedure_add_int_argument (procedure, "out-high",
_("Hi_gh"),
_("Highest sample color intensity"),
1, 255, 255,

12
plug-ins/common/smooth-palette.c
View file

@ -131,37 +131,37 @@ palette_create_procedure (GimpPlugIn *plug_in,
"Scott Draves",
"1997");
GIMP_PROC_ARG_INT (procedure, "width",
gimp_procedure_add_int_argument (procedure, "width",
_("_Width"),
_("Width"),
2, GIMP_MAX_IMAGE_SIZE, 256,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "height",
gimp_procedure_add_int_argument (procedure, "height",
_("_Height"),
_("Height"),
2, GIMP_MAX_IMAGE_SIZE, 64,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "n-tries",
gimp_procedure_add_int_argument (procedure, "n-tries",
_("Search _depth"),
_("Search depth"),
1, 1024, 50,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "show-image",
gimp_procedure_add_boolean_argument (procedure, "show-image",
_("Show image"),
_("Show image"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_VAL_IMAGE (procedure, "new-image",
gimp_procedure_add_image_return_value (procedure, "new-image",
_("New image"),
_("Output image"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_VAL_LAYER (procedure, "new-layer",
gimp_procedure_add_layer_return_value (procedure, "new-layer",
_("New layer"),
_("Output layer"),
FALSE,

26
plug-ins/common/sparkle.c
View file

@ -192,82 +192,82 @@ sparkle_create_procedure (GimpPlugIn *plug_in,
"John Beale",
"Version 1.27, September 2003");
GIMP_PROC_ARG_DOUBLE (procedure, "lum-threshold",
gimp_procedure_add_double_argument (procedure, "lum-threshold",
_("Lu_minosity threshold"),
_("Adjust the luminosity threshold"),
0.0, 0.1, 0.01,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "flare-inten",
gimp_procedure_add_double_argument (procedure, "flare-inten",
_("_Flare intensity"),
_("Adjust the flare intensity"),
0.0, 1.0, 0.5,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "spike-len",
gimp_procedure_add_int_argument (procedure, "spike-len",
_("Spi_ke length"),
_("Adjust the spike length (in pixels)"),
1, 100, 20,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "spike-points",
gimp_procedure_add_int_argument (procedure, "spike-points",
_("Spike _points"),
_("Adjust the number of spikes"),
1, 16, 4,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "spike-angle",
gimp_procedure_add_int_argument (procedure, "spike-angle",
_("Spike angle (-_1: random)"),
_("Adjust the spike angle "
"(-1 causes a random angle to be chosen)"),
-1, 360, 15,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "density",
gimp_procedure_add_double_argument (procedure, "density",
_("Spike _density"),
_("Adjust the spike density"),
0.0, 1.0, 1.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "transparency",
gimp_procedure_add_double_argument (procedure, "transparency",
_("_Transparency"),
_("Adjust the opacity of the spikes"),
0.0, 1.0, 0.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "random-hue",
gimp_procedure_add_double_argument (procedure, "random-hue",
_("Random _hue"),
_("Adjust how much the hue should be "
"changed randomly"),
0.0, 1.0, 0.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "random-saturation",
gimp_procedure_add_double_argument (procedure, "random-saturation",
_("R_andom saturation"),
_("Adjust how much the saturation should be "
"changed randomly"),
0.0, 1.0, 0.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "preserve-luminosity",
gimp_procedure_add_boolean_argument (procedure, "preserve-luminosity",
_("Preserve l_uminosity"),
_("Should the luminosity be preserved?"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "inverse",
gimp_procedure_add_boolean_argument (procedure, "inverse",
_("In_verse"),
_("Should the effect be inversed?"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "border",
gimp_procedure_add_boolean_argument (procedure, "border",
_("Add _border"),
_("Draw a border of spikes around the image"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "color-type",
gimp_procedure_add_int_argument (procedure, "color-type",
_("Color type"),
_("Color of sparkles: { NATURAL (0), "
"FOREGROUND (1), BACKGROUND (2) }"),

2
plug-ins/common/sphere-designer.c
View file

@ -424,7 +424,7 @@ designer_create_procedure (GimpPlugIn *plug_in,
"Vidar Madsen",
"1999");
GIMP_PROC_AUX_ARG_BYTES (procedure, "settings-data",
gimp_procedure_add_bytes_aux_argument (procedure, "settings-data",
"Settings data",
"TODO: eventually we must implement proper args for every settings",
GIMP_PARAM_READWRITE);

2
plug-ins/common/tile-small.c
View file

@ -281,7 +281,7 @@ tile_create_procedure (GimpPlugIn *plug_in,
"Andy Thomas",
"1997");
GIMP_PROC_ARG_INT (procedure, "num-tiles",
gimp_procedure_add_int_argument (procedure, "num-tiles",
_("_n²"),
_("Number of tiles to make"),
2, MAX_SEGS, 2,

10
plug-ins/common/tile.c
View file

@ -157,31 +157,31 @@ tile_create_procedure (GimpPlugIn *plug_in,
* sense or when we want stored values to only apply when run on a same
* image.
*/
GIMP_PROC_ARG_INT (procedure, "new-width",
gimp_procedure_add_int_argument (procedure, "new-width",
_("New _width"),
_("New (tiled) image width"),
1, GIMP_MAX_IMAGE_SIZE, 1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "new-height",
gimp_procedure_add_int_argument (procedure, "new-height",
_("New _height"),
_("New (tiled) image height"),
1, GIMP_MAX_IMAGE_SIZE, 1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "new-image",
gimp_procedure_add_boolean_argument (procedure, "new-image",
_("New _image"),
_("Create a new image"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_VAL_IMAGE (procedure, "new-image",
gimp_procedure_add_image_return_value (procedure, "new-image",
"New image",
"Output image (NULL if new-image == FALSE)",
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_VAL_LAYER (procedure, "new-layer",
gimp_procedure_add_layer_return_value (procedure, "new-layer",
"New layer",
"Output layer (NULL if new-image == FALSE)",
TRUE,

2
plug-ins/common/unit-editor.c
View file

@ -184,7 +184,7 @@ editor_create_procedure (GimpPlugIn *plug_in,
"Michael Natterer <mitch@gimp.org>",
"2000");
GIMP_PROC_ARG_ENUM (procedure, "run-mode",
gimp_procedure_add_enum_argument (procedure, "run-mode",
"Run mode",
"The run mode",
GIMP_TYPE_RUN_MODE,

18
plug-ins/common/van-gogh-lic.c
View file

@ -155,7 +155,7 @@ lic_create_procedure (GimpPlugIn *plug_in,
"Tom Bech & Federico Mena Quintero",
"Version 0.14, September 24 1997");
GIMP_PROC_ARG_CHOICE (procedure, "effect-channel",
gimp_procedure_add_choice_argument (procedure, "effect-channel",
_("E_ffect Channel"),
_("Effect Channel"),
gimp_choice_new_with_values ("hue", LIC_HUE, _("Hue"), NULL,
@ -165,7 +165,7 @@ lic_create_procedure (GimpPlugIn *plug_in,
"brightness",
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "effect-operator",
gimp_procedure_add_choice_argument (procedure, "effect-operator",
_("Effect O_perator"),
_("Effect Operator"),
gimp_choice_new_with_values ("derivative", 0, _("Derivative"), NULL,
@ -174,7 +174,7 @@ lic_create_procedure (GimpPlugIn *plug_in,
"gradient",
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "effect-convolve",
gimp_procedure_add_choice_argument (procedure, "effect-convolve",
_("Con_volve"),
_("Convolve"),
gimp_choice_new_with_values ("with-white-noise", 0, _("With white noise"), NULL,
@ -183,37 +183,37 @@ lic_create_procedure (GimpPlugIn *plug_in,
"with-source-image",
G_PARAM_READWRITE);
GIMP_PROC_ARG_DRAWABLE (procedure, "effect-image",
gimp_procedure_add_drawable_argument (procedure, "effect-image",
_("Effect i_mage"),
_("Effect image"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "filter-length",
gimp_procedure_add_double_argument (procedure, "filter-length",
_("Fil_ter length"),
_("Filter length"),
0.1, 64.0, 5.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "noise-magnitude",
gimp_procedure_add_double_argument (procedure, "noise-magnitude",
_("_Noise Magnitude"),
_("Noise Magnitude"),
1.0, 5.0, 2.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "integration-steps",
gimp_procedure_add_double_argument (procedure, "integration-steps",
_("Inte_gration steps"),
_("Integration steps"),
1.0, 40.0, 25.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "min-value",
gimp_procedure_add_double_argument (procedure, "min-value",
_("Minimum v_alue"),
_("Minimum value"),
-100.0, 0, -25.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "max-value",
gimp_procedure_add_double_argument (procedure, "max-value",
_("Ma_ximum value"),
_("Maximum value"),
0.0, 100, 25.0,

28
plug-ins/common/warp.c
View file

@ -231,37 +231,37 @@ warp_create_procedure (GimpPlugIn *plug_in,
"John P. Beale",
"1997");
GIMP_PROC_ARG_DOUBLE (procedure, "amount",
gimp_procedure_add_double_argument (procedure, "amount",
_("Step si_ze"),
_("Pixel displacement multiplier"),
-G_MAXDOUBLE, G_MAXDOUBLE, 10.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DRAWABLE (procedure, "warp-map",
gimp_procedure_add_drawable_argument (procedure, "warp-map",
_("Dis_placement Map"),
_("Displacement control map"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "iter",
gimp_procedure_add_int_argument (procedure, "iter",
_("I_terations"),
_("Iteration count"),
1, 100, 5,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "dither",
gimp_procedure_add_double_argument (procedure, "dither",
_("_Dither size"),
_("Random dither amount"),
0, 100, 0.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "angle",
gimp_procedure_add_double_argument (procedure, "angle",
_("Rotatio_n angle"),
_("Angle of gradient vector rotation"),
0, 360, 90.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "wrap-type",
gimp_procedure_add_choice_argument (procedure, "wrap-type",
_("On ed_ges"),
_("Wrap type"),
gimp_choice_new_with_values ("wrap", WRAP, _("Wrap"), NULL,
@ -272,49 +272,49 @@ warp_create_procedure (GimpPlugIn *plug_in,
"wrap",
G_PARAM_READWRITE);
GIMP_PROC_ARG_DRAWABLE (procedure, "mag-map",
gimp_procedure_add_drawable_argument (procedure, "mag-map",
_("_Magnitude Map"),
_("Magnitude control map"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "mag-use",
gimp_procedure_add_boolean_argument (procedure, "mag-use",
_("_Use magnitude map"),
_("Use magnitude map"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "substeps",
gimp_procedure_add_int_argument (procedure, "substeps",
_("Su_bsteps"),
_("Substeps between image updates"),
1, 100, 1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DRAWABLE (procedure, "grad-map",
gimp_procedure_add_drawable_argument (procedure, "grad-map",
_("Gradient Ma_p"),
_("Gradient control map"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "grad-scale",
gimp_procedure_add_double_argument (procedure, "grad-scale",
_("Gradient s_cale"),
_("Scaling factor for gradient map (0=don't use)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DRAWABLE (procedure, "vector-map",
gimp_procedure_add_drawable_argument (procedure, "vector-map",
_("_Vector Map"),
_("Fixed vector control map"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "vector-scale",
gimp_procedure_add_double_argument (procedure, "vector-scale",
_("Vector magn_itude"),
_("Scaling factor for fixed vector map (0=don't use)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "vector-angle",
gimp_procedure_add_double_argument (procedure, "vector-angle",
_("Ang_le"),
_("Angle for fixed vector map"),
0, 360, 0.0,

6
plug-ins/common/wavelet-decompose.c
View file

@ -127,13 +127,13 @@ wavelet_create_procedure (GimpPlugIn *plug_in,
"Miroslav Talasek <miroslav.talasek@seznam.cz>",
"19 January 2017");
GIMP_PROC_ARG_INT (procedure, "scales",
gimp_procedure_add_int_argument (procedure, "scales",
_("Scal_es"),
_("Number of scales"),
1, 7, 5,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "create-group",
gimp_procedure_add_boolean_argument (procedure, "create-group",
_("Create a layer group to store the "
"_decomposition"),
_("Create a layer group to store the "
@ -141,7 +141,7 @@ wavelet_create_procedure (GimpPlugIn *plug_in,
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "create-masks",
gimp_procedure_add_boolean_argument (procedure, "create-masks",
_("_Add a layer mask to each scales layer"),
_("Add a layer mask to each scales layer"),
FALSE,

2
plug-ins/common/web-browser.c
View file

@ -125,7 +125,7 @@ browser_create_procedure (GimpPlugIn *plug_in,
"2003",
"2003/09/16");
GIMP_PROC_ARG_STRING (procedure, "url",
gimp_procedure_add_string_argument (procedure, "url",
"URL",
"URL to open",
"https://www.gimp.org/",

10
plug-ins/common/web-page.c
View file

@ -128,32 +128,32 @@ webpage_create_procedure (GimpPlugIn *plug_in,
"2011",
"2011");
GIMP_PROC_ARG_ENUM (procedure, "run-mode",
gimp_procedure_add_enum_argument (procedure, "run-mode",
"Run mode",
"The run mode",
GIMP_TYPE_RUN_MODE,
GIMP_RUN_INTERACTIVE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "url",
gimp_procedure_add_string_argument (procedure, "url",
_("Enter location (_URI)"),
_("URL of the webpage to screenshot"),
"https://www.gimp.org/",
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "width",
gimp_procedure_add_int_argument (procedure, "width",
_("_Width (pixels)"),
_("The width of the screenshot (in pixels)"),
100, GIMP_MAX_IMAGE_SIZE, 1024,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "font-size",
gimp_procedure_add_int_argument (procedure, "font-size",
_("_Font size"),
_("The font size to use in the page (in pt)"),
1, 1000, 12,
G_PARAM_READWRITE);
GIMP_PROC_VAL_IMAGE (procedure, "image",
gimp_procedure_add_image_return_value (procedure, "image",
"Image",
"The output image",
FALSE,

6
plug-ins/file-bmp/bmp.c
View file

@ -194,21 +194,21 @@ bmp_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"bmp");
GIMP_PROC_ARG_BOOLEAN (procedure, "use-rle",
gimp_procedure_add_boolean_argument (procedure, "use-rle",
_("Ru_n-Length Encoded"),
_("Use run-length-encoding compression "
"(only valid for 4 and 8-bit indexed images)"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "write-color-space",
gimp_procedure_add_boolean_argument (procedure, "write-color-space",
_("_Write color space information"),
_("Whether or not to write BITMAPV5HEADER "
"color space data"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "rgb-format",
gimp_procedure_add_int_argument (procedure, "rgb-format",
_("R_GB format"),
_("Export format for RGB images "
"(0=RGB_565, 1=RGBA_5551, 2=RGB_555, 3=RGB_888, "

34
plug-ins/file-dds/dds.c
View file

@ -144,13 +144,13 @@ dds_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_magics (GIMP_FILE_PROCEDURE (procedure),
"0,string,DDS");
GIMP_PROC_ARG_BOOLEAN (procedure, "load-mipmaps",
gimp_procedure_add_boolean_argument (procedure, "load-mipmaps",
_("Load _mipmaps"),
_("Load mipmaps if present"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "flip-image",
gimp_procedure_add_boolean_argument (procedure, "flip-image",
_("Flip image _vertically"),
_("Flip the image vertically on import"),
FALSE,
@ -183,7 +183,7 @@ dds_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"dds");
GIMP_PROC_ARG_CHOICE (procedure, "compression-format",
gimp_procedure_add_choice_argument (procedure, "compression-format",
_("Compressio_n"),
_("Compression format"),
gimp_choice_new_with_values ("none", DDS_COMPRESS_NONE, _("None"), NULL,
@ -201,13 +201,13 @@ dds_create_procedure (GimpPlugIn *plug_in,
"none",
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "perceptual-metric",
gimp_procedure_add_boolean_argument (procedure, "perceptual-metric",
_("Use percept_ual error metric"),
_("Use a perceptual error metric during compression"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "format",
gimp_procedure_add_choice_argument (procedure, "format",
_("_Format"),
_("Pixel format"),
gimp_choice_new_with_values ("default", DDS_FORMAT_DEFAULT, _("Default"), NULL,
@ -229,7 +229,7 @@ dds_create_procedure (GimpPlugIn *plug_in,
"default",
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "save-type",
gimp_procedure_add_choice_argument (procedure, "save-type",
_("Sav_e type"),
_("How to save the image"),
gimp_choice_new_with_values ("layer", DDS_SAVE_SELECTED_LAYER, _("Selected layer"), NULL,
@ -241,26 +241,26 @@ dds_create_procedure (GimpPlugIn *plug_in,
"layer",
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "flip-image",
gimp_procedure_add_boolean_argument (procedure, "flip-image",
_("Flip image _vertically on export"),
_("Flip the image vertically on export"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "transparent-color",
gimp_procedure_add_boolean_argument (procedure, "transparent-color",
_("Set _transparent color"),
_("Make an indexed color transparent"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "transparent-index",
gimp_procedure_add_int_argument (procedure, "transparent-index",
_("Transparent inde_x"),
_("Index of transparent color or -1 to disable "
"(for indexed images only)."),
0, 255, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "mipmaps",
gimp_procedure_add_choice_argument (procedure, "mipmaps",
_("_Mipmaps"),
_("How to handle mipmaps"),
gimp_choice_new_with_values ("none", DDS_MIPMAP_NONE, _("No mipmaps"), NULL,
@ -270,7 +270,7 @@ dds_create_procedure (GimpPlugIn *plug_in,
"none",
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "mipmap-filter",
gimp_procedure_add_choice_argument (procedure, "mipmap-filter",
_("F_ilter"),
_("Filtering to use when generating mipmaps"),
gimp_choice_new_with_values ("default", DDS_MIPMAP_FILTER_DEFAULT, _("Default"), NULL,
@ -287,7 +287,7 @@ dds_create_procedure (GimpPlugIn *plug_in,
"default",
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "mipmap-wrap",
gimp_procedure_add_choice_argument (procedure, "mipmap-wrap",
_("_Wrap mode"),
_("Wrap mode to use when generating mipmaps"),
gimp_choice_new_with_values ("default", DDS_MIPMAP_WRAP_DEFAULT, _("Default"), NULL,
@ -298,32 +298,32 @@ dds_create_procedure (GimpPlugIn *plug_in,
"default",
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "gamma-correct",
gimp_procedure_add_boolean_argument (procedure, "gamma-correct",
_("Appl_y gamma correction"),
_("Use gamma correct mipmap filtering"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "srgb",
gimp_procedure_add_boolean_argument (procedure, "srgb",
_("Use sRG_B colorspace"),
_("Use sRGB colorspace for gamma correction"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "gamma",
gimp_procedure_add_double_argument (procedure, "gamma",
_("_Gamma"),
_("Gamma value to use for gamma correction (e.g. 2.2)"),
0.0, 10.0, 0.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "preserve-alpha-coverage",
gimp_procedure_add_boolean_argument (procedure, "preserve-alpha-coverage",
_("Preserve al_pha test coverage"),
_("Preserve alpha test coverage for alpha "
"channel maps"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "alpha-test-threshold",
gimp_procedure_add_double_argument (procedure, "alpha-test-threshold",
_("Alp_ha test threshold"),
_("Alpha test threshold value for which alpha test "
"coverage should be preserved"),

4
plug-ins/file-fits/fits.c
View file

@ -195,13 +195,13 @@ fits_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_magics (GIMP_FILE_PROCEDURE (procedure),
"0,string,SIMPLE");
GIMP_PROC_AUX_ARG_INT (procedure, "replace",
gimp_procedure_add_int_aux_argument (procedure, "replace",
_("Replacement for undefined pixels"),
_("Replacement for undefined pixels"),
0, 255, 0,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_INT (procedure, "use-data-min-max",
gimp_procedure_add_int_aux_argument (procedure, "use-data-min-max",
_("Pixel value scaling"),
_("Use DATAMIN/DATAMAX-scaling if possible"),
0, 1, 0,

16
plug-ins/file-fli/fli-gimp.c
View file

@ -196,13 +196,13 @@ fli_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"fli,flc");
GIMP_PROC_ARG_INT (procedure, "from-frame",
gimp_procedure_add_int_argument (procedure, "from-frame",
_("_From frame"),
_("Load beginning from this frame"),
-1, G_MAXINT, -1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "to-frame",
gimp_procedure_add_int_argument (procedure, "to-frame",
_("_To frame"),
_("End loading with this frame"),
-1, G_MAXINT, -1,
@ -234,13 +234,13 @@ fli_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"fli,flc");
GIMP_PROC_ARG_INT (procedure, "from-frame",
gimp_procedure_add_int_argument (procedure, "from-frame",
_("_From frame"),
_("Export beginning from this frame"),
-1, G_MAXINT, -1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "to-frame",
gimp_procedure_add_int_argument (procedure, "to-frame",
_("_To frame"),
_("End exporting with this frame "
"(or -1 for all frames)"),
@ -263,24 +263,24 @@ fli_create_procedure (GimpPlugIn *plug_in,
"Jens Ch. Restemeier",
"1997");
GIMP_PROC_ARG_FILE (procedure, "file",
gimp_procedure_add_file_argument (procedure, "file",
"File",
"The local file to get info about",
G_PARAM_READWRITE);
GIMP_PROC_VAL_INT (procedure, "width",
gimp_procedure_add_int_return_value (procedure, "width",
"Width",
"Width of one frame",
0, GIMP_MAX_IMAGE_SIZE, 0,
G_PARAM_READWRITE);
GIMP_PROC_VAL_INT (procedure, "height",
gimp_procedure_add_int_return_value (procedure, "height",
"Height",
"Height of one frame",
0, GIMP_MAX_IMAGE_SIZE, 0,
G_PARAM_READWRITE);
GIMP_PROC_VAL_INT (procedure, "frames",
gimp_procedure_add_int_return_value (procedure, "frames",
"Frames",
"Number of frames",
0, G_MAXINT, 0,

22
plug-ins/file-ico/ico.c
View file

@ -333,22 +333,22 @@ ico_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"cur");
GIMP_PROC_ARG_INT (procedure, "n-hot-spot-x",
gimp_procedure_add_int_argument (procedure, "n-hot-spot-x",
"Number of hot spot's X coordinates",
"Number of hot spot's X coordinates",
0, G_MAXINT, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT32_ARRAY (procedure, "hot-spot-x",
gimp_procedure_add_int32_array_argument (procedure, "hot-spot-x",
"Hot spot X",
"X coordinates of hot spot (one per layer)",
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "n-hot-spot-y",
gimp_procedure_add_int_argument (procedure, "n-hot-spot-y",
"Number of hot spot's Y coordinates",
"Number of hot spot's Y coordinates",
0, G_MAXINT, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT32_ARRAY (procedure, "hot-spot-y",
gimp_procedure_add_int32_array_argument (procedure, "hot-spot-y",
"Hot spot Y",
"Y coordinates of hot spot (one per layer)",
G_PARAM_READWRITE);
@ -380,41 +380,41 @@ ico_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"ani");
GIMP_PROC_ARG_STRING (procedure, "cursor-name",
gimp_procedure_add_string_argument (procedure, "cursor-name",
"Cursor Name",
_("Cursor Name (Optional)"),
NULL,
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "author-name",
gimp_procedure_add_string_argument (procedure, "author-name",
"Cursor Author",
_("Cursor Author (Optional)"),
NULL,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "default-delay",
gimp_procedure_add_int_argument (procedure, "default-delay",
"Default delay",
"Default delay between frames "
"in jiffies (1/60 of a second)",
0, G_MAXINT, 8,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "n-hot-spot-x",
gimp_procedure_add_int_argument (procedure, "n-hot-spot-x",
"Number of hot spot's X coordinates",
"Number of hot spot's X coordinates",
0, G_MAXINT, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT32_ARRAY (procedure, "hot-spot-x",
gimp_procedure_add_int32_array_argument (procedure, "hot-spot-x",
"Hot spot X",
"X coordinates of hot spot (one per layer)",
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "n-hot-spot-y",
gimp_procedure_add_int_argument (procedure, "n-hot-spot-y",
"Number of hot spot's Y coordinates",
"Number of hot spot's Y coordinates",
0, G_MAXINT, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT32_ARRAY (procedure, "hot-spot-y",
gimp_procedure_add_int32_array_argument (procedure, "hot-spot-y",
"Hot spot Y",
"Y coordinates of hot spot (one per layer)",
G_PARAM_READWRITE);

32
plug-ins/file-jpeg/jpeg.c
View file

@ -200,37 +200,37 @@ jpeg_create_procedure (GimpPlugIn *plug_in,
/* See bugs #63610 and #61088 for a discussion about the quality
* settings
*/
GIMP_PROC_ARG_DOUBLE (procedure, "quality",
gimp_procedure_add_double_argument (procedure, "quality",
_("_Quality"),
_("Quality of exported image"),
0.0, 1.0, 0.9,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "smoothing",
gimp_procedure_add_double_argument (procedure, "smoothing",
_("S_moothing"),
_("Smoothing factor for exported image"),
0.0, 1.0, 0.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "optimize",
gimp_procedure_add_boolean_argument (procedure, "optimize",
_("Optimi_ze"),
_("Use optimized tables during Huffman coding"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "progressive",
gimp_procedure_add_boolean_argument (procedure, "progressive",
_("_Progressive"),
_("Create progressive JPEG images"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "cmyk",
gimp_procedure_add_boolean_argument (procedure, "cmyk",
_("Export as CM_YK"),
_("Create a CMYK JPEG image using the soft-proofing color profile"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "sub-sampling",
gimp_procedure_add_choice_argument (procedure, "sub-sampling",
_("Su_bsampling"),
_("Sub-sampling type"),
gimp_choice_new_with_values ("sub-sampling-1x1", JPEG_SUBSAMPLING_1x1_1x1_1x1, _("4:4:4 (best quality)"), NULL,
@ -240,21 +240,21 @@ jpeg_create_procedure (GimpPlugIn *plug_in,
NULL),
"sub-sampling-1x1", G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "baseline",
gimp_procedure_add_boolean_argument (procedure, "baseline",
_("Baseline"),
_("Force creation of a baseline JPEG "
"(non-baseline JPEGs can't be read by all decoders)"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "restart",
gimp_procedure_add_int_argument (procedure, "restart",
_("Inter_val (MCU rows):"),
_("Interval of restart markers "
"(in MCU rows, 0 = no restart markers)"),
0, 64, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "dct",
gimp_procedure_add_choice_argument (procedure, "dct",
_("_DCT method"),
_("DCT method to use"),
gimp_choice_new_with_values ("fixed", 1, _("Fast Integer"), NULL,
@ -265,7 +265,7 @@ jpeg_create_procedure (GimpPlugIn *plug_in,
/* Some auxiliary arguments mostly for interactive usage. */
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "use-original-quality",
gimp_procedure_add_boolean_aux_argument (procedure, "use-original-quality",
_("_Use quality settings from original image"),
_("If the original image was loaded from a JPEG "
"file using non-standard quality settings "
@ -273,33 +273,33 @@ jpeg_create_procedure (GimpPlugIn *plug_in,
"get almost the same quality and file size."),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_INT (procedure, "original-quality",
gimp_procedure_add_int_aux_argument (procedure, "original-quality",
NULL, NULL,
-1, 100, -1,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_INT (procedure, "original-sub-sampling",
gimp_procedure_add_int_aux_argument (procedure, "original-sub-sampling",
NULL, NULL,
JPEG_SUBSAMPLING_2x2_1x1_1x1,
JPEG_SUBSAMPLING_1x2_1x1_1x1,
JPEG_SUBSAMPLING_2x2_1x1_1x1,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_INT (procedure, "original-num-quant-tables",
gimp_procedure_add_int_aux_argument (procedure, "original-num-quant-tables",
NULL, NULL,
-1, 4, -1,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "show-preview",
gimp_procedure_add_boolean_aux_argument (procedure, "show-preview",
_("Sho_w preview in image window"),
_("Creates a temporary layer with an export preview"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "use-arithmetic-coding",
gimp_procedure_add_boolean_aux_argument (procedure, "use-arithmetic-coding",
_("Use _arithmetic coding"),
_("Older software may have trouble opening "
"arithmetic-coded images"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "use-restart",
gimp_procedure_add_boolean_aux_argument (procedure, "use-restart",
_("Use restart mar_kers"),
NULL, FALSE,
G_PARAM_READWRITE);

16
plug-ins/file-psd/psd.c
View file

@ -233,34 +233,34 @@ psd_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"psd");
GIMP_PROC_ARG_BOOLEAN (procedure, "clippingpath",
gimp_procedure_add_boolean_argument (procedure, "clippingpath",
_("Assign a Clipping _Path"),
_("Select a path to be the "
"clipping path"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "clippingpathname",
gimp_procedure_add_string_argument (procedure, "clippingpathname",
_("Clipping Path _Name"),
_("Clipping path name\n"
"(ignored if no clipping path)"),
NULL,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "clippingpathflatness",
gimp_procedure_add_double_argument (procedure, "clippingpathflatness",
_("Path _Flatness"),
_("Clipping path flatness in device pixels\n"
"(ignored if no clipping path)"),
0.0, 100.0, 0.2,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "cmyk",
gimp_procedure_add_boolean_argument (procedure, "cmyk",
_("Export as _CMYK"),
_("Export a CMYK PSD image using the soft-proofing color profile"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "duotone",
gimp_procedure_add_boolean_argument (procedure, "duotone",
_("Export as _Duotone"),
_("Export as a Duotone PSD file if Duotone color space information "
"was attached to the image when originally imported."),
@ -283,7 +283,7 @@ psd_create_procedure (GimpPlugIn *plug_in,
"John Marshall",
"John Marshall",
"2007");
GIMP_PROC_ARG_INT (procedure, "size",
gimp_procedure_add_int_argument (procedure, "size",
"Metadata size",
NULL,
0, G_MAXINT, 0,
@ -294,13 +294,13 @@ psd_create_procedure (GimpPlugIn *plug_in,
"The image",
FALSE,
GIMP_PARAM_READWRITE));
GIMP_PROC_ARG_BOOLEAN (procedure, "metadata-type",
gimp_procedure_add_boolean_argument (procedure, "metadata-type",
"Metadata type",
"If the metadata contains image or "
"layer PSD resources.",
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "cmyk",
gimp_procedure_add_boolean_argument (procedure, "cmyk",
"CMYK",
"If the layer metadata needs to be "
"converted from CMYK colorspace.",

2
plug-ins/file-sgi/sgi.c
View file

@ -188,7 +188,7 @@ sgi_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"sgi,rgb,rgba,bw,icon");
GIMP_PROC_ARG_INT (procedure, "compression",
gimp_procedure_add_int_argument (procedure, "compression",
_("Compression _type"),
_("Compression level (0 = none, 1 = RLE, 2 = ARLE)"),
0, 2, SGI_COMP_RLE,

18
plug-ins/file-tiff/file-tiff.c
View file

@ -183,13 +183,13 @@ tiff_create_procedure (GimpPlugIn *plug_in,
* them AUX for now and leave it as further exercise to decide whether it
* should be part of the PDB API.
*/
GIMP_PROC_AUX_ARG_ENUM (procedure, "target",
gimp_procedure_add_enum_aux_argument (procedure, "target",
"Open _pages as", NULL,
GIMP_TYPE_PAGE_SELECTOR_TARGET,
GIMP_PAGE_SELECTOR_TARGET_LAYERS,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "keep-empty-space",
gimp_procedure_add_boolean_aux_argument (procedure, "keep-empty-space",
_("_Keep empty space around imported layers"),
NULL, TRUE, GIMP_PARAM_READWRITE);
}
@ -223,14 +223,14 @@ tiff_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"tif,tiff");
GIMP_PROC_ARG_BOOLEAN (procedure, "bigtiff",
gimp_procedure_add_boolean_argument (procedure, "bigtiff",
_("Export in _BigTIFF variant file format"),
_("The BigTIFF variant file format uses 64-bit offsets, "
"hence supporting over 4GiB files and bigger"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "compression",
gimp_procedure_add_choice_argument (procedure, "compression",
_("Co_mpression"),
_("Compression type"),
gimp_choice_new_with_values ("none", GIMP_COMPRESSION_NONE, _("None"), NULL,
@ -243,32 +243,32 @@ tiff_create_procedure (GimpPlugIn *plug_in,
NULL),
"none", G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "save-transparent-pixels",
gimp_procedure_add_boolean_argument (procedure, "save-transparent-pixels",
_("Save color _values from transparent pixels"),
_("Keep the color data masked by an alpha channel "
"intact (do not store premultiplied components)"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "cmyk",
gimp_procedure_add_boolean_argument (procedure, "cmyk",
_("Export as CMY_K"),
_("Create a CMYK TIFF image using the soft-proofing color profile"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-layers",
gimp_procedure_add_boolean_aux_argument (procedure, "save-layers",
_("Save La_yers"),
_("Save Layers"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "crop-layers",
gimp_procedure_add_boolean_aux_argument (procedure, "crop-layers",
_("Crop L_ayers"),
_("Crop Layers"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-geotiff",
gimp_procedure_add_boolean_aux_argument (procedure, "save-geotiff",
_("Save _GeoTIFF data"),
_("Save GeoTIFF data"),
TRUE,

22
plug-ins/file-webp/file-webp.c
View file

@ -165,32 +165,32 @@ webp_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"webp");
GIMP_PROC_ARG_INT (procedure, "preset",
gimp_procedure_add_int_argument (procedure, "preset",
_("Source _type"),
_("WebP encoder preset (Default=0, Picture=1, Photo=2, Drawing=3, "
"Icon=4, Text=5)"),
0, 5, WEBP_PRESET_DEFAULT,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "lossless",
gimp_procedure_add_boolean_argument (procedure, "lossless",
_("L_ossless"),
_("Use lossless encoding"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "quality",
gimp_procedure_add_double_argument (procedure, "quality",
_("Image _quality"),
_("Quality of the image"),
0, 100, 90,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "alpha-quality",
gimp_procedure_add_double_argument (procedure, "alpha-quality",
_("Alpha q_uality"),
_("Quality of the image's alpha channel"),
0, 100, 100,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "use-sharp-yuv",
gimp_procedure_add_boolean_argument (procedure, "use-sharp-yuv",
_("Use Sharp YU_V"),
/* TRANSLATORS: \xe2\x86\x92 is a Unicode
* "Rightward Arrow" in UTF-8 encoding.
@ -199,38 +199,38 @@ webp_create_procedure (GimpPlugIn *plug_in,
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "animation-loop",
gimp_procedure_add_boolean_argument (procedure, "animation-loop",
_("Loop _forever"),
_("Loop animation infinitely"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "minimize-size",
gimp_procedure_add_boolean_argument (procedure, "minimize-size",
_("_Minimize output size (slower)"),
_("Minimize output file size"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "keyframe-distance",
gimp_procedure_add_int_argument (procedure, "keyframe-distance",
_("Max distance between _key-frames"),
_("Maximum distance between keyframes"),
0, G_MAXINT, 50,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "default-delay",
gimp_procedure_add_int_argument (procedure, "default-delay",
_("_Default delay between frames"),
_("Default delay (in milliseconds) to use when timestamps"
" for frames are not available or forced."),
0, G_MAXINT, 200,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "force-delay",
gimp_procedure_add_boolean_argument (procedure, "force-delay",
_("Use default dela_y for all frames"),
_("Force default delay on all frames"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "animation",
gimp_procedure_add_boolean_argument (procedure, "animation",
_("Save a_nimation"),
_("Use layers for animation"),
FALSE,

20
plug-ins/flame/flame.c
View file

@ -191,52 +191,52 @@ flame_create_procedure (GimpPlugIn *plug_in,
"Scott Draves",
"1997");
GIMP_PROC_ARG_DOUBLE (procedure, "brightness",
gimp_procedure_add_double_argument (procedure, "brightness",
_("_Brightness"), NULL,
0.0, 5.0, 1.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "contrast",
gimp_procedure_add_double_argument (procedure, "contrast",
_("Co_ntrast"), NULL,
0.0, 5.0, 1.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "gamma",
gimp_procedure_add_double_argument (procedure, "gamma",
_("_Gamma"), NULL,
1.0, 5.0, 1.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "sample-density",
gimp_procedure_add_double_argument (procedure, "sample-density",
_("Sample _density"), NULL,
0.1, 20.0, 5.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "spatial-oversample",
gimp_procedure_add_int_argument (procedure, "spatial-oversample",
_("Spa_tial oversample"), NULL,
1, 4, 2.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "spatial-filter-radius",
gimp_procedure_add_double_argument (procedure, "spatial-filter-radius",
_("Spatial _filter radius"), NULL,
0.0, 4.0, 0.75,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "zoom",
gimp_procedure_add_double_argument (procedure, "zoom",
_("_Zoom"), NULL,
-4.0, 4.0, 0.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "x",
gimp_procedure_add_double_argument (procedure, "x",
_("_X"), NULL,
-2.0, 2.0, 0.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "y",
gimp_procedure_add_double_argument (procedure, "y",
_("_Y"), NULL,
-2.0, 2.0, 0.0,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BYTES (procedure, "settings-data",
gimp_procedure_add_bytes_aux_argument (procedure, "settings-data",
"Settings data",
"TODO: eventually we must implement proper args for every settings",
GIMP_PARAM_READWRITE);

40
plug-ins/fractal-explorer/fractal-explorer.c
View file

@ -253,7 +253,7 @@ explorer_create_procedure (GimpPlugIn *plug_in,
"www.multimania.com/cotting)",
"December, 1998");
GIMP_PROC_ARG_CHOICE (procedure, "fractal-type",
gimp_procedure_add_choice_argument (procedure, "fractal-type",
_("Fr_actal Type"),
_("Type of Fractal Pattern"),
gimp_choice_new_with_values ("mandelbrot", 0, _("Mandelbrot"), NULL,
@ -269,74 +269,74 @@ explorer_create_procedure (GimpPlugIn *plug_in,
"mandelbrot",
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "xmin",
gimp_procedure_add_double_argument (procedure, "xmin",
_("Lef_t"),
_("X min fractal image delimiter"),
-3.000, 3.000, -2.000,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "xmax",
gimp_procedure_add_double_argument (procedure, "xmax",
_("Ri_ght"),
_("X max fractal image delimiter"),
-3.000, 3.000, 2.000,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "ymin",
gimp_procedure_add_double_argument (procedure, "ymin",
_("To_p"),
_("Y min fractal image delimiter"),
-3.000, 3.000, -1.500,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "ymax",
gimp_procedure_add_double_argument (procedure, "ymax",
_("_Bottom"),
_("Y max fractal image delimiter"),
-3.000, 3.000, 1.500,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "iter",
gimp_procedure_add_double_argument (procedure, "iter",
_("Iteratio_ns"),
_("Iteration value"),
1, 1000, 50,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "cx",
gimp_procedure_add_double_argument (procedure, "cx",
_("C_X"),
_("cx value"),
-2.5000, 2.5000, -0.75,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "cy",
gimp_procedure_add_double_argument (procedure, "cy",
_("C_Y"),
_("cy value"),
-2.5000, 2.5000, -0.2,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "color-mode",
gimp_procedure_add_int_argument (procedure, "color-mode",
_("Color mode"),
_("0: Apply colormap as specified by the parameters "
"above; 1: Apply active gradient to final image"),
0, 1, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "red-stretch",
gimp_procedure_add_double_argument (procedure, "red-stretch",
_("Red stretch"),
_("Red stretching factor"),
0, 1, 1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "green-stretch",
gimp_procedure_add_double_argument (procedure, "green-stretch",
_("Green stretch"),
_("Green stretching factor"),
0, 1, 1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "blue-stretch",
gimp_procedure_add_double_argument (procedure, "blue-stretch",
_("Blue stretch"),
_("Blue stretching factor"),
0, 1, 1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "red-mode",
gimp_procedure_add_choice_argument (procedure, "red-mode",
_("_Red"),
_("Red application mode"),
gimp_choice_new_with_values ("red-sin", 0, _("Sine"), NULL,
@ -346,7 +346,7 @@ explorer_create_procedure (GimpPlugIn *plug_in,
"red-cos",
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "green-mode",
gimp_procedure_add_choice_argument (procedure, "green-mode",
_("_Green"),
_("Green application mode"),
gimp_choice_new_with_values ("green-sin", 0, _("Sine"), NULL,
@ -356,7 +356,7 @@ explorer_create_procedure (GimpPlugIn *plug_in,
"green-cos",
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "blue-mode",
gimp_procedure_add_choice_argument (procedure, "blue-mode",
_("_Blue"),
_("Blue application mode"),
gimp_choice_new_with_values ("blue-sin", 0, _("Sine"), NULL,
@ -366,30 +366,30 @@ explorer_create_procedure (GimpPlugIn *plug_in,
"blue-sin",
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "red-invert",
gimp_procedure_add_boolean_argument (procedure, "red-invert",
_("In_version"),
_("Red inversion mode"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "green-invert",
gimp_procedure_add_boolean_argument (procedure, "green-invert",
_("I_nversion"),
_("Green inversion mode"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "blue-invert",
gimp_procedure_add_boolean_argument (procedure, "blue-invert",
_("_Inversion"),
_("Blue inversion mode"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "n-colors",
gimp_procedure_add_int_argument (procedure, "n-colors",
_("_Number of colors"),
_("Number of Colors for mapping"),
2, 8192, 512,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "use-loglog-smoothing",
gimp_procedure_add_boolean_argument (procedure, "use-loglog-smoothing",
_("_Use log log smoothing"),
_("Use log log smoothing to eliminate "
"\"banding\" in the result"),

4
plug-ins/gimpressionist/gimp.c
View file

@ -132,13 +132,13 @@ gimpressionist_create_procedure (GimpPlugIn *plug_in,
"Vidar Madsen",
PLUG_IN_VERSION);
GIMP_PROC_ARG_STRING (procedure, "preset",
gimp_procedure_add_string_argument (procedure, "preset",
_("Preset"),
_("Preset Name"),
NULL,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BYTES (procedure, "settings-data",
gimp_procedure_add_bytes_aux_argument (procedure, "settings-data",
"Settings data",
"TODO: eventually we must implement proper args for every settings",
GIMP_PARAM_READWRITE);

22
plug-ins/gradient-flare/gradient-flare.c
View file

@ -831,68 +831,68 @@ gflare_create_procedure (GimpPlugIn *plug_in,
"Eiichi Takamori, and a lot of GIMP people",
"1997");
GIMP_PROC_ARG_STRING (procedure, "gflare-name",
gimp_procedure_add_string_argument (procedure, "gflare-name",
"GFlare name",
"Name of the GFlare to render",
"Default",
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "center-x",
gimp_procedure_add_int_argument (procedure, "center-x",
"Center X",
"X coordinate of center of GFlare",
-GIMP_MAX_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE, 128,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "center-y",
gimp_procedure_add_int_argument (procedure, "center-y",
"Center Y",
"Y coordinate of center of GFlare",
-GIMP_MAX_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE, 128,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "radius",
gimp_procedure_add_double_argument (procedure, "radius",
_("Radi_us"),
_("Radius of GFlare (pixel)"),
1, GIMP_MAX_IMAGE_SIZE, 100,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "rotation",
gimp_procedure_add_double_argument (procedure, "rotation",
_("Ro_tation"),
_("Rotation of GFlare (degree)"),
0, 360, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "hue",
gimp_procedure_add_double_argument (procedure, "hue",
_("_Hue rotation"),
_("Hue rotation of GFlare (degree)"),
0, 360, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "vector-angle",
gimp_procedure_add_double_argument (procedure, "vector-angle",
_("Vector _angle"),
_("Vector angle for second flares (degree)"),
0, 360, 60,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "vector-length",
gimp_procedure_add_double_argument (procedure, "vector-length",
_("Vector len_gth"),
_("Vector length for second flares "
"(percentage of Radius)"),
0, 10000, 400,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "use-asupsample",
gimp_procedure_add_boolean_argument (procedure, "use-asupsample",
_("Ada_ptive supersampling"),
_("Use adaptive supersampling while rendering"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "asupsample-max-depth",
gimp_procedure_add_int_argument (procedure, "asupsample-max-depth",
_("_Max depth"),
_("Max depth for adaptive supersampling"),
0, 10, 3,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "asupsample-threshold",
gimp_procedure_add_double_argument (procedure, "asupsample-threshold",
_("Threshol_d"),
_("Threshold for adaptive supersampling"),
0.0, 1.0, 0.2,

14
plug-ins/help-browser/help-browser.c
View file

@ -104,24 +104,24 @@ help_browser_create_procedure (GimpPlugIn *plug_in,
"Henrik Brix Andersen",
"1999-2008");
GIMP_PROC_ARG_ENUM (procedure, "run-mode",
gimp_procedure_add_enum_argument (procedure, "run-mode",
"Run mode",
"The run mode",
GIMP_TYPE_RUN_MODE,
GIMP_RUN_INTERACTIVE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRV (procedure, "domain-names",
gimp_procedure_add_string_array_argument (procedure, "domain-names",
"Domain names",
"Domain names",
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRV (procedure, "domain-uris",
gimp_procedure_add_string_array_argument (procedure, "domain-uris",
"Domain URIs",
"Domain URIs",
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BYTES (procedure, "dialog-data",
gimp_procedure_add_bytes_aux_argument (procedure, "dialog-data",
"Dialog data",
"Remembering dialog's basic features; this is never meant to be a public argument",
GIMP_PARAM_READWRITE);
@ -220,19 +220,19 @@ temp_proc_install (GimpPlugIn *plug_in)
"Henrik Brix Andersen",
"1999-2008");
GIMP_PROC_ARG_STRING (procedure, "help-domain",
gimp_procedure_add_string_argument (procedure, "help-domain",
"Help domain",
"Help domain to use",
NULL,
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "help-locales",
gimp_procedure_add_string_argument (procedure, "help-locales",
"Help locales",
"Language to use",
NULL,
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "help-id",
gimp_procedure_add_string_argument (procedure, "help-id",
"Help ID",
"Help ID to open",
NULL,

12
plug-ins/help/help.c
View file

@ -137,12 +137,12 @@ help_create_procedure (GimpPlugIn *plug_in,
"Sven Neumann, Michael Natterer & Henrik Brix Andersen",
"1999-2008");
GIMP_PROC_ARG_STRV (procedure, "domain-names",
gimp_procedure_add_string_array_argument (procedure, "domain-names",
"Domain Names",
"Domain names",
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRV (procedure, "domain-uris",
gimp_procedure_add_string_array_argument (procedure, "domain-uris",
"Domain URIs",
"Domain URIs",
G_PARAM_READWRITE);
@ -210,25 +210,25 @@ help_temp_proc_install (GimpPlugIn *plug_in)
"Henrik Brix Andersen",
"1999-2008");
GIMP_PROC_ARG_STRING (procedure, "help-proc",
gimp_procedure_add_string_argument (procedure, "help-proc",
"The procedure of the browser to use",
"The procedure of the browser to use",
NULL,
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "help-domain",
gimp_procedure_add_string_argument (procedure, "help-domain",
"Help domain to use",
"Help domain to use",
NULL,
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "help-locales",
gimp_procedure_add_string_argument (procedure, "help-locales",
"Language to use",
"Language to use",
NULL,
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "help-id",
gimp_procedure_add_string_argument (procedure, "help-id",
"Help ID to open",
"Help ID to open",
NULL,

2
plug-ins/ifs-compose/ifs-compose.c
View file

@ -452,7 +452,7 @@ ifs_create_procedure (GimpPlugIn *plug_in,
"Owen Taylor",
"1997");
GIMP_PROC_AUX_ARG_STRING (procedure, "fractal-str",
gimp_procedure_add_string_aux_argument (procedure, "fractal-str",
"The fractal description serialized as string",
NULL, NULL,
GIMP_PARAM_READWRITE);

144
plug-ins/lighting/lighting-main.c
View file

@ -146,32 +146,32 @@ lighting_create_procedure (GimpPlugIn *plug_in,
"Tom Bech & Federico Mena Quintero",
"Version 0.2.0, March 15 1998");
GIMP_PROC_ARG_DRAWABLE (procedure, "bump-drawable",
gimp_procedure_add_drawable_argument (procedure, "bump-drawable",
_("B_ump map image"),
_("Bumpmap drawable (set to NULL if disabled)"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DRAWABLE (procedure, "env-drawable",
gimp_procedure_add_drawable_argument (procedure, "env-drawable",
_("Enviro_nment map image"),
_("Environmentmap drawable "
"(set to NULL if disabled)"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "do-bumpmap",
gimp_procedure_add_boolean_argument (procedure, "do-bumpmap",
_("Enable bump mappi_ng"),
_("Enable bumpmapping"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "do-envmap",
gimp_procedure_add_boolean_argument (procedure, "do-envmap",
_("Enable en_vironment mapping"),
_("Enable envmapping"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "bumpmap-type",
gimp_procedure_add_choice_argument (procedure, "bumpmap-type",
_("Cur_ve"),
_("Type of mapping"),
gimp_choice_new_with_values ("bumpmap-linear", LINEAR_MAP, _("Linear"), NULL,
@ -182,13 +182,13 @@ lighting_create_procedure (GimpPlugIn *plug_in,
"bumpmap-linear",
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "bumpmap-max-height",
gimp_procedure_add_double_argument (procedure, "bumpmap-max-height",
_("Ma_ximum height"),
_("The maximum height of the bumpmap"),
0.0, G_MAXFLOAT, 0.1,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_CHOICE (procedure, "which-light",
gimp_procedure_add_choice_aux_argument (procedure, "which-light",
_("Active"),
_("Which light is active in the GUI"),
gimp_choice_new_with_values ("light-1", 0, _("Light 1"), NULL,
@ -201,14 +201,14 @@ lighting_create_procedure (GimpPlugIn *plug_in,
"light-1",
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "isolate",
gimp_procedure_add_boolean_aux_argument (procedure, "isolate",
_("Isolate"),
_("Only show the active lighting in "
"the preview"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "light-type-1",
gimp_procedure_add_choice_argument (procedure, "light-type-1",
_("Type"),
_("Type of light source"),
gimp_choice_new_with_values ("light-none", NO_LIGHT, _("None"), NULL,
@ -219,119 +219,119 @@ lighting_create_procedure (GimpPlugIn *plug_in,
"light-point",
G_PARAM_READWRITE);
GIMP_PROC_ARG_COLOR (procedure, "light-color-1",
gimp_procedure_add_color_argument (procedure, "light-color-1",
_("Color"),
_("Light source color"),
TRUE, default_color_1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "light-intensity-1",
gimp_procedure_add_double_argument (procedure, "light-intensity-1",
_("Intensity"),
_("Light source intensity"),
0, 100.0, 1.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "light-position-x-1",
gimp_procedure_add_double_argument (procedure, "light-position-x-1",
_("Light position X"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, -1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "light-position-y-1",
gimp_procedure_add_double_argument (procedure, "light-position-y-1",
_("Light position Y"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, -1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "light-position-z-1",
gimp_procedure_add_double_argument (procedure, "light-position-z-1",
_("Light position Z"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "light-direction-x-1",
gimp_procedure_add_double_argument (procedure, "light-direction-x-1",
_("Light direction X"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, -1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "light-direction-y-1",
gimp_procedure_add_double_argument (procedure, "light-direction-y-1",
_("Light direction Y"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, -1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "light-direction-z-1",
gimp_procedure_add_double_argument (procedure, "light-direction-z-1",
_("Light direction Z"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "ambient-intensity",
gimp_procedure_add_double_argument (procedure, "ambient-intensity",
_("Ambient intensity"),
_("Material ambient intensity "
"(Glowing)"),
0, 1, 0.2,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "diffuse-intensity",
gimp_procedure_add_double_argument (procedure, "diffuse-intensity",
_("Diffuse intensity"),
_("Material diffuse intensity "
"(Bright)"),
0, 1, 0.5,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "diffuse-reflectivity",
gimp_procedure_add_double_argument (procedure, "diffuse-reflectivity",
_("Diffuse reflectivity"),
_("Material diffuse reflectivity"),
0, 1, 0.4,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "specular-reflectivity",
gimp_procedure_add_double_argument (procedure, "specular-reflectivity",
_("Specular reflectivity"),
_("Material specular reflectivity"),
0, 1, 0.5,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "highlight",
gimp_procedure_add_double_argument (procedure, "highlight",
_("Highlight"),
_("Material highlight (note, it's exponential) "
"(Polished)"),
0, G_MAXDOUBLE, 27.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "metallic",
gimp_procedure_add_boolean_argument (procedure, "metallic",
_("Metallic"),
_("Make surfaces look metallic"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "antialiasing",
gimp_procedure_add_boolean_argument (procedure, "antialiasing",
_("_Antialiasing"),
_("Apply antialiasing"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "new-image",
gimp_procedure_add_boolean_argument (procedure, "new-image",
_("Create new ima_ge"),
_("Create a new image"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "transparent-background",
gimp_procedure_add_boolean_argument (procedure, "transparent-background",
_("Trans_parent background"),
_("Make background transparent"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "distance",
gimp_procedure_add_double_argument (procedure, "distance",
_("_Distance"),
_("Distance of observer from surface"),
0, 2.0, 0.25,
G_PARAM_READWRITE);
/* GUI-only arguments for additional light sources */
GIMP_PROC_AUX_ARG_CHOICE (procedure, "light-type-2",
gimp_procedure_add_choice_aux_argument (procedure, "light-type-2",
_("Type"),
_("Type of light source"),
gimp_choice_new_with_values ("light-none", NO_LIGHT, _("None"), NULL,
@ -342,55 +342,55 @@ lighting_create_procedure (GimpPlugIn *plug_in,
"light-none",
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_COLOR (procedure, "light-color-2",
gimp_procedure_add_color_aux_argument (procedure, "light-color-2",
_("Color"),
_("Light source color"),
TRUE, default_color_2,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-intensity-2",
gimp_procedure_add_double_aux_argument (procedure, "light-intensity-2",
_("Intensity"),
_("Light source intensity"),
0, 100.0, 1.0,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-position-x-2",
gimp_procedure_add_double_aux_argument (procedure, "light-position-x-2",
_("Light position X"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, -2,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-position-y-2",
gimp_procedure_add_double_aux_argument (procedure, "light-position-y-2",
_("Light position Y"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, -1,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-position-z-2",
gimp_procedure_add_double_aux_argument (procedure, "light-position-z-2",
_("Light position Z"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-direction-x-2",
gimp_procedure_add_double_aux_argument (procedure, "light-direction-x-2",
_("Light direction X"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-direction-y-2",
gimp_procedure_add_double_aux_argument (procedure, "light-direction-y-2",
_("Light direction Y"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, -1,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-direction-z-2",
gimp_procedure_add_double_aux_argument (procedure, "light-direction-z-2",
_("Light direction Z"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_CHOICE (procedure, "light-type-3",
gimp_procedure_add_choice_aux_argument (procedure, "light-type-3",
_("Type"),
_("Type of light source"),
gimp_choice_new_with_values ("light-none", NO_LIGHT, _("None"), NULL,
@ -401,55 +401,55 @@ lighting_create_procedure (GimpPlugIn *plug_in,
"light-none",
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_COLOR (procedure, "light-color-3",
gimp_procedure_add_color_aux_argument (procedure, "light-color-3",
_("Color"),
_("Light source color"),
TRUE, default_color_3,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-intensity-3",
gimp_procedure_add_double_aux_argument (procedure, "light-intensity-3",
_("Intensity"),
_("Light source intensity"),
0, 100.0, 1.0,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-position-x-3",
gimp_procedure_add_double_aux_argument (procedure, "light-position-x-3",
_("Light position X"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-position-y-3",
gimp_procedure_add_double_aux_argument (procedure, "light-position-y-3",
_("Light position Y"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 2,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-position-z-3",
gimp_procedure_add_double_aux_argument (procedure, "light-position-z-3",
_("Light position Z"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-direction-x-3",
gimp_procedure_add_double_aux_argument (procedure, "light-direction-x-3",
_("Light direction X"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-direction-y-3",
gimp_procedure_add_double_aux_argument (procedure, "light-direction-y-3",
_("Light direction Y"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-direction-z-3",
gimp_procedure_add_double_aux_argument (procedure, "light-direction-z-3",
_("Light direction Z"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_CHOICE (procedure, "light-type-4",
gimp_procedure_add_choice_aux_argument (procedure, "light-type-4",
_("Type"),
_("Type of light source"),
gimp_choice_new_with_values ("light-none", NO_LIGHT, _("None"), NULL,
@ -460,55 +460,55 @@ lighting_create_procedure (GimpPlugIn *plug_in,
"light-none",
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_COLOR (procedure, "light-color-4",
gimp_procedure_add_color_aux_argument (procedure, "light-color-4",
_("Color"),
_("Light source color"),
TRUE, default_color_4,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-intensity-4",
gimp_procedure_add_double_aux_argument (procedure, "light-intensity-4",
_("Intensity"),
_("Light source intensity"),
0, 100.0, 1.0,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-position-x-4",
gimp_procedure_add_double_aux_argument (procedure, "light-position-x-4",
_("Light position X"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-position-y-4",
gimp_procedure_add_double_aux_argument (procedure, "light-position-y-4",
_("Light position Y"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-position-z-4",
gimp_procedure_add_double_aux_argument (procedure, "light-position-z-4",
_("Light position Z"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-direction-x-4",
gimp_procedure_add_double_aux_argument (procedure, "light-direction-x-4",
_("Light direction X"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-direction-y-4",
gimp_procedure_add_double_aux_argument (procedure, "light-direction-y-4",
_("Light direction Y"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-direction-z-4",
gimp_procedure_add_double_aux_argument (procedure, "light-direction-z-4",
_("Light direction Z"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_CHOICE (procedure, "light-type-5",
gimp_procedure_add_choice_aux_argument (procedure, "light-type-5",
_("Type"),
_("Type of light source"),
gimp_choice_new_with_values ("light-none", NO_LIGHT, _("None"), NULL,
@ -519,55 +519,55 @@ lighting_create_procedure (GimpPlugIn *plug_in,
"light-none",
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_COLOR (procedure, "light-color-5",
gimp_procedure_add_color_aux_argument (procedure, "light-color-5",
_("Color"),
_("Light source color"),
TRUE, default_color_5,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-intensity-5",
gimp_procedure_add_double_aux_argument (procedure, "light-intensity-5",
_("Intensity"),
_("Light source intensity"),
0, 100.0, 1.0,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-position-x-5",
gimp_procedure_add_double_aux_argument (procedure, "light-position-x-5",
_("Light position X"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-position-y-5",
gimp_procedure_add_double_aux_argument (procedure, "light-position-y-5",
_("Light position Y"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-position-z-5",
gimp_procedure_add_double_aux_argument (procedure, "light-position-z-5",
_("Light position Z"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-direction-x-5",
gimp_procedure_add_double_aux_argument (procedure, "light-direction-x-5",
_("Light direction X"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-direction-y-5",
gimp_procedure_add_double_aux_argument (procedure, "light-direction-y-5",
_("Light direction Y"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-direction-z-5",
gimp_procedure_add_double_aux_argument (procedure, "light-direction-z-5",
_("Light direction Z"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_CHOICE (procedure, "light-type-6",
gimp_procedure_add_choice_aux_argument (procedure, "light-type-6",
_("Type"),
_("Type of light source"),
gimp_choice_new_with_values ("light-none", NO_LIGHT, _("None"), NULL,
@ -578,49 +578,49 @@ lighting_create_procedure (GimpPlugIn *plug_in,
"light-none",
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_COLOR (procedure, "light-color-6",
gimp_procedure_add_color_aux_argument (procedure, "light-color-6",
_("Color"),
_("Light source color"),
TRUE, default_color_6,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-intensity-6",
gimp_procedure_add_double_aux_argument (procedure, "light-intensity-6",
_("Intensity"),
_("Light source intensity"),
0, 100.0, 1.0,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-position-x-6",
gimp_procedure_add_double_aux_argument (procedure, "light-position-x-6",
_("Light position X"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-position-y-6",
gimp_procedure_add_double_aux_argument (procedure, "light-position-y-6",
_("Light position Y"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-position-z-6",
gimp_procedure_add_double_aux_argument (procedure, "light-position-z-6",
_("Light position Z"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-direction-x-6",
gimp_procedure_add_double_aux_argument (procedure, "light-direction-x-6",
_("Light direction X"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-direction-y-6",
gimp_procedure_add_double_aux_argument (procedure, "light-direction-y-6",
_("Light direction Y"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-direction-z-6",
gimp_procedure_add_double_aux_argument (procedure, "light-direction-z-6",
_("Light direction Z"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,

100
plug-ins/map-object/map-object-main.c
View file

@ -135,7 +135,7 @@ map_create_procedure (GimpPlugIn *plug_in,
"Tom Bech & Federico Mena Quintero",
"Version 1.2.0, July 16 1998");
GIMP_PROC_ARG_CHOICE (procedure, "map-type",
gimp_procedure_add_choice_argument (procedure, "map-type",
_("Map _to"),
_("Type of mapping"),
gimp_choice_new_with_values ("map-plane", MAP_PLANE, _("Plane"), NULL,
@ -146,87 +146,87 @@ map_create_procedure (GimpPlugIn *plug_in,
"map-plane",
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "viewpoint-x",
gimp_procedure_add_double_argument (procedure, "viewpoint-x",
_("X"),
_("Position of viewpoint (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0.5,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "viewpoint-y",
gimp_procedure_add_double_argument (procedure, "viewpoint-y",
_("Y"),
_("Position of viewpoint (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0.5,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "viewpoint-z",
gimp_procedure_add_double_argument (procedure, "viewpoint-z",
_("Z"),
_("Position of viewpoint (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 2.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "position-x",
gimp_procedure_add_double_argument (procedure, "position-x",
_("Position X"),
_("Object position (x,y,z)"),
-1.0, 2.0, 0.5,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "position-y",
gimp_procedure_add_double_argument (procedure, "position-y",
_("Position Y"),
_("Object position (x,y,z)"),
-1.0, 2.0, 0.5,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "position-z",
gimp_procedure_add_double_argument (procedure, "position-z",
_("Position Z"),
_("Object position (x,y,z)"),
-1.0, 2.0, 0.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "first-axis-x",
gimp_procedure_add_double_argument (procedure, "first-axis-x",
_("X"),
_("First axis of object (x,y,z)"),
-1.0, 2.0, 1.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "first-axis-y",
gimp_procedure_add_double_argument (procedure, "first-axis-y",
_("y"),
_("First axis of object (x,y,z)"),
-1.0, 2.0, 0.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "first-axis-z",
gimp_procedure_add_double_argument (procedure, "first-axis-z",
_("Z"),
_("First axis of object (x,y,z)"),
-1.0, 2.0, 0.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "second-axis-x",
gimp_procedure_add_double_argument (procedure, "second-axis-x",
_("X"),
_("Second axis of object (x,y,z)"),
-1.0, 2.0, 0.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "second-axis-y",
gimp_procedure_add_double_argument (procedure, "second-axis-y",
_("Y"),
_("Second axis of object (x,y,z)"),
-1.0, 2.0, 1.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "second-axis-z",
gimp_procedure_add_double_argument (procedure, "second-axis-z",
_("Z"),
_("Second axis of object (x,y,z)"),
-1.0, 2.0, 0.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "rotation-angle-x",
gimp_procedure_add_double_argument (procedure, "rotation-angle-x",
_("Angle X"),
_("Rotation about X axis in degrees"),
-360, 360, 0.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "rotation-angle-y",
gimp_procedure_add_double_argument (procedure, "rotation-angle-y",
_("Angle Y"),
_("Rotation about Y axis in degrees"),
-360, 360, 0.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "rotation-angle-z",
gimp_procedure_add_double_argument (procedure, "rotation-angle-z",
_("Angle Z"),
_("Rotation about Z axis in degrees"),
-360, 360, 0.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "light-type",
gimp_procedure_add_choice_argument (procedure, "light-type",
_("Light source type"),
_("Type of lightsource"),
gimp_choice_new_with_values ("point-light", POINT_LIGHT, _("Point Light"), NULL,
@ -236,193 +236,193 @@ map_create_procedure (GimpPlugIn *plug_in,
"point-light",
G_PARAM_READWRITE);
GIMP_PROC_ARG_COLOR (procedure, "light-color",
gimp_procedure_add_color_argument (procedure, "light-color",
_("Light source _color"),
_("Light source color"),
TRUE, default_color,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "light-position-x",
gimp_procedure_add_double_argument (procedure, "light-position-x",
_("Light position X"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, -0.5,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "light-position-y",
gimp_procedure_add_double_argument (procedure, "light-position-y",
_("Light position Y"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, -0.5,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "light-position-z",
gimp_procedure_add_double_argument (procedure, "light-position-z",
_("Light position Z"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 2.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "light-direction-x",
gimp_procedure_add_double_argument (procedure, "light-direction-x",
_("Light direction X"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, -1.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "light-direction-y",
gimp_procedure_add_double_argument (procedure, "light-direction-y",
_("Light direction Y"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, -1.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "light-direction-z",
gimp_procedure_add_double_argument (procedure, "light-direction-z",
_("Light direction Z"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "ambient-intensity",
gimp_procedure_add_double_argument (procedure, "ambient-intensity",
_("Ambie_nt"),
_("Material ambient intensity"),
0, 1, 0.3,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "diffuse-intensity",
gimp_procedure_add_double_argument (procedure, "diffuse-intensity",
_("D_iffuse"),
_("Material diffuse intensity"),
0, 1, 1.0,
G_PARAM_READWRITE);
/* Reflectivity */
GIMP_PROC_ARG_DOUBLE (procedure, "diffuse-reflectivity",
gimp_procedure_add_double_argument (procedure, "diffuse-reflectivity",
_("Di_ffuse"),
_("Material diffuse reflectivity"),
0, 1, 0.5,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "specular-reflectivity",
gimp_procedure_add_double_argument (procedure, "specular-reflectivity",
_("Spec_ular"),
_("Material specular reflectivity"),
0, 1, 0.5,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "highlight",
gimp_procedure_add_double_argument (procedure, "highlight",
_("Highligh_t"),
_("Material highlight "
"(note, it's exponential)"),
0, G_MAXDOUBLE, 27.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "antialiasing",
gimp_procedure_add_boolean_argument (procedure, "antialiasing",
_("Antialia_sing"),
_("Apply antialiasing"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "depth",
gimp_procedure_add_double_argument (procedure, "depth",
_("_Depth"),
_("Antialiasing quality. Higher is better, "
"but slower"),
1.0, 5.0, 3.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "threshold",
gimp_procedure_add_double_argument (procedure, "threshold",
_("Thr_eshold"),
_("Stop when pixel differences are smaller than "
"this value"),
0.001, 1000.0, 0.250,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "tiled",
gimp_procedure_add_boolean_argument (procedure, "tiled",
_("_Tile source image"),
_("Tile source image"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "new-image",
gimp_procedure_add_boolean_argument (procedure, "new-image",
_("Create _new image"),
_("Create a new image"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "new-layer",
gimp_procedure_add_boolean_argument (procedure, "new-layer",
_("Create ne_w layer"),
_("Create a new layer when applying filter"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "transparent-background",
gimp_procedure_add_boolean_argument (procedure, "transparent-background",
_("Transparent bac_kground"),
_("Make background transparent"),
FALSE,
G_PARAM_READWRITE);
/* Sphere Options */
GIMP_PROC_ARG_DOUBLE (procedure, "sphere-radius",
gimp_procedure_add_double_argument (procedure, "sphere-radius",
_("Radi_us"),
_("Sphere radius"),
0, G_MAXDOUBLE, 0.25,
G_PARAM_READWRITE);
/* Box Options */
GIMP_PROC_ARG_DRAWABLE (procedure, "box-front-drawable",
gimp_procedure_add_drawable_argument (procedure, "box-front-drawable",
_("Fro_nt"),
_("Box front face "
"(set this to NULL if not used)"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DRAWABLE (procedure, "box-back-drawable",
gimp_procedure_add_drawable_argument (procedure, "box-back-drawable",
_("B_ack"),
_("Box back face"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DRAWABLE (procedure, "box-top-drawable",
gimp_procedure_add_drawable_argument (procedure, "box-top-drawable",
_("To_p"),
_("Box top face"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DRAWABLE (procedure, "box-bottom-drawable",
gimp_procedure_add_drawable_argument (procedure, "box-bottom-drawable",
_("Bo_ttom"),
_("Box bottom face"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DRAWABLE (procedure, "box-left-drawable",
gimp_procedure_add_drawable_argument (procedure, "box-left-drawable",
_("Le_ft"),
_("Box left face"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DRAWABLE (procedure, "box-right-drawable",
gimp_procedure_add_drawable_argument (procedure, "box-right-drawable",
_("Ri_ght"),
_("Box right face"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "x-scale",
gimp_procedure_add_double_argument (procedure, "x-scale",
_("Scale X"),
_("Box X size"),
0, G_MAXDOUBLE, 0.5,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "y-scale",
gimp_procedure_add_double_argument (procedure, "y-scale",
_("Scale Y"),
_("Box Y size"),
0, G_MAXDOUBLE, 0.5,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "z-scale",
gimp_procedure_add_double_argument (procedure, "z-scale",
_("Scale Z"),
_("Box Z size"),
0, G_MAXDOUBLE, 0.5,
G_PARAM_READWRITE);
/* Cylinder options */
GIMP_PROC_ARG_DRAWABLE (procedure, "cyl-top-drawable",
gimp_procedure_add_drawable_argument (procedure, "cyl-top-drawable",
_("_Top"),
_("Cylinder top face "
"(set this to NULL if not used)"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DRAWABLE (procedure, "cyl-bottom-drawable",
gimp_procedure_add_drawable_argument (procedure, "cyl-bottom-drawable",
_("_Bottom"),
_("Cylinder bottom face "
"(set this to NULL if not used)"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "cylinder-radius",
gimp_procedure_add_double_argument (procedure, "cylinder-radius",
_("Radi_us"),
_("Cylinder radius"),
0, G_MAXDOUBLE, 0.25,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "cylinder-length",
gimp_procedure_add_double_argument (procedure, "cylinder-length",
_("Cylin_der length"),
_("Cylinder length"),
0, G_MAXDOUBLE, 0.25,

12
plug-ins/pagecurl/pagecurl.c
View file

@ -225,7 +225,7 @@ pagecurl_create_procedure (GimpPlugIn *plug_in,
"Federico Mena Quintero and Simon Budig",
PLUG_IN_VERSION);
GIMP_PROC_ARG_CHOICE (procedure, "colors",
gimp_procedure_add_choice_argument (procedure, "colors",
_("Colors"), NULL,
gimp_choice_new_with_values ("fg-bg", CURL_COLORS_FG_BG, _("Foreground / background colors"), NULL,
"current-gradient", CURL_COLORS_GRADIENT, _("Current gradient"), NULL,
@ -234,7 +234,7 @@ pagecurl_create_procedure (GimpPlugIn *plug_in,
"fg-bg",
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "edge",
gimp_procedure_add_choice_argument (procedure, "edge",
_("Locatio_n"),
_("Corner which is curled"),
gimp_choice_new_with_values ("upper-left", CURL_EDGE_UPPER_LEFT, _("Upper left"), NULL,
@ -245,7 +245,7 @@ pagecurl_create_procedure (GimpPlugIn *plug_in,
"lower-right",
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "orientation",
gimp_procedure_add_choice_argument (procedure, "orientation",
_("Or_ientation"), NULL,
gimp_choice_new_with_values ("vertical", CURL_ORIENTATION_VERTICAL, _("Vertical"), NULL,
"horizontal", CURL_ORIENTATION_HORIZONTAL, _("Horizontal"), NULL,
@ -253,19 +253,19 @@ pagecurl_create_procedure (GimpPlugIn *plug_in,
"vertical",
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "shade",
gimp_procedure_add_boolean_argument (procedure, "shade",
_("Sh_ade"),
_("Shade the region under the curl"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "opacity",
gimp_procedure_add_double_argument (procedure, "opacity",
_("Opaci_ty"),
_("Opacity"),
0.0, 1.0, 0.0,
GIMP_PARAM_READWRITE);
GIMP_PROC_VAL_LAYER (procedure, "curl-layer",
gimp_procedure_add_layer_return_value (procedure, "curl-layer",
"Curl layer",
"The new layer with the curl.",
FALSE,

2
plug-ins/print/print.c
View file

@ -551,7 +551,7 @@ print_temp_proc_install (GimpImage *image)
"Sven Neumann",
"2008");
GIMP_PROC_ARG_IMAGE (procedure, "image",
gimp_procedure_add_image_argument (procedure, "image",
"Image",
"The image to notify about",
FALSE,

24
plug-ins/screenshot/screenshot.c
View file

@ -153,45 +153,45 @@ screenshot_create_procedure (GimpPlugIn *plug_in,
gimp_procedure_set_icon_pixbuf (procedure,
gdk_pixbuf_new_from_resource ("/org/gimp/screenshot-icons/screenshot-icon.png", NULL));
GIMP_PROC_ARG_ENUM (procedure, "run-mode",
gimp_procedure_add_enum_argument (procedure, "run-mode",
"Run mode",
"The run mode",
GIMP_TYPE_RUN_MODE,
GIMP_RUN_NONINTERACTIVE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "shoot-type",
gimp_procedure_add_int_argument (procedure, "shoot-type",
_("Shoot _area"),
_("The shoot type { SHOOT-WINDOW (0), SHOOT-ROOT (1), "
"SHOOT-REGION (2) }"),
0, 2, SHOOT_WINDOW,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "x1",
gimp_procedure_add_int_argument (procedure, "x1",
"X1",
"Region left x coord for SHOOT-WINDOW",
G_MININT, G_MAXINT, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "y1",
gimp_procedure_add_int_argument (procedure, "y1",
"Y1",
"Region top y coord for SHOOT-WINDOW",
G_MININT, G_MAXINT, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "x2",
gimp_procedure_add_int_argument (procedure, "x2",
"X2",
"Region right x coord for SHOOT-WINDOW",
G_MININT, G_MAXINT, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "y2",
gimp_procedure_add_int_argument (procedure, "y2",
"Y2",
"Region bottom y coord for SHOOT-WINDOW",
G_MININT, G_MAXINT, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "include-pointer",
gimp_procedure_add_boolean_argument (procedure, "include-pointer",
_("Include _mouse pointer"),
_("Your pointing device's cursor will be part of the image"),
FALSE,
@ -200,7 +200,7 @@ screenshot_create_procedure (GimpPlugIn *plug_in,
/* Since no backends allow window screenshot non-interactively so far, no
* need to expose this argument to the API.
*/
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "include-decoration",
gimp_procedure_add_boolean_aux_argument (procedure, "include-decoration",
_("Include window _decoration"),
_("Title bar, window borders and shadow will be part of the image"),
#ifdef PLATFORM_OSX
@ -210,24 +210,24 @@ screenshot_create_procedure (GimpPlugIn *plug_in,
TRUE,
#endif
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_INT (procedure, "selection-delay",
gimp_procedure_add_int_aux_argument (procedure, "selection-delay",
_("Selection d_elay"),
_("Delay before selection of the window or the region"),
0, 20, 0,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_INT (procedure, "screenshot-delay",
gimp_procedure_add_int_aux_argument (procedure, "screenshot-delay",
_("Screenshot dela_y"),
_("Delay before snapping the screenshot"),
0, 20, 0,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_INT (procedure, "color-profile",
gimp_procedure_add_int_aux_argument (procedure, "color-profile",
_("Color _Profile"),
"{ SCREENSHOT_PROFILE_POLICY_MONITOR, (0), "
"SCREENSHOT_PROFILE_POLICY_MONITOR, (1) } ",
0, 1, SCREENSHOT_PROFILE_POLICY_MONITOR,
G_PARAM_READWRITE);
GIMP_PROC_VAL_IMAGE (procedure, "image",
gimp_procedure_add_image_return_value (procedure, "image",
"Image",
"Output image",
FALSE,

2
plug-ins/script-fu/script-fu-refresh.c
View file

@ -91,7 +91,7 @@ script_fu_register_refresh_procedure (GimpPlugIn *plug_in)
"Spencer Kimball & Peter Mattis",
"1997");
GIMP_PROC_ARG_ENUM (procedure, "run-mode",
gimp_procedure_add_enum_argument (procedure, "run-mode",
"Run mode",
"The run mode",
GIMP_TYPE_RUN_MODE,

6
plug-ins/script-fu/script-fu.c
View file

@ -131,13 +131,13 @@ script_fu_create_procedure (GimpPlugIn *plug_in,
"Spencer Kimball & Peter Mattis",
"1997");
GIMP_PROC_ARG_ENUM (procedure, "run-mode",
gimp_procedure_add_enum_argument (procedure, "run-mode",
"Run mode",
"The run mode",
GIMP_TYPE_RUN_MODE,
GIMP_RUN_INTERACTIVE,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_STRV (procedure, "history",
gimp_procedure_add_string_array_argument (procedure, "history",
"Command history",
"History",
G_PARAM_READWRITE);
@ -159,7 +159,7 @@ script_fu_create_procedure (GimpPlugIn *plug_in,
"Spencer Kimball & Peter Mattis",
"1997");
GIMP_PROC_ARG_ENUM (procedure, "run-mode",
gimp_procedure_add_enum_argument (procedure, "run-mode",
"Run mode",
"The run mode",
GIMP_TYPE_RUN_MODE,

Some files were not shown because too many files have changed in this diff Show more