procyberian/gimp
2
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/gimp.git synced 2025-07-03 09:23:24 +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

22
libgimp/gimpbatchprocedure.c
View file

@ -97,18 +97,18 @@ gimp_batch_procedure_constructed (GObject *object)
G_OBJECT_CLASS (parent_class)->constructed (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", "Run mode",
"The run mode", "The run mode",
GIMP_TYPE_RUN_MODE, GIMP_TYPE_RUN_MODE,
GIMP_RUN_NONINTERACTIVE, GIMP_RUN_NONINTERACTIVE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "script", gimp_procedure_add_string_argument (procedure, "script",
"Batch commands in the target language", "Batch commands in the target language",
"Batch commands in the target language, which will be run by the interpreter", "Batch commands in the target language, which will be run by the interpreter",
"", "",
G_PARAM_READWRITE); G_PARAM_READWRITE);
} }
static void static void

12
libgimp/gimpdrawablechooser.c
View file

@ -513,12 +513,12 @@ gimp_drawable_chooser_clicked (GimpDrawableChooser *chooser)
(GimpRunFunc) gimp_temp_callback_run, (GimpRunFunc) gimp_temp_callback_run,
g_object_ref (chooser), g_object_ref (chooser),
(GDestroyNotify) g_object_unref); (GDestroyNotify) g_object_unref);
GIMP_PROC_ARG_DRAWABLE (callback_procedure, "drawable", gimp_procedure_add_drawable_argument (callback_procedure, "drawable",
"Drawable", "The selected drawable", "Drawable", "The selected drawable",
TRUE, G_PARAM_READWRITE); 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", "Closing", "If the dialog was closing",
FALSE, G_PARAM_READWRITE); FALSE, G_PARAM_READWRITE);
gimp_plug_in_add_temp_procedure (plug_in, callback_procedure); gimp_plug_in_add_temp_procedure (plug_in, callback_procedure);
g_object_unref (callback_procedure); g_object_unref (callback_procedure);

88
libgimp/gimpexportprocedure.c
View file

@ -214,16 +214,16 @@ gimp_export_procedure_constructed (GObject *object)
G_OBJECT_CLASS (parent_class)->constructed (object); G_OBJECT_CLASS (parent_class)->constructed (object);
GIMP_PROC_ARG_IMAGE (procedure, "image", gimp_procedure_add_image_argument (procedure, "image",
"Image", "Image",
"The image to export", "The image to export",
FALSE, FALSE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_FILE (procedure, "file", gimp_procedure_add_file_argument (procedure, "file",
"File", "File",
"The file to export to", "The file to export to",
GIMP_PARAM_READWRITE); GIMP_PARAM_READWRITE);
} }
static void static void
@ -458,47 +458,47 @@ gimp_export_procedure_add_metadata (GimpExportProcedure *export_procedure)
return; return;
if (export_procedure->priv->supports_exif) 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"),
_("Save Exif (Exchangeable image file format) metadata"), _("Save Exif (Exchangeable image file format) metadata"),
gimp_export_exif (), gimp_export_exif (),
G_PARAM_READWRITE); G_PARAM_READWRITE);
if (export_procedure->priv->supports_iptc) 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"),
_("Save IPTC (International Press Telecommunications Council) metadata"), _("Save IPTC (International Press Telecommunications Council) metadata"),
gimp_export_iptc (), gimp_export_iptc (),
G_PARAM_READWRITE); G_PARAM_READWRITE);
if (export_procedure->priv->supports_xmp) 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"),
_("Save XMP (Extensible Metadata Platform) metadata"), _("Save XMP (Extensible Metadata Platform) metadata"),
gimp_export_xmp (), gimp_export_xmp (),
G_PARAM_READWRITE); G_PARAM_READWRITE);
if (export_procedure->priv->supports_profile) 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 color _profile"),
_("Save the ICC color profile as metadata"), _("Save the ICC color profile as metadata"),
gimp_export_color_profile (), gimp_export_color_profile (),
G_PARAM_READWRITE); G_PARAM_READWRITE);
if (export_procedure->priv->supports_thumbnail) 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 _thumbnail"),
_("Save a smaller representation of the image as metadata"), _("Save a smaller representation of the image as metadata"),
gimp_export_thumbnail (), gimp_export_thumbnail (),
G_PARAM_READWRITE); G_PARAM_READWRITE);
if (export_procedure->priv->supports_comment) 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 c_omment"),
_("Save a comment as metadata"), _("Save a comment as metadata"),
gimp_export_comment (), gimp_export_comment (),
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_STRING (procedure, "gimp-comment", gimp_procedure_add_string_aux_argument (procedure, "gimp-comment",
_("Comment"), _("Comment"),
_("Image comment"), _("Image comment"),
gimp_get_default_comment (), gimp_get_default_comment (),
G_PARAM_READWRITE); G_PARAM_READWRITE);
gimp_procedure_set_argument_sync (procedure, "gimp-comment", gimp_procedure_set_argument_sync (procedure, "gimp-comment",
GIMP_ARGUMENT_SYNC_PARASITE); GIMP_ARGUMENT_SYNC_PARASITE);

12
libgimp/gimpfileprocedure.c
View file

@ -76,12 +76,12 @@ gimp_file_procedure_constructed (GObject *object)
G_OBJECT_CLASS (parent_class)->constructed (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", "Run mode",
"The run mode", "The run mode",
GIMP_TYPE_RUN_MODE, GIMP_TYPE_RUN_MODE,
GIMP_RUN_NONINTERACTIVE, GIMP_RUN_NONINTERACTIVE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
} }
static void static void

42
libgimp/gimpimageprocedure.c
View file

@ -105,30 +105,30 @@ gimp_image_procedure_constructed (GObject *object)
G_OBJECT_CLASS (parent_class)->constructed (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", "Run mode",
"The run mode", "The run mode",
GIMP_TYPE_RUN_MODE, GIMP_TYPE_RUN_MODE,
GIMP_RUN_NONINTERACTIVE, GIMP_RUN_NONINTERACTIVE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_IMAGE (procedure, "image", gimp_procedure_add_image_argument (procedure, "image",
"Image", "Image",
"The input image", "The input image",
FALSE, FALSE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "num-drawables", gimp_procedure_add_int_argument (procedure, "num-drawables",
"Number of drawables", "Number of drawables",
"Number of input drawables", "Number of input drawables",
0, G_MAXINT, 1, 0, G_MAXINT, 1,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_OBJECT_ARRAY (procedure, "drawables", gimp_procedure_add_object_array_argument (procedure, "drawables",
"Drawables", "Drawables",
"The input drawables", "The input drawables",
GIMP_TYPE_DRAWABLE, GIMP_TYPE_DRAWABLE,
G_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE); G_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE);
} }
static void static void

18
libgimp/gimploadprocedure.c
View file

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

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 * 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. * to do this is by simply using [func@export_comment], [func@export_exif] etc.
* as default values for these arguments when adding them using * 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 * Returns: (transfer none) (nullable): The metadata to be used
* for this export, or %NULL if @original_image doesn't have * for this export, or %NULL if @original_image doesn't have

42
libgimp/gimpprogress.c
View file

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

144
libgimp/gimpresourceselect.c
View file

@ -113,10 +113,10 @@ static void
create_callback_PDB_procedure_params (GimpProcedure *procedure, create_callback_PDB_procedure_params (GimpProcedure *procedure,
GType resource_type) GType resource_type)
{ {
GIMP_PROC_ARG_RESOURCE (procedure, "resource", gimp_procedure_add_resource_argument (procedure, "resource",
"Resource", "Resource",
"The resource", "The resource",
G_PARAM_READWRITE); G_PARAM_READWRITE);
/* Create args for the extra, superfluous args that core is passing.*/ /* Create args for the extra, superfluous args that core is passing.*/
if (g_type_is_a (resource_type, GIMP_TYPE_FONT)) if (g_type_is_a (resource_type, GIMP_TYPE_FONT))
@ -125,98 +125,98 @@ create_callback_PDB_procedure_params (GimpProcedure *procedure,
} }
else if (g_type_is_a (resource_type, GIMP_TYPE_GRADIENT)) 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", "Gradient width",
"The gradient width", "The gradient width",
0, G_MAXINT, 0, 0, G_MAXINT, 0,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_FLOAT_ARRAY (procedure, "gradient-data", gimp_procedure_add_float_array_argument (procedure, "gradient-data",
"Gradient data", "Gradient data",
"The gradient data", "The gradient data",
G_PARAM_READWRITE); G_PARAM_READWRITE);
} }
else if (g_type_is_a (resource_type, GIMP_TYPE_BRUSH)) 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", "Opacity",
NULL, NULL,
0.0, 100.0, 100.0, 0.0, 100.0, 100.0,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "spacing", gimp_procedure_add_int_argument (procedure, "spacing",
"Spacing", "Spacing",
NULL, NULL,
-1, 1000, 20, -1, 1000, 20,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_ENUM (procedure, "paint-mode", gimp_procedure_add_enum_argument (procedure, "paint-mode",
"Paint mode", "Paint mode",
NULL, NULL,
GIMP_TYPE_LAYER_MODE, GIMP_TYPE_LAYER_MODE,
GIMP_LAYER_MODE_NORMAL, GIMP_LAYER_MODE_NORMAL,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "mask-width", gimp_procedure_add_int_argument (procedure, "mask-width",
"Brush width", "Brush width",
NULL, NULL,
0, 10000, 0, 0, 10000, 0,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "mask-height", gimp_procedure_add_int_argument (procedure, "mask-height",
"Brush height", "Brush height",
NULL, NULL,
0, 10000, 0, 0, 10000, 0,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_BYTES (procedure, "mask-data", gimp_procedure_add_bytes_argument (procedure, "mask-data",
"Mask data", "Mask data",
"The brush mask data", "The brush mask data",
G_PARAM_READWRITE); G_PARAM_READWRITE);
} }
else if (g_type_is_a (resource_type, GIMP_TYPE_PALETTE)) 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", "Num colors",
"Number of colors", "Number of colors",
0, G_MAXINT, 0, 0, G_MAXINT, 0,
G_PARAM_READWRITE); G_PARAM_READWRITE);
} }
else if (g_type_is_a (resource_type, GIMP_TYPE_PATTERN)) 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", "Mask width",
"Pattern width", "Pattern width",
0, 10000, 0, 0, 10000, 0,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "mask-height", gimp_procedure_add_int_argument (procedure, "mask-height",
"Mask height", "Mask height",
"Pattern height", "Pattern height",
0, 10000, 0, 0, 10000, 0,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "mask-bpp", gimp_procedure_add_int_argument (procedure, "mask-bpp",
"Mask bpp", "Mask bpp",
"Pattern bytes per pixel", "Pattern bytes per pixel",
0, 10000, 0, 0, 10000, 0,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_BYTES (procedure, "mask-data", gimp_procedure_add_bytes_argument (procedure, "mask-data",
"Mask data", "Mask data",
"The pattern mask data", "The pattern mask data",
G_PARAM_READWRITE); G_PARAM_READWRITE);
} }
else else
{ {
g_warning ("%s: unhandled resource type", G_STRFUNC); g_warning ("%s: unhandled resource type", G_STRFUNC);
} }
GIMP_PROC_ARG_BOOLEAN (procedure, "closing", gimp_procedure_add_boolean_argument (procedure, "closing",
"Closing", "Closing",
"If the dialog was closing", "If the dialog was closing",
FALSE, FALSE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
} }
/* Open (create) a remote chooser dialog of resource. /* Open (create) a remote chooser dialog of resource.

70
libgimp/gimpthumbnailprocedure.c
View file

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

66
libgimp/gimpvectorloadprocedure.c
View file

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

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

@ -188,55 +188,55 @@ align_layers_create_procedure (GimpPlugIn *plug_in,
"Shuji Narazaki", "Shuji Narazaki",
"1997"); "1997");
GIMP_PROC_ARG_INT (procedure, "horizontal-style", gimp_procedure_add_int_argument (procedure, "horizontal-style",
_("_Horizontal style"), _("_Horizontal style"),
_("(None = 0, Collect = 1, " _("(None = 0, Collect = 1, "
"Fill left to right = 2, Fill right to left = 3, " "Fill left to right = 2, Fill right to left = 3, "
"Snap to grid = 4)"), "Snap to grid = 4)"),
H_NONE, SNAP2HGRID, H_NONE, H_NONE, SNAP2HGRID, H_NONE,
GIMP_PARAM_READWRITE); GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "horizontal-base", gimp_procedure_add_int_argument (procedure, "horizontal-base",
_("Hori_zontal base"), _("Hori_zontal base"),
_("(Left edge = 0, Center = 1, " _("(Left edge = 0, Center = 1, "
"Right edge = 2)"), "Right edge = 2)"),
H_BASE_LEFT, H_BASE_RIGHT, H_BASE_LEFT, H_BASE_LEFT, H_BASE_RIGHT, H_BASE_LEFT,
GIMP_PARAM_READWRITE); GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "vertical-style", gimp_procedure_add_int_argument (procedure, "vertical-style",
_("_Vertical style"), _("_Vertical style"),
_("(None = 0, Collect = 1, " _("(None = 0, Collect = 1, "
"Fill left to right = 2, Fill right to left = 3, " "Fill left to right = 2, Fill right to left = 3, "
"Snap to grid = 4)"), "Snap to grid = 4)"),
V_NONE, SNAP2VGRID, V_NONE, V_NONE, SNAP2VGRID, V_NONE,
GIMP_PARAM_READWRITE); GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "vertical-base", gimp_procedure_add_int_argument (procedure, "vertical-base",
_("Ver_tical base"), _("Ver_tical base"),
_("(Left edge = 0, Center = 1, " _("(Left edge = 0, Center = 1, "
"Right edge = 2)"), "Right edge = 2)"),
V_BASE_TOP, V_BASE_BOTTOM, V_BASE_TOP, V_BASE_TOP, V_BASE_BOTTOM, V_BASE_TOP,
GIMP_PARAM_READWRITE); GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "grid-size", gimp_procedure_add_int_argument (procedure, "grid-size",
_("_Grid"), _("_Grid"),
_("Grid"), _("Grid"),
1, 200, 10, 1, 200, 10,
GIMP_PARAM_READWRITE); GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, gimp_procedure_add_boolean_argument (procedure,
"ignore-bottom-layer", "ignore-bottom-layer",
_("Ignore the _bottom layer even if visible"), _("Ignore the _bottom layer even if visible"),
_("Ignore the bottom layer even if visible"), _("Ignore the bottom layer even if visible"),
TRUE, TRUE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, gimp_procedure_add_boolean_argument (procedure,
"use-bottom-layer", "use-bottom-layer",
_("_Use the (invisible) bottom layer as the base"), _("_Use the (invisible) bottom layer as the base"),
_("Use the (invisible) bottom layer as the base"), _("Use the (invisible) bottom layer as the base"),
FALSE, FALSE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
/* TODO: these 2 arguments existed in the original procedure but /* TODO: these 2 arguments existed in the original procedure but
* were actually unused. If we want to keep them, let's at least * were actually unused. If we want to keep them, let's at least
@ -244,16 +244,16 @@ align_layers_create_procedure (GimpPlugIn *plug_in,
* them. * them.
*/ */
/* /*
GIMP_PROC_ARG_BOOLEAN (procedure, gimp_procedure_add_boolean_argument (procedure,
"link-after-alignment", "link-after-alignment",
"Link the visible layers after alignment", "Link the visible layers after alignment",
FALSE, FALSE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, gimp_procedure_add_boolean_argument (procedure,
"use-bottom", "use-bottom",
"use the bottom layer as the base of alignment", "use the bottom layer as the base of alignment",
TRUE, TRUE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
*/ */
} }

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

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

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

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

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

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

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

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

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

@ -136,36 +136,37 @@ busy_dialog_create_procedure (GimpPlugIn *plug_in,
"Ell", "Ell",
"2018"); "2018");
GIMP_PROC_ARG_ENUM (procedure, "run-mode", gimp_procedure_add_enum_argument (procedure, "run-mode",
"Run mode", "Run mode",
"The run mode", "The run mode",
GIMP_TYPE_RUN_MODE, GIMP_TYPE_RUN_MODE,
GIMP_RUN_INTERACTIVE, GIMP_RUN_INTERACTIVE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "read-fd", gimp_procedure_add_int_argument (procedure, "read-fd",
"The read file descriptor", "The read file descriptor",
"The read file descriptor", "The read file descriptor",
G_MININT, G_MAXINT, 0, G_MININT, G_MAXINT, 0,
G_PARAM_READWRITE); 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",
"The write file descriptor", "The write file descriptor",
G_MININT, G_MAXINT, 0, G_MININT, G_MAXINT, 0,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "message",
"The message",
"The message",
NULL,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "cancelable", gimp_procedure_add_string_argument (procedure, "message",
"Whether the dialog is cancelable", "The message",
"Whether the dialog is cancelable", "The message",
FALSE, NULL,
G_PARAM_READWRITE); G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "cancelable",
"Whether the dialog is cancelable",
"Whether the dialog is cancelable",
FALSE,
G_PARAM_READWRITE);
} }
return procedure; return procedure;

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

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

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

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

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

@ -195,10 +195,10 @@ remap_create_procedure (GimpPlugIn *plug_in,
"Mukund Sivaraman <muks@mukund.org>", "Mukund Sivaraman <muks@mukund.org>",
"June 2006"); "June 2006");
GIMP_PROC_ARG_BYTES (procedure, "map", gimp_procedure_add_bytes_argument (procedure, "map",
_("Map"), _("Map"),
_("Remap array for the colormap"), _("Remap array for the colormap"),
G_PARAM_READWRITE); G_PARAM_READWRITE);
} }
else if (strcmp (name, PLUG_IN_PROC_SWAP) == 0) else if (strcmp (name, PLUG_IN_PROC_SWAP) == 0)
{ {
@ -228,17 +228,17 @@ remap_create_procedure (GimpPlugIn *plug_in,
"Mukund Sivaraman <muks@mukund.org>", "Mukund Sivaraman <muks@mukund.org>",
"June 2006"); "June 2006");
GIMP_PROC_ARG_INT (procedure, "index1", gimp_procedure_add_int_argument (procedure, "index1",
_("Index 1"), _("Index 1"),
_("First index in the colormap"), _("First index in the colormap"),
0, 255, 0, 0, 255, 0,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "index2", gimp_procedure_add_int_argument (procedure, "index2",
_("Index 2"), _("Index 2"),
_("Second (other) index in the colormap"), _("Second (other) index in the colormap"),
0, 255, 0, 0, 255, 0,
G_PARAM_READWRITE); G_PARAM_READWRITE);
} }
return procedure; return procedure;

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

@ -414,47 +414,47 @@ compose_create_procedure (GimpPlugIn *plug_in,
"Peter Kirchgessner (peter@kirchgessner.net)", "Peter Kirchgessner (peter@kirchgessner.net)",
"1997"); "1997");
GIMP_PROC_ARG_IMAGE (procedure, "image-2", gimp_procedure_add_image_argument (procedure, "image-2",
_("Image 2"), _("Image 2"),
_("Second input image"), _("Second input image"),
TRUE, TRUE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_IMAGE (procedure, "image-3", gimp_procedure_add_image_argument (procedure, "image-3",
_("Image 3"), _("Image 3"),
_("Third input image"), _("Third input image"),
TRUE, TRUE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_IMAGE (procedure, "image-4", gimp_procedure_add_image_argument (procedure, "image-4",
_("Image 4"), _("Image 4"),
_("Fourth input image"), _("Fourth input image"),
TRUE, TRUE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "compose-type", gimp_procedure_add_choice_argument (procedure, "compose-type",
_("Color _model"), _("Color _model"),
type_desc->str, type_desc->str,
gimp_choice_new_with_values ("rgb", 0, _("RGB"), NULL, gimp_choice_new_with_values ("rgb", 0, _("RGB"), NULL,
"rgba", 1, _("RGBA"), NULL, "rgba", 1, _("RGBA"), NULL,
"hsv", 2, _("HSV"), NULL, "hsv", 2, _("HSV"), NULL,
"hsl", 3, _("HSL"), NULL, "hsl", 3, _("HSL"), NULL,
"cmyk", 4, _("CMYK"), NULL, "cmyk", 4, _("CMYK"), NULL,
"lab", 5, _("LAB"), NULL, "lab", 5, _("LAB"), NULL,
"lch", 6, _("LCH"), NULL, "lch", 6, _("LCH"), NULL,
"ycbcr470", 7, _("YCbCr ITU R470"), NULL, "ycbcr470", 7, _("YCbCr ITU R470"), NULL,
"ycbcr709", 8, _("YCbCr ITU R709"), NULL, "ycbcr709", 8, _("YCbCr ITU R709"), NULL,
"ycbcr470f", 9, _("YCbCr ITU R470 256"), NULL, "ycbcr470f", 9, _("YCbCr ITU R470 256"), NULL,
"ycbcr709f", 10, _("YCbCr ITU R709 256"), NULL, "ycbcr709f", 10, _("YCbCr ITU R709 256"), NULL,
NULL), NULL),
"rgb", "rgb",
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_VAL_IMAGE (procedure, "new-image", gimp_procedure_add_image_return_value (procedure, "new-image",
_("New image"), _("New image"),
_("Output image"), _("Output image"),
FALSE, FALSE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
} }
else if (! strcmp (name, DRAWABLE_COMPOSE_PROC)) else if (! strcmp (name, DRAWABLE_COMPOSE_PROC))
{ {
@ -477,47 +477,47 @@ compose_create_procedure (GimpPlugIn *plug_in,
"Peter Kirchgessner (peter@kirchgessner.net)", "Peter Kirchgessner (peter@kirchgessner.net)",
"1998"); "1998");
GIMP_PROC_ARG_DRAWABLE (procedure, "drawable-2", gimp_procedure_add_drawable_argument (procedure, "drawable-2",
_("Drawable 2"), _("Drawable 2"),
_("Second input drawable"), _("Second input drawable"),
TRUE, TRUE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_DRAWABLE (procedure, "drawable-3", gimp_procedure_add_drawable_argument (procedure, "drawable-3",
_("Drawable 3"), _("Drawable 3"),
_("Third input drawable"), _("Third input drawable"),
TRUE, TRUE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_DRAWABLE (procedure, "drawable-4", gimp_procedure_add_drawable_argument (procedure, "drawable-4",
_("Drawable 4"), _("Drawable 4"),
_("Fourth input drawable"), _("Fourth input drawable"),
TRUE, TRUE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "compose-type", gimp_procedure_add_choice_argument (procedure, "compose-type",
_("Color _model"), _("Color _model"),
type_desc->str, type_desc->str,
gimp_choice_new_with_values ("rgb", 0, _("RGB"), NULL, gimp_choice_new_with_values ("rgb", 0, _("RGB"), NULL,
"rgba", 1, _("RGBA"), NULL, "rgba", 1, _("RGBA"), NULL,
"hsv", 2, _("HSV"), NULL, "hsv", 2, _("HSV"), NULL,
"hsl", 3, _("HSL"), NULL, "hsl", 3, _("HSL"), NULL,
"cmyk", 4, _("CMYK"), NULL, "cmyk", 4, _("CMYK"), NULL,
"lab", 5, _("LAB"), NULL, "lab", 5, _("LAB"), NULL,
"lch", 6, _("LCH"), NULL, "lch", 6, _("LCH"), NULL,
"ycbcr470", 7, _("YCbCr ITU R470"), NULL, "ycbcr470", 7, _("YCbCr ITU R470"), NULL,
"ycbcr709", 8, _("YCbCr ITU R709"), NULL, "ycbcr709", 8, _("YCbCr ITU R709"), NULL,
"ycbcr470f", 9, _("YCbCr ITU R470 256"), NULL, "ycbcr470f", 9, _("YCbCr ITU R470 256"), NULL,
"ycbcr709f", 10, _("YCbCr ITU R709 256"), NULL, "ycbcr709f", 10, _("YCbCr ITU R709 256"), NULL,
NULL), NULL),
"rgb", "rgb",
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_VAL_IMAGE (procedure, "new-image", gimp_procedure_add_image_return_value (procedure, "new-image",
_("New image"), _("New image"),
_("Output image"), _("Output image"),
FALSE, FALSE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
} }
else if (! strcmp (name, RECOMPOSE_PROC)) else if (! strcmp (name, RECOMPOSE_PROC))
{ {

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

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

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

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

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

@ -294,63 +294,63 @@ decompose_create_procedure (GimpPlugIn *plug_in,
"Peter Kirchgessner, Clarence Risher", "Peter Kirchgessner, Clarence Risher",
"1997"); "1997");
GIMP_PROC_ARG_CHOICE (procedure, "decompose-type", gimp_procedure_add_choice_argument (procedure, "decompose-type",
_("Color _model"), _("Color _model"),
_("The model to decompose to"), _("The model to decompose to"),
gimp_choice_new_with_values ("rgb", 0, _("RGB"), NULL, gimp_choice_new_with_values ("rgb", 0, _("RGB"), NULL,
"rgba", 1, _("RGBA"), NULL, "rgba", 1, _("RGBA"), NULL,
"alpha", 2, _("Alpha"), NULL, "alpha", 2, _("Alpha"), NULL,
"hsv", 3, _("HSV"), NULL, "hsv", 3, _("HSV"), NULL,
"hsl", 4, _("HSL"), NULL, "hsl", 4, _("HSL"), NULL,
"cmyk", 5, _("CMYK"), NULL, "cmyk", 5, _("CMYK"), NULL,
"lab", 6, _("LAB"), NULL, "lab", 6, _("LAB"), NULL,
"lch", 7, _("LCH"), NULL, "lch", 7, _("LCH"), NULL,
"ycbcr470", 8, _("YCbCr ITU R470"), NULL, "ycbcr470", 8, _("YCbCr ITU R470"), NULL,
"ycbcr709", 9, _("YCbCr ITU R709"), NULL, "ycbcr709", 9, _("YCbCr ITU R709"), NULL,
"ycbcr470f", 10, _("YCbCr ITU R470 256"), NULL, "ycbcr470f", 10, _("YCbCr ITU R470 256"), NULL,
"ycbcr709f", 11, _("YCbCr ITU R709 256"), NULL, "ycbcr709f", 11, _("YCbCr ITU R709 256"), NULL,
NULL), NULL),
"rgb", "rgb",
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "layers-mode", gimp_procedure_add_boolean_argument (procedure, "layers-mode",
_("_Decompose to layers"), _("_Decompose to layers"),
_("Create channels as layers in a single image"), _("Create channels as layers in a single image"),
TRUE, TRUE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "use-registration", gimp_procedure_add_boolean_argument (procedure, "use-registration",
_("_Foreground as registration color"), _("_Foreground as registration color"),
_("When enabled, pixels in the foreground color " _("When enabled, pixels in the foreground color "
"will appear black in all output images. This " "will appear black in all output images. This "
"can be used for things like crop marks that " "can be used for things like crop marks that "
"have to show up on all channels."), "have to show up on all channels."),
FALSE, FALSE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_VAL_IMAGE (procedure, "new-image-1", gimp_procedure_add_image_return_value (procedure, "new-image-1",
"New image 1", "New image 1",
"Output gray image 1", "Output gray image 1",
FALSE, FALSE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_VAL_IMAGE (procedure, "new-image-2", gimp_procedure_add_image_return_value (procedure, "new-image-2",
"New image 2", "New image 2",
"Output gray image 2 (N/A for single channel extract)", "Output gray image 2 (N/A for single channel extract)",
TRUE, TRUE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_VAL_IMAGE (procedure, "new-image-3", gimp_procedure_add_image_return_value (procedure, "new-image-3",
"New image 3", "New image 3",
"Output gray image 3 (N/A for single channel extract)", "Output gray image 3 (N/A for single channel extract)",
TRUE, TRUE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_VAL_IMAGE (procedure, "new-image-4", gimp_procedure_add_image_return_value (procedure, "new-image-4",
"New image 4", "New image 4",
"Output gray image 4 (N/A for single channel extract)", "Output gray image 4 (N/A for single channel extract)",
TRUE, TRUE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
g_string_free (type_desc, TRUE); g_string_free (type_desc, TRUE);
} }

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

@ -219,53 +219,53 @@ merge_create_procedure (GimpPlugIn *plug_in,
"Sean Cier", "Sean Cier",
PLUG_IN_VERSION); PLUG_IN_VERSION);
GIMP_PROC_ARG_DRAWABLE (procedure, "source-1", gimp_procedure_add_drawable_argument (procedure, "source-1",
_("Source _1"), _("Source _1"),
_("Source 1"), _("Source 1"),
TRUE, TRUE,
G_PARAM_READWRITE); 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"),
_("Depth map 1"), _("Depth map 1"),
TRUE, TRUE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_DRAWABLE (procedure, "source-2", gimp_procedure_add_drawable_argument (procedure, "source-2",
_("Source _2"), _("Source _2"),
_("Source 2"), _("Source 2"),
TRUE, TRUE,
G_PARAM_READWRITE); 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"),
_("Depth map 2"), _("Depth map 2"),
TRUE, TRUE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "overlap", gimp_procedure_add_double_argument (procedure, "overlap",
_("O_verlap"), _("O_verlap"),
_("Overlap"), _("Overlap"),
0, 2, 0, 0, 2, 0,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "offset", gimp_procedure_add_double_argument (procedure, "offset",
_("O_ffset"), _("O_ffset"),
_("Depth relative offset"), _("Depth relative offset"),
-1, 1, 0, -1, 1, 0,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "scale-1", gimp_procedure_add_double_argument (procedure, "scale-1",
_("Sc_ale 1"), _("Sc_ale 1"),
_("Depth relative scale 1"), _("Depth relative scale 1"),
-1, 1, 1, -1, 1, 1,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "scale-2", gimp_procedure_add_double_argument (procedure, "scale-2",
_("Scal_e 2"), _("Scal_e 2"),
_("Depth relative scale 2"), _("Depth relative scale 2"),
-1, 1, 1, -1, 1, 1,
G_PARAM_READWRITE); G_PARAM_READWRITE);
} }
return procedure; return procedure;

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

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

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

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

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

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

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

@ -153,10 +153,10 @@ cel_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_magics (GIMP_FILE_PROCEDURE (procedure), gimp_file_procedure_set_magics (GIMP_FILE_PROCEDURE (procedure),
"0,string,KiSS\\040"); "0,string,KiSS\\040");
GIMP_PROC_ARG_FILE (procedure, "palette-file", gimp_procedure_add_file_argument (procedure, "palette-file",
_("_Palette file"), _("_Palette file"),
_("KCF file to load palette from"), _("KCF file to load palette from"),
G_PARAM_READWRITE); G_PARAM_READWRITE);
} }
else if (! strcmp (name, EXPORT_PROC)) else if (! strcmp (name, EXPORT_PROC))
{ {
@ -183,10 +183,10 @@ cel_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"cel"); "cel");
GIMP_PROC_ARG_FILE (procedure, "palette-file", gimp_procedure_add_file_argument (procedure, "palette-file",
"Palette file", _("_Palette file"),
"File to save palette to", _("File to save palette to"),
G_PARAM_READWRITE); G_PARAM_READWRITE);
} }
return procedure; return procedure;

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

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

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

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

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

@ -179,71 +179,71 @@ gif_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"gif"); "gif");
GIMP_PROC_ARG_BOOLEAN (procedure, "interlace", gimp_procedure_add_boolean_argument (procedure, "interlace",
_("_Interlace"), _("_Interlace"),
_("Try to export as interlaced"), _("Try to export as interlaced"),
FALSE, FALSE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "loop", gimp_procedure_add_boolean_argument (procedure, "loop",
_("Loop _Forever"), _("Loop _Forever"),
_("(animated gif) Loop infinitely"), _("(animated gif) Loop infinitely"),
TRUE, TRUE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "number-of-repeats", gimp_procedure_add_int_argument (procedure, "number-of-repeats",
_("_Number of repeats"), _("_Number of repeats"),
_("(animated gif) Number of repeats " _("(animated gif) Number of repeats "
"(Ignored if 'loop' is TRUE)"), "(Ignored if 'loop' is TRUE)"),
0, G_MAXSHORT - 1, 0, 0, G_MAXSHORT - 1, 0,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "default-delay", gimp_procedure_add_int_argument (procedure, "default-delay",
_("_Delay between frames when unspecified"), _("_Delay between frames when unspecified"),
_("(animated gif) Default delay between frames " _("(animated gif) Default delay between frames "
"in milliseconds"), "in milliseconds"),
0, G_MAXINT, 100, 0, G_MAXINT, 100,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "default-dispose", gimp_procedure_add_int_argument (procedure, "default-dispose",
_("Frame disposal _when unspecified"), _("Frame disposal _when unspecified"),
_("(animated gif) Default disposal type " _("(animated gif) Default disposal type "
"(0=`don't care`, " "(0=`don't care`, "
"1=combine, " "1=combine, "
"2=replace)"), "2=replace)"),
0, 2, 0, 0, 2, 0,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "as-animation", gimp_procedure_add_boolean_argument (procedure, "as-animation",
_("_As animation"), _("_As animation"),
_("Export GIF as animation?"), _("Export GIF as animation?"),
FALSE, FALSE,
G_PARAM_READWRITE); 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"), _("_Use delay entered above for all frames"),
_("(animated gif) Use specified delay for all frames"), _("(animated gif) Use specified delay for all frames"),
FALSE, FALSE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "force-dispose", gimp_procedure_add_boolean_argument (procedure, "force-dispose",
_("Use dis_posal entered above " _("Use dis_posal entered above "
"for all frames"), "for all frames"),
_("(animated gif) Use specified disposal for all frames"), _("(animated gif) Use specified disposal for all frames"),
FALSE, FALSE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-comment", gimp_procedure_add_boolean_aux_argument (procedure, "save-comment",
_("Sa_ve comment"), _("Sa_ve comment"),
_("Save the image comment in the GIF file"), _("Save the image comment in the GIF file"),
gimp_export_comment (), gimp_export_comment (),
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_STRING (procedure, "gimp-comment", gimp_procedure_add_string_aux_argument (procedure, "gimp-comment",
_("Commen_t"), _("Commen_t"),
_("Image comment"), _("Image comment"),
gimp_get_default_comment (), gimp_get_default_comment (),
G_PARAM_READWRITE); G_PARAM_READWRITE);
gimp_procedure_set_argument_sync (procedure, "gimp-comment", gimp_procedure_set_argument_sync (procedure, "gimp-comment",
GIMP_ARGUMENT_SYNC_PARASITE); GIMP_ARGUMENT_SYNC_PARASITE);
@ -329,7 +329,7 @@ gif_export (GimpProcedure *procedure,
if (status == GIMP_PDB_SUCCESS) if (status == GIMP_PDB_SUCCESS)
{ {
GList *drawables; GList *drawables;
/* Create an exportable image based on the export options */ /* Create an exportable image based on the export options */
switch (run_mode) switch (run_mode)
@ -360,7 +360,7 @@ gif_export (GimpProcedure *procedure,
} }
drawables = gimp_image_list_layers (image); drawables = gimp_image_list_layers (image);
if (! export_image (file, image, drawables->data, orig_image, if (! export_image (file, image, drawables->data, orig_image,
G_OBJECT (config), &error)) G_OBJECT (config), &error))
{ {
status = GIMP_PDB_EXECUTION_ERROR; status = GIMP_PDB_EXECUTION_ERROR;
@ -373,7 +373,7 @@ gif_export (GimpProcedure *procedure,
if (export == GIMP_EXPORT_EXPORT) if (export == GIMP_EXPORT_EXPORT)
gimp_image_delete (image); gimp_image_delete (image);
return gimp_procedure_new_return_values (procedure, status, error); return gimp_procedure_new_return_values (procedure, status, error);
} }

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

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

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

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

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

@ -251,55 +251,55 @@ heif_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"heif,heic"); "heif,heic");
GIMP_PROC_ARG_INT (procedure, "quality", gimp_procedure_add_int_argument (procedure, "quality",
_("_Quality"), _("_Quality"),
_("Quality factor (0 = worst, 100 = best)"), _("Quality factor (0 = worst, 100 = best)"),
0, 100, 50, 0, 100, 50,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "lossless", gimp_procedure_add_boolean_argument (procedure, "lossless",
_("L_ossless"), _("L_ossless"),
_("Use lossless compression"), _("Use lossless compression"),
FALSE, FALSE,
G_PARAM_READWRITE); 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 color prof_ile"),
_("Save the image's color profile"), _("Save the image's color profile"),
gimp_export_color_profile (), gimp_export_color_profile (),
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "save-bit-depth", gimp_procedure_add_int_argument (procedure, "save-bit-depth",
_("_Bit depth"), _("_Bit depth"),
_("Bit depth of exported image"), _("Bit depth of exported image"),
8, 12, 8, 8, 12, 8,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "pixel-format", gimp_procedure_add_int_argument (procedure, "pixel-format",
_("_Pixel format"), _("_Pixel format"),
_("Format of color sub-sampling"), _("Format of color sub-sampling"),
HEIFPLUGIN_EXPORT_FORMAT_RGB, HEIFPLUGIN_EXPORT_FORMAT_YUV420, HEIFPLUGIN_EXPORT_FORMAT_RGB, HEIFPLUGIN_EXPORT_FORMAT_YUV420,
HEIFPLUGIN_EXPORT_FORMAT_YUV420, HEIFPLUGIN_EXPORT_FORMAT_YUV420,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "encoder-speed", gimp_procedure_add_int_argument (procedure, "encoder-speed",
_("Enco_der speed"), _("Enco_der speed"),
_("Tradeoff between speed and compression"), _("Tradeoff between speed and compression"),
HEIFPLUGIN_ENCODER_SPEED_SLOW, HEIFPLUGIN_ENCODER_SPEED_FASTER, HEIFPLUGIN_ENCODER_SPEED_SLOW, HEIFPLUGIN_ENCODER_SPEED_FASTER,
HEIFPLUGIN_ENCODER_SPEED_BALANCED, HEIFPLUGIN_ENCODER_SPEED_BALANCED,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "save-exif", gimp_procedure_add_boolean_argument (procedure, "save-exif",
_("Save Exi_f"), _("Save Exi_f"),
_("Toggle saving Exif data"), _("Toggle saving Exif data"),
gimp_export_exif (), gimp_export_exif (),
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "save-xmp", gimp_procedure_add_boolean_argument (procedure, "save-xmp",
_("Save _XMP"), _("Save _XMP"),
_("Toggle saving XMP data"), _("Toggle saving XMP data"),
gimp_export_xmp (), gimp_export_xmp (),
G_PARAM_READWRITE); G_PARAM_READWRITE);
} }
else if (! strcmp (name, LOAD_PROC_AV1)) else if (! strcmp (name, LOAD_PROC_AV1))
{ {
@ -361,55 +361,55 @@ heif_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_priority (GIMP_FILE_PROCEDURE (procedure), 100); 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"),
_("Quality factor (0 = worst, 100 = best)"), _("Quality factor (0 = worst, 100 = best)"),
0, 100, 50, 0, 100, 50,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "lossless", gimp_procedure_add_boolean_argument (procedure, "lossless",
_("L_ossless"), _("L_ossless"),
_("Use lossless compression"), _("Use lossless compression"),
FALSE, FALSE,
G_PARAM_READWRITE); 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 color prof_ile"),
_("Save the image's color profile"), _("Save the image's color profile"),
gimp_export_color_profile (), gimp_export_color_profile (),
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "save-bit-depth", gimp_procedure_add_int_argument (procedure, "save-bit-depth",
_("_Bit depth"), _("_Bit depth"),
_("Bit depth of exported image"), _("Bit depth of exported image"),
8, 12, 8, 8, 12, 8,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "pixel-format", gimp_procedure_add_int_argument (procedure, "pixel-format",
_("_Pixel format"), _("_Pixel format"),
_("Format of color sub-sampling"), _("Format of color sub-sampling"),
HEIFPLUGIN_EXPORT_FORMAT_RGB, HEIFPLUGIN_EXPORT_FORMAT_YUV420, HEIFPLUGIN_EXPORT_FORMAT_RGB, HEIFPLUGIN_EXPORT_FORMAT_YUV420,
HEIFPLUGIN_EXPORT_FORMAT_YUV420, HEIFPLUGIN_EXPORT_FORMAT_YUV420,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "encoder-speed", gimp_procedure_add_int_argument (procedure, "encoder-speed",
_("Enco_der speed"), _("Enco_der speed"),
_("Tradeoff between speed and compression"), _("Tradeoff between speed and compression"),
HEIFPLUGIN_ENCODER_SPEED_SLOW, HEIFPLUGIN_ENCODER_SPEED_FASTER, HEIFPLUGIN_ENCODER_SPEED_SLOW, HEIFPLUGIN_ENCODER_SPEED_FASTER,
HEIFPLUGIN_ENCODER_SPEED_BALANCED, HEIFPLUGIN_ENCODER_SPEED_BALANCED,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "save-exif", gimp_procedure_add_boolean_argument (procedure, "save-exif",
_("Save Exi_f"), _("Save Exi_f"),
_("Toggle saving Exif data"), _("Toggle saving Exif data"),
gimp_export_exif (), gimp_export_exif (),
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "save-xmp", gimp_procedure_add_boolean_argument (procedure, "save-xmp",
_("Save _XMP"), _("Save _XMP"),
_("Toggle saving XMP data"), _("Toggle saving XMP data"),
gimp_export_xmp (), gimp_export_xmp (),
G_PARAM_READWRITE); G_PARAM_READWRITE);
} }
#if LIBHEIF_HAVE_VERSION(1,17,0) #if LIBHEIF_HAVE_VERSION(1,17,0)
else if (! strcmp (name, LOAD_PROC_HEJ2)) else if (! strcmp (name, LOAD_PROC_HEJ2))

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

@ -170,83 +170,83 @@ html_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"html,htm"); "html,htm");
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "use-caption", gimp_procedure_add_boolean_aux_argument (procedure, "use-caption",
_("Use c_aption"), _("Use c_aption"),
_("Enable if you would like to have the table " _("Enable if you would like to have the table "
"captioned."), "captioned."),
FALSE, FALSE,
GIMP_PARAM_READWRITE); GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_STRING (procedure, "caption-text", gimp_procedure_add_string_aux_argument (procedure, "caption-text",
_("Capt_ion"), _("Capt_ion"),
_("The text for the table caption."), _("The text for the table caption."),
"Made with GIMP Table Magic", "Made with GIMP Table Magic",
GIMP_PARAM_READWRITE); GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_STRING (procedure, "cell-content", gimp_procedure_add_string_aux_argument (procedure, "cell-content",
_("Cell con_tent"), _("Cell con_tent"),
_("The text to go into each cell."), _("The text to go into each cell."),
"&nbsp;", "&nbsp;",
GIMP_PARAM_READWRITE); GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_STRING (procedure, "cell-width", gimp_procedure_add_string_aux_argument (procedure, "cell-width",
_("_Width"), _("_Width"),
_("The width for each table cell. " _("The width for each table cell. "
"Can be a number or a percent."), "Can be a number or a percent."),
"", "",
GIMP_PARAM_READWRITE); GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_STRING (procedure, "cell-height", gimp_procedure_add_string_aux_argument (procedure, "cell-height",
_("_Height"), _("_Height"),
_("The height for each table cell. " _("The height for each table cell. "
"Can be a number or a percent."), "Can be a number or a percent."),
"", "",
GIMP_PARAM_READWRITE); GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "full-document", gimp_procedure_add_boolean_aux_argument (procedure, "full-document",
_("_Generate full HTML document"), _("_Generate full HTML document"),
_("If enabled GTM will output a full HTML " _("If enabled GTM will output a full HTML "
"document with <HTML>, <BODY>, etc. tags " "document with <HTML>, <BODY>, etc. tags "
"instead of just the table html."), "instead of just the table html."),
TRUE, TRUE,
GIMP_PARAM_READWRITE); GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_INT (procedure, "border", gimp_procedure_add_int_aux_argument (procedure, "border",
_("_Border"), _("_Border"),
_("The number of pixels in the table border."), _("The number of pixels in the table border."),
0, 1000, 2, 0, 1000, 2,
GIMP_PARAM_READWRITE); GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "span-tags", gimp_procedure_add_boolean_aux_argument (procedure, "span-tags",
_("_Use cellspan"), _("_Use cellspan"),
_("If enabled GTM will replace any " _("If enabled GTM will replace any "
"rectangular sections of identically " "rectangular sections of identically "
"colored blocks with one large cell with " "colored blocks with one large cell with "
"ROWSPAN and COLSPAN values."), "ROWSPAN and COLSPAN values."),
FALSE, FALSE,
GIMP_PARAM_READWRITE); 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"), _("Co_mpress TD tags"),
_("Enabling this will cause GTM to " _("Enabling this will cause GTM to "
"leave no whitespace between the TD " "leave no whitespace between the TD "
"tags and the cell content. This is only " "tags and the cell content. This is only "
"necessary for pixel level positioning " "necessary for pixel level positioning "
"control."), "control."),
FALSE, FALSE,
GIMP_PARAM_READWRITE); GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_INT (procedure, "cell-padding", gimp_procedure_add_int_aux_argument (procedure, "cell-padding",
_("Cell-pa_dding"), _("Cell-pa_dding"),
_("The amount of cell padding."), _("The amount of cell padding."),
0, 1000, 4, 0, 1000, 4,
GIMP_PARAM_READWRITE); GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_INT (procedure, "cell-spacing", gimp_procedure_add_int_aux_argument (procedure, "cell-spacing",
_("Cell spaci_ng"), _("Cell spaci_ng"),
_("The amount of cell spacing."), _("The amount of cell spacing."),
0, 1000, 0, 0, 1000, 0,
GIMP_PARAM_READWRITE); GIMP_PARAM_READWRITE);
} }
return procedure; return procedure;

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -222,42 +222,42 @@ pdf_create_procedure (GimpPlugIn *plug_in,
gimp_load_procedure_set_thumbnail_loader (GIMP_LOAD_PROCEDURE (procedure), gimp_load_procedure_set_thumbnail_loader (GIMP_LOAD_PROCEDURE (procedure),
LOAD_THUMB_PROC); LOAD_THUMB_PROC);
GIMP_PROC_ARG_STRING (procedure, "password", gimp_procedure_add_string_argument (procedure, "password",
_("PDF password"), _("PDF password"),
_("The password to decrypt the encrypted PDF file"), _("The password to decrypt the encrypted PDF file"),
NULL, NULL,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "reverse-order", gimp_procedure_add_boolean_argument (procedure, "reverse-order",
_("Load in re_verse order"), _("Load in re_verse order"),
_("Load PDF pages in reverse order"), _("Load PDF pages in reverse order"),
FALSE, FALSE,
G_PARAM_READWRITE); 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 * GIMP_TYPE_PAGE_SELECTOR_TARGET but it won't work right now (see FIXME
* comment in libgimp/gimpgpparams-body.c:116). * comment in libgimp/gimpgpparams-body.c:116).
GIMP_PROC_ARG_ENUM (procedure, "target", gimp_procedure_add_enum_argument (procedure, "target",
_("Open pages as"), _("Open pages as"),
_("Number of pages to load (0 for all)"), _("Number of pages to load (0 for all)"),
GIMP_TYPE_PAGE_SELECTOR_TARGET, GIMP_TYPE_PAGE_SELECTOR_TARGET,
GIMP_PAGE_SELECTOR_TARGET_LAYERS, GIMP_PAGE_SELECTOR_TARGET_LAYERS,
G_PARAM_READWRITE); G_PARAM_READWRITE);
*/ */
GIMP_PROC_AUX_ARG_INT (procedure, "target", gimp_procedure_add_int_aux_argument (procedure, "target",
_("Open pages as"), _("Open pages as"),
_("Number of pages to load (0 for all)"), _("Number of pages to load (0 for all)"),
GIMP_PAGE_SELECTOR_TARGET_LAYERS, GIMP_PAGE_SELECTOR_TARGET_IMAGES, GIMP_PAGE_SELECTOR_TARGET_LAYERS, GIMP_PAGE_SELECTOR_TARGET_IMAGES,
GIMP_PAGE_SELECTOR_TARGET_LAYERS, GIMP_PAGE_SELECTOR_TARGET_LAYERS,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "n-pages", gimp_procedure_add_int_argument (procedure, "n-pages",
_("N pages"), _("N pages"),
_("Number of pages to load (0 for all)"), _("Number of pages to load (0 for all)"),
0, G_MAXINT, 0, 0, G_MAXINT, 0,
G_PARAM_READWRITE); G_PARAM_READWRITE);
/* FIXME: shouldn't the whole selector be considered as one argument /* FIXME: shouldn't the whole selector be considered as one argument
* containing properties "target", "n-pages" and "pages" as a single * containing properties "target", "n-pages" and "pages" as a single
@ -266,22 +266,22 @@ pdf_create_procedure (GimpPlugIn *plug_in,
* some settings generally, not sure that the list of page makes sense * some settings generally, not sure that the list of page makes sense
* from one PDF document loaded to another (different) one. * 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"), _("Pages"),
_("The pages to load in the expected order"), _("The pages to load in the expected order"),
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "antialias", gimp_procedure_add_boolean_argument (procedure, "antialias",
_("Use _Anti-aliasing"), _("Use _Anti-aliasing"),
_("Render texts with anti-aliasing"), _("Render texts with anti-aliasing"),
TRUE, TRUE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "white-background", gimp_procedure_add_boolean_argument (procedure, "white-background",
_("_Fill transparent areas with white"), _("_Fill transparent areas with white"),
_("Render all pages as opaque by filling the background in white"), _("Render all pages as opaque by filling the background in white"),
TRUE, TRUE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
} }
else if (! strcmp (name, LOAD_THUMB_PROC)) else if (! strcmp (name, LOAD_THUMB_PROC))
{ {

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

@ -234,70 +234,70 @@ png_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"png"); "png");
GIMP_PROC_ARG_BOOLEAN (procedure, "interlaced", gimp_procedure_add_boolean_argument (procedure, "interlaced",
_("_Interlacing (Adam7)"), _("_Interlacing (Adam7)"),
_("Use Adam7 interlacing"), _("Use Adam7 interlacing"),
FALSE, FALSE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "compression", gimp_procedure_add_int_argument (procedure, "compression",
_("Co_mpression level"), _("Co_mpression level"),
_("Deflate Compression factor (0..9)"), _("Deflate Compression factor (0..9)"),
0, 9, 9, 0, 9, 9,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "bkgd", gimp_procedure_add_boolean_argument (procedure, "bkgd",
_("Save _background color"), _("Save _background color"),
_("Write bKGD chunk (PNG metadata)"), _("Write bKGD chunk (PNG metadata)"),
TRUE, TRUE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "offs", gimp_procedure_add_boolean_argument (procedure, "offs",
_("Save layer o_ffset"), _("Save layer o_ffset"),
_("Write oFFs chunk (PNG metadata)"), _("Write oFFs chunk (PNG metadata)"),
FALSE, FALSE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "phys", gimp_procedure_add_boolean_argument (procedure, "phys",
_("Save resol_ution"), _("Save resol_ution"),
_("Write pHYs chunk (PNG metadata)"), _("Write pHYs chunk (PNG metadata)"),
TRUE, TRUE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "time", gimp_procedure_add_boolean_argument (procedure, "time",
_("Save creation _time"), _("Save creation _time"),
_("Write tIME chunk (PNG metadata)"), _("Write tIME chunk (PNG metadata)"),
TRUE, TRUE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "save-transparent", gimp_procedure_add_boolean_argument (procedure, "save-transparent",
_("Save color _values from transparent pixels"), _("Save color _values from transparent pixels"),
_("Preserve color of completely transparent pixels"), _("Preserve color of completely transparent pixels"),
FALSE, FALSE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "optimize-palette", gimp_procedure_add_boolean_argument (procedure, "optimize-palette",
_("_Optimize for smallest possible palette size"), _("_Optimize for smallest possible palette size"),
_("When checked, save as 1, 2, 4, or 8-bit depending" _("When checked, save as 1, 2, 4, or 8-bit depending"
" on number of colors used. When unchecked, always" " on number of colors used. When unchecked, always"
" save as 8-bit"), " save as 8-bit"),
FALSE, FALSE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_CHOICE (procedure, "format", gimp_procedure_add_choice_argument (procedure, "format",
_("_Pixel format"), _("_Pixel format"),
_("PNG export format"), _("PNG export format"),
gimp_choice_new_with_values ("auto", PNG_FORMAT_AUTO, _("Automatic"), NULL, gimp_choice_new_with_values ("auto", PNG_FORMAT_AUTO, _("Automatic"), NULL,
"rgb8", PNG_FORMAT_RGB8, _("8 bpc RGB"), NULL, "rgb8", PNG_FORMAT_RGB8, _("8 bpc RGB"), NULL,
"gray8", PNG_FORMAT_GRAY8, _("8 bpc GRAY"), NULL, "gray8", PNG_FORMAT_GRAY8, _("8 bpc GRAY"), NULL,
"rgba8", PNG_FORMAT_RGBA8, _("8 bpc RGBA"), NULL, "rgba8", PNG_FORMAT_RGBA8, _("8 bpc RGBA"), NULL,
"graya8", PNG_FORMAT_GRAYA8, _("8 bpc GRAYA"), NULL, "graya8", PNG_FORMAT_GRAYA8, _("8 bpc GRAYA"), NULL,
"rgb16", PNG_FORMAT_RGB16, _("16 bpc RGB"), NULL, "rgb16", PNG_FORMAT_RGB16, _("16 bpc RGB"), NULL,
"gray16", PNG_FORMAT_GRAY16, _("16 bpc GRAY"), NULL, "gray16", PNG_FORMAT_GRAY16, _("16 bpc GRAY"), NULL,
"rgba16", PNG_FORMAT_RGBA16, _("16 bpc RGBA"), NULL, "rgba16", PNG_FORMAT_RGBA16, _("16 bpc RGBA"), NULL,
"graya16", PNG_FORMAT_GRAYA16, _("16 bpc GRAYA"), NULL, "graya16", PNG_FORMAT_GRAYA16, _("16 bpc GRAYA"), NULL,
NULL), NULL),
"auto", G_PARAM_READWRITE); "auto", G_PARAM_READWRITE);
gimp_export_procedure_set_support_exif (GIMP_EXPORT_PROCEDURE (procedure), TRUE); gimp_export_procedure_set_support_exif (GIMP_EXPORT_PROCEDURE (procedure), TRUE);
gimp_export_procedure_set_support_iptc (GIMP_EXPORT_PROCEDURE (procedure), TRUE); gimp_export_procedure_set_support_iptc (GIMP_EXPORT_PROCEDURE (procedure), TRUE);

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

@ -367,11 +367,11 @@ pnm_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"pnm"); "pnm");
GIMP_PROC_ARG_INT (procedure, "raw", gimp_procedure_add_int_argument (procedure, "raw",
_("Data formatting"), _("Data formatting"),
_("TRUE for raw output, FALSE for ascii output"), _("TRUE for raw output, FALSE for ascii output"),
0, 1, 1, 0, 1, 1,
G_PARAM_READWRITE); G_PARAM_READWRITE);
} }
else if (! strcmp (name, PBM_EXPORT_PROC)) else if (! strcmp (name, PBM_EXPORT_PROC))
{ {
@ -403,11 +403,11 @@ pnm_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"pbm"); "pbm");
GIMP_PROC_ARG_INT (procedure, "raw", gimp_procedure_add_int_argument (procedure, "raw",
_("Data formatting"), _("Data formatting"),
_("TRUE for raw output, FALSE for ascii output"), _("TRUE for raw output, FALSE for ascii output"),
0, 1, 1, 0, 1, 1,
G_PARAM_READWRITE); G_PARAM_READWRITE);
} }
else if (! strcmp (name, PGM_EXPORT_PROC)) else if (! strcmp (name, PGM_EXPORT_PROC))
{ {
@ -439,11 +439,11 @@ pnm_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"pgm"); "pgm");
GIMP_PROC_ARG_INT (procedure, "raw", gimp_procedure_add_int_argument (procedure, "raw",
_("Data formatting"), _("Data formatting"),
_("TRUE for raw output, FALSE for ascii output"), _("TRUE for raw output, FALSE for ascii output"),
0, 1, 1, 0, 1, 1,
G_PARAM_READWRITE); G_PARAM_READWRITE);
} }
else if (! strcmp (name, PPM_EXPORT_PROC)) else if (! strcmp (name, PPM_EXPORT_PROC))
{ {
@ -475,11 +475,11 @@ pnm_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"ppm"); "ppm");
GIMP_PROC_ARG_INT (procedure, "raw", gimp_procedure_add_int_argument (procedure, "raw",
"Data formatting", "Data formatting",
_("TRUE for raw output, FALSE for ascii output"), _("TRUE for raw output, FALSE for ascii output"),
0, 1, 1, 0, 1, 1,
G_PARAM_READWRITE); G_PARAM_READWRITE);
} }
else if (! strcmp (name, PAM_EXPORT_PROC)) else if (! strcmp (name, PAM_EXPORT_PROC))
{ {

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

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

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

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

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

@ -349,88 +349,88 @@ raw_create_procedure (GimpPlugIn *plug_in,
/* Properties for image data. */ /* Properties for image data. */
GIMP_PROC_ARG_INT (procedure, "width", gimp_procedure_add_int_argument (procedure, "width",
_("_Width"), _("_Width"),
_("Image width in number of pixels"), _("Image width in number of pixels"),
1, GIMP_MAX_IMAGE_SIZE, PREVIEW_SIZE, 1, GIMP_MAX_IMAGE_SIZE, PREVIEW_SIZE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "height", gimp_procedure_add_int_argument (procedure, "height",
_("_Height"), _("_Height"),
_("Image height in number of pixels"), _("Image height in number of pixels"),
1, GIMP_MAX_IMAGE_SIZE, PREVIEW_SIZE, 1, GIMP_MAX_IMAGE_SIZE, PREVIEW_SIZE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "offset", gimp_procedure_add_int_argument (procedure, "offset",
_("O_ffset"), _("O_ffset"),
_("Offset to beginning of image in raw data"), _("Offset to beginning of image in raw data"),
0, GIMP_MAX_IMAGE_SIZE, 0, 0, GIMP_MAX_IMAGE_SIZE, 0,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "pixel-format", gimp_procedure_add_choice_argument (procedure, "pixel-format",
_("Pi_xel format"), _("Pi_xel format"),
_("The layout of pixel data, such as components and their order"), _("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, gimp_choice_new_with_values ("rgb-8bpp", RAW_RGB_8BPP, _("RGB 8-bit"), NULL,
"rgb-16bpp", RAW_RGB_16BPP, _("RGB 16-bit"), NULL, "rgb-16bpp", RAW_RGB_16BPP, _("RGB 16-bit"), NULL,
"rgb-32bpp", RAW_RGB_32BPP, _("RGB 32-bit"), NULL, "rgb-32bpp", RAW_RGB_32BPP, _("RGB 32-bit"), NULL,
"rgba-8bpp", RAW_RGBA_8BPP, _("RGBA 8-bit"), NULL, "rgba-8bpp", RAW_RGBA_8BPP, _("RGBA 8-bit"), NULL,
"rgba-16bpp", RAW_RGBA_16BPP, _("RGBA 16-bit"), NULL, "rgba-16bpp", RAW_RGBA_16BPP, _("RGBA 16-bit"), NULL,
"rgba-32bpp", RAW_RGBA_32BPP, _("RGBA 32-bit"), NULL, "rgba-32bpp", RAW_RGBA_32BPP, _("RGBA 32-bit"), NULL,
"rgb565", RAW_RGB565, _("RGB565"), NULL, "rgb565", RAW_RGB565, _("RGB565"), NULL,
"bgr565", RAW_BGR565, _("BGR565"), NULL, "bgr565", RAW_BGR565, _("BGR565"), NULL,
"grayscale-1bpp", RAW_GRAY_1BPP, _("B&W 1 bit"), NULL, "grayscale-1bpp", RAW_GRAY_1BPP, _("B&W 1 bit"), NULL,
"grayscale-2bpp", RAW_GRAY_2BPP, _("Grayscale 2-bit"), NULL, "grayscale-2bpp", RAW_GRAY_2BPP, _("Grayscale 2-bit"), NULL,
"grayscale-4bpp", RAW_GRAY_4BPP, _("Grayscale 4-bit"), NULL, "grayscale-4bpp", RAW_GRAY_4BPP, _("Grayscale 4-bit"), NULL,
"grayscale-8bpp", RAW_GRAY_8BPP, _("Grayscale 8-bit"), NULL, "grayscale-8bpp", RAW_GRAY_8BPP, _("Grayscale 8-bit"), NULL,
"grayscale-16bpp", RAW_GRAY_16BPP, _("Grayscale 16-bit"), NULL, "grayscale-16bpp", RAW_GRAY_16BPP, _("Grayscale 16-bit"), NULL,
"grayscale-32bpp", RAW_GRAY_32BPP, _("Grayscale 32-bit"), NULL, "grayscale-32bpp", RAW_GRAY_32BPP, _("Grayscale 32-bit"), NULL,
"grayscale-alpha-8bpp", RAW_GRAYA_8BPP, _("Grayscale-Alpha 8-bit"), NULL, "grayscale-alpha-8bpp", RAW_GRAYA_8BPP, _("Grayscale-Alpha 8-bit"), NULL,
"grayscale-alpha-16bpp", RAW_GRAYA_16BPP, _("Grayscale-Alpha 16-bit"), NULL, "grayscale-alpha-16bpp", RAW_GRAYA_16BPP, _("Grayscale-Alpha 16-bit"), NULL,
"grayscale-alpha-32bpp", RAW_GRAYA_32BPP, _("Grayscale-Alpha 32-bit"), NULL, "grayscale-alpha-32bpp", RAW_GRAYA_32BPP, _("Grayscale-Alpha 32-bit"), NULL,
"indexed", RAW_INDEXED, _("Indexed"), NULL, "indexed", RAW_INDEXED, _("Indexed"), NULL,
"indexed-alpha", RAW_INDEXEDA, _("Indexed Alpha"), NULL, "indexed-alpha", RAW_INDEXEDA, _("Indexed Alpha"), NULL,
NULL), NULL),
"rgb-8bpp", G_PARAM_READWRITE); "rgb-8bpp", G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "data-type", gimp_procedure_add_choice_argument (procedure, "data-type",
_("_Data type"), _("_Data type"),
_("Data type used to represent pixel values"), _("Data type used to represent pixel values"),
gimp_choice_new_with_values ("unsigned", RAW_ENCODING_UNSIGNED, _("Unsigned Integer"), NULL, gimp_choice_new_with_values ("unsigned", RAW_ENCODING_UNSIGNED, _("Unsigned Integer"), NULL,
"signed", RAW_ENCODING_SIGNED, _("Signed Integer"), NULL, "signed", RAW_ENCODING_SIGNED, _("Signed Integer"), NULL,
"float", RAW_ENCODING_FLOAT, _("Floating Point"), NULL, "float", RAW_ENCODING_FLOAT, _("Floating Point"), NULL,
NULL), NULL),
"unsigned", G_PARAM_READWRITE); "unsigned", G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "endianness", gimp_procedure_add_choice_argument (procedure, "endianness",
_("_Endianness"), _("_Endianness"),
_("Order of sequences of bytes"), _("Order of sequences of bytes"),
gimp_choice_new_with_values ("little-endian", RAW_LITTLE_ENDIAN, _("Little Endian"), NULL, gimp_choice_new_with_values ("little-endian", RAW_LITTLE_ENDIAN, _("Little Endian"), NULL,
"big-endian", RAW_BIG_ENDIAN, _("Big Endian"), NULL, "big-endian", RAW_BIG_ENDIAN, _("Big Endian"), NULL,
NULL), NULL),
"little-endian", G_PARAM_READWRITE); "little-endian", G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "planar-configuration", gimp_procedure_add_choice_argument (procedure, "planar-configuration",
_("Planar confi_guration"), _("Planar confi_guration"),
_("How color pixel data are stored"), _("How color pixel data are stored"),
gimp_choice_new_with_values ("contiguous", RAW_PLANAR_CONTIGUOUS, _("Contiguous"), NULL, gimp_choice_new_with_values ("contiguous", RAW_PLANAR_CONTIGUOUS, _("Contiguous"), NULL,
"planar", RAW_PLANAR_SEPARATE, _("Planar"), NULL, "planar", RAW_PLANAR_SEPARATE, _("Planar"), NULL,
NULL), NULL),
"contiguous", G_PARAM_READWRITE); "contiguous", G_PARAM_READWRITE);
/* Properties for palette data. */ /* Properties for palette data. */
GIMP_PROC_ARG_INT (procedure, "palette-offset", gimp_procedure_add_int_argument (procedure, "palette-offset",
_("Palette Offse_t"), _("Palette Offse_t"),
_("Offset to beginning of data in the palette file"), _("Offset to beginning of data in the palette file"),
0, GIMP_MAX_IMAGE_SIZE, 0, 0, GIMP_MAX_IMAGE_SIZE, 0,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "palette-type", gimp_procedure_add_choice_argument (procedure, "palette-type",
_("Palette's la_yout"), _("Palette's la_yout"),
_("The layout for the palette's color channels"), _("The layout for the palette's color channels"),
gimp_choice_new_with_values ("rgb", RAW_PALETTE_RGB, _("R, G, B (normal)"), NULL, 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, "bgr", RAW_PALETTE_BGR, _("B, G, R, X (BMP style)"), NULL,
NULL), NULL),
"rgb", G_PARAM_READWRITE); "rgb", G_PARAM_READWRITE);
GIMP_PROC_ARG_FILE (procedure, "palette-file", gimp_procedure_add_file_argument (procedure, "palette-file",
_("_Palette File"), _("_Palette File"),
_("The file containing palette data"), _("The file containing palette data"),
G_PARAM_READWRITE); G_PARAM_READWRITE);
} }
else if (! strcmp (name, LOAD_HGT_PROC)) else if (! strcmp (name, LOAD_HGT_PROC))
{ {
@ -462,34 +462,34 @@ raw_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"hgt"); "hgt");
GIMP_PROC_ARG_CHOICE (procedure, "sample-spacing", gimp_procedure_add_choice_argument (procedure, "sample-spacing",
_("Sa_mple spacing"), _("Sa_mple spacing"),
_("The sample spacing of the data."), _("The sample spacing of the data."),
gimp_choice_new_with_values ("auto-detect", HGT_SRTM_AUTO_DETECT, _("Auto-Detect"), NULL, gimp_choice_new_with_values ("auto-detect", HGT_SRTM_AUTO_DETECT, _("Auto-Detect"), NULL,
"srtm-1", HGT_SRTM_1, _("SRTM-1 (1 arc second)"), NULL, "srtm-1", HGT_SRTM_1, _("SRTM-1 (1 arc second)"), NULL,
"srtm-3", HGT_SRTM_3, _("SRTM-3 (3 arc seconds)"), NULL, "srtm-3", HGT_SRTM_3, _("SRTM-3 (3 arc seconds)"), NULL,
NULL), NULL),
"auto-detect", G_PARAM_READWRITE); "auto-detect", G_PARAM_READWRITE);
/* Properties for palette data. */ /* Properties for palette data. */
GIMP_PROC_ARG_INT (procedure, "palette-offset", gimp_procedure_add_int_argument (procedure, "palette-offset",
_("Palette Offse_t"), _("Palette Offse_t"),
_("Offset to beginning of data in the palette file"), _("Offset to beginning of data in the palette file"),
0, GIMP_MAX_IMAGE_SIZE, 0, 0, GIMP_MAX_IMAGE_SIZE, 0,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "palette-type", gimp_procedure_add_choice_argument (procedure, "palette-type",
_("Palette's la_yout"), _("Palette's la_yout"),
_("The layout for the palette's color channels"), _("The layout for the palette's color channels"),
gimp_choice_new_with_values ("rgb", RAW_PALETTE_RGB, _("R, G, B (normal)"), NULL, 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, "bgr", RAW_PALETTE_BGR, _("B, G, R, X (BMP style)"), NULL,
NULL), NULL),
"rgb", G_PARAM_READWRITE); "rgb", G_PARAM_READWRITE);
GIMP_PROC_ARG_FILE (procedure, "palette-file", gimp_procedure_add_file_argument (procedure, "palette-file",
_("_Palette File"), _("_Palette File"),
_("The file containing palette data"), _("The file containing palette data"),
G_PARAM_READWRITE); G_PARAM_READWRITE);
} }
else if (! strcmp (name, EXPORT_PROC)) else if (! strcmp (name, EXPORT_PROC))
{ {
@ -513,21 +513,21 @@ raw_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"data,raw"); "data,raw");
GIMP_PROC_ARG_CHOICE (procedure, "planar-configuration", gimp_procedure_add_choice_argument (procedure, "planar-configuration",
_("Planar configuration"), _("Planar configuration"),
_("How color pixel data are stored"), _("How color pixel data are stored"),
gimp_choice_new_with_values ("contiguous", RAW_PLANAR_CONTIGUOUS, _("Contiguous"), NULL, gimp_choice_new_with_values ("contiguous", RAW_PLANAR_CONTIGUOUS, _("Contiguous"), NULL,
"planar", RAW_PLANAR_SEPARATE, _("Planar"), NULL, "planar", RAW_PLANAR_SEPARATE, _("Planar"), NULL,
NULL), NULL),
"contiguous", G_PARAM_READWRITE); "contiguous", G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "palette-type", gimp_procedure_add_choice_argument (procedure, "palette-type",
_("Palette's la_yout"), _("Palette's la_yout"),
_("The layout for the palette's color channels"), _("The layout for the palette's color channels"),
gimp_choice_new_with_values ("rgb", RAW_PALETTE_RGB, _("R, G, B (normal)"), NULL, 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, "bgr", RAW_PALETTE_BGR, _("B, G, R, X (BMP style)"), NULL,
NULL), NULL),
"rgb", G_PARAM_READWRITE); "rgb", G_PARAM_READWRITE);
} }
gimp_file_procedure_set_format_name (GIMP_FILE_PROCEDURE (procedure), gimp_file_procedure_set_format_name (GIMP_FILE_PROCEDURE (procedure),

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

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

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

@ -184,14 +184,14 @@ svg_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_magics (GIMP_FILE_PROCEDURE (procedure), gimp_file_procedure_set_magics (GIMP_FILE_PROCEDURE (procedure),
"0,string,<?xml,0,string,<svg"); "0,string,<?xml,0,string,<svg");
GIMP_PROC_ARG_CHOICE (procedure, "paths", gimp_procedure_add_choice_argument (procedure, "paths",
_("_Paths"), _("_Paths"),
_("Whether and how to import paths so that they can be used with the path tool"), _("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, gimp_choice_new_with_values ("no-import", 0, _("Don't import paths"), NULL,
"import", 0, _("Import paths individually"), NULL, "import", 0, _("Import paths individually"), NULL,
"import-merged", 0, _("Merge imported paths"), NULL, "import-merged", 0, _("Merge imported paths"), NULL,
NULL), NULL),
"no-import", G_PARAM_READWRITE); "no-import", G_PARAM_READWRITE);
} }
return procedure; return procedure;

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -125,17 +125,17 @@ guillotine_create_procedure (GimpPlugIn *plug_in,
"Adam D. Moss (adam@foxbox.org)", "Adam D. Moss (adam@foxbox.org)",
"1998"); "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",
"Number of images created", "Number of images created",
0, G_MAXINT, 0, 0, G_MAXINT, 0,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_VAL_OBJECT_ARRAY (procedure, "images", gimp_procedure_add_object_array_return_value (procedure, "images",
"Output images", "Output images",
"Output images", "Output images",
GIMP_TYPE_IMAGE, GIMP_TYPE_IMAGE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
} }
return procedure; return procedure;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -127,25 +127,25 @@ wavelet_create_procedure (GimpPlugIn *plug_in,
"Miroslav Talasek <miroslav.talasek@seznam.cz>", "Miroslav Talasek <miroslav.talasek@seznam.cz>",
"19 January 2017"); "19 January 2017");
GIMP_PROC_ARG_INT (procedure, "scales", gimp_procedure_add_int_argument (procedure, "scales",
_("Scal_es"), _("Scal_es"),
_("Number of scales"), _("Number of scales"),
1, 7, 5, 1, 7, 5,
G_PARAM_READWRITE); 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 " _("Create a layer group to store the "
"_decomposition"), "_decomposition"),
_("Create a layer group to store the " _("Create a layer group to store the "
"decomposition"), "decomposition"),
TRUE, TRUE,
G_PARAM_READWRITE); 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"),
_("Add a layer mask to each scales layer"), _("Add a layer mask to each scales layer"),
FALSE, FALSE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
} }
return procedure; return procedure;

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

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

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

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

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

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

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

@ -144,17 +144,17 @@ dds_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_magics (GIMP_FILE_PROCEDURE (procedure), gimp_file_procedure_set_magics (GIMP_FILE_PROCEDURE (procedure),
"0,string,DDS"); "0,string,DDS");
GIMP_PROC_ARG_BOOLEAN (procedure, "load-mipmaps", gimp_procedure_add_boolean_argument (procedure, "load-mipmaps",
_("Load _mipmaps"), _("Load _mipmaps"),
_("Load mipmaps if present"), _("Load mipmaps if present"),
TRUE, TRUE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "flip-image", gimp_procedure_add_boolean_argument (procedure, "flip-image",
_("Flip image _vertically"), _("Flip image _vertically"),
_("Flip the image vertically on import"), _("Flip the image vertically on import"),
FALSE, FALSE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
} }
else if (! strcmp (name, EXPORT_PROC)) else if (! strcmp (name, EXPORT_PROC))
{ {
@ -183,152 +183,152 @@ dds_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"dds"); "dds");
GIMP_PROC_ARG_CHOICE (procedure, "compression-format", gimp_procedure_add_choice_argument (procedure, "compression-format",
_("Compressio_n"), _("Compressio_n"),
_("Compression format"), _("Compression format"),
gimp_choice_new_with_values ("none", DDS_COMPRESS_NONE, _("None"), NULL, gimp_choice_new_with_values ("none", DDS_COMPRESS_NONE, _("None"), NULL,
"bc1", DDS_COMPRESS_BC1, _("BC1 / DXT1"), NULL, "bc1", DDS_COMPRESS_BC1, _("BC1 / DXT1"), NULL,
"bc2", DDS_COMPRESS_BC2, _("BC2 / DXT3"), NULL, "bc2", DDS_COMPRESS_BC2, _("BC2 / DXT3"), NULL,
"bc3, ", DDS_COMPRESS_BC3, _("BC3 / DXT5"), NULL, "bc3, ", DDS_COMPRESS_BC3, _("BC3 / DXT5"), NULL,
"bc3n", DDS_COMPRESS_BC3N, _("BC3nm / DXT5nm"), NULL, "bc3n", DDS_COMPRESS_BC3N, _("BC3nm / DXT5nm"), NULL,
"bc4", DDS_COMPRESS_BC4, _("BC4 / ATI1 (3Dc+)"), NULL, "bc4", DDS_COMPRESS_BC4, _("BC4 / ATI1 (3Dc+)"), NULL,
"bc5", DDS_COMPRESS_BC5, _("BC5 / ATI2 (3Dc)"), NULL, "bc5", DDS_COMPRESS_BC5, _("BC5 / ATI2 (3Dc)"), NULL,
"rxgb", DDS_COMPRESS_RXGB, _("RXGB (DXT5)"), NULL, "rxgb", DDS_COMPRESS_RXGB, _("RXGB (DXT5)"), NULL,
"aexp", DDS_COMPRESS_AEXP, _("Alpha Exponent (DXT5)"), NULL, "aexp", DDS_COMPRESS_AEXP, _("Alpha Exponent (DXT5)"), NULL,
"ycocg", DDS_COMPRESS_YCOCG, _("YCoCg (DXT5)"), NULL, "ycocg", DDS_COMPRESS_YCOCG, _("YCoCg (DXT5)"), NULL,
"ycocgs", DDS_COMPRESS_YCOCGS, _("YCoCg scaled (DXT5)"), NULL, "ycocgs", DDS_COMPRESS_YCOCGS, _("YCoCg scaled (DXT5)"), NULL,
NULL), NULL),
"none", "none",
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "perceptual-metric", gimp_procedure_add_boolean_argument (procedure, "perceptual-metric",
_("Use percept_ual error metric"), _("Use percept_ual error metric"),
_("Use a perceptual error metric during compression"), _("Use a perceptual error metric during compression"),
FALSE, FALSE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "format", gimp_procedure_add_choice_argument (procedure, "format",
_("_Format"), _("_Format"),
_("Pixel format"), _("Pixel format"),
gimp_choice_new_with_values ("default", DDS_FORMAT_DEFAULT, _("Default"), NULL, gimp_choice_new_with_values ("default", DDS_FORMAT_DEFAULT, _("Default"), NULL,
"rgb8", DDS_FORMAT_RGB8, _("RGB8"), NULL, "rgb8", DDS_FORMAT_RGB8, _("RGB8"), NULL,
"rgba8", DDS_FORMAT_RGBA8, _("RGBA8"), NULL, "rgba8", DDS_FORMAT_RGBA8, _("RGBA8"), NULL,
"bgr8", DDS_FORMAT_BGR8, _("BGR8"), NULL, "bgr8", DDS_FORMAT_BGR8, _("BGR8"), NULL,
"abgr8, ", DDS_FORMAT_ABGR8, _("ABGR8"), NULL, "abgr8, ", DDS_FORMAT_ABGR8, _("ABGR8"), NULL,
"r5g6b5", DDS_FORMAT_R5G6B5, _("R5G6B5"), NULL, "r5g6b5", DDS_FORMAT_R5G6B5, _("R5G6B5"), NULL,
"rgba4", DDS_FORMAT_RGBA4, _("RGBA4"), NULL, "rgba4", DDS_FORMAT_RGBA4, _("RGBA4"), NULL,
"rgb5a1", DDS_FORMAT_RGB5A1, _("RGB5A1"), NULL, "rgb5a1", DDS_FORMAT_RGB5A1, _("RGB5A1"), NULL,
"rgb10a2", DDS_FORMAT_RGB10A2, _("RGB10A2"), NULL, "rgb10a2", DDS_FORMAT_RGB10A2, _("RGB10A2"), NULL,
"r3g3b2", DDS_FORMAT_R3G3B2, _("R3G3B2"), NULL, "r3g3b2", DDS_FORMAT_R3G3B2, _("R3G3B2"), NULL,
"a8", DDS_FORMAT_A8, _("A8"), NULL, "a8", DDS_FORMAT_A8, _("A8"), NULL,
"l8", DDS_FORMAT_L8, _("L8"), NULL, "l8", DDS_FORMAT_L8, _("L8"), NULL,
"l8a8", DDS_FORMAT_L8A8, _("L8A8"), NULL, "l8a8", DDS_FORMAT_L8A8, _("L8A8"), NULL,
"aexp", DDS_FORMAT_AEXP, _("AEXP"), NULL, "aexp", DDS_FORMAT_AEXP, _("AEXP"), NULL,
"ycocg", DDS_FORMAT_YCOCG, _("YCOCG"), NULL, "ycocg", DDS_FORMAT_YCOCG, _("YCOCG"), NULL,
NULL), NULL),
"default", "default",
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "save-type", gimp_procedure_add_choice_argument (procedure, "save-type",
_("Sav_e type"), _("Sav_e type"),
_("How to save the image"), _("How to save the image"),
gimp_choice_new_with_values ("layer", DDS_SAVE_SELECTED_LAYER, _("Selected layer"), NULL, gimp_choice_new_with_values ("layer", DDS_SAVE_SELECTED_LAYER, _("Selected layer"), NULL,
"canvas", DDS_SAVE_VISIBLE_LAYERS, _("All visible layers"), NULL, "canvas", DDS_SAVE_VISIBLE_LAYERS, _("All visible layers"), NULL,
"cube", DDS_SAVE_CUBEMAP, _("As cube map"), NULL, "cube", DDS_SAVE_CUBEMAP, _("As cube map"), NULL,
"volume", DDS_SAVE_VOLUMEMAP, _("As volume map"), NULL, "volume", DDS_SAVE_VOLUMEMAP, _("As volume map"), NULL,
"array", DDS_SAVE_ARRAY, _("As texture array"), NULL, "array", DDS_SAVE_ARRAY, _("As texture array"), NULL,
NULL), NULL),
"layer", "layer",
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "flip-image", gimp_procedure_add_boolean_argument (procedure, "flip-image",
_("Flip image _vertically on export"), _("Flip image _vertically on export"),
_("Flip the image vertically on export"), _("Flip the image vertically on export"),
FALSE, FALSE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "transparent-color", gimp_procedure_add_boolean_argument (procedure, "transparent-color",
_("Set _transparent color"), _("Set _transparent color"),
_("Make an indexed color transparent"), _("Make an indexed color transparent"),
FALSE, FALSE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "transparent-index", gimp_procedure_add_int_argument (procedure, "transparent-index",
_("Transparent inde_x"), _("Transparent inde_x"),
_("Index of transparent color or -1 to disable " _("Index of transparent color or -1 to disable "
"(for indexed images only)."), "(for indexed images only)."),
0, 255, 0, 0, 255, 0,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "mipmaps", gimp_procedure_add_choice_argument (procedure, "mipmaps",
_("_Mipmaps"), _("_Mipmaps"),
_("How to handle mipmaps"), _("How to handle mipmaps"),
gimp_choice_new_with_values ("none", DDS_MIPMAP_NONE, _("No mipmaps"), NULL, gimp_choice_new_with_values ("none", DDS_MIPMAP_NONE, _("No mipmaps"), NULL,
"generate", DDS_MIPMAP_GENERATE, _("Generate mipmaps"), NULL, "generate", DDS_MIPMAP_GENERATE, _("Generate mipmaps"), NULL,
"existing", DDS_MIPMAP_EXISTING, _("Use existing mipmaps"), NULL, "existing", DDS_MIPMAP_EXISTING, _("Use existing mipmaps"), NULL,
NULL), NULL),
"none", "none",
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "mipmap-filter", gimp_procedure_add_choice_argument (procedure, "mipmap-filter",
_("F_ilter"), _("F_ilter"),
_("Filtering to use when generating mipmaps"), _("Filtering to use when generating mipmaps"),
gimp_choice_new_with_values ("default", DDS_MIPMAP_FILTER_DEFAULT, _("Default"), NULL, gimp_choice_new_with_values ("default", DDS_MIPMAP_FILTER_DEFAULT, _("Default"), NULL,
"nearest", DDS_MIPMAP_FILTER_NEAREST, _("Nearest"), NULL, "nearest", DDS_MIPMAP_FILTER_NEAREST, _("Nearest"), NULL,
"box", DDS_MIPMAP_FILTER_BOX, _("Box"), NULL, "box", DDS_MIPMAP_FILTER_BOX, _("Box"), NULL,
"triangle", DDS_MIPMAP_FILTER_TRIANGLE, _("Triangle"), NULL, "triangle", DDS_MIPMAP_FILTER_TRIANGLE, _("Triangle"), NULL,
"quadratic", DDS_MIPMAP_FILTER_QUADRATIC, _("Quadratic"), NULL, "quadratic", DDS_MIPMAP_FILTER_QUADRATIC, _("Quadratic"), NULL,
"bspline", DDS_MIPMAP_FILTER_BSPLINE, _("B-Spline"), NULL, "bspline", DDS_MIPMAP_FILTER_BSPLINE, _("B-Spline"), NULL,
"mitchell", DDS_MIPMAP_FILTER_MITCHELL, _("Mitchell"), NULL, "mitchell", DDS_MIPMAP_FILTER_MITCHELL, _("Mitchell"), NULL,
"catrom", DDS_MIPMAP_FILTER_CATROM, _("Catmull-Rom"), NULL, "catrom", DDS_MIPMAP_FILTER_CATROM, _("Catmull-Rom"), NULL,
"lanczos", DDS_MIPMAP_FILTER_LANCZOS, _("Lanczos"), NULL, "lanczos", DDS_MIPMAP_FILTER_LANCZOS, _("Lanczos"), NULL,
"kaiser", DDS_MIPMAP_FILTER_KAISER, _("Kaiser"), NULL, "kaiser", DDS_MIPMAP_FILTER_KAISER, _("Kaiser"), NULL,
NULL), NULL),
"default", "default",
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "mipmap-wrap", gimp_procedure_add_choice_argument (procedure, "mipmap-wrap",
_("_Wrap mode"), _("_Wrap mode"),
_("Wrap mode to use when generating mipmaps"), _("Wrap mode to use when generating mipmaps"),
gimp_choice_new_with_values ("default", DDS_MIPMAP_WRAP_DEFAULT, _("Default"), NULL, gimp_choice_new_with_values ("default", DDS_MIPMAP_WRAP_DEFAULT, _("Default"), NULL,
"mirror", DDS_MIPMAP_WRAP_MIRROR, _("Mirror"), NULL, "mirror", DDS_MIPMAP_WRAP_MIRROR, _("Mirror"), NULL,
"repeat", DDS_MIPMAP_WRAP_REPEAT, _("Repeat"), NULL, "repeat", DDS_MIPMAP_WRAP_REPEAT, _("Repeat"), NULL,
"clamp", DDS_MIPMAP_WRAP_CLAMP, _("Clamp"), NULL, "clamp", DDS_MIPMAP_WRAP_CLAMP, _("Clamp"), NULL,
NULL), NULL),
"default", "default",
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "gamma-correct", gimp_procedure_add_boolean_argument (procedure, "gamma-correct",
_("Appl_y gamma correction"), _("Appl_y gamma correction"),
_("Use gamma correct mipmap filtering"), _("Use gamma correct mipmap filtering"),
FALSE, FALSE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "srgb", gimp_procedure_add_boolean_argument (procedure, "srgb",
_("Use sRG_B colorspace"), _("Use sRG_B colorspace"),
_("Use sRGB colorspace for gamma correction"), _("Use sRGB colorspace for gamma correction"),
FALSE, FALSE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "gamma", gimp_procedure_add_double_argument (procedure, "gamma",
_("_Gamma"), _("_Gamma"),
_("Gamma value to use for gamma correction (e.g. 2.2)"), _("Gamma value to use for gamma correction (e.g. 2.2)"),
0.0, 10.0, 0.0, 0.0, 10.0, 0.0,
G_PARAM_READWRITE); 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 al_pha test coverage"),
_("Preserve alpha test coverage for alpha " _("Preserve alpha test coverage for alpha "
"channel maps"), "channel maps"),
FALSE, FALSE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "alpha-test-threshold", gimp_procedure_add_double_argument (procedure, "alpha-test-threshold",
_("Alp_ha test threshold"), _("Alp_ha test threshold"),
_("Alpha test threshold value for which alpha test " _("Alpha test threshold value for which alpha test "
"coverage should be preserved"), "coverage should be preserved"),
0.0, 1.0, 0.5, 0.0, 1.0, 0.5,
G_PARAM_READWRITE); G_PARAM_READWRITE);
} }
return procedure; return procedure;

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

@ -195,17 +195,17 @@ fits_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_magics (GIMP_FILE_PROCEDURE (procedure), gimp_file_procedure_set_magics (GIMP_FILE_PROCEDURE (procedure),
"0,string,SIMPLE"); "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"),
_("Replacement for undefined pixels"), _("Replacement for undefined pixels"),
0, 255, 0, 0, 255, 0,
G_PARAM_READWRITE); 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"), _("Pixel value scaling"),
_("Use DATAMIN/DATAMAX-scaling if possible"), _("Use DATAMIN/DATAMAX-scaling if possible"),
0, 1, 0, 0, 1, 0,
G_PARAM_READWRITE); G_PARAM_READWRITE);
} }
else if (! strcmp (name, EXPORT_PROC)) else if (! strcmp (name, EXPORT_PROC))
{ {

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

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

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

@ -333,25 +333,25 @@ ico_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"cur"); "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",
"Number of hot spot's X coordinates", "Number of hot spot's X coordinates",
0, G_MAXINT, 0, 0, G_MAXINT, 0,
G_PARAM_READWRITE); 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", "Hot spot X",
"X coordinates of hot spot (one per layer)", "X coordinates of hot spot (one per layer)",
G_PARAM_READWRITE); 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",
"Number of hot spot's Y coordinates", "Number of hot spot's Y coordinates",
0, G_MAXINT, 0, 0, G_MAXINT, 0,
G_PARAM_READWRITE); 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", "Hot spot Y",
"Y coordinates of hot spot (one per layer)", "Y coordinates of hot spot (one per layer)",
G_PARAM_READWRITE); G_PARAM_READWRITE);
} }
else if (! strcmp (name, EXPORT_ANI_PROC)) else if (! strcmp (name, EXPORT_ANI_PROC))
{ {
@ -380,44 +380,44 @@ ico_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"ani"); "ani");
GIMP_PROC_ARG_STRING (procedure, "cursor-name", gimp_procedure_add_string_argument (procedure, "cursor-name",
"Cursor Name", "Cursor Name",
_("Cursor Name (Optional)"), _("Cursor Name (Optional)"),
NULL, NULL,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "author-name", gimp_procedure_add_string_argument (procedure, "author-name",
"Cursor Author", "Cursor Author",
_("Cursor Author (Optional)"), _("Cursor Author (Optional)"),
NULL, NULL,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "default-delay", gimp_procedure_add_int_argument (procedure, "default-delay",
"Default delay", "Default delay",
"Default delay between frames " "Default delay between frames "
"in jiffies (1/60 of a second)", "in jiffies (1/60 of a second)",
0, G_MAXINT, 8, 0, G_MAXINT, 8,
G_PARAM_READWRITE); 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",
"Number of hot spot's X coordinates", "Number of hot spot's X coordinates",
0, G_MAXINT, 0, 0, G_MAXINT, 0,
G_PARAM_READWRITE); 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", "Hot spot X",
"X coordinates of hot spot (one per layer)", "X coordinates of hot spot (one per layer)",
G_PARAM_READWRITE); 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",
"Number of hot spot's Y coordinates", "Number of hot spot's Y coordinates",
0, G_MAXINT, 0, 0, G_MAXINT, 0,
G_PARAM_READWRITE); 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", "Hot spot Y",
"Y coordinates of hot spot (one per layer)", "Y coordinates of hot spot (one per layer)",
G_PARAM_READWRITE); G_PARAM_READWRITE);
} }
return procedure; return procedure;

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

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

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

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

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

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

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

@ -183,15 +183,15 @@ tiff_create_procedure (GimpPlugIn *plug_in,
* them AUX for now and leave it as further exercise to decide whether it * them AUX for now and leave it as further exercise to decide whether it
* should be part of the PDB API. * 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, "Open _pages as", NULL,
GIMP_TYPE_PAGE_SELECTOR_TARGET, GIMP_TYPE_PAGE_SELECTOR_TARGET,
GIMP_PAGE_SELECTOR_TARGET_LAYERS, GIMP_PAGE_SELECTOR_TARGET_LAYERS,
G_PARAM_READWRITE); 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"), _("_Keep empty space around imported layers"),
NULL, TRUE, GIMP_PARAM_READWRITE); NULL, TRUE, GIMP_PARAM_READWRITE);
} }
else if (! strcmp (name, EXPORT_PROC)) else if (! strcmp (name, EXPORT_PROC))
{ {
@ -223,56 +223,56 @@ tiff_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"tif,tiff"); "tif,tiff");
GIMP_PROC_ARG_BOOLEAN (procedure, "bigtiff", gimp_procedure_add_boolean_argument (procedure, "bigtiff",
_("Export in _BigTIFF variant file format"), _("Export in _BigTIFF variant file format"),
_("The BigTIFF variant file format uses 64-bit offsets, " _("The BigTIFF variant file format uses 64-bit offsets, "
"hence supporting over 4GiB files and bigger"), "hence supporting over 4GiB files and bigger"),
FALSE, FALSE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "compression", gimp_procedure_add_choice_argument (procedure, "compression",
_("Co_mpression"), _("Co_mpression"),
_("Compression type"), _("Compression type"),
gimp_choice_new_with_values ("none", GIMP_COMPRESSION_NONE, _("None"), NULL, gimp_choice_new_with_values ("none", GIMP_COMPRESSION_NONE, _("None"), NULL,
"lzw", GIMP_COMPRESSION_LZW, _("LZW"), NULL, "lzw", GIMP_COMPRESSION_LZW, _("LZW"), NULL,
"packbits", GIMP_COMPRESSION_PACKBITS, _("Pack Bits"), NULL, "packbits", GIMP_COMPRESSION_PACKBITS, _("Pack Bits"), NULL,
"adobe_deflate", GIMP_COMPRESSION_ADOBE_DEFLATE, _("Deflate"), NULL, "adobe_deflate", GIMP_COMPRESSION_ADOBE_DEFLATE, _("Deflate"), NULL,
"jpeg", GIMP_COMPRESSION_JPEG, _("JPEG"), NULL, "jpeg", GIMP_COMPRESSION_JPEG, _("JPEG"), NULL,
"ccittfax3", GIMP_COMPRESSION_CCITTFAX3, _("CCITT Group 3 fax"), NULL, "ccittfax3", GIMP_COMPRESSION_CCITTFAX3, _("CCITT Group 3 fax"), NULL,
"ccittfax4", GIMP_COMPRESSION_CCITTFAX4, _("CCITT Group 4 fax"), NULL, "ccittfax4", GIMP_COMPRESSION_CCITTFAX4, _("CCITT Group 4 fax"), NULL,
NULL), NULL),
"none", G_PARAM_READWRITE); "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"), _("Save color _values from transparent pixels"),
_("Keep the color data masked by an alpha channel " _("Keep the color data masked by an alpha channel "
"intact (do not store premultiplied components)"), "intact (do not store premultiplied components)"),
TRUE, TRUE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "cmyk", gimp_procedure_add_boolean_argument (procedure, "cmyk",
_("Export as CMY_K"), _("Export as CMY_K"),
_("Create a CMYK TIFF image using the soft-proofing color profile"), _("Create a CMYK TIFF image using the soft-proofing color profile"),
FALSE, FALSE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-layers", gimp_procedure_add_boolean_aux_argument (procedure, "save-layers",
_("Save La_yers"), _("Save La_yers"),
_("Save Layers"), _("Save Layers"),
TRUE, TRUE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "crop-layers", gimp_procedure_add_boolean_aux_argument (procedure, "crop-layers",
_("Crop L_ayers"), _("Crop L_ayers"),
_("Crop Layers"), _("Crop Layers"),
TRUE, TRUE,
G_PARAM_READWRITE); 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"),
_("Save GeoTIFF data"), _("Save GeoTIFF data"),
TRUE, TRUE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
gimp_export_procedure_set_support_exif (GIMP_EXPORT_PROCEDURE (procedure), TRUE); gimp_export_procedure_set_support_exif (GIMP_EXPORT_PROCEDURE (procedure), TRUE);
gimp_export_procedure_set_support_iptc (GIMP_EXPORT_PROCEDURE (procedure), TRUE); gimp_export_procedure_set_support_iptc (GIMP_EXPORT_PROCEDURE (procedure), TRUE);

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

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

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

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

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

@ -253,148 +253,148 @@ explorer_create_procedure (GimpPlugIn *plug_in,
"www.multimania.com/cotting)", "www.multimania.com/cotting)",
"December, 1998"); "December, 1998");
GIMP_PROC_ARG_CHOICE (procedure, "fractal-type", gimp_procedure_add_choice_argument (procedure, "fractal-type",
_("Fr_actal Type"), _("Fr_actal Type"),
_("Type of Fractal Pattern"), _("Type of Fractal Pattern"),
gimp_choice_new_with_values ("mandelbrot", 0, _("Mandelbrot"), NULL, gimp_choice_new_with_values ("mandelbrot", 0, _("Mandelbrot"), NULL,
"julia", 1, _("Julia"), NULL, "julia", 1, _("Julia"), NULL,
"barnsley-1", 2, _("Barnsley 1"), NULL, "barnsley-1", 2, _("Barnsley 1"), NULL,
"barnsley-2", 3, _("Barnsley 2"), NULL, "barnsley-2", 3, _("Barnsley 2"), NULL,
"barnsley-3", 4, _("Barnsley 3"), NULL, "barnsley-3", 4, _("Barnsley 3"), NULL,
"spider", 5, _("Spider"), NULL, "spider", 5, _("Spider"), NULL,
"man-o-war", 6, _("Man-o-War"), NULL, "man-o-war", 6, _("Man-o-War"), NULL,
"lambda", 7, _("Lambda"), NULL, "lambda", 7, _("Lambda"), NULL,
"sierpinski", 8, _("Sierpinski"), NULL, "sierpinski", 8, _("Sierpinski"), NULL,
NULL), NULL),
"mandelbrot", "mandelbrot",
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "xmin", gimp_procedure_add_double_argument (procedure, "xmin",
_("Lef_t"), _("Lef_t"),
_("X min fractal image delimiter"), _("X min fractal image delimiter"),
-3.000, 3.000, -2.000, -3.000, 3.000, -2.000,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "xmax", gimp_procedure_add_double_argument (procedure, "xmax",
_("Ri_ght"), _("Ri_ght"),
_("X max fractal image delimiter"), _("X max fractal image delimiter"),
-3.000, 3.000, 2.000, -3.000, 3.000, 2.000,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "ymin", gimp_procedure_add_double_argument (procedure, "ymin",
_("To_p"), _("To_p"),
_("Y min fractal image delimiter"), _("Y min fractal image delimiter"),
-3.000, 3.000, -1.500, -3.000, 3.000, -1.500,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "ymax", gimp_procedure_add_double_argument (procedure, "ymax",
_("_Bottom"), _("_Bottom"),
_("Y max fractal image delimiter"), _("Y max fractal image delimiter"),
-3.000, 3.000, 1.500, -3.000, 3.000, 1.500,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "iter", gimp_procedure_add_double_argument (procedure, "iter",
_("Iteratio_ns"), _("Iteratio_ns"),
_("Iteration value"), _("Iteration value"),
1, 1000, 50, 1, 1000, 50,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "cx", gimp_procedure_add_double_argument (procedure, "cx",
_("C_X"), _("C_X"),
_("cx value"), _("cx value"),
-2.5000, 2.5000, -0.75, -2.5000, 2.5000, -0.75,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "cy", gimp_procedure_add_double_argument (procedure, "cy",
_("C_Y"), _("C_Y"),
_("cy value"), _("cy value"),
-2.5000, 2.5000, -0.2, -2.5000, 2.5000, -0.2,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "color-mode", gimp_procedure_add_int_argument (procedure, "color-mode",
_("Color mode"), _("Color mode"),
_("0: Apply colormap as specified by the parameters " _("0: Apply colormap as specified by the parameters "
"above; 1: Apply active gradient to final image"), "above; 1: Apply active gradient to final image"),
0, 1, 0, 0, 1, 0,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "red-stretch", gimp_procedure_add_double_argument (procedure, "red-stretch",
_("Red stretch"), _("Red stretch"),
_("Red stretching factor"), _("Red stretching factor"),
0, 1, 1, 0, 1, 1,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "green-stretch", gimp_procedure_add_double_argument (procedure, "green-stretch",
_("Green stretch"), _("Green stretch"),
_("Green stretching factor"), _("Green stretching factor"),
0, 1, 1, 0, 1, 1,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "blue-stretch", gimp_procedure_add_double_argument (procedure, "blue-stretch",
_("Blue stretch"), _("Blue stretch"),
_("Blue stretching factor"), _("Blue stretching factor"),
0, 1, 1, 0, 1, 1,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "red-mode", gimp_procedure_add_choice_argument (procedure, "red-mode",
_("_Red"), _("_Red"),
_("Red application mode"), _("Red application mode"),
gimp_choice_new_with_values ("red-sin", 0, _("Sine"), NULL, gimp_choice_new_with_values ("red-sin", 0, _("Sine"), NULL,
"red-cos", 1, _("Cosine"), NULL, "red-cos", 1, _("Cosine"), NULL,
"red-none", 2, _("None"), NULL, "red-none", 2, _("None"), NULL,
NULL), NULL),
"red-cos", "red-cos",
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "green-mode", gimp_procedure_add_choice_argument (procedure, "green-mode",
_("_Green"), _("_Green"),
_("Green application mode"), _("Green application mode"),
gimp_choice_new_with_values ("green-sin", 0, _("Sine"), NULL, gimp_choice_new_with_values ("green-sin", 0, _("Sine"), NULL,
"green-cos", 1, _("Cosine"), NULL, "green-cos", 1, _("Cosine"), NULL,
"green-none", 2, _("None"), NULL, "green-none", 2, _("None"), NULL,
NULL), NULL),
"green-cos", "green-cos",
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "blue-mode", gimp_procedure_add_choice_argument (procedure, "blue-mode",
_("_Blue"), _("_Blue"),
_("Blue application mode"), _("Blue application mode"),
gimp_choice_new_with_values ("blue-sin", 0, _("Sine"), NULL, gimp_choice_new_with_values ("blue-sin", 0, _("Sine"), NULL,
"blue-cos", 1, _("Cosine"), NULL, "blue-cos", 1, _("Cosine"), NULL,
"blue-none", 2, _("None"), NULL, "blue-none", 2, _("None"), NULL,
NULL), NULL),
"blue-sin", "blue-sin",
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "red-invert", gimp_procedure_add_boolean_argument (procedure, "red-invert",
_("In_version"), _("In_version"),
_("Red inversion mode"), _("Red inversion mode"),
FALSE, FALSE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "green-invert", gimp_procedure_add_boolean_argument (procedure, "green-invert",
_("I_nversion"), _("I_nversion"),
_("Green inversion mode"), _("Green inversion mode"),
FALSE, FALSE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "blue-invert", gimp_procedure_add_boolean_argument (procedure, "blue-invert",
_("_Inversion"), _("_Inversion"),
_("Blue inversion mode"), _("Blue inversion mode"),
FALSE, FALSE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "n-colors", gimp_procedure_add_int_argument (procedure, "n-colors",
_("_Number of colors"), _("_Number of colors"),
_("Number of Colors for mapping"), _("Number of Colors for mapping"),
2, 8192, 512, 2, 8192, 512,
G_PARAM_READWRITE); 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"),
_("Use log log smoothing to eliminate " _("Use log log smoothing to eliminate "
"\"banding\" in the result"), "\"banding\" in the result"),
FALSE, FALSE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
} }

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

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

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

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

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

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

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

@ -137,15 +137,15 @@ help_create_procedure (GimpPlugIn *plug_in,
"Sven Neumann, Michael Natterer & Henrik Brix Andersen", "Sven Neumann, Michael Natterer & Henrik Brix Andersen",
"1999-2008"); "1999-2008");
GIMP_PROC_ARG_STRV (procedure, "domain-names", gimp_procedure_add_string_array_argument (procedure, "domain-names",
"Domain Names", "Domain Names",
"Domain names", "Domain names",
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_STRV (procedure, "domain-uris", gimp_procedure_add_string_array_argument (procedure, "domain-uris",
"Domain URIs", "Domain URIs",
"Domain URIs", "Domain URIs",
G_PARAM_READWRITE); G_PARAM_READWRITE);
} }
return procedure; return procedure;
@ -210,25 +210,25 @@ help_temp_proc_install (GimpPlugIn *plug_in)
"Henrik Brix Andersen", "Henrik Brix Andersen",
"1999-2008"); "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",
"The procedure of the browser to use", "The procedure of the browser to use",
NULL, NULL,
G_PARAM_READWRITE); 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",
"Help domain to use", "Help domain to use",
NULL, NULL,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "help-locales", gimp_procedure_add_string_argument (procedure, "help-locales",
"Language to use", "Language to use",
"Language to use", "Language to use",
NULL, NULL,
G_PARAM_READWRITE); 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",
"Help ID to open", "Help ID to open",
NULL, NULL,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -131,16 +131,16 @@ script_fu_create_procedure (GimpPlugIn *plug_in,
"Spencer Kimball & Peter Mattis", "Spencer Kimball & Peter Mattis",
"1997"); "1997");
GIMP_PROC_ARG_ENUM (procedure, "run-mode", gimp_procedure_add_enum_argument (procedure, "run-mode",
"Run mode", "Run mode",
"The run mode", "The run mode",
GIMP_TYPE_RUN_MODE, GIMP_TYPE_RUN_MODE,
GIMP_RUN_INTERACTIVE, GIMP_RUN_INTERACTIVE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_STRV (procedure, "history", gimp_procedure_add_string_array_argument (procedure, "history",
"Command history", "Command history",
"History", "History",
G_PARAM_READWRITE); G_PARAM_READWRITE);
} }
else if (! strcmp (name, "plug-in-script-fu-text-console")) else if (! strcmp (name, "plug-in-script-fu-text-console"))
{ {
@ -159,12 +159,12 @@ script_fu_create_procedure (GimpPlugIn *plug_in,
"Spencer Kimball & Peter Mattis", "Spencer Kimball & Peter Mattis",
"1997"); "1997");
GIMP_PROC_ARG_ENUM (procedure, "run-mode", gimp_procedure_add_enum_argument (procedure, "run-mode",
"Run mode", "Run mode",
"The run mode", "The run mode",
GIMP_TYPE_RUN_MODE, GIMP_TYPE_RUN_MODE,
GIMP_RUN_INTERACTIVE, GIMP_RUN_INTERACTIVE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
} }
else if (! strcmp (name, "plug-in-script-fu-eval")) else if (! strcmp (name, "plug-in-script-fu-eval"))
{ {

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