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

plug-ins: Port argument macros to functions 

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
Show Stats 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);
GIMP_PROC_ARG_ENUM (procedure, "run-mode",
"Run mode",
"The run mode",
GIMP_TYPE_RUN_MODE,
GIMP_RUN_NONINTERACTIVE,
G_PARAM_READWRITE);
gimp_procedure_add_enum_argument (procedure, "run-mode",
"Run mode",
"The run mode",
GIMP_TYPE_RUN_MODE,
GIMP_RUN_NONINTERACTIVE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "script",
"Batch commands in the target language",
"Batch commands in the target language, which will be run by the interpreter",
"",
G_PARAM_READWRITE);
gimp_procedure_add_string_argument (procedure, "script",
"Batch commands in the target language",
"Batch commands in the target language, which will be run by the interpreter",
"",
G_PARAM_READWRITE);
}
static void

12
libgimp/gimpdrawablechooser.c
View File

@ -513,12 +513,12 @@ gimp_drawable_chooser_clicked (GimpDrawableChooser *chooser)
(GimpRunFunc) gimp_temp_callback_run,
g_object_ref (chooser),
(GDestroyNotify) g_object_unref);
GIMP_PROC_ARG_DRAWABLE (callback_procedure, "drawable",
"Drawable", "The selected drawable",
TRUE, G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (callback_procedure, "closing",
"Closing", "If the dialog was closing",
FALSE, G_PARAM_READWRITE);
gimp_procedure_add_drawable_argument (callback_procedure, "drawable",
"Drawable", "The selected drawable",
TRUE, G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (callback_procedure, "closing",
"Closing", "If the dialog was closing",
FALSE, G_PARAM_READWRITE);
gimp_plug_in_add_temp_procedure (plug_in, 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);
GIMP_PROC_ARG_IMAGE (procedure, "image",
"Image",
"The image to export",
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_image_argument (procedure, "image",
"Image",
"The image to export",
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_FILE (procedure, "file",
"File",
"The file to export to",
GIMP_PARAM_READWRITE);
gimp_procedure_add_file_argument (procedure, "file",
"File",
"The file to export to",
GIMP_PARAM_READWRITE);
}
static void
@ -458,47 +458,47 @@ gimp_export_procedure_add_metadata (GimpExportProcedure *export_procedure)
return;
if (export_procedure->priv->supports_exif)
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-exif",
_("Save _Exif"),
_("Save Exif (Exchangeable image file format) metadata"),
gimp_export_exif (),
G_PARAM_READWRITE);
gimp_procedure_add_boolean_aux_argument (procedure, "save-exif",
_("Save _Exif"),
_("Save Exif (Exchangeable image file format) metadata"),
gimp_export_exif (),
G_PARAM_READWRITE);
if (export_procedure->priv->supports_iptc)
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-iptc",
_("Save _IPTC"),
_("Save IPTC (International Press Telecommunications Council) metadata"),
gimp_export_iptc (),
G_PARAM_READWRITE);
gimp_procedure_add_boolean_aux_argument (procedure, "save-iptc",
_("Save _IPTC"),
_("Save IPTC (International Press Telecommunications Council) metadata"),
gimp_export_iptc (),
G_PARAM_READWRITE);
if (export_procedure->priv->supports_xmp)
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-xmp",
_("Save _XMP"),
_("Save XMP (Extensible Metadata Platform) metadata"),
gimp_export_xmp (),
G_PARAM_READWRITE);
gimp_procedure_add_boolean_aux_argument (procedure, "save-xmp",
_("Save _XMP"),
_("Save XMP (Extensible Metadata Platform) metadata"),
gimp_export_xmp (),
G_PARAM_READWRITE);
if (export_procedure->priv->supports_profile)
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-color-profile",
_("Save color _profile"),
_("Save the ICC color profile as metadata"),
gimp_export_color_profile (),
G_PARAM_READWRITE);
gimp_procedure_add_boolean_aux_argument (procedure, "save-color-profile",
_("Save color _profile"),
_("Save the ICC color profile as metadata"),
gimp_export_color_profile (),
G_PARAM_READWRITE);
if (export_procedure->priv->supports_thumbnail)
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-thumbnail",
_("Save _thumbnail"),
_("Save a smaller representation of the image as metadata"),
gimp_export_thumbnail (),
G_PARAM_READWRITE);
gimp_procedure_add_boolean_aux_argument (procedure, "save-thumbnail",
_("Save _thumbnail"),
_("Save a smaller representation of the image as metadata"),
gimp_export_thumbnail (),
G_PARAM_READWRITE);
if (export_procedure->priv->supports_comment)
{
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-comment",
_("Save c_omment"),
_("Save a comment as metadata"),
gimp_export_comment (),
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_STRING (procedure, "gimp-comment",
_("Comment"),
_("Image comment"),
gimp_get_default_comment (),
G_PARAM_READWRITE);
gimp_procedure_add_boolean_aux_argument (procedure, "save-comment",
_("Save c_omment"),
_("Save a comment as metadata"),
gimp_export_comment (),
G_PARAM_READWRITE);
gimp_procedure_add_string_aux_argument (procedure, "gimp-comment",
_("Comment"),
_("Image comment"),
gimp_get_default_comment (),
G_PARAM_READWRITE);
gimp_procedure_set_argument_sync (procedure, "gimp-comment",
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);
GIMP_PROC_ARG_ENUM (procedure, "run-mode",
"Run mode",
"The run mode",
GIMP_TYPE_RUN_MODE,
GIMP_RUN_NONINTERACTIVE,
G_PARAM_READWRITE);
gimp_procedure_add_enum_argument (procedure, "run-mode",
"Run mode",
"The run mode",
GIMP_TYPE_RUN_MODE,
GIMP_RUN_NONINTERACTIVE,
G_PARAM_READWRITE);
}
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);
GIMP_PROC_ARG_ENUM (procedure, "run-mode",
"Run mode",
"The run mode",
GIMP_TYPE_RUN_MODE,
GIMP_RUN_NONINTERACTIVE,
G_PARAM_READWRITE);
gimp_procedure_add_enum_argument (procedure, "run-mode",
"Run mode",
"The run mode",
GIMP_TYPE_RUN_MODE,
GIMP_RUN_NONINTERACTIVE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_IMAGE (procedure, "image",
"Image",
"The input image",
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_image_argument (procedure, "image",
"Image",
"The input image",
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "num-drawables",
"Number of drawables",
"Number of input drawables",
0, G_MAXINT, 1,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "num-drawables",
"Number of drawables",
"Number of input drawables",
0, G_MAXINT, 1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_OBJECT_ARRAY (procedure, "drawables",
"Drawables",
"The input drawables",
GIMP_TYPE_DRAWABLE,
G_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE);
gimp_procedure_add_object_array_argument (procedure, "drawables",
"Drawables",
"The input drawables",
GIMP_TYPE_DRAWABLE,
G_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE);
}
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);
GIMP_PROC_ARG_FILE (procedure, "file",
"File",
"The file to load",
GIMP_PARAM_READWRITE);
gimp_procedure_add_file_argument (procedure, "file",
"File",
"The file to load",
GIMP_PARAM_READWRITE);
GIMP_PROC_VAL_IMAGE (procedure, "image",
"Image",
"Output image",
TRUE,
GIMP_PARAM_READWRITE);
gimp_procedure_add_image_return_value (procedure, "image",
"Image",
"Output image",
TRUE,
GIMP_PARAM_READWRITE);
}
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
* to do this is by simply using [func@export_comment], [func@export_exif] etc.
* as default values for these arguments when adding them using
* GIMP_PROC_ARG_BOOLEAN() or GIMP_PROC_AUX_ARG_BOOLEAN().
* gimp_procedure_add_boolean_argument() or
* gimp_procedure_add_boolean_aux_argument().
*
* Returns: (transfer none) (nullable): The metadata to be used
* for this export, or %NULL if @original_image doesn't have

42
libgimp/gimpprogress.c
View File

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

144
libgimp/gimpresourceselect.c
View File

@ -113,10 +113,10 @@ static void
create_callback_PDB_procedure_params (GimpProcedure *procedure,
GType resource_type)
{
GIMP_PROC_ARG_RESOURCE (procedure, "resource",
"Resource",
"The resource",
G_PARAM_READWRITE);
gimp_procedure_add_resource_argument (procedure, "resource",
"Resource",
"The resource",
G_PARAM_READWRITE);
/* Create args for the extra, superfluous args that core is passing.*/
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))
{
GIMP_PROC_ARG_INT (procedure, "gradient-width",
"Gradient width",
"The gradient width",
0, G_MAXINT, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "gradient-width",
"Gradient width",
"The gradient width",
0, G_MAXINT, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_FLOAT_ARRAY (procedure, "gradient-data",
"Gradient data",
"The gradient data",
G_PARAM_READWRITE);
gimp_procedure_add_float_array_argument (procedure, "gradient-data",
"Gradient data",
"The gradient data",
G_PARAM_READWRITE);
}
else if (g_type_is_a (resource_type, GIMP_TYPE_BRUSH))
{
GIMP_PROC_ARG_DOUBLE (procedure, "opacity",
"Opacity",
NULL,
0.0, 100.0, 100.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "opacity",
"Opacity",
NULL,
0.0, 100.0, 100.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "spacing",
"Spacing",
NULL,
-1, 1000, 20,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "spacing",
"Spacing",
NULL,
-1, 1000, 20,
G_PARAM_READWRITE);
GIMP_PROC_ARG_ENUM (procedure, "paint-mode",
"Paint mode",
NULL,
GIMP_TYPE_LAYER_MODE,
GIMP_LAYER_MODE_NORMAL,
G_PARAM_READWRITE);
gimp_procedure_add_enum_argument (procedure, "paint-mode",
"Paint mode",
NULL,
GIMP_TYPE_LAYER_MODE,
GIMP_LAYER_MODE_NORMAL,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "mask-width",
"Brush width",
NULL,
0, 10000, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "mask-width",
"Brush width",
NULL,
0, 10000, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "mask-height",
"Brush height",
NULL,
0, 10000, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "mask-height",
"Brush height",
NULL,
0, 10000, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BYTES (procedure, "mask-data",
"Mask data",
"The brush mask data",
G_PARAM_READWRITE);
gimp_procedure_add_bytes_argument (procedure, "mask-data",
"Mask data",
"The brush mask data",
G_PARAM_READWRITE);
}
else if (g_type_is_a (resource_type, GIMP_TYPE_PALETTE))
{
GIMP_PROC_ARG_INT (procedure, "num-colors",
"Num colors",
"Number of colors",
0, G_MAXINT, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "num-colors",
"Num colors",
"Number of colors",
0, G_MAXINT, 0,
G_PARAM_READWRITE);
}
else if (g_type_is_a (resource_type, GIMP_TYPE_PATTERN))
{
GIMP_PROC_ARG_INT (procedure, "mask-width",
"Mask width",
"Pattern width",
0, 10000, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "mask-width",
"Mask width",
"Pattern width",
0, 10000, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "mask-height",
"Mask height",
"Pattern height",
0, 10000, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "mask-height",
"Mask height",
"Pattern height",
0, 10000, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "mask-bpp",
"Mask bpp",
"Pattern bytes per pixel",
0, 10000, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "mask-bpp",
"Mask bpp",
"Pattern bytes per pixel",
0, 10000, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BYTES (procedure, "mask-data",
"Mask data",
"The pattern mask data",
G_PARAM_READWRITE);
gimp_procedure_add_bytes_argument (procedure, "mask-data",
"Mask data",
"The pattern mask data",
G_PARAM_READWRITE);
}
else
{
g_warning ("%s: unhandled resource type", G_STRFUNC);
}
GIMP_PROC_ARG_BOOLEAN (procedure, "closing",
"Closing",
"If the dialog was closing",
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "closing",
"Closing",
"If the dialog was closing",
FALSE,
G_PARAM_READWRITE);
}
/* 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);
GIMP_PROC_ARG_FILE (procedure, "file",
"File",
"The file to load the thumbnail from",
GIMP_PARAM_READWRITE);
gimp_procedure_add_file_argument (procedure, "file",
"File",
"The file to load the thumbnail from",
GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "thumb-size",
"Thumb Size",
"Preferred thumbnail size",
16, 2014, 256,
GIMP_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "thumb-size",
"Thumb Size",
"Preferred thumbnail size",
16, 2014, 256,
GIMP_PARAM_READWRITE);
GIMP_PROC_VAL_IMAGE (procedure, "image",
"Image",
"Thumbnail image",
TRUE,
GIMP_PARAM_READWRITE);
gimp_procedure_add_image_return_value (procedure, "image",
"Image",
"Thumbnail image",
TRUE,
GIMP_PARAM_READWRITE);
GIMP_PROC_VAL_INT (procedure, "image-width",
"Image width",
"Width of the full-sized image (0 for unknown)",
0, GIMP_MAX_IMAGE_SIZE, 0,
GIMP_PARAM_READWRITE);
gimp_procedure_add_int_return_value (procedure, "image-width",
"Image width",
"Width of the full-sized image (0 for unknown)",
0, GIMP_MAX_IMAGE_SIZE, 0,
GIMP_PARAM_READWRITE);
GIMP_PROC_VAL_INT (procedure, "image-height",
"Image height",
"Height of the full-sized image (0 for unknown)",
0, GIMP_MAX_IMAGE_SIZE, 0,
GIMP_PARAM_READWRITE);
gimp_procedure_add_int_return_value (procedure, "image-height",
"Image height",
"Height of the full-sized image (0 for unknown)",
0, GIMP_MAX_IMAGE_SIZE, 0,
GIMP_PARAM_READWRITE);
GIMP_PROC_VAL_ENUM (procedure, "image-type",
"Image type",
"Type of the image",
GIMP_TYPE_IMAGE_TYPE,
GIMP_RGB_IMAGE,
GIMP_PARAM_READWRITE);
gimp_procedure_add_enum_return_value (procedure, "image-type",
"Image type",
"Type of the image",
GIMP_TYPE_IMAGE_TYPE,
GIMP_RGB_IMAGE,
GIMP_PARAM_READWRITE);
GIMP_PROC_VAL_INT (procedure, "num-layers",
"Num layers",
"Number of layers in the image",
1, G_MAXINT, 1,
GIMP_PARAM_READWRITE);
gimp_procedure_add_int_return_value (procedure, "num-layers",
"Num layers",
"Number of layers in the image",
1, G_MAXINT, 1,
GIMP_PARAM_READWRITE);
}
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);
GIMP_PROC_ARG_INT (procedure, "width",
_("_Width (pixels)"),
"Width (in pixels) to load the image in. "
"(0 for the corresponding width per native ratio)",
0, GIMP_MAX_IMAGE_SIZE, 0,
GIMP_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "width",
_("_Width (pixels)"),
"Width (in pixels) to load the image in. "
"(0 for the corresponding width per native ratio)",
0, GIMP_MAX_IMAGE_SIZE, 0,
GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "height",
_("_Height (pixels)"),
"Height (in pixels) to load the image in. "
"(0 for the corresponding height per native ratio)",
0, GIMP_MAX_IMAGE_SIZE, 0,
GIMP_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "height",
_("_Height (pixels)"),
"Height (in pixels) to load the image in. "
"(0 for the corresponding height per native ratio)",
0, GIMP_MAX_IMAGE_SIZE, 0,
GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "keep-ratio",
_("_Keep aspect ratio"),
_("Force dimensions with aspect ratio"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "prefer-native-dimensions",
_("_Prefer native dimensions"),
_("Load and use dimensions from source file"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "keep-ratio",
_("_Keep aspect ratio"),
_("Force dimensions with aspect ratio"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "prefer-native-dimensions",
_("_Prefer native dimensions"),
_("Load and use dimensions from source file"),
FALSE,
G_PARAM_READWRITE);
/* Note: the "pixel-density" is saved in pixels per inch. "physical-unit"
* property is only there for display.
*/
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "pixel-density",
_("Resolu_tion"),
_("Pixel Density: number of pixels per physical unit"),
GIMP_MIN_RESOLUTION, GIMP_MAX_RESOLUTION,
GIMP_VECTOR_LOAD_DEFAULT_PIXEL_DENSITY,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_INT (procedure, "physical-unit",
_("Unit"),
_("Physical unit"),
GIMP_UNIT_INCH, GIMP_UNIT_PICA, GIMP_UNIT_INCH,
G_PARAM_READWRITE);
gimp_procedure_add_double_aux_argument (procedure, "pixel-density",
_("Resolu_tion"),
_("Pixel Density: number of pixels per physical unit"),
GIMP_MIN_RESOLUTION, GIMP_MAX_RESOLUTION,
GIMP_VECTOR_LOAD_DEFAULT_PIXEL_DENSITY,
G_PARAM_READWRITE);
gimp_procedure_add_int_aux_argument (procedure, "physical-unit",
_("Unit"),
_("Physical unit"),
GIMP_UNIT_INCH, GIMP_UNIT_PICA, GIMP_UNIT_INCH,
G_PARAM_READWRITE);
}
static void

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

@ -188,55 +188,55 @@ align_layers_create_procedure (GimpPlugIn *plug_in,
"Shuji Narazaki",
"1997");
GIMP_PROC_ARG_INT (procedure, "horizontal-style",
_("_Horizontal style"),
_("(None = 0, Collect = 1, "
"Fill left to right = 2, Fill right to left = 3, "
"Snap to grid = 4)"),
H_NONE, SNAP2HGRID, H_NONE,
GIMP_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "horizontal-style",
_("_Horizontal style"),
_("(None = 0, Collect = 1, "
"Fill left to right = 2, Fill right to left = 3, "
"Snap to grid = 4)"),
H_NONE, SNAP2HGRID, H_NONE,
GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "horizontal-base",
_("Hori_zontal base"),
_("(Left edge = 0, Center = 1, "
"Right edge = 2)"),
H_BASE_LEFT, H_BASE_RIGHT, H_BASE_LEFT,
GIMP_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "horizontal-base",
_("Hori_zontal base"),
_("(Left edge = 0, Center = 1, "
"Right edge = 2)"),
H_BASE_LEFT, H_BASE_RIGHT, H_BASE_LEFT,
GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "vertical-style",
_("_Vertical style"),
_("(None = 0, Collect = 1, "
"Fill left to right = 2, Fill right to left = 3, "
"Snap to grid = 4)"),
V_NONE, SNAP2VGRID, V_NONE,
GIMP_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "vertical-style",
_("_Vertical style"),
_("(None = 0, Collect = 1, "
"Fill left to right = 2, Fill right to left = 3, "
"Snap to grid = 4)"),
V_NONE, SNAP2VGRID, V_NONE,
GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "vertical-base",
_("Ver_tical base"),
_("(Left edge = 0, Center = 1, "
"Right edge = 2)"),
V_BASE_TOP, V_BASE_BOTTOM, V_BASE_TOP,
GIMP_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "vertical-base",
_("Ver_tical base"),
_("(Left edge = 0, Center = 1, "
"Right edge = 2)"),
V_BASE_TOP, V_BASE_BOTTOM, V_BASE_TOP,
GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "grid-size",
_("_Grid"),
_("Grid"),
1, 200, 10,
GIMP_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "grid-size",
_("_Grid"),
_("Grid"),
1, 200, 10,
GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure,
"ignore-bottom-layer",
_("Ignore the _bottom layer even if visible"),
_("Ignore the bottom layer even if visible"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure,
"ignore-bottom-layer",
_("Ignore the _bottom layer even if visible"),
_("Ignore the bottom layer even if visible"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure,
"use-bottom-layer",
_("_Use the (invisible) bottom layer as the base"),
_("Use the (invisible) bottom layer as the base"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure,
"use-bottom-layer",
_("_Use the (invisible) bottom layer as the base"),
_("Use the (invisible) bottom layer as the base"),
FALSE,
G_PARAM_READWRITE);
/* TODO: these 2 arguments existed in the original procedure but
* 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.
*/
/*
GIMP_PROC_ARG_BOOLEAN (procedure,
"link-after-alignment",
"Link the visible layers after alignment",
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure,
"use-bottom",
"use the bottom layer as the base of alignment",
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure,
"link-after-alignment",
"Link the visible layers after alignment",
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure,
"use-bottom",
"use the bottom layer as the base of alignment",
TRUE,
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>",
"1997-2003");
GIMP_PROC_VAL_IMAGE (procedure, "result",
"Result",
"Resultimg image",
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_image_return_value (procedure, "result",
"Result",
"Resulting image",
FALSE,
G_PARAM_READWRITE);
}
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>",
"1997, 1998...");
GIMP_PROC_AUX_ARG_BYTES (procedure, "settings-data",
"Settings data",
"TODO: eventually we must implement proper args for every settings",
GIMP_PARAM_READWRITE);
gimp_procedure_add_bytes_aux_argument (procedure, "settings-data",
"Settings data",
"TODO: eventually we must implement proper args for every settings",
GIMP_PARAM_READWRITE);
}
return procedure;

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

@ -150,31 +150,31 @@ blinds_create_procedure (GimpPlugIn *plug_in,
"Andy Thomas",
"1997");
GIMP_PROC_ARG_INT (procedure, "angle-displacement",
_("_Displacement"),
_("Angle of Displacement"),
0, 90, 30,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "angle-displacement",
_("_Displacement"),
_("Angle of Displacement"),
0, 90, 30,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "num-segments",
_("_Number of segments"),
_("Number of segments in blinds"),
1, MAX_FANS, 3,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "num-segments",
_("_Number of segments"),
_("Number of segments in blinds"),
1, MAX_FANS, 3,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "orientation",
_("Orientation"),
_("The orientation"),
GIMP_ORIENTATION_HORIZONTAL,
GIMP_ORIENTATION_VERTICAL,
GIMP_ORIENTATION_HORIZONTAL,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "orientation",
_("Orientation"),
_("The orientation"),
GIMP_ORIENTATION_HORIZONTAL,
GIMP_ORIENTATION_VERTICAL,
GIMP_ORIENTATION_HORIZONTAL,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "bg-transparent",
_("_Transparent"),
_("Background transparent"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "bg-transparent",
_("_Transparent"),
_("Background transparent"),
FALSE,
G_PARAM_READWRITE);
}
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",
"1998");
GIMP_PROC_ARG_INT (procedure, "thickness",
_("_Thickness"),
_("Border size to take in count"),
0, G_MAXINT, 3,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_UNIT (procedure, "thickness-unit",
_("Thickness unit of measure"),
_("Border size unit of measure"),
TRUE, TRUE, GIMP_UNIT_PIXEL,
GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "bucket-exponent",
_("Bucket Si_ze"),
_("Bits for bucket size (default=4: 16 Levels)"),
0, G_MAXINT, 4,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "thickness",
_("_Thickness"),
_("Border size to take in count"),
0, G_MAXINT, 3,
G_PARAM_READWRITE);
gimp_procedure_add_unit_aux_argument (procedure, "thickness-unit",
_("Thickness unit of measure"),
_("Border size unit of measure"),
TRUE, TRUE, GIMP_UNIT_PIXEL,
GIMP_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "bucket-exponent",
_("Bucket Si_ze"),
_("Bits for bucket size (default=4: 16 Levels)"),
0, G_MAXINT, 4,
G_PARAM_READWRITE);
GIMP_PROC_VAL_COLOR (procedure, "borderaverage",
_("The average color of the specified border."),
_("The average color of the specified border."),
TRUE, default_return_color,
G_PARAM_READWRITE);
gimp_procedure_add_color_return_value (procedure, "borderaverage",
_("The average color of the specified border."),
_("The average color of the specified border."),
TRUE, default_return_color,
G_PARAM_READWRITE);
}
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",
"2018");
GIMP_PROC_ARG_ENUM (procedure, "run-mode",
"Run mode",
"The run mode",
GIMP_TYPE_RUN_MODE,
GIMP_RUN_INTERACTIVE,
G_PARAM_READWRITE);
gimp_procedure_add_enum_argument (procedure, "run-mode",
"Run mode",
"The run mode",
GIMP_TYPE_RUN_MODE,
GIMP_RUN_INTERACTIVE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "read-fd",
"The read file descriptor",
"The read file descriptor",
G_MININT, G_MAXINT, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "read-fd",
"The read file descriptor",
"The read file descriptor",
G_MININT, G_MAXINT, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "write-fd",
"The write file descriptor",
"The write file descriptor",
G_MININT, G_MAXINT, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "write-fd",
"The write file descriptor",
"The write file descriptor",
G_MININT, G_MAXINT, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "message",
"The message",
"The message",
NULL,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "cancelable",
"Whether the dialog is cancelable",
"Whether the dialog is cancelable",
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_string_argument (procedure, "message",
"The message",
"The message",
NULL,
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;

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

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

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

@ -532,16 +532,16 @@ explorer_create_procedure (GimpPlugIn *plug_in,
"Shuji Narazaki",
"1997");
GIMP_PROC_ARG_FILE (procedure, "parameter-file",
_("Parameter File"),
_("The parameter file from which CML_explorer makes an image. "
"This argument is only used in non-interactive runs."),
G_PARAM_READWRITE);
gimp_procedure_add_file_argument (procedure, "parameter-file",
_("Parameter File"),
_("The parameter file from which CML_explorer makes an image. "
"This argument is only used in non-interactive runs."),
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BYTES (procedure, "settings-data",
"Settings data",
"TODO: eventually we must implement proper args for every settings",
GIMP_PARAM_READWRITE);
gimp_procedure_add_bytes_aux_argument (procedure, "settings-data",
"Settings data",
"TODO: eventually we must implement proper args for every settings",
GIMP_PARAM_READWRITE);
}
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>",
"June 2006");
GIMP_PROC_ARG_BYTES (procedure, "map",
_("Map"),
_("Remap array for the colormap"),
G_PARAM_READWRITE);
gimp_procedure_add_bytes_argument (procedure, "map",
_("Map"),
_("Remap array for the colormap"),
G_PARAM_READWRITE);
}
else if (strcmp (name, PLUG_IN_PROC_SWAP) == 0)
{
@ -228,17 +228,17 @@ remap_create_procedure (GimpPlugIn *plug_in,
"Mukund Sivaraman <muks@mukund.org>",
"June 2006");
GIMP_PROC_ARG_INT (procedure, "index1",
_("Index 1"),
_("First index in the colormap"),
0, 255, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "index1",
_("Index 1"),
_("First index in the colormap"),
0, 255, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "index2",
_("Index 2"),
_("Second (other) index in the colormap"),
0, 255, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "index2",
_("Index 2"),
_("Second (other) index in the colormap"),
0, 255, 0,
G_PARAM_READWRITE);
}
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)",
"1997");
GIMP_PROC_ARG_IMAGE (procedure, "image-2",
_("Image 2"),
_("Second input image"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_image_argument (procedure, "image-2",
_("Image 2"),
_("Second input image"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_IMAGE (procedure, "image-3",
_("Image 3"),
_("Third input image"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_image_argument (procedure, "image-3",
_("Image 3"),
_("Third input image"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_IMAGE (procedure, "image-4",
_("Image 4"),
_("Fourth input image"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_image_argument (procedure, "image-4",
_("Image 4"),
_("Fourth input image"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "compose-type",
_("Color _model"),
type_desc->str,
gimp_choice_new_with_values ("rgb", 0, _("RGB"), NULL,
"rgba", 1, _("RGBA"), NULL,
"hsv", 2, _("HSV"), NULL,
"hsl", 3, _("HSL"), NULL,
"cmyk", 4, _("CMYK"), NULL,
"lab", 5, _("LAB"), NULL,
"lch", 6, _("LCH"), NULL,
"ycbcr470", 7, _("YCbCr ITU R470"), NULL,
"ycbcr709", 8, _("YCbCr ITU R709"), NULL,
"ycbcr470f", 9, _("YCbCr ITU R470 256"), NULL,
"ycbcr709f", 10, _("YCbCr ITU R709 256"), NULL,
NULL),
"rgb",
G_PARAM_READWRITE);
gimp_procedure_add_choice_argument (procedure, "compose-type",
_("Color _model"),
type_desc->str,
gimp_choice_new_with_values ("rgb", 0, _("RGB"), NULL,
"rgba", 1, _("RGBA"), NULL,
"hsv", 2, _("HSV"), NULL,
"hsl", 3, _("HSL"), NULL,
"cmyk", 4, _("CMYK"), NULL,
"lab", 5, _("LAB"), NULL,
"lch", 6, _("LCH"), NULL,
"ycbcr470", 7, _("YCbCr ITU R470"), NULL,
"ycbcr709", 8, _("YCbCr ITU R709"), NULL,
"ycbcr470f", 9, _("YCbCr ITU R470 256"), NULL,
"ycbcr709f", 10, _("YCbCr ITU R709 256"), NULL,
NULL),
"rgb",
G_PARAM_READWRITE);
GIMP_PROC_VAL_IMAGE (procedure, "new-image",
_("New image"),
_("Output image"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_image_return_value (procedure, "new-image",
_("New image"),
_("Output image"),
FALSE,
G_PARAM_READWRITE);
}
else if (! strcmp (name, DRAWABLE_COMPOSE_PROC))
{
@ -477,47 +477,47 @@ compose_create_procedure (GimpPlugIn *plug_in,
"Peter Kirchgessner (peter@kirchgessner.net)",
"1998");
GIMP_PROC_ARG_DRAWABLE (procedure, "drawable-2",
_("Drawable 2"),
_("Second input drawable"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_drawable_argument (procedure, "drawable-2",
_("Drawable 2"),
_("Second input drawable"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DRAWABLE (procedure, "drawable-3",
_("Drawable 3"),
_("Third input drawable"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_drawable_argument (procedure, "drawable-3",
_("Drawable 3"),
_("Third input drawable"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DRAWABLE (procedure, "drawable-4",
_("Drawable 4"),
_("Fourth input drawable"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_drawable_argument (procedure, "drawable-4",
_("Drawable 4"),
_("Fourth input drawable"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "compose-type",
_("Color _model"),
type_desc->str,
gimp_choice_new_with_values ("rgb", 0, _("RGB"), NULL,
"rgba", 1, _("RGBA"), NULL,
"hsv", 2, _("HSV"), NULL,
"hsl", 3, _("HSL"), NULL,
"cmyk", 4, _("CMYK"), NULL,
"lab", 5, _("LAB"), NULL,
"lch", 6, _("LCH"), NULL,
"ycbcr470", 7, _("YCbCr ITU R470"), NULL,
"ycbcr709", 8, _("YCbCr ITU R709"), NULL,
"ycbcr470f", 9, _("YCbCr ITU R470 256"), NULL,
"ycbcr709f", 10, _("YCbCr ITU R709 256"), NULL,
NULL),
"rgb",
G_PARAM_READWRITE);
gimp_procedure_add_choice_argument (procedure, "compose-type",
_("Color _model"),
type_desc->str,
gimp_choice_new_with_values ("rgb", 0, _("RGB"), NULL,
"rgba", 1, _("RGBA"), NULL,
"hsv", 2, _("HSV"), NULL,
"hsl", 3, _("HSL"), NULL,
"cmyk", 4, _("CMYK"), NULL,
"lab", 5, _("LAB"), NULL,
"lch", 6, _("LCH"), NULL,
"ycbcr470", 7, _("YCbCr ITU R470"), NULL,
"ycbcr709", 8, _("YCbCr ITU R709"), NULL,
"ycbcr470f", 9, _("YCbCr ITU R470 256"), NULL,
"ycbcr709f", 10, _("YCbCr ITU R709 256"), NULL,
NULL),
"rgb",
G_PARAM_READWRITE);
GIMP_PROC_VAL_IMAGE (procedure, "new-image",
_("New image"),
_("Output image"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_image_return_value (procedure, "new-image",
_("New image"),
_("Output image"),
FALSE,
G_PARAM_READWRITE);
}
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",
"2003");
GIMP_PROC_ARG_INT (procedure, "scale",
_("Scal_e"),
_("Biggest scale value"),
MIN_GAUSSIAN_SCALE, MAX_GAUSSIAN_SCALE, 240,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "scale",
_("Scal_e"),
_("Biggest scale value"),
MIN_GAUSSIAN_SCALE, MAX_GAUSSIAN_SCALE, 240,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "nscales",
_("Scale _division"),
_("Number of scales"),
0, MAX_RETINEX_SCALES, 3,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "nscales",
_("Scale _division"),
_("Number of scales"),
0, MAX_RETINEX_SCALES, 3,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "scales-mode",
_("Le_vel"),
_("Retinex distribution through scales "
"{ Uniform (0), Low (1), High (2) }"),
RETINEX_UNIFORM, RETINEX_HIGH, RETINEX_UNIFORM,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "scales-mode",
_("Le_vel"),
_("Retinex distribution through scales "
"{ Uniform (0), Low (1), High (2) }"),
RETINEX_UNIFORM, RETINEX_HIGH, RETINEX_UNIFORM,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "cvar",
_("Dy_namic"),
_("Variance value"),
0, 4, 1.2,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "cvar",
_("Dy_namic"),
_("Variance value"),
0, 4, 1.2,
G_PARAM_READWRITE);
}
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_VERSION);
GIMP_PROC_ARG_DOUBLE (procedure, "rotation",
_("Rotat_e"),
_("Direction {angle 0 to 360 degree } "
"of the bend effect"),
0, 360, 0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "rotation",
_("Rotat_e"),
_("Direction {angle 0 to 360 degree } "
"of the bend effect"),
0, 360, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "smoothing",
_("Smoo_thing"),
_("Smoothing"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "smoothing",
_("Smoo_thing"),
_("Smoothing"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "antialias",
_("_Antialiasing"),
_("Antialias"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "antialias",
_("_Antialiasing"),
_("Antialias"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "work-on-copy",
_("Work on cop_y"),
_("Copy the drawable and bend the copy"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "work-on-copy",
_("Work on cop_y"),
_("Copy the drawable and bend the copy"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "curve-type",
_("Curve Type"),
_("{ 0 == smooth (use 17 points), "
"1 == freehand (use 256 val_y) }"),
0, 1, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "curve-type",
_("Curve Type"),
_("{ 0 == smooth (use 17 points), "
"1 == freehand (use 256 val_y) }"),
0, 1, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "curve-border",
_("Curve for Border"),
_("Choose the active border line to edit"),
0, 1, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "curve-border",
_("Curve for Border"),
_("Choose the active border line to edit"),
0, 1, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "argc-upper-point-x",
_("Argc upper point X"),
_("Argc upper point X"),
2, 17, 2,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "argc-upper-point-x",
_("Argc upper point X"),
_("Argc upper point X"),
2, 17, 2,
G_PARAM_READWRITE);
GIMP_PROC_ARG_FLOAT_ARRAY (procedure, "upper-point-x",
_("Upper point X"),
_("Array of 17 x point coords "
"{ 0.0 <= x <= 1.0 or -1 for unused point }"),
G_PARAM_READWRITE);
gimp_procedure_add_float_array_argument (procedure, "upper-point-x",
_("Upper point X"),
_("Array of 17 x point coords "
"{ 0.0 <= x <= 1.0 or -1 for unused point }"),
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "argc-upper-point-y",
_("Argc upper point Y"),
_("Argc upper point Y"),
2, 17, 2,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "argc-upper-point-y",
_("Argc upper point Y"),
_("Argc upper point Y"),
2, 17, 2,
G_PARAM_READWRITE);
GIMP_PROC_ARG_FLOAT_ARRAY (procedure, "upper-point-y",
_("Upper point Y"),
_("Array of 17 y point coords "
"{ 0.0 <= y <= 1.0 or -1 for unused point }"),
G_PARAM_READWRITE);
gimp_procedure_add_float_array_argument (procedure, "upper-point-y",
_("Upper point Y"),
_("Array of 17 y point coords "
"{ 0.0 <= y <= 1.0 or -1 for unused point }"),
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "argc-lower-point-x",
_("Argc lower point X"),
_("Argc lower point X"),
2, 17, 2,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "argc-lower-point-x",
_("Argc lower point X"),
_("Argc lower point X"),
2, 17, 2,
G_PARAM_READWRITE);
GIMP_PROC_ARG_FLOAT_ARRAY (procedure, "lower-point-x",
_("Lower point X"),
_("Array of 17 x point coords "
"{ 0.0 <= x <= 1.0 or -1 for unused point }"),
G_PARAM_READWRITE);
gimp_procedure_add_float_array_argument (procedure, "lower-point-x",
_("Lower point X"),
_("Array of 17 x point coords "
"{ 0.0 <= x <= 1.0 or -1 for unused point }"),
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "argc-lower-point-y",
_("Argc lower point Y"),
_("Argc lower point Y"),
2, 17, 2,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "argc-lower-point-y",
_("Argc lower point Y"),
_("Argc lower point Y"),
2, 17, 2,
G_PARAM_READWRITE);
GIMP_PROC_ARG_FLOAT_ARRAY (procedure, "lower-point-y",
_("Lower point Y"),
_("Array of 17 y point coords "
"{ 0.0 <= y <= 1.0 or -1 for unused point }"),
G_PARAM_READWRITE);
gimp_procedure_add_float_array_argument (procedure, "lower-point-y",
_("Lower point Y"),
_("Array of 17 y point coords "
"{ 0.0 <= y <= 1.0 or -1 for unused point }"),
G_PARAM_READWRITE);
GIMP_PROC_ARG_BYTES (procedure, "upper-val-y",
_("Upper val Y"),
_("Array of 256 y freehand coords "
"{ 0 <= y <= 255 }"),
G_PARAM_READWRITE);
gimp_procedure_add_bytes_argument (procedure, "upper-val-y",
_("Upper val Y"),
_("Array of 256 y freehand coords "
"{ 0 <= y <= 255 }"),
G_PARAM_READWRITE);
GIMP_PROC_ARG_BYTES (procedure, "lower-val-y",
_("Lower val Y"),
_("Array of 256 y freehand coords "
"{ 0 <= y <= 255 }"),
G_PARAM_READWRITE);
gimp_procedure_add_bytes_argument (procedure, "lower-val-y",
_("Lower val Y"),
_("Array of 256 y freehand coords "
"{ 0 <= y <= 255 }"),
G_PARAM_READWRITE);
GIMP_PROC_VAL_LAYER (procedure, "bent-layer",
_("Bent layer"),
_("The transformed layer"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_layer_return_value (procedure, "bent-layer",
_("Bent layer"),
_("The transformed layer"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BYTES (procedure, "settings-data",
"Settings data",
"TODO: eventually we must implement proper args for every settings",
GIMP_PARAM_READWRITE);
gimp_procedure_add_bytes_aux_argument (procedure, "settings-data",
"Settings data",
"TODO: eventually we must implement proper args for every settings",
GIMP_PARAM_READWRITE);
}
return procedure;

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

@ -294,63 +294,63 @@ decompose_create_procedure (GimpPlugIn *plug_in,
"Peter Kirchgessner, Clarence Risher",
"1997");
GIMP_PROC_ARG_CHOICE (procedure, "decompose-type",
_("Color _model"),
_("The model to decompose to"),
gimp_choice_new_with_values ("rgb", 0, _("RGB"), NULL,
"rgba", 1, _("RGBA"), NULL,
"alpha", 2, _("Alpha"), NULL,
"hsv", 3, _("HSV"), NULL,
"hsl", 4, _("HSL"), NULL,
"cmyk", 5, _("CMYK"), NULL,
"lab", 6, _("LAB"), NULL,
"lch", 7, _("LCH"), NULL,
"ycbcr470", 8, _("YCbCr ITU R470"), NULL,
"ycbcr709", 9, _("YCbCr ITU R709"), NULL,
"ycbcr470f", 10, _("YCbCr ITU R470 256"), NULL,
"ycbcr709f", 11, _("YCbCr ITU R709 256"), NULL,
NULL),
"rgb",
G_PARAM_READWRITE);
gimp_procedure_add_choice_argument (procedure, "decompose-type",
_("Color _model"),
_("The model to decompose to"),
gimp_choice_new_with_values ("rgb", 0, _("RGB"), NULL,
"rgba", 1, _("RGBA"), NULL,
"alpha", 2, _("Alpha"), NULL,
"hsv", 3, _("HSV"), NULL,
"hsl", 4, _("HSL"), NULL,
"cmyk", 5, _("CMYK"), NULL,
"lab", 6, _("LAB"), NULL,
"lch", 7, _("LCH"), NULL,
"ycbcr470", 8, _("YCbCr ITU R470"), NULL,
"ycbcr709", 9, _("YCbCr ITU R709"), NULL,
"ycbcr470f", 10, _("YCbCr ITU R470 256"), NULL,
"ycbcr709f", 11, _("YCbCr ITU R709 256"), NULL,
NULL),
"rgb",
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "layers-mode",
_("_Decompose to layers"),
_("Create channels as layers in a single image"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "layers-mode",
_("_Decompose to layers"),
_("Create channels as layers in a single image"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "use-registration",
_("_Foreground as registration color"),
_("When enabled, pixels in the foreground color "
"will appear black in all output images. This "
"can be used for things like crop marks that "
"have to show up on all channels."),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "use-registration",
_("_Foreground as registration color"),
_("When enabled, pixels in the foreground color "
"will appear black in all output images. This "
"can be used for things like crop marks that "
"have to show up on all channels."),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_VAL_IMAGE (procedure, "new-image-1",
"New image 1",
"Output gray image 1",
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_image_return_value (procedure, "new-image-1",
"New image 1",
"Output gray image 1",
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_VAL_IMAGE (procedure, "new-image-2",
"New image 2",
"Output gray image 2 (N/A for single channel extract)",
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_image_return_value (procedure, "new-image-2",
"New image 2",
"Output gray image 2 (N/A for single channel extract)",
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_VAL_IMAGE (procedure, "new-image-3",
"New image 3",
"Output gray image 3 (N/A for single channel extract)",
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_image_return_value (procedure, "new-image-3",
"New image 3",
"Output gray image 3 (N/A for single channel extract)",
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_VAL_IMAGE (procedure, "new-image-4",
"New image 4",
"Output gray image 4 (N/A for single channel extract)",
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_image_return_value (procedure, "new-image-4",
"New image 4",
"Output gray image 4 (N/A for single channel extract)",
TRUE,
G_PARAM_READWRITE);
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",
PLUG_IN_VERSION);
GIMP_PROC_ARG_DRAWABLE (procedure, "source-1",
_("Source _1"),
_("Source 1"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_drawable_argument (procedure, "source-1",
_("Source _1"),
_("Source 1"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DRAWABLE (procedure, "depth-map-1",
_("_Depth map 1"),
_("Depth map 1"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_drawable_argument (procedure, "depth-map-1",
_("_Depth map 1"),
_("Depth map 1"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DRAWABLE (procedure, "source-2",
_("Source _2"),
_("Source 2"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_drawable_argument (procedure, "source-2",
_("Source _2"),
_("Source 2"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DRAWABLE (procedure, "depth-map-2",
_("Depth _map 2"),
_("Depth map 2"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_drawable_argument (procedure, "depth-map-2",
_("Depth _map 2"),
_("Depth map 2"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "overlap",
_("O_verlap"),
_("Overlap"),
0, 2, 0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "overlap",
_("O_verlap"),
_("Overlap"),
0, 2, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "offset",
_("O_ffset"),
_("Depth relative offset"),
-1, 1, 0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "offset",
_("O_ffset"),
_("Depth relative offset"),
-1, 1, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "scale-1",
_("Sc_ale 1"),
_("Depth relative scale 1"),
-1, 1, 1,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "scale-1",
_("Sc_ale 1"),
_("Depth relative scale 1"),
-1, 1, 1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "scale-2",
_("Scal_e 2"),
_("Depth relative scale 2"),
-1, 1, 1,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "scale-2",
_("Scal_e 2"),
_("Depth relative scale 2"),
-1, 1, 1,
G_PARAM_READWRITE);
}
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",
PLUG_IN_VERSION);
GIMP_PROC_ARG_INT (procedure, "radius",
_("R_adius"),
_("Filter box radius"),
1, MAX_RADIUS, 3,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "radius",
_("R_adius"),
_("Filter box radius"),
1, MAX_RADIUS, 3,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "type",
_("_Filter Type"),
_("Filter type { MEDIAN (0), ADAPTIVE (1), "
"RECURSIVE-MEDIAN (2), RECURSIVE-ADAPTIVE (3) }"),
0, 3, FILTER_ADAPTIVE,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "type",
_("_Filter Type"),
_("Filter type { MEDIAN (0), ADAPTIVE (1), "
"RECURSIVE-MEDIAN (2), RECURSIVE-ADAPTIVE (3) }"),
0, 3, FILTER_ADAPTIVE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "black",
_("_Black level"),
_("Black level"),
-1, 255, 7,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "black",
_("_Black level"),
_("Black level"),
-1, 255, 7,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "white",
_("_White level"),
_("White level"),
0, 256, 248,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "white",
_("_White level"),
_("White level"),
0, 256, 248,
G_PARAM_READWRITE);
}
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>",
PLUG_IN_VERSION);
GIMP_PROC_ARG_INT (procedure, "avg-width",
_("_Width"),
_("Averaging filter width"),
2, MAX_AVG, 36,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "avg-width",
_("_Width"),
_("Averaging filter width"),
2, MAX_AVG, 36,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure,
"create-histogram",
_("Create _histogram"),
_("Output a histogram"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure,
"create-histogram",
_("Create _histogram"),
_("Output a histogram"),
FALSE,
G_PARAM_READWRITE);
}
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++);
GIMP_PROC_ARG_INT (procedure, "file-type",
_("_Format"),
_("File type to use"),
0, i, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "file-type",
_("_Format"),
_("File type to use"),
0, i, 0,
G_PARAM_READWRITE);
}
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),
"0,string,KiSS\\040");
GIMP_PROC_ARG_FILE (procedure, "palette-file",
_("_Palette file"),
_("KCF file to load palette from"),
G_PARAM_READWRITE);
gimp_procedure_add_file_argument (procedure, "palette-file",
_("_Palette file"),
_("KCF file to load palette from"),
G_PARAM_READWRITE);
}
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),
"cel");
GIMP_PROC_ARG_FILE (procedure, "palette-file",
"Palette file",
"File to save palette to",
G_PARAM_READWRITE);
gimp_procedure_add_file_argument (procedure, "palette-file",
_("_Palette file"),
_("File to save palette to"),
G_PARAM_READWRITE);
}
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),
"c");
GIMP_PROC_AUX_ARG_STRING (procedure, "prefixed-name",
_("_Prefixed name"),
_("Prefixed name"),
"gimp_image",
GIMP_PARAM_READWRITE);
gimp_procedure_add_string_aux_argument (procedure, "prefixed-name",
_("_Prefixed name"),
_("Prefixed name"),
"gimp_image",
GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_STRING (procedure, "gimp-comment",
_("Comme_nt"),
_("Comment"),
gimp_get_default_comment (),
GIMP_PARAM_READWRITE);
gimp_procedure_add_string_aux_argument (procedure, "gimp-comment",
_("Comme_nt"),
_("Comment"),
gimp_get_default_comment (),
GIMP_PARAM_READWRITE);
gimp_procedure_set_argument_sync (procedure, "gimp-comment",
GIMP_ARGUMENT_SYNC_PARASITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-comment",
_("Save comment to _file"),
_("Save comment"),
gimp_export_comment (),
GIMP_PARAM_READWRITE);
gimp_procedure_add_boolean_aux_argument (procedure, "save-comment",
_("Save comment to _file"),
_("Save comment"),
gimp_export_comment (),
GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "glib-types",
_("Use GLib types (guint_8*)"),
_("Use GLib types"),
TRUE,
GIMP_PARAM_READWRITE);
gimp_procedure_add_boolean_aux_argument (procedure, "glib-types",
_("Use GLib types (guint_8*)"),
_("Use GLib types"),
TRUE,
GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-alpha",
_("Save alpha channel (RG_BA/RGB)"),
_("Save the alpha channel"),
FALSE,
GIMP_PARAM_READWRITE);
gimp_procedure_add_boolean_aux_argument (procedure, "save-alpha",
_("Save alpha channel (RG_BA/RGB)"),
_("Save the alpha channel"),
FALSE,
GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "rgb565",
_("Save as RGB565 (1_6-bit)"),
_("Use RGB565 encoding"),
FALSE,
GIMP_PARAM_READWRITE);
gimp_procedure_add_boolean_aux_argument (procedure, "rgb565",
_("Save as RGB565 (1_6-bit)"),
_("Use RGB565 encoding"),
FALSE,
GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "use-macros",
_("_Use macros instead of struct"),
_("Use C macros"),
FALSE,
GIMP_PARAM_READWRITE);
gimp_procedure_add_boolean_aux_argument (procedure, "use-macros",
_("_Use macros instead of struct"),
_("Use C macros"),
FALSE,
GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "use-rle",
_("Use _1 bit Run-Length-Encoding"),
_("Use run-length-encoding"),
FALSE,
GIMP_PARAM_READWRITE);
gimp_procedure_add_boolean_aux_argument (procedure, "use-rle",
_("Use _1 bit Run-Length-Encoding"),
_("Use run-length-encoding"),
FALSE,
GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "opacity",
_("Opaci_ty"),
_("Opacity"),
0.0, 100.0, 100.0,
GIMP_PARAM_READWRITE);
gimp_procedure_add_double_aux_argument (procedure, "opacity",
_("Opaci_ty"),
_("Opacity"),
0.0, 100.0, 100.0,
GIMP_PARAM_READWRITE);
}
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),
TRUE);
GIMP_PROC_ARG_INT (procedure, "spacing",
_("Sp_acing"),
_("Spacing of the brush"),
1, 1000, 10,
GIMP_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "spacing",
_("Sp_acing"),
_("Spacing of the brush"),
1, 1000, 10,
GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "description",
_("_Description"),
_("Short description of the brush"),
_("GIMP Brush"),
GIMP_PARAM_READWRITE);
gimp_procedure_add_string_argument (procedure, "description",
_("_Description"),
_("Short description of the brush"),
_("GIMP Brush"),
GIMP_PARAM_READWRITE);
}
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),
"gif");
GIMP_PROC_ARG_BOOLEAN (procedure, "interlace",
_("_Interlace"),
_("Try to export as interlaced"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "interlace",
_("_Interlace"),
_("Try to export as interlaced"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "loop",
_("Loop _Forever"),
_("(animated gif) Loop infinitely"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "loop",
_("Loop _Forever"),
_("(animated gif) Loop infinitely"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "number-of-repeats",
_("_Number of repeats"),
_("(animated gif) Number of repeats "
"(Ignored if 'loop' is TRUE)"),
0, G_MAXSHORT - 1, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "number-of-repeats",
_("_Number of repeats"),
_("(animated gif) Number of repeats "
"(Ignored if 'loop' is TRUE)"),
0, G_MAXSHORT - 1, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "default-delay",
_("_Delay between frames when unspecified"),
_("(animated gif) Default delay between frames "
"in milliseconds"),
0, G_MAXINT, 100,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "default-delay",
_("_Delay between frames when unspecified"),
_("(animated gif) Default delay between frames "
"in milliseconds"),
0, G_MAXINT, 100,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "default-dispose",
_("Frame disposal _when unspecified"),
_("(animated gif) Default disposal type "
"(0=`don't care`, "
"1=combine, "
"2=replace)"),
0, 2, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "default-dispose",
_("Frame disposal _when unspecified"),
_("(animated gif) Default disposal type "
"(0=`don't care`, "
"1=combine, "
"2=replace)"),
0, 2, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "as-animation",
_("_As animation"),
_("Export GIF as animation?"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "as-animation",
_("_As animation"),
_("Export GIF as animation?"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "force-delay",
_("_Use delay entered above for all frames"),
_("(animated gif) Use specified delay for all frames"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "force-delay",
_("_Use delay entered above for all frames"),
_("(animated gif) Use specified delay for all frames"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "force-dispose",
_("Use dis_posal entered above "
"for all frames"),
_("(animated gif) Use specified disposal for all frames"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "force-dispose",
_("Use dis_posal entered above "
"for all frames"),
_("(animated gif) Use specified disposal for all frames"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-comment",
_("Sa_ve comment"),
_("Save the image comment in the GIF file"),
gimp_export_comment (),
G_PARAM_READWRITE);
gimp_procedure_add_boolean_aux_argument (procedure, "save-comment",
_("Sa_ve comment"),
_("Save the image comment in the GIF file"),
gimp_export_comment (),
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_STRING (procedure, "gimp-comment",
_("Commen_t"),
_("Image comment"),
gimp_get_default_comment (),
G_PARAM_READWRITE);
gimp_procedure_add_string_aux_argument (procedure, "gimp-comment",
_("Commen_t"),
_("Image comment"),
gimp_get_default_comment (),
G_PARAM_READWRITE);
gimp_procedure_set_argument_sync (procedure, "gimp-comment",
GIMP_ARGUMENT_SYNC_PARASITE);
@ -329,7 +329,7 @@ gif_export (GimpProcedure *procedure,
if (status == GIMP_PDB_SUCCESS)
{
GList *drawables;
GList *drawables;
/* Create an exportable image based on the export options */
switch (run_mode)
@ -360,7 +360,7 @@ gif_export (GimpProcedure *procedure,
}
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))
{
status = GIMP_PDB_EXECUTION_ERROR;
@ -373,7 +373,7 @@ gif_export (GimpProcedure *procedure,
if (export == GIMP_EXPORT_EXPORT)
gimp_image_delete (image);
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),
TRUE);
GIMP_PROC_ARG_INT (procedure, "spacing",
_("Spacing (_percent)"),
_("Spacing of the brush"),
1, 1000, 20,
GIMP_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "spacing",
_("Spacing (_percent)"),
_("Spacing of the brush"),
1, 1000, 20,
GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "description",
_("_Description"),
_("Short description of the GIH brush pipe"),
"GIMP Brush Pipe",
GIMP_PARAM_READWRITE);
gimp_procedure_add_string_argument (procedure, "description",
_("_Description"),
_("Short description of the GIH brush pipe"),
"GIMP Brush Pipe",
GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "cell-width",
_("Cell _width"),
_("Width of the brush cells in pixels"),
1, 1000, 1,
GIMP_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "cell-width",
_("Cell _width"),
_("Width of the brush cells in pixels"),
1, 1000, 1,
GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "cell-height",
_("Cell _height"),
_("Height of the brush cells in pixels"),
1, 1000, 1,
GIMP_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "cell-height",
_("Cell _height"),
_("Height of the brush cells in pixels"),
1, 1000, 1,
GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "num-cells",
_("_Number of cells"),
_("Number of cells to cut up"),
1, 1000, 1,
GIMP_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "num-cells",
_("_Number of cells"),
_("Number of cells to cut up"),
1, 1000, 1,
GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_BYTES (procedure, "ranks",
_("_Rank"),
_("Ranks of the dimensions"),
GIMP_PARAM_READWRITE);
gimp_procedure_add_bytes_argument (procedure, "ranks",
_("_Rank"),
_("Ranks of the dimensions"),
GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_STRV (procedure, "selection-modes",
"Selection modes",
_("Selection modes"),
GIMP_PARAM_READWRITE);
gimp_procedure_add_string_array_argument (procedure, "selection-modes",
_("Selection modes"),
_("Selection modes"),
GIMP_PARAM_READWRITE);
/* Auxiliary arguments. Only useful for the GUI, to pass info around. */
GIMP_PROC_AUX_ARG_STRING (procedure, "info-text",
_("Display as"),
_("Describe how the layers will be split"),
"", GIMP_PARAM_READWRITE);
gimp_procedure_add_string_aux_argument (procedure, "info-text",
_("Display as"),
_("Describe how the layers will be split"),
"", GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_INT (procedure, "dimension",
_("D_imension"),
_("How many dimensions the animated brush has"),
1, 1000, 1,
GIMP_PARAM_READWRITE);
gimp_procedure_add_int_aux_argument (procedure, "dimension",
_("D_imension"),
_("How many dimensions the animated brush has"),
1, 1000, 1,
GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_INT32_ARRAY (procedure, "guides",
"Guides",
"Guides to show how the layers will be split in cells",
GIMP_PARAM_READWRITE);
gimp_procedure_add_int32_array_aux_argument (procedure, "guides",
"Guides",
"Guides to show how the layers will be split in cells",
GIMP_PARAM_READWRITE);
}
return procedure;

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

@ -116,24 +116,24 @@ glob_create_procedure (GimpPlugIn *plug_in,
"Sven Neumann",
"2004");
GIMP_PROC_ARG_STRING (procedure, "pattern",
"Pattern",
"The glob pattern (in UTF-8 encoding)",
NULL,
G_PARAM_READWRITE);
gimp_procedure_add_string_argument (procedure, "pattern",
"Pattern",
"The glob pattern (in UTF-8 encoding)",
NULL,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "filename-encoding",
"Filename encoding",
"FALSE to return UTF-8 strings, TRUE to return "
"strings in filename encoding",
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "filename-encoding",
"Filename encoding",
"FALSE to return UTF-8 strings, TRUE to return "
"strings in filename encoding",
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_VAL_STRV (procedure, "files",
"Files",
"The list of matching filenames",
G_PARAM_READWRITE |
GIMP_PARAM_NO_VALIDATE);
gimp_procedure_add_string_array_return_value (procedure, "files",
"Files",
"The list of matching filenames",
G_PARAM_READWRITE |
GIMP_PARAM_NO_VALIDATE);
}
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),
"heif,heic");
GIMP_PROC_ARG_INT (procedure, "quality",
_("_Quality"),
_("Quality factor (0 = worst, 100 = best)"),
0, 100, 50,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "quality",
_("_Quality"),
_("Quality factor (0 = worst, 100 = best)"),
0, 100, 50,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "lossless",
_("L_ossless"),
_("Use lossless compression"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "lossless",
_("L_ossless"),
_("Use lossless compression"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-color-profile",
_("Save color prof_ile"),
_("Save the image's color profile"),
gimp_export_color_profile (),
G_PARAM_READWRITE);
gimp_procedure_add_boolean_aux_argument (procedure, "save-color-profile",
_("Save color prof_ile"),
_("Save the image's color profile"),
gimp_export_color_profile (),
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "save-bit-depth",
_("_Bit depth"),
_("Bit depth of exported image"),
8, 12, 8,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "save-bit-depth",
_("_Bit depth"),
_("Bit depth of exported image"),
8, 12, 8,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "pixel-format",
_("_Pixel format"),
_("Format of color sub-sampling"),
HEIFPLUGIN_EXPORT_FORMAT_RGB, HEIFPLUGIN_EXPORT_FORMAT_YUV420,
HEIFPLUGIN_EXPORT_FORMAT_YUV420,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "pixel-format",
_("_Pixel format"),
_("Format of color sub-sampling"),
HEIFPLUGIN_EXPORT_FORMAT_RGB, HEIFPLUGIN_EXPORT_FORMAT_YUV420,
HEIFPLUGIN_EXPORT_FORMAT_YUV420,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "encoder-speed",
_("Enco_der speed"),
_("Tradeoff between speed and compression"),
HEIFPLUGIN_ENCODER_SPEED_SLOW, HEIFPLUGIN_ENCODER_SPEED_FASTER,
HEIFPLUGIN_ENCODER_SPEED_BALANCED,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "encoder-speed",
_("Enco_der speed"),
_("Tradeoff between speed and compression"),
HEIFPLUGIN_ENCODER_SPEED_SLOW, HEIFPLUGIN_ENCODER_SPEED_FASTER,
HEIFPLUGIN_ENCODER_SPEED_BALANCED,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "save-exif",
_("Save Exi_f"),
_("Toggle saving Exif data"),
gimp_export_exif (),
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "save-exif",
_("Save Exi_f"),
_("Toggle saving Exif data"),
gimp_export_exif (),
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "save-xmp",
_("Save _XMP"),
_("Toggle saving XMP data"),
gimp_export_xmp (),
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "save-xmp",
_("Save _XMP"),
_("Toggle saving XMP data"),
gimp_export_xmp (),
G_PARAM_READWRITE);
}
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_PROC_ARG_INT (procedure, "quality",
_("_Quality"),
_("Quality factor (0 = worst, 100 = best)"),
0, 100, 50,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "quality",
_("_Quality"),
_("Quality factor (0 = worst, 100 = best)"),
0, 100, 50,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "lossless",
_("L_ossless"),
_("Use lossless compression"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "lossless",
_("L_ossless"),
_("Use lossless compression"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-color-profile",
_("Save color prof_ile"),
_("Save the image's color profile"),
gimp_export_color_profile (),
G_PARAM_READWRITE);
gimp_procedure_add_boolean_aux_argument (procedure, "save-color-profile",
_("Save color prof_ile"),
_("Save the image's color profile"),
gimp_export_color_profile (),
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "save-bit-depth",
_("_Bit depth"),
_("Bit depth of exported image"),
8, 12, 8,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "save-bit-depth",
_("_Bit depth"),
_("Bit depth of exported image"),
8, 12, 8,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "pixel-format",
_("_Pixel format"),
_("Format of color sub-sampling"),
HEIFPLUGIN_EXPORT_FORMAT_RGB, HEIFPLUGIN_EXPORT_FORMAT_YUV420,
HEIFPLUGIN_EXPORT_FORMAT_YUV420,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "pixel-format",
_("_Pixel format"),
_("Format of color sub-sampling"),
HEIFPLUGIN_EXPORT_FORMAT_RGB, HEIFPLUGIN_EXPORT_FORMAT_YUV420,
HEIFPLUGIN_EXPORT_FORMAT_YUV420,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "encoder-speed",
_("Enco_der speed"),
_("Tradeoff between speed and compression"),
HEIFPLUGIN_ENCODER_SPEED_SLOW, HEIFPLUGIN_ENCODER_SPEED_FASTER,
HEIFPLUGIN_ENCODER_SPEED_BALANCED,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "encoder-speed",
_("Enco_der speed"),
_("Tradeoff between speed and compression"),
HEIFPLUGIN_ENCODER_SPEED_SLOW, HEIFPLUGIN_ENCODER_SPEED_FASTER,
HEIFPLUGIN_ENCODER_SPEED_BALANCED,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "save-exif",
_("Save Exi_f"),
_("Toggle saving Exif data"),
gimp_export_exif (),
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "save-exif",
_("Save Exi_f"),
_("Toggle saving Exif data"),
gimp_export_exif (),
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "save-xmp",
_("Save _XMP"),
_("Toggle saving XMP data"),
gimp_export_xmp (),
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "save-xmp",
_("Save _XMP"),
_("Toggle saving XMP data"),
gimp_export_xmp (),
G_PARAM_READWRITE);
}
#if LIBHEIF_HAVE_VERSION(1,17,0)
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),
"html,htm");
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "use-caption",
_("Use c_aption"),
_("Enable if you would like to have the table "
"captioned."),
FALSE,
GIMP_PARAM_READWRITE);
gimp_procedure_add_boolean_aux_argument (procedure, "use-caption",
_("Use c_aption"),
_("Enable if you would like to have the table "
"captioned."),
FALSE,
GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_STRING (procedure, "caption-text",
_("Capt_ion"),
_("The text for the table caption."),
"Made with GIMP Table Magic",
GIMP_PARAM_READWRITE);
gimp_procedure_add_string_aux_argument (procedure, "caption-text",
_("Capt_ion"),
_("The text for the table caption."),
"Made with GIMP Table Magic",
GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_STRING (procedure, "cell-content",
_("Cell con_tent"),
_("The text to go into each cell."),
"&nbsp;",
GIMP_PARAM_READWRITE);
gimp_procedure_add_string_aux_argument (procedure, "cell-content",
_("Cell con_tent"),
_("The text to go into each cell."),
"&nbsp;",
GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_STRING (procedure, "cell-width",
_("_Width"),
_("The width for each table cell. "
"Can be a number or a percent."),
"",
GIMP_PARAM_READWRITE);
gimp_procedure_add_string_aux_argument (procedure, "cell-width",
_("_Width"),
_("The width for each table cell. "
"Can be a number or a percent."),
"",
GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_STRING (procedure, "cell-height",
_("_Height"),
_("The height for each table cell. "
"Can be a number or a percent."),
"",
GIMP_PARAM_READWRITE);
gimp_procedure_add_string_aux_argument (procedure, "cell-height",
_("_Height"),
_("The height for each table cell. "
"Can be a number or a percent."),
"",
GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "full-document",
_("_Generate full HTML document"),
_("If enabled GTM will output a full HTML "
"document with <HTML>, <BODY>, etc. tags "
"instead of just the table html."),
TRUE,
GIMP_PARAM_READWRITE);
gimp_procedure_add_boolean_aux_argument (procedure, "full-document",
_("_Generate full HTML document"),
_("If enabled GTM will output a full HTML "
"document with <HTML>, <BODY>, etc. tags "
"instead of just the table html."),
TRUE,
GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_INT (procedure, "border",
_("_Border"),
_("The number of pixels in the table border."),
0, 1000, 2,
GIMP_PARAM_READWRITE);
gimp_procedure_add_int_aux_argument (procedure, "border",
_("_Border"),
_("The number of pixels in the table border."),
0, 1000, 2,
GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "span-tags",
_("_Use cellspan"),
_("If enabled GTM will replace any "
"rectangular sections of identically "
"colored blocks with one large cell with "
"ROWSPAN and COLSPAN values."),
FALSE,
GIMP_PARAM_READWRITE);
gimp_procedure_add_boolean_aux_argument (procedure, "span-tags",
_("_Use cellspan"),
_("If enabled GTM will replace any "
"rectangular sections of identically "
"colored blocks with one large cell with "
"ROWSPAN and COLSPAN values."),
FALSE,
GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "compress-td-tags",
_("Co_mpress TD tags"),
_("Enabling this will cause GTM to "
"leave no whitespace between the TD "
"tags and the cell content. This is only "
"necessary for pixel level positioning "
"control."),
FALSE,
GIMP_PARAM_READWRITE);
gimp_procedure_add_boolean_aux_argument (procedure, "compress-td-tags",
_("Co_mpress TD tags"),
_("Enabling this will cause GTM to "
"leave no whitespace between the TD "
"tags and the cell content. This is only "
"necessary for pixel level positioning "
"control."),
FALSE,
GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_INT (procedure, "cell-padding",
_("Cell-pa_dding"),
_("The amount of cell padding."),
0, 1000, 4,
GIMP_PARAM_READWRITE);
gimp_procedure_add_int_aux_argument (procedure, "cell-padding",
_("Cell-pa_dding"),
_("The amount of cell padding."),
0, 1000, 4,
GIMP_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_INT (procedure, "cell-spacing",
_("Cell spaci_ng"),
_("The amount of cell spacing."),
0, 1000, 0,
GIMP_PARAM_READWRITE);
gimp_procedure_add_int_aux_argument (procedure, "cell-spacing",
_("Cell spaci_ng"),
_("The amount of cell spacing."),
0, 1000, 0,
GIMP_PARAM_READWRITE);
}
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),
"j2k,j2c,jpc");
GIMP_PROC_ARG_INT (procedure, "colorspace",
_("Color s_pace"),
_("Color space { UNKNOWN (0), GRAYSCALE (1), RGB (2), "
"CMYK (3), YCbCr (4), xvYCC (5) }"),
0, 5, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "colorspace",
_("Color s_pace"),
_("Color space { UNKNOWN (0), GRAYSCALE (1), RGB (2), "
"CMYK (3), YCbCr (4), xvYCC (5) }"),
0, 5, 0,
G_PARAM_READWRITE);
}
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),
"jxl");
GIMP_PROC_ARG_BOOLEAN (procedure, "lossless",
_("L_ossless"),
_("Use lossless compression"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "lossless",
_("L_ossless"),
_("Use lossless compression"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "compression",
_("Co_mpression/maxError"),
_("Max. butteraugli distance, lower = higher quality. Range: 0 .. 15. 1.0 = visually lossless."),
0.1, 15, 1,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "compression",
_("Co_mpression/maxError"),
_("Max. butteraugli distance, lower = higher quality. Range: 0 .. 15. 1.0 = visually lossless."),
0.1, 15, 1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "save-bit-depth",
_("_Bit depth"),
_("Bit depth of exported image"),
8, 16, 8,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "save-bit-depth",
_("_Bit depth"),
_("Bit depth of exported image"),
8, 16, 8,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "speed",
_("Effort/S_peed"),
_("Encoder effort setting"),
1, 9,
7,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "speed",
_("Effort/S_peed"),
_("Encoder effort setting"),
1, 9,
7,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "uses-original-profile",
_("Save ori_ginal profile"),
_("Store ICC profile to exported JXL file"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "uses-original-profile",
_("Save ori_ginal profile"),
_("Store ICC profile to exported JXL file"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "cmyk",
_("Export as CMY_K"),
_("Create a CMYK JPEG XL image using the soft-proofing color profile"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "cmyk",
_("Export as CMY_K"),
_("Create a CMYK JPEG XL image using the soft-proofing color profile"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "save-exif",
_("Save Exi_f"),
_("Toggle saving Exif data"),
gimp_export_exif (),
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "save-exif",
_("Save Exi_f"),
_("Toggle saving Exif data"),
gimp_export_exif (),
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "save-xmp",
_("Save _XMP"),
_("Toggle saving XMP data"),
gimp_export_xmp (),
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "save-xmp",
_("Save _XMP"),
_("Toggle saving XMP data"),
gimp_export_xmp (),
G_PARAM_READWRITE);
}
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),
"mng");
GIMP_PROC_ARG_BOOLEAN (procedure, "interlaced",
_("_Interlace"),
_("Use interlacing"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "interlaced",
_("_Interlace"),
_("Use interlacing"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "png-compression",
_("_PNG compression level"),
_("PNG compression level, choose a high compression "
"level for small file size"),
0, 9, 9,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "png-compression",
_("_PNG compression level"),
_("PNG compression level, choose a high compression "
"level for small file size"),
0, 9, 9,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "jpeg-quality",
_("JPEG compression _quality"),
_("JPEG quality factor"),
0, 1, 0.75,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "jpeg-quality",
_("JPEG compression _quality"),
_("JPEG quality factor"),
0, 1, 0.75,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "jpeg-smoothing",
_("_JPEG smoothing factor"),
_("JPEG smoothing factor"),
0, 1, 0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "jpeg-smoothing",
_("_JPEG smoothing factor"),
_("JPEG smoothing factor"),
0, 1, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "loop",
_("L_oop"),
_("(ANIMATED MNG) Loop infinitely"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "loop",
_("L_oop"),
_("(ANIMATED MNG) Loop infinitely"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "default-delay",
_("Default fra_me delay"),
_("(ANIMATED MNG) Default delay between frames in "
"milliseconds"),
1, G_MAXINT, 100,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "default-delay",
_("Default fra_me delay"),
_("(ANIMATED MNG) Default delay between frames in "
"milliseconds"),
1, G_MAXINT, 100,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "default-chunks",
_("Default chunks t_ype"),
_("(ANIMATED MNG) Default chunks type "
"(0 = PNG + Delta PNG; 1 = JNG + Delta PNG; "
"2 = All PNG; 3 = All JNG)"),
0, 3, CHUNKS_PNG_D,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "default-chunks",
_("Default chunks t_ype"),
_("(ANIMATED MNG) Default chunks type "
"(0 = PNG + Delta PNG; 1 = JNG + Delta PNG; "
"2 = All PNG; 3 = All JNG)"),
0, 3, CHUNKS_PNG_D,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "default-dispose",
_("De_fault frame disposal"),
_("(ANIMATED MNG) Default dispose type "
"(0 = combine; 1 = replace)"),
0, 1, DISPOSE_COMBINE,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "default-dispose",
_("De_fault frame disposal"),
_("(ANIMATED MNG) Default dispose type "
"(0 = combine; 1 = replace)"),
0, 1, DISPOSE_COMBINE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "bkgd",
_("Save _background color"),
_("Write bKGd (background color) chunk"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "bkgd",
_("Save _background color"),
_("Write bKGd (background color) chunk"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "gama",
_("Save _gamma"),
_("Write gAMA (gamma) chunk"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "gama",
_("Save _gamma"),
_("Write gAMA (gamma) chunk"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "phys",
_("Sa_ve resolution"),
_("Write pHYs (image resolution) chunk"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "phys",
_("Sa_ve resolution"),
_("Write pHYs (image resolution) chunk"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "time",
_("Save creation _time"),
_("Write tIME (creation time) chunk"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "time",
_("Save creation _time"),
_("Write tIME (creation time) chunk"),
TRUE,
G_PARAM_READWRITE);
}
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),
TRUE);
GIMP_PROC_ARG_STRING (procedure, "description",
_("_Description"),
_("Short description of the pattern"),
_("GIMP Pattern"),
GIMP_PARAM_READWRITE);
gimp_procedure_add_string_argument (procedure, "description",
_("_Description"),
_("Short description of the pattern"),
_("GIMP Pattern"),
GIMP_PARAM_READWRITE);
}
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>",
"January 1997");
GIMP_PROC_ARG_INT (procedure, "override-palette",
_("Palette Options"),
_("Use built-in palette (0) or override with "
"black/white (1)"),
0, 1, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "override-palette",
_("Palette Options"),
_("Use built-in palette (0) or override with "
"black/white (1)"),
0, 1, 0,
G_PARAM_READWRITE);
gimp_file_procedure_set_mime_types (GIMP_FILE_PROCEDURE (procedure),
"image/x-pcx");
@ -249,12 +249,12 @@ pcx_create_procedure (GimpPlugIn *plug_in,
"Alex S.",
"2023");
GIMP_PROC_ARG_INT (procedure, "override-palette",
_("Palette Options"),
_("Use built-in palette (0) or override with "
"black/white (1)"),
0, 1, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "override-palette",
_("Palette Options"),
_("Use built-in palette (0) or override with "
"black/white (1)"),
0, 1, 0,
G_PARAM_READWRITE);
gimp_file_procedure_set_mime_types (GIMP_FILE_PROCEDURE (procedure),
"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_documentation (procedure,
"Exports files in ZSoft PCX file format",
_("Exports files in ZSoft PCX file format"),
"FIXME: write help for pcx_export",
name);
gimp_procedure_set_attribution (procedure,

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),
"pdf");
GIMP_PROC_ARG_BOOLEAN (procedure, "vectorize",
_("Convert _bitmaps to vector graphics where possible"),
_("Convert bitmaps to vector graphics where possible"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "vectorize",
_("Convert _bitmaps to vector graphics where possible"),
_("Convert bitmaps to vector graphics where possible"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "ignore-hidden",
_("O_mit hidden layers and layers with zero opacity"),
_("Non-visible layers will not be exported"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "ignore-hidden",
_("O_mit hidden layers and layers with zero opacity"),
_("Non-visible layers will not be exported"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "apply-masks",
_("_Apply layer masks"),
_("Apply layer masks before saving (Keeping the mask "
"will not change the output, only the PDF structure)"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "apply-masks",
_("_Apply layer masks"),
_("Apply layer masks before saving (Keeping the mask "
"will not change the output, only the PDF structure)"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "layers-as-pages",
_("La_yers as pages"),
_("Layers as pages (bottom layers first)."),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "layers-as-pages",
_("La_yers as pages"),
_("Layers as pages (bottom layers first)."),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "reverse-order",
_("Re_verse order"),
_("Reverse the pages order (top layers first)."),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "reverse-order",
_("Re_verse order"),
_("Reverse the pages order (top layers first)."),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "root-layers-only",
_("Roo_t layers only"),
_("Only the root layers are considered pages"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "root-layers-only",
_("Roo_t layers only"),
_("Only the root layers are considered pages"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "convert-text-layers",
_("Convert te_xt layers to image"),
_("Convert text layers to raster graphics"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "convert-text-layers",
_("Convert te_xt layers to image"),
_("Convert text layers to raster graphics"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "fill-background-color",
_("_Fill transparent areas with background color"),
_("Fill transparent areas with background color if "
"layer has an alpha channel"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "fill-background-color",
_("_Fill transparent areas with background color"),
_("Fill transparent areas with background color if "
"layer has an alpha channel"),
TRUE,
G_PARAM_READWRITE);
}
else if (! strcmp (name, EXPORT_MULTI_PROC))
{
@ -409,57 +409,57 @@ pdf_create_procedure (GimpPlugIn *plug_in,
"Copyright Barak Itkin",
"August 2009");
GIMP_PROC_ARG_ENUM (procedure, "run-mode",
"Run mode",
"The run mode",
GIMP_TYPE_RUN_MODE,
GIMP_RUN_INTERACTIVE,
G_PARAM_READWRITE);
gimp_procedure_add_enum_argument (procedure, "run-mode",
"Run mode",
"The run mode",
GIMP_TYPE_RUN_MODE,
GIMP_RUN_INTERACTIVE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "count",
_("Count"),
_("The number of images entered (This will be the "
"number of pages)."),
1, MAX_PAGE_COUNT, 1,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "count",
_("Count"),
_("The number of images entered (This will be the "
"number of pages)."),
1, MAX_PAGE_COUNT, 1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT32_ARRAY (procedure, "images",
"Images",
"Input image for each page (An image can "
"appear more than once)",
G_PARAM_READWRITE);
gimp_procedure_add_int32_array_argument (procedure, "images",
"Images",
"Input image for each page (An image can "
"appear more than once)",
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "vectorize",
_("Convert _bitmaps to vector graphics where possible"),
_("Convert bitmaps to vector graphics where possible"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "vectorize",
_("Convert _bitmaps to vector graphics where possible"),
_("Convert bitmaps to vector graphics where possible"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "ignore-hidden",
_("O_mit hidden layers and layers with zero opacity"),
_("Non-visible layers will not be exported"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "ignore-hidden",
_("O_mit hidden layers and layers with zero opacity"),
_("Non-visible layers will not be exported"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "apply-masks",
_("_Apply layer masks"),
_("Apply layer masks before saving (Keeping the mask "
"will not change the output, only the PDF structure)"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "apply-masks",
_("_Apply layer masks"),
_("Apply layer masks before saving (Keeping the mask "
"will not change the output, only the PDF structure)"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "fill-background-color",
_("_Fill transparent areas with background color"),
_("Fill transparent areas with background color if "
"layer has an alpha channel"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "fill-background-color",
_("_Fill transparent areas with background color"),
_("Fill transparent areas with background color if "
"layer has an alpha channel"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "uri",
_("Save to"),
_("The URI of the file to save to"),
NULL,
GIMP_PARAM_READWRITE);
gimp_procedure_add_string_argument (procedure, "uri",
_("Save to"),
_("The URI of the file to save to"),
NULL,
GIMP_PARAM_READWRITE);
}
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),
LOAD_THUMB_PROC);
GIMP_PROC_ARG_STRING (procedure, "password",
_("PDF password"),
_("The password to decrypt the encrypted PDF file"),
NULL,
G_PARAM_READWRITE);
gimp_procedure_add_string_argument (procedure, "password",
_("PDF password"),
_("The password to decrypt the encrypted PDF file"),
NULL,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "reverse-order",
_("Load in re_verse order"),
_("Load PDF pages in reverse order"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "reverse-order",
_("Load in re_verse order"),
_("Load PDF pages in reverse order"),
FALSE,
G_PARAM_READWRITE);
/* FIXME: this should be a GIMP_PROC_ARG_ENUM of type
/* FIXME: this should be a gimp_procedure_add_enum_argument () of type
* GIMP_TYPE_PAGE_SELECTOR_TARGET but it won't work right now (see FIXME
* comment in libgimp/gimpgpparams-body.c:116).
GIMP_PROC_ARG_ENUM (procedure, "target",
_("Open pages as"),
_("Number of pages to load (0 for all)"),
GIMP_TYPE_PAGE_SELECTOR_TARGET,
GIMP_PAGE_SELECTOR_TARGET_LAYERS,
G_PARAM_READWRITE);
gimp_procedure_add_enum_argument (procedure, "target",
_("Open pages as"),
_("Number of pages to load (0 for all)"),
GIMP_TYPE_PAGE_SELECTOR_TARGET,
GIMP_PAGE_SELECTOR_TARGET_LAYERS,
G_PARAM_READWRITE);
*/
GIMP_PROC_AUX_ARG_INT (procedure, "target",
_("Open pages as"),
_("Number of pages to load (0 for all)"),
GIMP_PAGE_SELECTOR_TARGET_LAYERS, GIMP_PAGE_SELECTOR_TARGET_IMAGES,
GIMP_PAGE_SELECTOR_TARGET_LAYERS,
G_PARAM_READWRITE);
gimp_procedure_add_int_aux_argument (procedure, "target",
_("Open pages as"),
_("Number of pages to load (0 for all)"),
GIMP_PAGE_SELECTOR_TARGET_LAYERS, GIMP_PAGE_SELECTOR_TARGET_IMAGES,
GIMP_PAGE_SELECTOR_TARGET_LAYERS,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "n-pages",
_("N pages"),
_("Number of pages to load (0 for all)"),
0, G_MAXINT, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "n-pages",
_("N pages"),
_("Number of pages to load (0 for all)"),
0, G_MAXINT, 0,
G_PARAM_READWRITE);
/* FIXME: shouldn't the whole selector be considered as one argument
* 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
* from one PDF document loaded to another (different) one.
*/
GIMP_PROC_ARG_INT32_ARRAY (procedure, "pages",
_("Pages"),
_("The pages to load in the expected order"),
G_PARAM_READWRITE);
gimp_procedure_add_int32_array_argument (procedure, "pages",
_("Pages"),
_("The pages to load in the expected order"),
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "antialias",
_("Use _Anti-aliasing"),
_("Render texts with anti-aliasing"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "antialias",
_("Use _Anti-aliasing"),
_("Render texts with anti-aliasing"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "white-background",
_("_Fill transparent areas with white"),
_("Render all pages as opaque by filling the background in white"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "white-background",
_("_Fill transparent areas with white"),
_("Render all pages as opaque by filling the background in white"),
TRUE,
G_PARAM_READWRITE);
}
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),
"png");
GIMP_PROC_ARG_BOOLEAN (procedure, "interlaced",
_("_Interlacing (Adam7)"),
_("Use Adam7 interlacing"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "interlaced",
_("_Interlacing (Adam7)"),
_("Use Adam7 interlacing"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "compression",
_("Co_mpression level"),
_("Deflate Compression factor (0..9)"),
0, 9, 9,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "compression",
_("Co_mpression level"),
_("Deflate Compression factor (0..9)"),
0, 9, 9,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "bkgd",
_("Save _background color"),
_("Write bKGD chunk (PNG metadata)"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "bkgd",
_("Save _background color"),
_("Write bKGD chunk (PNG metadata)"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "offs",
_("Save layer o_ffset"),
_("Write oFFs chunk (PNG metadata)"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "offs",
_("Save layer o_ffset"),
_("Write oFFs chunk (PNG metadata)"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "phys",
_("Save resol_ution"),
_("Write pHYs chunk (PNG metadata)"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "phys",
_("Save resol_ution"),
_("Write pHYs chunk (PNG metadata)"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "time",
_("Save creation _time"),
_("Write tIME chunk (PNG metadata)"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "time",
_("Save creation _time"),
_("Write tIME chunk (PNG metadata)"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "save-transparent",
_("Save color _values from transparent pixels"),
_("Preserve color of completely transparent pixels"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "save-transparent",
_("Save color _values from transparent pixels"),
_("Preserve color of completely transparent pixels"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "optimize-palette",
_("_Optimize for smallest possible palette size"),
_("When checked, save as 1, 2, 4, or 8-bit depending"
" on number of colors used. When unchecked, always"
" save as 8-bit"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "optimize-palette",
_("_Optimize for smallest possible palette size"),
_("When checked, save as 1, 2, 4, or 8-bit depending"
" on number of colors used. When unchecked, always"
" save as 8-bit"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_CHOICE (procedure, "format",
_("_Pixel format"),
_("PNG export format"),
gimp_choice_new_with_values ("auto", PNG_FORMAT_AUTO, _("Automatic"), NULL,
"rgb8", PNG_FORMAT_RGB8, _("8 bpc RGB"), NULL,
"gray8", PNG_FORMAT_GRAY8, _("8 bpc GRAY"), NULL,
"rgba8", PNG_FORMAT_RGBA8, _("8 bpc RGBA"), NULL,
"graya8", PNG_FORMAT_GRAYA8, _("8 bpc GRAYA"), NULL,
"rgb16", PNG_FORMAT_RGB16, _("16 bpc RGB"), NULL,
"gray16", PNG_FORMAT_GRAY16, _("16 bpc GRAY"), NULL,
"rgba16", PNG_FORMAT_RGBA16, _("16 bpc RGBA"), NULL,
"graya16", PNG_FORMAT_GRAYA16, _("16 bpc GRAYA"), NULL,
NULL),
"auto", G_PARAM_READWRITE);
gimp_procedure_add_choice_argument (procedure, "format",
_("_Pixel format"),
_("PNG export format"),
gimp_choice_new_with_values ("auto", PNG_FORMAT_AUTO, _("Automatic"), NULL,
"rgb8", PNG_FORMAT_RGB8, _("8 bpc RGB"), NULL,
"gray8", PNG_FORMAT_GRAY8, _("8 bpc GRAY"), NULL,
"rgba8", PNG_FORMAT_RGBA8, _("8 bpc RGBA"), NULL,
"graya8", PNG_FORMAT_GRAYA8, _("8 bpc GRAYA"), NULL,
"rgb16", PNG_FORMAT_RGB16, _("16 bpc RGB"), NULL,
"gray16", PNG_FORMAT_GRAY16, _("16 bpc GRAY"), NULL,
"rgba16", PNG_FORMAT_RGBA16, _("16 bpc RGBA"), NULL,
"graya16", PNG_FORMAT_GRAYA16, _("16 bpc GRAYA"), NULL,
NULL),
"auto", G_PARAM_READWRITE);
gimp_export_procedure_set_support_exif (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),
"pnm");
GIMP_PROC_ARG_INT (procedure, "raw",
_("Data formatting"),
_("TRUE for raw output, FALSE for ascii output"),
0, 1, 1,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "raw",
_("Data formatting"),
_("TRUE for raw output, FALSE for ascii output"),
0, 1, 1,
G_PARAM_READWRITE);
}
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),
"pbm");
GIMP_PROC_ARG_INT (procedure, "raw",
_("Data formatting"),
_("TRUE for raw output, FALSE for ascii output"),
0, 1, 1,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "raw",
_("Data formatting"),
_("TRUE for raw output, FALSE for ascii output"),
0, 1, 1,
G_PARAM_READWRITE);
}
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),
"pgm");
GIMP_PROC_ARG_INT (procedure, "raw",
_("Data formatting"),
_("TRUE for raw output, FALSE for ascii output"),
0, 1, 1,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "raw",
_("Data formatting"),
_("TRUE for raw output, FALSE for ascii output"),
0, 1, 1,
G_PARAM_READWRITE);
}
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),
"ppm");
GIMP_PROC_ARG_INT (procedure, "raw",
"Data formatting",
_("TRUE for raw output, FALSE for ascii output"),
0, 1, 1,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "raw",
"Data formatting",
_("TRUE for raw output, FALSE for ascii output"),
0, 1, 1,
G_PARAM_READWRITE);
}
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),
LOAD_PS_THUMB_PROC);
GIMP_PROC_ARG_BOOLEAN (procedure, "check-bbox",
_("Try _Bounding Box"),
_("FALSE: Use width/height, TRUE: Use BoundingBox"),
TRUE,
GIMP_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "check-bbox",
_("Try _Bounding Box"),
_("FALSE: Use width/height, TRUE: Use BoundingBox"),
TRUE,
GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "pages",
_("_Pages"),
_("Pages to load (e.g.: 1,3,5-7)"),
"1",
GIMP_PARAM_READWRITE);
gimp_procedure_add_string_argument (procedure, "pages",
_("_Pages"),
_("Pages to load (e.g.: 1,3,5-7)"),
"1",
GIMP_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "coloring",
_("Colorin_g"),
_("Import color format"),
gimp_choice_new_with_values ("bw", 4, _("B/W"), NULL,
"grayscale", 5, _("Gray"), NULL,
"rgb", 6, _("Color"), NULL,
"automatic", 7, _("Automatic"), NULL,
NULL),
"rgb", G_PARAM_READWRITE);
gimp_procedure_add_choice_argument (procedure, "coloring",
_("Colorin_g"),
_("Import color format"),
gimp_choice_new_with_values ("bw", 4, _("B/W"), NULL,
"grayscale", 5, _("Gray"), NULL,
"rgb", 6, _("Color"), NULL,
"automatic", 7, _("Automatic"), NULL,
NULL),
"rgb", G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "text-alpha-bits",
_("Te_xt anti-aliasing"),
_("Text anti-aliasing strength"),
gimp_choice_new_with_values ("none", 1, _("None"), NULL,
"weak", 2, _("Weak"), NULL,
"strong", 4, _("Strong"), NULL,
NULL),
"none", G_PARAM_READWRITE);
gimp_procedure_add_choice_argument (procedure, "text-alpha-bits",
_("Te_xt anti-aliasing"),
_("Text anti-aliasing strength"),
gimp_choice_new_with_values ("none", 1, _("None"), NULL,
"weak", 2, _("Weak"), NULL,
"strong", 4, _("Strong"), NULL,
NULL),
"none", G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "graphic-alpha-bits",
_("Gra_phic anti-aliasing"),
_("Graphic anti-aliasing strength"),
gimp_choice_new_with_values ("none", 1, _("None"), NULL,
"weak", 2, _("Weak"), NULL,
"strong", 4, _("Strong"), NULL,
NULL),
"none", G_PARAM_READWRITE);
gimp_procedure_add_choice_argument (procedure, "graphic-alpha-bits",
_("Gra_phic anti-aliasing"),
_("Graphic anti-aliasing strength"),
gimp_choice_new_with_values ("none", 1, _("None"), NULL,
"weak", 2, _("Weak"), NULL,
"strong", 4, _("Strong"), NULL,
NULL),
"none", G_PARAM_READWRITE);
}
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),
TRUE);
GIMP_PROC_ARG_DOUBLE (procedure, "width",
_("_Width"),
_("Width of the image in PostScript file "
"(0: use input image size)"),
0, GIMP_MAX_IMAGE_SIZE, 287.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "width",
_("_Width"),
_("Width of the image in PostScript file "
"(0: use input image size)"),
0, GIMP_MAX_IMAGE_SIZE, 287.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "height",
_("_Height"),
_("Height of the image in PostScript file "
"(0: use input image size)"),
0, GIMP_MAX_IMAGE_SIZE, 200.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "height",
_("_Height"),
_("Height of the image in PostScript file "
"(0: use input image size)"),
0, GIMP_MAX_IMAGE_SIZE, 200.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "x-offset",
_("_X offset"),
_("X-offset to image from lower left corner"),
-GIMP_MAX_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE, 5.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "x-offset",
_("_X offset"),
_("X-offset to image from lower left corner"),
-GIMP_MAX_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE, 5.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "y-offset",
_("Y o_ffset"),
_("Y-offset to image from lower left corner"),
-GIMP_MAX_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE, 5.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "y-offset",
_("Y o_ffset"),
_("Y-offset to image from lower left corner"),
-GIMP_MAX_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE, 5.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "unit",
_("_Unit"),
_("Unit of measure for offset values"),
gimp_choice_new_with_values ("inch", 0, _("Inch"), NULL,
"millimeter", 1, _("Millimeter"), NULL,
NULL),
"inch", G_PARAM_READWRITE);
gimp_procedure_add_choice_argument (procedure, "unit",
_("_Unit"),
_("Unit of measure for offset values"),
gimp_choice_new_with_values ("inch", 0, _("Inch"), NULL,
"millimeter", 1, _("Millimeter"), NULL,
NULL),
"inch", G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "keep-ratio",
_("_Keep aspect ratio"),
_("If enabled, aspect ratio will be maintained on export. "
"Otherwise, the width and height values will be used."),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "keep-ratio",
_("_Keep aspect ratio"),
_("If enabled, aspect ratio will be maintained on export. "
"Otherwise, the width and height values will be used."),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "rotation",
_("Rotation"),
"0, 90, 180, 270",
0, 270, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "rotation",
_("Rotation"),
"0, 90, 180, 270",
0, 270, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "level",
_("PostScript Level _2"),
_("If enabled, export in PostScript Level 2 format. "
"Otherwise, export in PostScript Level 1 format."),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "level",
_("PostScript Level _2"),
_("If enabled, export in PostScript Level 2 format. "
"Otherwise, export in PostScript Level 1 format."),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "eps-flag",
_("Encapsula_ted PostScript"),
_("If enabled, export as Encapsulated PostScript. "
"Otherwise, export as PostScript."),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "eps-flag",
_("Encapsula_ted PostScript"),
_("If enabled, export as Encapsulated PostScript. "
"Otherwise, export as PostScript."),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "show-preview",
_("_Preview"),
_("Show Preview"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "show-preview",
_("_Preview"),
_("Show Preview"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "preview",
_("Preview Si_ze"),
_("Maximum size of preview. Set to 0 for no preview."),
0, GIMP_MAX_IMAGE_SIZE, 256,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "preview",
_("Preview Si_ze"),
_("Maximum size of preview. Set to 0 for no preview."),
0, GIMP_MAX_IMAGE_SIZE, 256,
G_PARAM_READWRITE);
}
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),
"psp,tub");
GIMP_PROC_ARG_INT (procedure, "compression",
"_Data Compression",
"Specify 0 for no compression, "
"1 for RLE, and 2 for LZ77",
0, 2, PSP_COMP_LZ77,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "compression",
"_Data Compression",
"Specify 0 for no compression, "
"1 for RLE, and 2 for LZ77",
0, 2, PSP_COMP_LZ77,
G_PARAM_READWRITE);
}
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. */
GIMP_PROC_ARG_INT (procedure, "width",
_("_Width"),
_("Image width in number of pixels"),
1, GIMP_MAX_IMAGE_SIZE, PREVIEW_SIZE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "height",
_("_Height"),
_("Image height in number of pixels"),
1, GIMP_MAX_IMAGE_SIZE, PREVIEW_SIZE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "offset",
_("O_ffset"),
_("Offset to beginning of image in raw data"),
0, GIMP_MAX_IMAGE_SIZE, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "width",
_("_Width"),
_("Image width in number of pixels"),
1, GIMP_MAX_IMAGE_SIZE, PREVIEW_SIZE,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "height",
_("_Height"),
_("Image height in number of pixels"),
1, GIMP_MAX_IMAGE_SIZE, PREVIEW_SIZE,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "offset",
_("O_ffset"),
_("Offset to beginning of image in raw data"),
0, GIMP_MAX_IMAGE_SIZE, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "pixel-format",
_("Pi_xel format"),
_("The layout of pixel data, such as components and their order"),
gimp_choice_new_with_values ("rgb-8bpp", RAW_RGB_8BPP, _("RGB 8-bit"), NULL,
"rgb-16bpp", RAW_RGB_16BPP, _("RGB 16-bit"), NULL,
"rgb-32bpp", RAW_RGB_32BPP, _("RGB 32-bit"), NULL,
"rgba-8bpp", RAW_RGBA_8BPP, _("RGBA 8-bit"), NULL,
"rgba-16bpp", RAW_RGBA_16BPP, _("RGBA 16-bit"), NULL,
"rgba-32bpp", RAW_RGBA_32BPP, _("RGBA 32-bit"), NULL,
"rgb565", RAW_RGB565, _("RGB565"), NULL,
"bgr565", RAW_BGR565, _("BGR565"), NULL,
"grayscale-1bpp", RAW_GRAY_1BPP, _("B&W 1 bit"), NULL,
"grayscale-2bpp", RAW_GRAY_2BPP, _("Grayscale 2-bit"), NULL,
"grayscale-4bpp", RAW_GRAY_4BPP, _("Grayscale 4-bit"), NULL,
"grayscale-8bpp", RAW_GRAY_8BPP, _("Grayscale 8-bit"), NULL,
"grayscale-16bpp", RAW_GRAY_16BPP, _("Grayscale 16-bit"), NULL,
"grayscale-32bpp", RAW_GRAY_32BPP, _("Grayscale 32-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-32bpp", RAW_GRAYA_32BPP, _("Grayscale-Alpha 32-bit"), NULL,
"indexed", RAW_INDEXED, _("Indexed"), NULL,
"indexed-alpha", RAW_INDEXEDA, _("Indexed Alpha"), NULL,
NULL),
"rgb-8bpp", G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "data-type",
_("_Data type"),
_("Data type used to represent pixel values"),
gimp_choice_new_with_values ("unsigned", RAW_ENCODING_UNSIGNED, _("Unsigned Integer"), NULL,
"signed", RAW_ENCODING_SIGNED, _("Signed Integer"), NULL,
"float", RAW_ENCODING_FLOAT, _("Floating Point"), NULL,
NULL),
"unsigned", G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "endianness",
_("_Endianness"),
_("Order of sequences of bytes"),
gimp_choice_new_with_values ("little-endian", RAW_LITTLE_ENDIAN, _("Little Endian"), NULL,
"big-endian", RAW_BIG_ENDIAN, _("Big Endian"), NULL,
NULL),
"little-endian", G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "planar-configuration",
_("Planar confi_guration"),
_("How color pixel data are stored"),
gimp_choice_new_with_values ("contiguous", RAW_PLANAR_CONTIGUOUS, _("Contiguous"), NULL,
"planar", RAW_PLANAR_SEPARATE, _("Planar"), NULL,
NULL),
"contiguous", G_PARAM_READWRITE);
gimp_procedure_add_choice_argument (procedure, "pixel-format",
_("Pi_xel format"),
_("The layout of pixel data, such as components and their order"),
gimp_choice_new_with_values ("rgb-8bpp", RAW_RGB_8BPP, _("RGB 8-bit"), NULL,
"rgb-16bpp", RAW_RGB_16BPP, _("RGB 16-bit"), NULL,
"rgb-32bpp", RAW_RGB_32BPP, _("RGB 32-bit"), NULL,
"rgba-8bpp", RAW_RGBA_8BPP, _("RGBA 8-bit"), NULL,
"rgba-16bpp", RAW_RGBA_16BPP, _("RGBA 16-bit"), NULL,
"rgba-32bpp", RAW_RGBA_32BPP, _("RGBA 32-bit"), NULL,
"rgb565", RAW_RGB565, _("RGB565"), NULL,
"bgr565", RAW_BGR565, _("BGR565"), NULL,
"grayscale-1bpp", RAW_GRAY_1BPP, _("B&W 1 bit"), NULL,
"grayscale-2bpp", RAW_GRAY_2BPP, _("Grayscale 2-bit"), NULL,
"grayscale-4bpp", RAW_GRAY_4BPP, _("Grayscale 4-bit"), NULL,
"grayscale-8bpp", RAW_GRAY_8BPP, _("Grayscale 8-bit"), NULL,
"grayscale-16bpp", RAW_GRAY_16BPP, _("Grayscale 16-bit"), NULL,
"grayscale-32bpp", RAW_GRAY_32BPP, _("Grayscale 32-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-32bpp", RAW_GRAYA_32BPP, _("Grayscale-Alpha 32-bit"), NULL,
"indexed", RAW_INDEXED, _("Indexed"), NULL,
"indexed-alpha", RAW_INDEXEDA, _("Indexed Alpha"), NULL,
NULL),
"rgb-8bpp", G_PARAM_READWRITE);
gimp_procedure_add_choice_argument (procedure, "data-type",
_("_Data type"),
_("Data type used to represent pixel values"),
gimp_choice_new_with_values ("unsigned", RAW_ENCODING_UNSIGNED, _("Unsigned Integer"), NULL,
"signed", RAW_ENCODING_SIGNED, _("Signed Integer"), NULL,
"float", RAW_ENCODING_FLOAT, _("Floating Point"), NULL,
NULL),
"unsigned", G_PARAM_READWRITE);
gimp_procedure_add_choice_argument (procedure, "endianness",
_("_Endianness"),
_("Order of sequences of bytes"),
gimp_choice_new_with_values ("little-endian", RAW_LITTLE_ENDIAN, _("Little Endian"), NULL,
"big-endian", RAW_BIG_ENDIAN, _("Big Endian"), NULL,
NULL),
"little-endian", G_PARAM_READWRITE);
gimp_procedure_add_choice_argument (procedure, "planar-configuration",
_("Planar confi_guration"),
_("How color pixel data are stored"),
gimp_choice_new_with_values ("contiguous", RAW_PLANAR_CONTIGUOUS, _("Contiguous"), NULL,
"planar", RAW_PLANAR_SEPARATE, _("Planar"), NULL,
NULL),
"contiguous", G_PARAM_READWRITE);
/* Properties for palette data. */
GIMP_PROC_ARG_INT (procedure, "palette-offset",
_("Palette Offse_t"),
_("Offset to beginning of data in the palette file"),
0, GIMP_MAX_IMAGE_SIZE, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "palette-offset",
_("Palette Offse_t"),
_("Offset to beginning of data in the palette file"),
0, GIMP_MAX_IMAGE_SIZE, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "palette-type",
_("Palette's la_yout"),
_("The layout for the palette's color channels"),
gimp_choice_new_with_values ("rgb", RAW_PALETTE_RGB, _("R, G, B (normal)"), NULL,
"bgr", RAW_PALETTE_BGR, _("B, G, R, X (BMP style)"), NULL,
NULL),
"rgb", G_PARAM_READWRITE);
GIMP_PROC_ARG_FILE (procedure, "palette-file",
_("_Palette File"),
_("The file containing palette data"),
G_PARAM_READWRITE);
gimp_procedure_add_choice_argument (procedure, "palette-type",
_("Palette's la_yout"),
_("The layout for the palette's color channels"),
gimp_choice_new_with_values ("rgb", RAW_PALETTE_RGB, _("R, G, B (normal)"), NULL,
"bgr", RAW_PALETTE_BGR, _("B, G, R, X (BMP style)"), NULL,
NULL),
"rgb", G_PARAM_READWRITE);
gimp_procedure_add_file_argument (procedure, "palette-file",
_("_Palette File"),
_("The file containing palette data"),
G_PARAM_READWRITE);
}
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),
"hgt");
GIMP_PROC_ARG_CHOICE (procedure, "sample-spacing",
_("Sa_mple spacing"),
_("The sample spacing of the data."),
gimp_choice_new_with_values ("auto-detect", HGT_SRTM_AUTO_DETECT, _("Auto-Detect"), NULL,
"srtm-1", HGT_SRTM_1, _("SRTM-1 (1 arc second)"), NULL,
"srtm-3", HGT_SRTM_3, _("SRTM-3 (3 arc seconds)"), NULL,
NULL),
"auto-detect", G_PARAM_READWRITE);
gimp_procedure_add_choice_argument (procedure, "sample-spacing",
_("Sa_mple spacing"),
_("The sample spacing of the data."),
gimp_choice_new_with_values ("auto-detect", HGT_SRTM_AUTO_DETECT, _("Auto-Detect"), NULL,
"srtm-1", HGT_SRTM_1, _("SRTM-1 (1 arc second)"), NULL,
"srtm-3", HGT_SRTM_3, _("SRTM-3 (3 arc seconds)"), NULL,
NULL),
"auto-detect", G_PARAM_READWRITE);
/* Properties for palette data. */
GIMP_PROC_ARG_INT (procedure, "palette-offset",
_("Palette Offse_t"),
_("Offset to beginning of data in the palette file"),
0, GIMP_MAX_IMAGE_SIZE, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "palette-offset",
_("Palette Offse_t"),
_("Offset to beginning of data in the palette file"),
0, GIMP_MAX_IMAGE_SIZE, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "palette-type",
_("Palette's la_yout"),
_("The layout for the palette's color channels"),
gimp_choice_new_with_values ("rgb", RAW_PALETTE_RGB, _("R, G, B (normal)"), NULL,
"bgr", RAW_PALETTE_BGR, _("B, G, R, X (BMP style)"), NULL,
NULL),
"rgb", G_PARAM_READWRITE);
GIMP_PROC_ARG_FILE (procedure, "palette-file",
_("_Palette File"),
_("The file containing palette data"),
G_PARAM_READWRITE);
gimp_procedure_add_choice_argument (procedure, "palette-type",
_("Palette's la_yout"),
_("The layout for the palette's color channels"),
gimp_choice_new_with_values ("rgb", RAW_PALETTE_RGB, _("R, G, B (normal)"), NULL,
"bgr", RAW_PALETTE_BGR, _("B, G, R, X (BMP style)"), NULL,
NULL),
"rgb", G_PARAM_READWRITE);
gimp_procedure_add_file_argument (procedure, "palette-file",
_("_Palette File"),
_("The file containing palette data"),
G_PARAM_READWRITE);
}
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),
"data,raw");
GIMP_PROC_ARG_CHOICE (procedure, "planar-configuration",
_("Planar configuration"),
_("How color pixel data are stored"),
gimp_choice_new_with_values ("contiguous", RAW_PLANAR_CONTIGUOUS, _("Contiguous"), NULL,
"planar", RAW_PLANAR_SEPARATE, _("Planar"), NULL,
NULL),
"contiguous", G_PARAM_READWRITE);
gimp_procedure_add_choice_argument (procedure, "planar-configuration",
_("Planar configuration"),
_("How color pixel data are stored"),
gimp_choice_new_with_values ("contiguous", RAW_PLANAR_CONTIGUOUS, _("Contiguous"), NULL,
"planar", RAW_PLANAR_SEPARATE, _("Planar"), NULL,
NULL),
"contiguous", G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "palette-type",
_("Palette's la_yout"),
_("The layout for the palette's color channels"),
gimp_choice_new_with_values ("rgb", RAW_PALETTE_RGB, _("R, G, B (normal)"), NULL,
"bgr", RAW_PALETTE_BGR, _("B, G, R, X (BMP style)"), NULL,
NULL),
"rgb", G_PARAM_READWRITE);
gimp_procedure_add_choice_argument (procedure, "palette-type",
_("Palette's la_yout"),
_("The layout for the palette's color channels"),
gimp_choice_new_with_values ("rgb", RAW_PALETTE_RGB, _("R, G, B (normal)"), NULL,
"bgr", RAW_PALETTE_BGR, _("B, G, R, X (BMP style)"), NULL,
NULL),
"rgb", G_PARAM_READWRITE);
}
gimp_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),
"im1,im8,im24,im32,rs,ras,sun");
GIMP_PROC_ARG_INT (procedure, "rle",
_("Data Formatting"),
_("Use standard (0) or Run-Length Encoded (1) output"),
0, 1, 1,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "rle",
_("Data Formatting"),
_("Use standard (0) or Run-Length Encoded (1) output"),
0, 1, 1,
G_PARAM_READWRITE);
}
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),
"0,string,<?xml,0,string,<svg");
GIMP_PROC_ARG_CHOICE (procedure, "paths",
_("_Paths"),
_("Whether and how to import paths so that they can be used with the path tool"),
gimp_choice_new_with_values ("no-import", 0, _("Don't import paths"), NULL,
"import", 0, _("Import paths individually"), NULL,
"import-merged", 0, _("Merge imported paths"), NULL,
NULL),
"no-import", G_PARAM_READWRITE);
gimp_procedure_add_choice_argument (procedure, "paths",
_("_Paths"),
_("Whether and how to import paths so that they can be used with the path tool"),
gimp_choice_new_with_values ("no-import", 0, _("Don't import paths"), NULL,
"import", 0, _("Import paths individually"), NULL,
"import-merged", 0, _("Merge imported paths"), NULL,
NULL),
"no-import", G_PARAM_READWRITE);
}
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),
"tga");
GIMP_PROC_ARG_BOOLEAN (procedure, "rle",
_("_Use RLE compression"),
_("Use RLE compression"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "rle",
_("_Use RLE compression"),
_("Use RLE compression"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "origin",
_("Ori_gin"),
_("Image origin (0 = top-left, 1 = bottom-left)"),
0, 1, ORIGIN_BOTTOM_LEFT,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "origin",
_("Ori_gin"),
_("Image origin (0 = top-left, 1 = bottom-left)"),
0, 1, ORIGIN_BOTTOM_LEFT,
G_PARAM_READWRITE);
}
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),
"xbm,icon,bitmap");
GIMP_PROC_ARG_BOOLEAN (procedure, "save-comment",
_("_Write comment"),
_("Write a comment at the beginning of the file."),
FALSE, /* *NOT* gimp_export_comment() */
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "save-comment",
_("_Write comment"),
_("Write a comment at the beginning of the file."),
FALSE, /* *NOT* gimp_export_comment() */
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "gimp-comment",
_("Co_mment"),
_("Image description (maximum 72 bytes)"),
gimp_get_default_comment (),
G_PARAM_READWRITE);
gimp_procedure_add_string_argument (procedure, "gimp-comment",
_("Co_mment"),
_("Image description (maximum 72 bytes)"),
gimp_get_default_comment (),
G_PARAM_READWRITE);
gimp_procedure_set_argument_sync (procedure, "gimp-comment",
GIMP_ARGUMENT_SYNC_PARASITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "x10-format",
_("_X10 format bitmap"),
_("Export in X10 format"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "x10-format",
_("_X10 format bitmap"),
_("Export in X10 format"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "use-hot-spot",
_("Write hot spot _values"),
_("Write hotspot information"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "use-hot-spot",
_("Write hot spot _values"),
_("Write hotspot information"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "hot-spot-x",
_("Hot s_pot X"),
_("X coordinate of hotspot"),
0, GIMP_MAX_IMAGE_SIZE, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "hot-spot-x",
_("Hot s_pot X"),
_("X coordinate of hotspot"),
0, GIMP_MAX_IMAGE_SIZE, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "hot-spot-y",
_("Hot spot _Y"),
_("Y coordinate of hotspot"),
0, GIMP_MAX_IMAGE_SIZE, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "hot-spot-y",
_("Hot spot _Y"),
_("Y coordinate of hotspot"),
0, GIMP_MAX_IMAGE_SIZE, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "prefix",
_("I_dentifier prefix"),
_("Identifier prefix [determined from filename]"),
"bitmap",
G_PARAM_READWRITE);
gimp_procedure_add_string_argument (procedure, "prefix",
_("I_dentifier prefix"),
_("Identifier prefix [determined from filename]"),
"bitmap",
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "write-mask",
_("Write extra mask _file"),
_("Write extra mask file"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "write-mask",
_("Write extra mask _file"),
_("Write extra mask file"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "mask-suffix",
_("Mas_k file extensions"),
_("Suffix of the mask file"),
"-mask",
G_PARAM_READWRITE);
gimp_procedure_add_string_argument (procedure, "mask-suffix",
_("Mas_k file extensions"),
_("Suffix of the mask file"),
"-mask",
G_PARAM_READWRITE);
}
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),
XCURSOR_EXTENSION);
GIMP_PROC_ARG_INT (procedure, "hot-spot-x",
_("Hot spot _X"),
_("X-coordinate of hot spot "
"(use -1, -1 to keep original hot spot)"),
-1, GIMP_MAX_IMAGE_SIZE, -1,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "hot-spot-x",
_("Hot spot _X"),
_("X-coordinate of hot spot "
"(use -1, -1 to keep original hot spot)"),
-1, GIMP_MAX_IMAGE_SIZE, -1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "hot-spot-y",
_("Hot spot _Y"),
_("Y-coordinate of hot spot "
"(use -1, -1 to keep original hot spot)"),
-1, GIMP_MAX_IMAGE_SIZE, -1,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "hot-spot-y",
_("Hot spot _Y"),
_("Y-coordinate of hot spot "
"(use -1, -1 to keep original hot spot)"),
-1, GIMP_MAX_IMAGE_SIZE, -1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "crop",
_("_Auto Crop all frames"),
_("Remove the empty borders of all frames."),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "crop",
_("_Auto Crop all frames"),
_("Remove the empty borders of all frames."),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "size",
_("Si_ze where unspecified"),
_("Default frame size if unspecified"),
gimp_choice_new_with_values ("size-12px", 12, ("12px"), NULL,
"size-16px", 16, ("16px"), NULL,
"size-24px", 24, ("24px"), NULL,
"size-32px", 32, ("32px"), NULL,
"size-36px", 36, ("36px"), NULL,
"size-40px", 40, ("40px"), NULL,
"size-48px", 48, ("48px"), NULL,
"size-64px", 64, ("64px"), NULL,
NULL),
"size-32px",
G_PARAM_READWRITE);
gimp_procedure_add_choice_argument (procedure, "size",
_("Si_ze where unspecified"),
_("Default frame size if unspecified"),
gimp_choice_new_with_values ("size-12px", 12, ("12px"), NULL,
"size-16px", 16, ("16px"), NULL,
"size-24px", 24, ("24px"), NULL,
"size-32px", 32, ("32px"), NULL,
"size-36px", 36, ("36px"), NULL,
"size-40px", 40, ("40px"), NULL,
"size-48px", 48, ("48px"), NULL,
"size-64px", 64, ("64px"), NULL,
NULL),
"size-32px",
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "size-replace",
_("_Use default size for all frames"),
_("Use default size for all frames"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "size-replace",
_("_Use default size for all frames"),
_("Use default size for all frames"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "delay",
_("_Delay where unspecified"),
_("Default time span in milliseconds in which "
"each frame is rendered"),
CURSOR_MINIMUM_DELAY, G_MAXINT, CURSOR_DEFAULT_DELAY,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "delay",
_("_Delay where unspecified"),
_("Default time span in milliseconds in which "
"each frame is rendered"),
CURSOR_MINIMUM_DELAY, G_MAXINT, CURSOR_DEFAULT_DELAY,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "delay-replace",
_("Use default delay for all _frames"),
_("Use default delay for all frames"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "delay-replace",
_("Use default delay for all _frames"),
_("Use default delay for all frames"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "xmc-copyright",
_("C_opyright"),
_("Copyright information"),
NULL,
G_PARAM_READWRITE);
gimp_procedure_add_string_argument (procedure, "xmc-copyright",
_("C_opyright"),
_("Copyright information"),
NULL,
G_PARAM_READWRITE);
gimp_procedure_set_argument_sync (procedure, "xmc-copyright",
GIMP_ARGUMENT_SYNC_PARASITE);
GIMP_PROC_ARG_STRING (procedure, "xmc-license",
_("Lice_nse"),
_("License information"),
NULL,
G_PARAM_READWRITE);
gimp_procedure_add_string_argument (procedure, "xmc-license",
_("Lice_nse"),
_("License information"),
NULL,
G_PARAM_READWRITE);
gimp_procedure_set_argument_sync (procedure, "xmc-license",
GIMP_ARGUMENT_SYNC_PARASITE);
GIMP_PROC_ARG_STRING (procedure, "gimp-comment",
_("Co_mment"),
_("Optional comment"),
gimp_get_default_comment (),
G_PARAM_READWRITE);
gimp_procedure_add_string_argument (procedure, "gimp-comment",
_("Co_mment"),
_("Optional comment"),
gimp_get_default_comment (),
G_PARAM_READWRITE);
gimp_procedure_set_argument_sync (procedure, "gimp-comment",
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),
"xpm");
GIMP_PROC_ARG_INT (procedure, "threshold",
_("_Threshold"),
_("Alpha threshold"),
0, 255, 127,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "threshold",
_("_Threshold"),
_("Alpha threshold"),
0, 255, 127,
G_PARAM_READWRITE);
}
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)",
"1997");
GIMP_PROC_ARG_INT (procedure, "film-height",
_("Film _height"),
_("Height of film (0: fit to images)"),
0, GIMP_MAX_IMAGE_SIZE, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "film-height",
_("Film _height"),
_("Height of film (0: fit to images)"),
0, GIMP_MAX_IMAGE_SIZE, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_COLOR (procedure, "film-color",
_("_Film color"),
_("Color of the film"),
TRUE, default_film_color,
G_PARAM_READWRITE);
gimp_procedure_add_color_argument (procedure, "film-color",
_("_Film color"),
_("Color of the film"),
TRUE, default_film_color,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "number-start",
_("Start _index"),
_("Start index for numbering"),
0, G_MAXINT, 1,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "number-start",
_("Start _index"),
_("Start index for numbering"),
0, G_MAXINT, 1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_FONT (procedure, "number-font",
_("Number _font"),
_("Font for drawing numbers"),
G_PARAM_READWRITE);
gimp_procedure_add_font_argument (procedure, "number-font",
_("Number _font"),
_("Font for drawing numbers"),
G_PARAM_READWRITE);
GIMP_PROC_ARG_COLOR (procedure, "number-color",
_("_Number color"),
_("Color for numbers"),
TRUE, default_number_color,
G_PARAM_READWRITE);
gimp_procedure_add_color_argument (procedure, "number-color",
_("_Number color"),
_("Color for numbers"),
TRUE, default_number_color,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "at-top",
_("At _top"),
_("Draw numbers at top"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "at-top",
_("At _top"),
_("Draw numbers at top"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "at-bottom",
_("At _bottom"),
_("Draw numbers at bottom"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "at-bottom",
_("At _bottom"),
_("Draw numbers at bottom"),
TRUE,
G_PARAM_READWRITE);
/* Arguments ignored in interactive mode. */
GIMP_PROC_ARG_OBJECT_ARRAY (procedure, "images",
"Images",
"Images to be used for film",
GIMP_TYPE_IMAGE,
G_PARAM_READWRITE);
gimp_procedure_add_object_array_argument (procedure, "images",
"Images",
"Images to be used for film",
GIMP_TYPE_IMAGE,
G_PARAM_READWRITE);
/* The more specific settings. */
GIMP_PROC_ARG_DOUBLE (procedure, "picture-height",
_("Image _height"),
_("As fraction of the strip height"),
0.0, 1.0, 0.695,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "picture-height",
_("Image _height"),
_("As fraction of the strip height"),
0.0, 1.0, 0.695,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "picture-spacing",
_("Image s_pacing"),
_("The spacing between 2 images, as fraction of the strip height"),
0.0, 1.0, 0.040,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "picture-spacing",
_("Image s_pacing"),
_("The spacing between 2 images, as fraction of the strip height"),
0.0, 1.0, 0.040,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "hole-offset",
_("Hole offse_t"),
_("The offset from the edge of film, as fraction of the strip height"),
0.0, 1.0, 0.058,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "hole-offset",
_("Hole offse_t"),
_("The offset from the edge of film, as fraction of the strip height"),
0.0, 1.0, 0.058,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "hole-width",
_("Hole _width"),
_("The width of the holes, as fraction of the strip height"),
0.0, 1.0, 0.052,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "hole-width",
_("Hole _width"),
_("The width of the holes, as fraction of the strip height"),
0.0, 1.0, 0.052,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "hole-height",
_("Hole hei_ght"),
_("The height of the holes, as fraction of the strip height"),
0.0, 1.0, 0.081,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "hole-height",
_("Hole hei_ght"),
_("The height of the holes, as fraction of the strip height"),
0.0, 1.0, 0.081,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "hole-spacing",
_("Hole _distance"),
_("The distance between holes, as fraction of the strip height"),
0.0, 1.0, 0.081,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "hole-spacing",
_("Hole _distance"),
_("The distance between holes, as fraction of the strip height"),
0.0, 1.0, 0.081,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "number-height",
_("_Number height"),
_("The height of drawn numbers, as fraction of the strip height"),
0.0, 1.0, 0.052,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "number-height",
_("_Number height"),
_("The height of drawn numbers, as fraction of the strip height"),
0.0, 1.0, 0.052,
G_PARAM_READWRITE);
/* Auxiliary argument mostly for the GUI. */
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "keep-height",
_("F_it height to images"),
_("Keep maximum image height"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_aux_argument (procedure, "keep-height",
_("F_it height to images"),
_("Keep maximum image height"),
TRUE,
G_PARAM_READWRITE);
/* Returned image. */
GIMP_PROC_VAL_IMAGE (procedure, "new-image",
"New image",
"Output image",
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_image_return_value (procedure, "new-image",
"New image",
"Output image",
FALSE,
G_PARAM_READWRITE);
}
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",
"1997 - 2000");
GIMP_PROC_ARG_INT (procedure, "hwidth",
"H width",
"Horizontal width",
0, GIMP_MAX_IMAGE_SIZE, 1,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "hwidth",
"H width",
"Horizontal width",
0, GIMP_MAX_IMAGE_SIZE, 1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "hspace",
"H space",
"Horizontal spacing",
1, GIMP_MAX_IMAGE_SIZE, 16,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "hspace",
"H space",
"Horizontal spacing",
1, GIMP_MAX_IMAGE_SIZE, 16,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "hoffset",
"H offset",
"Horizontal offset",
0, GIMP_MAX_IMAGE_SIZE, 8,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "hoffset",
"H offset",
"Horizontal offset",
0, GIMP_MAX_IMAGE_SIZE, 8,
G_PARAM_READWRITE);
/* TODO: for "hcolor", "icolor" and "vcolor", the original code would use
* the foreground color as default. Future work would be to get the
* foreground/background color from context.
*/
GIMP_PROC_ARG_COLOR (procedure, "hcolor",
"H color",
"Horizontal color",
TRUE, default_hcolor,
G_PARAM_READWRITE);
gimp_procedure_add_color_argument (procedure, "hcolor",
"H color",
"Horizontal color",
TRUE, default_hcolor,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "vwidth",
"V width",
"Vertical width",
0, GIMP_MAX_IMAGE_SIZE, 1,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "vwidth",
"V width",
"Vertical width",
0, GIMP_MAX_IMAGE_SIZE, 1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "vspace",
"V space",
"Vertical spacing",
1, GIMP_MAX_IMAGE_SIZE, 16,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "vspace",
"V space",
"Vertical spacing",
1, GIMP_MAX_IMAGE_SIZE, 16,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "voffset",
"V offset",
"Vertical offset",
0, GIMP_MAX_IMAGE_SIZE, 8,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "voffset",
"V offset",
"Vertical offset",
0, GIMP_MAX_IMAGE_SIZE, 8,
G_PARAM_READWRITE);
GIMP_PROC_ARG_COLOR (procedure, "vcolor",
"V color",
"Vertical color",
TRUE, default_vcolor,
G_PARAM_READWRITE);
gimp_procedure_add_color_argument (procedure, "vcolor",
"V color",
"Vertical color",
TRUE, default_vcolor,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "iwidth",
"I width",
"Intersection width",
0, GIMP_MAX_IMAGE_SIZE, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "iwidth",
"I width",
"Intersection width",
0, GIMP_MAX_IMAGE_SIZE, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "ispace",
"I space",
"Intersection spacing",
1, GIMP_MAX_IMAGE_SIZE, 2,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "ispace",
"I space",
"Intersection spacing",
1, GIMP_MAX_IMAGE_SIZE, 2,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "ioffset",
"I offset",
"Intersection offset",
0, GIMP_MAX_IMAGE_SIZE, 6,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "ioffset",
"I offset",
"Intersection offset",
0, GIMP_MAX_IMAGE_SIZE, 6,
G_PARAM_READWRITE);
GIMP_PROC_ARG_COLOR (procedure, "icolor",
"I color",
"Intersection color",
TRUE, default_icolor,
G_PARAM_READWRITE);
gimp_procedure_add_color_argument (procedure, "icolor",
"I color",
"Intersection color",
TRUE, default_icolor,
G_PARAM_READWRITE);
g_object_unref (default_hcolor);
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)",
"1998");
GIMP_PROC_VAL_INT (procedure, "image-count",
"Number of images created",
"Number of images created",
0, G_MAXINT, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int_return_value (procedure, "image-count",
"Number of images created",
"Number of images created",
0, G_MAXINT, 0,
G_PARAM_READWRITE);
GIMP_PROC_VAL_OBJECT_ARRAY (procedure, "images",
"Output images",
"Output images",
GIMP_TYPE_IMAGE,
G_PARAM_READWRITE);
gimp_procedure_add_object_array_return_value (procedure, "images",
"Output images",
"Output images",
GIMP_TYPE_IMAGE,
G_PARAM_READWRITE);
}
return procedure;

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

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

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

@ -409,37 +409,37 @@ jigsaw_create_procedure (GimpPlugIn *plug_in,
"Nigel Wetten",
"May 2000");
GIMP_PROC_ARG_INT (procedure, "x",
_("_Horizontal"),
_("Number of pieces going across"),
MIN_XTILES, MAX_XTILES, 5,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "x",
_("_Horizontal"),
_("Number of pieces going across"),
MIN_XTILES, MAX_XTILES, 5,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "y",
_("_Vertical"),
_("Number of pieces going down"),
MIN_YTILES, MAX_YTILES, 5,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "y",
_("_Vertical"),
_("Number of pieces going down"),
MIN_YTILES, MAX_YTILES, 5,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "style",
_("Jigsaw Style"),
_("The style/shape of the jigsaw puzzle "
"{ Square (0), Curved (1) }"),
0, 1, BEZIER_1,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "style",
_("Jigsaw Style"),
_("The style/shape of the jigsaw puzzle "
"{ Square (0), Curved (1) }"),
0, 1, BEZIER_1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "blend-lines",
_("_Blend width"),
_("Degree of slope of each piece's edge"),
MIN_BLEND_LINES, MAX_BLEND_LINES, 3,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "blend-lines",
_("_Blend width"),
_("Degree of slope of each piece's edge"),
MIN_BLEND_LINES, MAX_BLEND_LINES, 3,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "blend-amount",
_("Hi_ghlight"),
_("The amount of highlighting on the edges "
"of each piece"),
MIN_BLEND_AMOUNT, MAX_BLEND_AMOUNT, 0.5,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "blend-amount",
_("Hi_ghlight"),
_("The amount of highlighting on the edges "
"of each piece"),
MIN_BLEND_AMOUNT, MAX_BLEND_AMOUNT, 0.5,
G_PARAM_READWRITE);
}
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",
"1995-1997");
GIMP_PROC_ARG_STRING (procedure, "filename",
_("File_name"),
_("The name of the file to save the image in"),
NULL,
G_PARAM_READWRITE);
gimp_procedure_add_string_argument (procedure, "filename",
_("File_name"),
_("The name of the file to save the image in"),
NULL,
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "to-address",
_("_To"),
_("The email address to send to"),
"",
G_PARAM_READWRITE);
gimp_procedure_add_string_argument (procedure, "to-address",
_("_To"),
_("The email address to send to"),
"",
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "from-address",
_("_From"),
_("The email address for the From: field"),
"",
G_PARAM_READWRITE);
gimp_procedure_add_string_argument (procedure, "from-address",
_("_From"),
_("The email address for the From: field"),
"",
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "subject",
_("Su_bject"),
_("The subject"),
"",
G_PARAM_READWRITE);
gimp_procedure_add_string_argument (procedure, "subject",
_("Su_bject"),
_("The subject"),
"",
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "comment",
_("Co_mment"),
_("The comment"),
NULL,
G_PARAM_READWRITE);
gimp_procedure_add_string_argument (procedure, "comment",
_("Co_mment"),
_("The comment"),
NULL,
G_PARAM_READWRITE);
}
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",
"1997");
GIMP_PROC_ARG_DOUBLE (procedure, "alpha",
_("_Alpha"),
_("The amount of the filter to apply"),
0, 1, 0.3,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "alpha",
_("_Alpha"),
_("The amount of the filter to apply"),
0, 1, 0.3,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "radius",
_("Ra_dius"),
_("The filter radius"),
1.0 / 3.0, 1, 1.0 / 3.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "radius",
_("Ra_dius"),
_("The filter radius"),
1.0 / 3.0, 1, 1.0 / 3.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "filter",
_("Filter"),
_("The Filter to Run, "
"0 - alpha trimmed mean; "
"1 - optimal estimation "
"(alpha controls noise variance); "
"2 - edge enhancement"),
0, 2, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "filter",
_("Filter"),
_("The Filter to Run, "
"0 - alpha trimmed mean; "
"1 - optimal estimation "
"(alpha controls noise variance); "
"2 - edge enhancement"),
0, 2, 0,
G_PARAM_READWRITE);
}
return procedure;

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

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

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

@ -135,12 +135,12 @@ browser_create_procedure (GimpPlugIn *plug_in,
"Thomas Noel",
"23th june 1997");
GIMP_PROC_ARG_ENUM (procedure, "run-mode",
"Run mode",
"The run mode",
GIMP_TYPE_RUN_MODE,
GIMP_RUN_INTERACTIVE,
G_PARAM_READWRITE);
gimp_procedure_add_enum_argument (procedure, "run-mode",
"Run mode",
"The run mode",
GIMP_TYPE_RUN_MODE,
GIMP_RUN_INTERACTIVE,
G_PARAM_READWRITE);
}
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",
PLUG_IN_VERSION);
GIMP_PROC_ARG_BOOLEAN (procedure, "anti-aliasing",
_("_Anti-aliasing"),
_("Enable anti-aliasing using an oversampling "
"algorithm"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "anti-aliasing",
_("_Anti-aliasing"),
_("Enable anti-aliasing using an oversampling "
"algorithm"),
TRUE,
G_PARAM_READWRITE);
/* Saving the pattern as a parasite is a trick allowing to store
* random binary data.
*/
GIMP_PROC_AUX_ARG_PARASITE (procedure, "pattern",
"Qbist pattern", NULL,
G_PARAM_READWRITE);
gimp_procedure_add_parasite_aux_argument (procedure, "pattern",
"Qbist pattern", NULL,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_STRING (procedure, "data-path",
"Path of data file",
_("Any file which will be used as source for pattern generation"),
NULL,
G_PARAM_READWRITE);
gimp_procedure_add_string_aux_argument (procedure, "data-path",
"Path of data file",
_("Any file which will be used as source for pattern generation"),
NULL,
G_PARAM_READWRITE);
}
return procedure;

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

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

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

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

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

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

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

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

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

@ -281,11 +281,11 @@ tile_create_procedure (GimpPlugIn *plug_in,
"Andy Thomas",
"1997");
GIMP_PROC_ARG_INT (procedure, "num-tiles",
_("_n²"),
_("Number of tiles to make"),
2, MAX_SEGS, 2,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "num-tiles",
_("_n²"),
_("Number of tiles to make"),
2, MAX_SEGS, 2,
G_PARAM_READWRITE);
}
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
* image.
*/
GIMP_PROC_ARG_INT (procedure, "new-width",
_("New _width"),
_("New (tiled) image width"),
1, GIMP_MAX_IMAGE_SIZE, 1,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "new-width",
_("New _width"),
_("New (tiled) image width"),
1, GIMP_MAX_IMAGE_SIZE, 1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "new-height",
_("New _height"),
_("New (tiled) image height"),
1, GIMP_MAX_IMAGE_SIZE, 1,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "new-height",
_("New _height"),
_("New (tiled) image height"),
1, GIMP_MAX_IMAGE_SIZE, 1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "new-image",
_("New _image"),
_("Create a new image"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "new-image",
_("New _image"),
_("Create a new image"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_VAL_IMAGE (procedure, "new-image",
"New image",
"Output image (NULL if new-image == FALSE)",
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_image_return_value (procedure, "new-image",
"New image",
"Output image (NULL if new-image == FALSE)",
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_VAL_LAYER (procedure, "new-layer",
"New layer",
"Output layer (NULL if new-image == FALSE)",
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_layer_return_value (procedure, "new-layer",
"New layer",
"Output layer (NULL if new-image == FALSE)",
TRUE,
G_PARAM_READWRITE);
}
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>",
"2000");
GIMP_PROC_ARG_ENUM (procedure, "run-mode",
"Run mode",
"The run mode",
GIMP_TYPE_RUN_MODE,
GIMP_RUN_INTERACTIVE,
G_PARAM_READWRITE);
gimp_procedure_add_enum_argument (procedure, "run-mode",
"Run mode",
"The run mode",
GIMP_TYPE_RUN_MODE,
GIMP_RUN_INTERACTIVE,
G_PARAM_READWRITE);
}
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",
"Version 0.14, September 24 1997");
GIMP_PROC_ARG_CHOICE (procedure, "effect-channel",
_("E_ffect Channel"),
_("Effect Channel"),
gimp_choice_new_with_values ("hue", LIC_HUE, _("Hue"), NULL,
"saturation", LIC_SATURATION, _("Saturation"), NULL,
"brightness", LIC_BRIGHTNESS, _("Brightness"), NULL,
NULL),
"brightness",
G_PARAM_READWRITE);
gimp_procedure_add_choice_argument (procedure, "effect-channel",
_("E_ffect Channel"),
_("Effect Channel"),
gimp_choice_new_with_values ("hue", LIC_HUE, _("Hue"), NULL,
"saturation", LIC_SATURATION, _("Saturation"), NULL,
"brightness", LIC_BRIGHTNESS, _("Brightness"), NULL,
NULL),
"brightness",
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "effect-operator",
_("Effect O_perator"),
_("Effect Operator"),
gimp_choice_new_with_values ("derivative", 0, _("Derivative"), NULL,
"gradient", 1, _("Gradient"), NULL,
NULL),
"gradient",
G_PARAM_READWRITE);
gimp_procedure_add_choice_argument (procedure, "effect-operator",
_("Effect O_perator"),
_("Effect Operator"),
gimp_choice_new_with_values ("derivative", 0, _("Derivative"), NULL,
"gradient", 1, _("Gradient"), NULL,
NULL),
"gradient",
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "effect-convolve",
_("Con_volve"),
_("Convolve"),
gimp_choice_new_with_values ("with-white-noise", 0, _("With white noise"), NULL,
"with-source-image", 1, _("With source image"), NULL,
NULL),
"with-source-image",
G_PARAM_READWRITE);
gimp_procedure_add_choice_argument (procedure, "effect-convolve",
_("Con_volve"),
_("Convolve"),
gimp_choice_new_with_values ("with-white-noise", 0, _("With white noise"), NULL,
"with-source-image", 1, _("With source image"), NULL,
NULL),
"with-source-image",
G_PARAM_READWRITE);
GIMP_PROC_ARG_DRAWABLE (procedure, "effect-image",
_("Effect i_mage"),
_("Effect image"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_drawable_argument (procedure, "effect-image",
_("Effect i_mage"),
_("Effect image"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "filter-length",
_("Fil_ter length"),
_("Filter length"),
0.1, 64.0, 5.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "filter-length",
_("Fil_ter length"),
_("Filter length"),
0.1, 64.0, 5.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "noise-magnitude",
_("_Noise Magnitude"),
_("Noise Magnitude"),
1.0, 5.0, 2.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "noise-magnitude",
_("_Noise Magnitude"),
_("Noise Magnitude"),
1.0, 5.0, 2.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "integration-steps",
_("Inte_gration steps"),
_("Integration steps"),
1.0, 40.0, 25.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "integration-steps",
_("Inte_gration steps"),
_("Integration steps"),
1.0, 40.0, 25.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "min-value",
_("Minimum v_alue"),
_("Minimum value"),
-100.0, 0, -25.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "min-value",
_("Minimum v_alue"),
_("Minimum value"),
-100.0, 0, -25.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "max-value",
_("Ma_ximum value"),
_("Maximum value"),
0.0, 100, 25.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "max-value",
_("Ma_ximum value"),
_("Maximum value"),
0.0, 100, 25.0,
G_PARAM_READWRITE);
}
return procedure;

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

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

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

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

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

@ -128,36 +128,36 @@ webpage_create_procedure (GimpPlugIn *plug_in,
"2011",
"2011");
GIMP_PROC_ARG_ENUM (procedure, "run-mode",
"Run mode",
"The run mode",
GIMP_TYPE_RUN_MODE,
GIMP_RUN_INTERACTIVE,
G_PARAM_READWRITE);
gimp_procedure_add_enum_argument (procedure, "run-mode",
"Run mode",
"The run mode",
GIMP_TYPE_RUN_MODE,
GIMP_RUN_INTERACTIVE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "url",
_("Enter location (_URI)"),
_("URL of the webpage to screenshot"),
"https://www.gimp.org/",
G_PARAM_READWRITE);
gimp_procedure_add_string_argument (procedure, "url",
_("Enter location (_URI)"),
_("URL of the webpage to screenshot"),
"https://www.gimp.org/",
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "width",
_("_Width (pixels)"),
_("The width of the screenshot (in pixels)"),
100, GIMP_MAX_IMAGE_SIZE, 1024,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "width",
_("_Width (pixels)"),
_("The width of the screenshot (in pixels)"),
100, GIMP_MAX_IMAGE_SIZE, 1024,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "font-size",
_("_Font size"),
_("The font size to use in the page (in pt)"),
1, 1000, 12,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "font-size",
_("_Font size"),
_("The font size to use in the page (in pt)"),
1, 1000, 12,
G_PARAM_READWRITE);
GIMP_PROC_VAL_IMAGE (procedure, "image",
"Image",
"The output image",
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_image_return_value (procedure, "image",
"Image",
"The output image",
FALSE,
G_PARAM_READWRITE);
}
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),
"bmp");
GIMP_PROC_ARG_BOOLEAN (procedure, "use-rle",
_("Ru_n-Length Encoded"),
_("Use run-length-encoding compression "
"(only valid for 4 and 8-bit indexed images)"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "use-rle",
_("Ru_n-Length Encoded"),
_("Use run-length-encoding compression "
"(only valid for 4 and 8-bit indexed images)"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "write-color-space",
_("_Write color space information"),
_("Whether or not to write BITMAPV5HEADER "
"color space data"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "write-color-space",
_("_Write color space information"),
_("Whether or not to write BITMAPV5HEADER "
"color space data"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "rgb-format",
_("R_GB format"),
_("Export format for RGB images "
"(0=RGB_565, 1=RGBA_5551, 2=RGB_555, 3=RGB_888, "
"4=RGBA_8888, 5=RGBX_8888)"),
0, 5, 3,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "rgb-format",
_("R_GB format"),
_("Export format for RGB images "
"(0=RGB_565, 1=RGBA_5551, 2=RGB_555, 3=RGB_888, "
"4=RGBA_8888, 5=RGBX_8888)"),
0, 5, 3,
G_PARAM_READWRITE);
}
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),
"0,string,DDS");
GIMP_PROC_ARG_BOOLEAN (procedure, "load-mipmaps",
_("Load _mipmaps"),
_("Load mipmaps if present"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "load-mipmaps",
_("Load _mipmaps"),
_("Load mipmaps if present"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "flip-image",
_("Flip image _vertically"),
_("Flip the image vertically on import"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "flip-image",
_("Flip image _vertically"),
_("Flip the image vertically on import"),
FALSE,
G_PARAM_READWRITE);
}
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),
"dds");
GIMP_PROC_ARG_CHOICE (procedure, "compression-format",
_("Compressio_n"),
_("Compression format"),
gimp_choice_new_with_values ("none", DDS_COMPRESS_NONE, _("None"), NULL,
"bc1", DDS_COMPRESS_BC1, _("BC1 / DXT1"), NULL,
"bc2", DDS_COMPRESS_BC2, _("BC2 / DXT3"), NULL,
"bc3, ", DDS_COMPRESS_BC3, _("BC3 / DXT5"), NULL,
"bc3n", DDS_COMPRESS_BC3N, _("BC3nm / DXT5nm"), NULL,
"bc4", DDS_COMPRESS_BC4, _("BC4 / ATI1 (3Dc+)"), NULL,
"bc5", DDS_COMPRESS_BC5, _("BC5 / ATI2 (3Dc)"), NULL,
"rxgb", DDS_COMPRESS_RXGB, _("RXGB (DXT5)"), NULL,
"aexp", DDS_COMPRESS_AEXP, _("Alpha Exponent (DXT5)"), NULL,
"ycocg", DDS_COMPRESS_YCOCG, _("YCoCg (DXT5)"), NULL,
"ycocgs", DDS_COMPRESS_YCOCGS, _("YCoCg scaled (DXT5)"), NULL,
NULL),
"none",
G_PARAM_READWRITE);
gimp_procedure_add_choice_argument (procedure, "compression-format",
_("Compressio_n"),
_("Compression format"),
gimp_choice_new_with_values ("none", DDS_COMPRESS_NONE, _("None"), NULL,
"bc1", DDS_COMPRESS_BC1, _("BC1 / DXT1"), NULL,
"bc2", DDS_COMPRESS_BC2, _("BC2 / DXT3"), NULL,
"bc3, ", DDS_COMPRESS_BC3, _("BC3 / DXT5"), NULL,
"bc3n", DDS_COMPRESS_BC3N, _("BC3nm / DXT5nm"), NULL,
"bc4", DDS_COMPRESS_BC4, _("BC4 / ATI1 (3Dc+)"), NULL,
"bc5", DDS_COMPRESS_BC5, _("BC5 / ATI2 (3Dc)"), NULL,
"rxgb", DDS_COMPRESS_RXGB, _("RXGB (DXT5)"), NULL,
"aexp", DDS_COMPRESS_AEXP, _("Alpha Exponent (DXT5)"), NULL,
"ycocg", DDS_COMPRESS_YCOCG, _("YCoCg (DXT5)"), NULL,
"ycocgs", DDS_COMPRESS_YCOCGS, _("YCoCg scaled (DXT5)"), NULL,
NULL),
"none",
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "perceptual-metric",
_("Use percept_ual error metric"),
_("Use a perceptual error metric during compression"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "perceptual-metric",
_("Use percept_ual error metric"),
_("Use a perceptual error metric during compression"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "format",
_("_Format"),
_("Pixel format"),
gimp_choice_new_with_values ("default", DDS_FORMAT_DEFAULT, _("Default"), NULL,
"rgb8", DDS_FORMAT_RGB8, _("RGB8"), NULL,
"rgba8", DDS_FORMAT_RGBA8, _("RGBA8"), NULL,
"bgr8", DDS_FORMAT_BGR8, _("BGR8"), NULL,
"abgr8, ", DDS_FORMAT_ABGR8, _("ABGR8"), NULL,
"r5g6b5", DDS_FORMAT_R5G6B5, _("R5G6B5"), NULL,
"rgba4", DDS_FORMAT_RGBA4, _("RGBA4"), NULL,
"rgb5a1", DDS_FORMAT_RGB5A1, _("RGB5A1"), NULL,
"rgb10a2", DDS_FORMAT_RGB10A2, _("RGB10A2"), NULL,
"r3g3b2", DDS_FORMAT_R3G3B2, _("R3G3B2"), NULL,
"a8", DDS_FORMAT_A8, _("A8"), NULL,
"l8", DDS_FORMAT_L8, _("L8"), NULL,
"l8a8", DDS_FORMAT_L8A8, _("L8A8"), NULL,
"aexp", DDS_FORMAT_AEXP, _("AEXP"), NULL,
"ycocg", DDS_FORMAT_YCOCG, _("YCOCG"), NULL,
NULL),
"default",
G_PARAM_READWRITE);
gimp_procedure_add_choice_argument (procedure, "format",
_("_Format"),
_("Pixel format"),
gimp_choice_new_with_values ("default", DDS_FORMAT_DEFAULT, _("Default"), NULL,
"rgb8", DDS_FORMAT_RGB8, _("RGB8"), NULL,
"rgba8", DDS_FORMAT_RGBA8, _("RGBA8"), NULL,
"bgr8", DDS_FORMAT_BGR8, _("BGR8"), NULL,
"abgr8, ", DDS_FORMAT_ABGR8, _("ABGR8"), NULL,
"r5g6b5", DDS_FORMAT_R5G6B5, _("R5G6B5"), NULL,
"rgba4", DDS_FORMAT_RGBA4, _("RGBA4"), NULL,
"rgb5a1", DDS_FORMAT_RGB5A1, _("RGB5A1"), NULL,
"rgb10a2", DDS_FORMAT_RGB10A2, _("RGB10A2"), NULL,
"r3g3b2", DDS_FORMAT_R3G3B2, _("R3G3B2"), NULL,
"a8", DDS_FORMAT_A8, _("A8"), NULL,
"l8", DDS_FORMAT_L8, _("L8"), NULL,
"l8a8", DDS_FORMAT_L8A8, _("L8A8"), NULL,
"aexp", DDS_FORMAT_AEXP, _("AEXP"), NULL,
"ycocg", DDS_FORMAT_YCOCG, _("YCOCG"), NULL,
NULL),
"default",
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "save-type",
_("Sav_e type"),
_("How to save the image"),
gimp_choice_new_with_values ("layer", DDS_SAVE_SELECTED_LAYER, _("Selected layer"), NULL,
"canvas", DDS_SAVE_VISIBLE_LAYERS, _("All visible layers"), NULL,
"cube", DDS_SAVE_CUBEMAP, _("As cube map"), NULL,
"volume", DDS_SAVE_VOLUMEMAP, _("As volume map"), NULL,
"array", DDS_SAVE_ARRAY, _("As texture array"), NULL,
NULL),
"layer",
G_PARAM_READWRITE);
gimp_procedure_add_choice_argument (procedure, "save-type",
_("Sav_e type"),
_("How to save the image"),
gimp_choice_new_with_values ("layer", DDS_SAVE_SELECTED_LAYER, _("Selected layer"), NULL,
"canvas", DDS_SAVE_VISIBLE_LAYERS, _("All visible layers"), NULL,
"cube", DDS_SAVE_CUBEMAP, _("As cube map"), NULL,
"volume", DDS_SAVE_VOLUMEMAP, _("As volume map"), NULL,
"array", DDS_SAVE_ARRAY, _("As texture array"), NULL,
NULL),
"layer",
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "flip-image",
_("Flip image _vertically on export"),
_("Flip the image vertically on export"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "flip-image",
_("Flip image _vertically on export"),
_("Flip the image vertically on export"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "transparent-color",
_("Set _transparent color"),
_("Make an indexed color transparent"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "transparent-color",
_("Set _transparent color"),
_("Make an indexed color transparent"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "transparent-index",
_("Transparent inde_x"),
_("Index of transparent color or -1 to disable "
"(for indexed images only)."),
0, 255, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "transparent-index",
_("Transparent inde_x"),
_("Index of transparent color or -1 to disable "
"(for indexed images only)."),
0, 255, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "mipmaps",
_("_Mipmaps"),
_("How to handle mipmaps"),
gimp_choice_new_with_values ("none", DDS_MIPMAP_NONE, _("No mipmaps"), NULL,
"generate", DDS_MIPMAP_GENERATE, _("Generate mipmaps"), NULL,
"existing", DDS_MIPMAP_EXISTING, _("Use existing mipmaps"), NULL,
NULL),
"none",
G_PARAM_READWRITE);
gimp_procedure_add_choice_argument (procedure, "mipmaps",
_("_Mipmaps"),
_("How to handle mipmaps"),
gimp_choice_new_with_values ("none", DDS_MIPMAP_NONE, _("No mipmaps"), NULL,
"generate", DDS_MIPMAP_GENERATE, _("Generate mipmaps"), NULL,
"existing", DDS_MIPMAP_EXISTING, _("Use existing mipmaps"), NULL,
NULL),
"none",
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "mipmap-filter",
_("F_ilter"),
_("Filtering to use when generating mipmaps"),
gimp_choice_new_with_values ("default", DDS_MIPMAP_FILTER_DEFAULT, _("Default"), NULL,
"nearest", DDS_MIPMAP_FILTER_NEAREST, _("Nearest"), NULL,
"box", DDS_MIPMAP_FILTER_BOX, _("Box"), NULL,
"triangle", DDS_MIPMAP_FILTER_TRIANGLE, _("Triangle"), NULL,
"quadratic", DDS_MIPMAP_FILTER_QUADRATIC, _("Quadratic"), NULL,
"bspline", DDS_MIPMAP_FILTER_BSPLINE, _("B-Spline"), NULL,
"mitchell", DDS_MIPMAP_FILTER_MITCHELL, _("Mitchell"), NULL,
"catrom", DDS_MIPMAP_FILTER_CATROM, _("Catmull-Rom"), NULL,
"lanczos", DDS_MIPMAP_FILTER_LANCZOS, _("Lanczos"), NULL,
"kaiser", DDS_MIPMAP_FILTER_KAISER, _("Kaiser"), NULL,
NULL),
"default",
G_PARAM_READWRITE);
gimp_procedure_add_choice_argument (procedure, "mipmap-filter",
_("F_ilter"),
_("Filtering to use when generating mipmaps"),
gimp_choice_new_with_values ("default", DDS_MIPMAP_FILTER_DEFAULT, _("Default"), NULL,
"nearest", DDS_MIPMAP_FILTER_NEAREST, _("Nearest"), NULL,
"box", DDS_MIPMAP_FILTER_BOX, _("Box"), NULL,
"triangle", DDS_MIPMAP_FILTER_TRIANGLE, _("Triangle"), NULL,
"quadratic", DDS_MIPMAP_FILTER_QUADRATIC, _("Quadratic"), NULL,
"bspline", DDS_MIPMAP_FILTER_BSPLINE, _("B-Spline"), NULL,
"mitchell", DDS_MIPMAP_FILTER_MITCHELL, _("Mitchell"), NULL,
"catrom", DDS_MIPMAP_FILTER_CATROM, _("Catmull-Rom"), NULL,
"lanczos", DDS_MIPMAP_FILTER_LANCZOS, _("Lanczos"), NULL,
"kaiser", DDS_MIPMAP_FILTER_KAISER, _("Kaiser"), NULL,
NULL),
"default",
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "mipmap-wrap",
_("_Wrap mode"),
_("Wrap mode to use when generating mipmaps"),
gimp_choice_new_with_values ("default", DDS_MIPMAP_WRAP_DEFAULT, _("Default"), NULL,
"mirror", DDS_MIPMAP_WRAP_MIRROR, _("Mirror"), NULL,
"repeat", DDS_MIPMAP_WRAP_REPEAT, _("Repeat"), NULL,
"clamp", DDS_MIPMAP_WRAP_CLAMP, _("Clamp"), NULL,
NULL),
"default",
G_PARAM_READWRITE);
gimp_procedure_add_choice_argument (procedure, "mipmap-wrap",
_("_Wrap mode"),
_("Wrap mode to use when generating mipmaps"),
gimp_choice_new_with_values ("default", DDS_MIPMAP_WRAP_DEFAULT, _("Default"), NULL,
"mirror", DDS_MIPMAP_WRAP_MIRROR, _("Mirror"), NULL,
"repeat", DDS_MIPMAP_WRAP_REPEAT, _("Repeat"), NULL,
"clamp", DDS_MIPMAP_WRAP_CLAMP, _("Clamp"), NULL,
NULL),
"default",
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "gamma-correct",
_("Appl_y gamma correction"),
_("Use gamma correct mipmap filtering"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "gamma-correct",
_("Appl_y gamma correction"),
_("Use gamma correct mipmap filtering"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "srgb",
_("Use sRG_B colorspace"),
_("Use sRGB colorspace for gamma correction"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "srgb",
_("Use sRG_B colorspace"),
_("Use sRGB colorspace for gamma correction"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "gamma",
_("_Gamma"),
_("Gamma value to use for gamma correction (e.g. 2.2)"),
0.0, 10.0, 0.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "gamma",
_("_Gamma"),
_("Gamma value to use for gamma correction (e.g. 2.2)"),
0.0, 10.0, 0.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "preserve-alpha-coverage",
_("Preserve al_pha test coverage"),
_("Preserve alpha test coverage for alpha "
"channel maps"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "preserve-alpha-coverage",
_("Preserve al_pha test coverage"),
_("Preserve alpha test coverage for alpha "
"channel maps"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "alpha-test-threshold",
_("Alp_ha test threshold"),
_("Alpha test threshold value for which alpha test "
"coverage should be preserved"),
0.0, 1.0, 0.5,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "alpha-test-threshold",
_("Alp_ha test threshold"),
_("Alpha test threshold value for which alpha test "
"coverage should be preserved"),
0.0, 1.0, 0.5,
G_PARAM_READWRITE);
}
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),
"0,string,SIMPLE");
GIMP_PROC_AUX_ARG_INT (procedure, "replace",
_("Replacement for undefined pixels"),
_("Replacement for undefined pixels"),
0, 255, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int_aux_argument (procedure, "replace",
_("Replacement for undefined pixels"),
_("Replacement for undefined pixels"),
0, 255, 0,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_INT (procedure, "use-data-min-max",
_("Pixel value scaling"),
_("Use DATAMIN/DATAMAX-scaling if possible"),
0, 1, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int_aux_argument (procedure, "use-data-min-max",
_("Pixel value scaling"),
_("Use DATAMIN/DATAMAX-scaling if possible"),
0, 1, 0,
G_PARAM_READWRITE);
}
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),
"fli,flc");
GIMP_PROC_ARG_INT (procedure, "from-frame",
_("_From frame"),
_("Load beginning from this frame"),
-1, G_MAXINT, -1,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "from-frame",
_("_From frame"),
_("Load beginning from this frame"),
-1, G_MAXINT, -1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "to-frame",
_("_To frame"),
_("End loading with this frame"),
-1, G_MAXINT, -1,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "to-frame",
_("_To frame"),
_("End loading with this frame"),
-1, G_MAXINT, -1,
G_PARAM_READWRITE);
}
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),
"fli,flc");
GIMP_PROC_ARG_INT (procedure, "from-frame",
_("_From frame"),
_("Export beginning from this frame"),
-1, G_MAXINT, -1,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "from-frame",
_("_From frame"),
_("Export beginning from this frame"),
-1, G_MAXINT, -1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "to-frame",
_("_To frame"),
_("End exporting with this frame "
"(or -1 for all frames)"),
-1, G_MAXINT, -1,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "to-frame",
_("_To frame"),
_("End exporting with this frame "
"(or -1 for all frames)"),
-1, G_MAXINT, -1,
G_PARAM_READWRITE);
}
else if (! strcmp (name, INFO_PROC))
{
@ -263,28 +263,28 @@ fli_create_procedure (GimpPlugIn *plug_in,
"Jens Ch. Restemeier",
"1997");
GIMP_PROC_ARG_FILE (procedure, "file",
"File",
"The local file to get info about",
G_PARAM_READWRITE);
gimp_procedure_add_file_argument (procedure, "file",
"File",
"The local file to get info about",
G_PARAM_READWRITE);
GIMP_PROC_VAL_INT (procedure, "width",
"Width",
"Width of one frame",
0, GIMP_MAX_IMAGE_SIZE, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int_return_value (procedure, "width",
"Width",
"Width of one frame",
0, GIMP_MAX_IMAGE_SIZE, 0,
G_PARAM_READWRITE);
GIMP_PROC_VAL_INT (procedure, "height",
"Height",
"Height of one frame",
0, GIMP_MAX_IMAGE_SIZE, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int_return_value (procedure, "height",
"Height",
"Height of one frame",
0, GIMP_MAX_IMAGE_SIZE, 0,
G_PARAM_READWRITE);
GIMP_PROC_VAL_INT (procedure, "frames",
"Frames",
"Number of frames",
0, G_MAXINT, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int_return_value (procedure, "frames",
"Frames",
"Number of frames",
0, G_MAXINT, 0,
G_PARAM_READWRITE);
}
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),
"cur");
GIMP_PROC_ARG_INT (procedure, "n-hot-spot-x",
"Number of hot spot's X coordinates",
"Number of hot spot's X coordinates",
0, G_MAXINT, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT32_ARRAY (procedure, "hot-spot-x",
"Hot spot X",
"X coordinates of hot spot (one per layer)",
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "n-hot-spot-x",
"Number of hot spot's X coordinates",
"Number of hot spot's X coordinates",
0, G_MAXINT, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int32_array_argument (procedure, "hot-spot-x",
"Hot spot X",
"X coordinates of hot spot (one per layer)",
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "n-hot-spot-y",
"Number of hot spot's Y coordinates",
"Number of hot spot's Y coordinates",
0, G_MAXINT, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT32_ARRAY (procedure, "hot-spot-y",
"Hot spot Y",
"Y coordinates of hot spot (one per layer)",
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "n-hot-spot-y",
"Number of hot spot's Y coordinates",
"Number of hot spot's Y coordinates",
0, G_MAXINT, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int32_array_argument (procedure, "hot-spot-y",
"Hot spot Y",
"Y coordinates of hot spot (one per layer)",
G_PARAM_READWRITE);
}
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),
"ani");
GIMP_PROC_ARG_STRING (procedure, "cursor-name",
"Cursor Name",
_("Cursor Name (Optional)"),
NULL,
G_PARAM_READWRITE);
gimp_procedure_add_string_argument (procedure, "cursor-name",
"Cursor Name",
_("Cursor Name (Optional)"),
NULL,
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "author-name",
"Cursor Author",
_("Cursor Author (Optional)"),
NULL,
G_PARAM_READWRITE);
gimp_procedure_add_string_argument (procedure, "author-name",
"Cursor Author",
_("Cursor Author (Optional)"),
NULL,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "default-delay",
"Default delay",
"Default delay between frames "
"in jiffies (1/60 of a second)",
0, G_MAXINT, 8,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "default-delay",
"Default delay",
"Default delay between frames "
"in jiffies (1/60 of a second)",
0, G_MAXINT, 8,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "n-hot-spot-x",
"Number of hot spot's X coordinates",
"Number of hot spot's X coordinates",
0, G_MAXINT, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT32_ARRAY (procedure, "hot-spot-x",
"Hot spot X",
"X coordinates of hot spot (one per layer)",
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "n-hot-spot-x",
"Number of hot spot's X coordinates",
"Number of hot spot's X coordinates",
0, G_MAXINT, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int32_array_argument (procedure, "hot-spot-x",
"Hot spot X",
"X coordinates of hot spot (one per layer)",
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "n-hot-spot-y",
"Number of hot spot's Y coordinates",
"Number of hot spot's Y coordinates",
0, G_MAXINT, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT32_ARRAY (procedure, "hot-spot-y",
"Hot spot Y",
"Y coordinates of hot spot (one per layer)",
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "n-hot-spot-y",
"Number of hot spot's Y coordinates",
"Number of hot spot's Y coordinates",
0, G_MAXINT, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int32_array_argument (procedure, "hot-spot-y",
"Hot spot Y",
"Y coordinates of hot spot (one per layer)",
G_PARAM_READWRITE);
}
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
* settings
*/
GIMP_PROC_ARG_DOUBLE (procedure, "quality",
_("_Quality"),
_("Quality of exported image"),
0.0, 1.0, 0.9,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "quality",
_("_Quality"),
_("Quality of exported image"),
0.0, 1.0, 0.9,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "smoothing",
_("S_moothing"),
_("Smoothing factor for exported image"),
0.0, 1.0, 0.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "smoothing",
_("S_moothing"),
_("Smoothing factor for exported image"),
0.0, 1.0, 0.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "optimize",
_("Optimi_ze"),
_("Use optimized tables during Huffman coding"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "optimize",
_("Optimi_ze"),
_("Use optimized tables during Huffman coding"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "progressive",
_("_Progressive"),
_("Create progressive JPEG images"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "progressive",
_("_Progressive"),
_("Create progressive JPEG images"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "cmyk",
_("Export as CM_YK"),
_("Create a CMYK JPEG image using the soft-proofing color profile"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "cmyk",
_("Export as CM_YK"),
_("Create a CMYK JPEG image using the soft-proofing color profile"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "sub-sampling",
_("Su_bsampling"),
_("Sub-sampling type"),
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-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,
NULL),
"sub-sampling-1x1", G_PARAM_READWRITE);
gimp_procedure_add_choice_argument (procedure, "sub-sampling",
_("Su_bsampling"),
_("Sub-sampling type"),
gimp_choice_new_with_values ("sub-sampling-1x1", JPEG_SUBSAMPLING_1x1_1x1_1x1, _("4:4:4 (best quality)"), NULL,
"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-2x2", JPEG_SUBSAMPLING_2x2_1x1_1x1, _("4:2:0 (chroma quartered)"), NULL,
NULL),
"sub-sampling-1x1", G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "baseline",
_("Baseline"),
_("Force creation of a baseline JPEG "
"(non-baseline JPEGs can't be read by all decoders)"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "baseline",
_("Baseline"),
_("Force creation of a baseline JPEG "
"(non-baseline JPEGs can't be read by all decoders)"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "restart",
_("Inter_val (MCU rows):"),
_("Interval of restart markers "
"(in MCU rows, 0 = no restart markers)"),
0, 64, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "restart",
_("Inter_val (MCU rows):"),
_("Interval of restart markers "
"(in MCU rows, 0 = no restart markers)"),
0, 64, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "dct",
_("_DCT method"),
_("DCT method to use"),
gimp_choice_new_with_values ("fixed", 1, _("Fast Integer"), NULL,
"integer", 0, _("Integer"), NULL,
"float", 2, _("Floating-Point"), NULL,
NULL),
"integer", G_PARAM_READWRITE);
gimp_procedure_add_choice_argument (procedure, "dct",
_("_DCT method"),
_("DCT method to use"),
gimp_choice_new_with_values ("fixed", 1, _("Fast Integer"), NULL,
"integer", 0, _("Integer"), NULL,
"float", 2, _("Floating-Point"), NULL,
NULL),
"integer", G_PARAM_READWRITE);
/* Some auxiliary arguments mostly for interactive usage. */
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "use-original-quality",
_("_Use quality settings from original image"),
_("If the original image was loaded from a JPEG "
"file using non-standard quality settings "
"(quantization tables), enable this option to "
"get almost the same quality and file size."),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_INT (procedure, "original-quality",
NULL, NULL,
-1, 100, -1,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_INT (procedure, "original-sub-sampling",
NULL, NULL,
JPEG_SUBSAMPLING_2x2_1x1_1x1,
JPEG_SUBSAMPLING_1x2_1x1_1x1,
JPEG_SUBSAMPLING_2x2_1x1_1x1,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_INT (procedure, "original-num-quant-tables",
NULL, NULL,
-1, 4, -1,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_aux_argument (procedure, "use-original-quality",
_("_Use quality settings from original image"),
_("If the original image was loaded from a JPEG "
"file using non-standard quality settings "
"(quantization tables), enable this option to "
"get almost the same quality and file size."),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_int_aux_argument (procedure, "original-quality",
NULL, NULL,
-1, 100, -1,
G_PARAM_READWRITE);
gimp_procedure_add_int_aux_argument (procedure, "original-sub-sampling",
NULL, NULL,
JPEG_SUBSAMPLING_2x2_1x1_1x1,
JPEG_SUBSAMPLING_1x2_1x1_1x1,
JPEG_SUBSAMPLING_2x2_1x1_1x1,
G_PARAM_READWRITE);
gimp_procedure_add_int_aux_argument (procedure, "original-num-quant-tables",
NULL, NULL,
-1, 4, -1,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "show-preview",
_("Sho_w preview in image window"),
_("Creates a temporary layer with an export preview"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "use-arithmetic-coding",
_("Use _arithmetic coding"),
_("Older software may have trouble opening "
"arithmetic-coded images"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "use-restart",
_("Use restart mar_kers"),
NULL, FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_aux_argument (procedure, "show-preview",
_("Sho_w preview in image window"),
_("Creates a temporary layer with an export preview"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_aux_argument (procedure, "use-arithmetic-coding",
_("Use _arithmetic coding"),
_("Older software may have trouble opening "
"arithmetic-coded images"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_aux_argument (procedure, "use-restart",
_("Use restart mar_kers"),
NULL, FALSE,
G_PARAM_READWRITE);
gimp_export_procedure_set_support_exif (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),
"psd");
GIMP_PROC_ARG_BOOLEAN (procedure, "clippingpath",
_("Assign a Clipping _Path"),
_("Select a path to be the "
"clipping path"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "clippingpath",
_("Assign a Clipping _Path"),
_("Select a path to be the "
"clipping path"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "clippingpathname",
_("Clipping Path _Name"),
_("Clipping path name\n"
"(ignored if no clipping path)"),
NULL,
G_PARAM_READWRITE);
gimp_procedure_add_string_argument (procedure, "clippingpathname",
_("Clipping Path _Name"),
_("Clipping path name\n"
"(ignored if no clipping path)"),
NULL,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "clippingpathflatness",
_("Path _Flatness"),
_("Clipping path flatness in device pixels\n"
"(ignored if no clipping path)"),
0.0, 100.0, 0.2,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "clippingpathflatness",
_("Path _Flatness"),
_("Clipping path flatness in device pixels\n"
"(ignored if no clipping path)"),
0.0, 100.0, 0.2,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "cmyk",
_("Export as _CMYK"),
_("Export a CMYK PSD image using the soft-proofing color profile"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "cmyk",
_("Export as _CMYK"),
_("Export a CMYK PSD image using the soft-proofing color profile"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "duotone",
_("Export as _Duotone"),
_("Export as a Duotone PSD file if Duotone color space information "
"was attached to the image when originally imported."),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "duotone",
_("Export as _Duotone"),
_("Export as a Duotone PSD file if Duotone color space information "
"was attached to the image when originally imported."),
FALSE,
G_PARAM_READWRITE);
}
else if (! strcmp (name, LOAD_METADATA_PROC))
{
@ -283,29 +283,29 @@ psd_create_procedure (GimpPlugIn *plug_in,
"John Marshall",
"John Marshall",
"2007");
GIMP_PROC_ARG_INT (procedure, "size",
"Metadata size",
NULL,
0, G_MAXINT, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "size",
"Metadata size",
NULL,
0, G_MAXINT, 0,
G_PARAM_READWRITE);
gimp_procedure_add_argument (procedure,
gimp_param_spec_image ("image",
"image",
"The image",
FALSE,
GIMP_PARAM_READWRITE));
GIMP_PROC_ARG_BOOLEAN (procedure, "metadata-type",
"Metadata type",
"If the metadata contains image or "
"layer PSD resources.",
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "cmyk",
"CMYK",
"If the layer metadata needs to be "
"converted from CMYK colorspace.",
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "metadata-type",
"Metadata type",
"If the metadata contains image or "
"layer PSD resources.",
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "cmyk",
"CMYK",
"If the layer metadata needs to be "
"converted from CMYK colorspace.",
FALSE,
G_PARAM_READWRITE);
}
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),
"sgi,rgb,rgba,bw,icon");
GIMP_PROC_ARG_INT (procedure, "compression",
_("Compression _type"),
_("Compression level (0 = none, 1 = RLE, 2 = ARLE)"),
0, 2, SGI_COMP_RLE,
GIMP_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "compression",
_("Compression _type"),
_("Compression level (0 = none, 1 = RLE, 2 = ARLE)"),
0, 2, SGI_COMP_RLE,
GIMP_PARAM_READWRITE);
}
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
* should be part of the PDB API.
*/
GIMP_PROC_AUX_ARG_ENUM (procedure, "target",
"Open _pages as", NULL,
GIMP_TYPE_PAGE_SELECTOR_TARGET,
GIMP_PAGE_SELECTOR_TARGET_LAYERS,
G_PARAM_READWRITE);
gimp_procedure_add_enum_aux_argument (procedure, "target",
"Open _pages as", NULL,
GIMP_TYPE_PAGE_SELECTOR_TARGET,
GIMP_PAGE_SELECTOR_TARGET_LAYERS,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "keep-empty-space",
_("_Keep empty space around imported layers"),
NULL, TRUE, GIMP_PARAM_READWRITE);
gimp_procedure_add_boolean_aux_argument (procedure, "keep-empty-space",
_("_Keep empty space around imported layers"),
NULL, TRUE, GIMP_PARAM_READWRITE);
}
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),
"tif,tiff");
GIMP_PROC_ARG_BOOLEAN (procedure, "bigtiff",
_("Export in _BigTIFF variant file format"),
_("The BigTIFF variant file format uses 64-bit offsets, "
"hence supporting over 4GiB files and bigger"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "bigtiff",
_("Export in _BigTIFF variant file format"),
_("The BigTIFF variant file format uses 64-bit offsets, "
"hence supporting over 4GiB files and bigger"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "compression",
_("Co_mpression"),
_("Compression type"),
gimp_choice_new_with_values ("none", GIMP_COMPRESSION_NONE, _("None"), NULL,
"lzw", GIMP_COMPRESSION_LZW, _("LZW"), NULL,
"packbits", GIMP_COMPRESSION_PACKBITS, _("Pack Bits"), NULL,
"adobe_deflate", GIMP_COMPRESSION_ADOBE_DEFLATE, _("Deflate"), NULL,
"jpeg", GIMP_COMPRESSION_JPEG, _("JPEG"), NULL,
"ccittfax3", GIMP_COMPRESSION_CCITTFAX3, _("CCITT Group 3 fax"), NULL,
"ccittfax4", GIMP_COMPRESSION_CCITTFAX4, _("CCITT Group 4 fax"), NULL,
NULL),
"none", G_PARAM_READWRITE);
gimp_procedure_add_choice_argument (procedure, "compression",
_("Co_mpression"),
_("Compression type"),
gimp_choice_new_with_values ("none", GIMP_COMPRESSION_NONE, _("None"), NULL,
"lzw", GIMP_COMPRESSION_LZW, _("LZW"), NULL,
"packbits", GIMP_COMPRESSION_PACKBITS, _("Pack Bits"), NULL,
"adobe_deflate", GIMP_COMPRESSION_ADOBE_DEFLATE, _("Deflate"), NULL,
"jpeg", GIMP_COMPRESSION_JPEG, _("JPEG"), NULL,
"ccittfax3", GIMP_COMPRESSION_CCITTFAX3, _("CCITT Group 3 fax"), NULL,
"ccittfax4", GIMP_COMPRESSION_CCITTFAX4, _("CCITT Group 4 fax"), NULL,
NULL),
"none", G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "save-transparent-pixels",
_("Save color _values from transparent pixels"),
_("Keep the color data masked by an alpha channel "
"intact (do not store premultiplied components)"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "save-transparent-pixels",
_("Save color _values from transparent pixels"),
_("Keep the color data masked by an alpha channel "
"intact (do not store premultiplied components)"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "cmyk",
_("Export as CMY_K"),
_("Create a CMYK TIFF image using the soft-proofing color profile"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "cmyk",
_("Export as CMY_K"),
_("Create a CMYK TIFF image using the soft-proofing color profile"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-layers",
_("Save La_yers"),
_("Save Layers"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_aux_argument (procedure, "save-layers",
_("Save La_yers"),
_("Save Layers"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "crop-layers",
_("Crop L_ayers"),
_("Crop Layers"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_aux_argument (procedure, "crop-layers",
_("Crop L_ayers"),
_("Crop Layers"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-geotiff",
_("Save _GeoTIFF data"),
_("Save GeoTIFF data"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_aux_argument (procedure, "save-geotiff",
_("Save _GeoTIFF data"),
_("Save GeoTIFF data"),
TRUE,
G_PARAM_READWRITE);
gimp_export_procedure_set_support_exif (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),
"webp");
GIMP_PROC_ARG_INT (procedure, "preset",
_("Source _type"),
_("WebP encoder preset (Default=0, Picture=1, Photo=2, Drawing=3, "
"Icon=4, Text=5)"),
0, 5, WEBP_PRESET_DEFAULT,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "preset",
_("Source _type"),
_("WebP encoder preset (Default=0, Picture=1, Photo=2, Drawing=3, "
"Icon=4, Text=5)"),
0, 5, WEBP_PRESET_DEFAULT,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "lossless",
_("L_ossless"),
_("Use lossless encoding"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "lossless",
_("L_ossless"),
_("Use lossless encoding"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "quality",
_("Image _quality"),
_("Quality of the image"),
0, 100, 90,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "quality",
_("Image _quality"),
_("Quality of the image"),
0, 100, 90,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "alpha-quality",
_("Alpha q_uality"),
_("Quality of the image's alpha channel"),
0, 100, 100,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "alpha-quality",
_("Alpha q_uality"),
_("Quality of the image's alpha channel"),
0, 100, 100,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "use-sharp-yuv",
_("Use Sharp YU_V"),
/* TRANSLATORS: \xe2\x86\x92 is a Unicode
* "Rightward Arrow" in UTF-8 encoding.
*/
_("Use sharper (but slower) RGB\xe2\x86\x92YUV conversion"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "use-sharp-yuv",
_("Use Sharp YU_V"),
/* TRANSLATORS: \xe2\x86\x92 is a Unicode
* "Rightward Arrow" in UTF-8 encoding.
*/
_("Use sharper (but slower) RGB\xe2\x86\x92YUV conversion"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "animation-loop",
_("Loop _forever"),
_("Loop animation infinitely"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "animation-loop",
_("Loop _forever"),
_("Loop animation infinitely"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "minimize-size",
_("_Minimize output size (slower)"),
_("Minimize output file size"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "minimize-size",
_("_Minimize output size (slower)"),
_("Minimize output file size"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "keyframe-distance",
_("Max distance between _key-frames"),
_("Maximum distance between keyframes"),
0, G_MAXINT, 50,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "keyframe-distance",
_("Max distance between _key-frames"),
_("Maximum distance between keyframes"),
0, G_MAXINT, 50,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "default-delay",
_("_Default delay between frames"),
_("Default delay (in milliseconds) to use when timestamps"
" for frames are not available or forced."),
0, G_MAXINT, 200,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "default-delay",
_("_Default delay between frames"),
_("Default delay (in milliseconds) to use when timestamps"
" for frames are not available or forced."),
0, G_MAXINT, 200,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "force-delay",
_("Use default dela_y for all frames"),
_("Force default delay on all frames"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "force-delay",
_("Use default dela_y for all frames"),
_("Force default delay on all frames"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "animation",
_("Save a_nimation"),
_("Use layers for animation"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "animation",
_("Save a_nimation"),
_("Use layers for animation"),
FALSE,
G_PARAM_READWRITE);
gimp_export_procedure_set_support_exif (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",
"1997");
GIMP_PROC_ARG_DOUBLE (procedure, "brightness",
_("_Brightness"), NULL,
0.0, 5.0, 1.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "brightness",
_("_Brightness"), NULL,
0.0, 5.0, 1.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "contrast",
_("Co_ntrast"), NULL,
0.0, 5.0, 1.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "contrast",
_("Co_ntrast"), NULL,
0.0, 5.0, 1.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "gamma",
_("_Gamma"), NULL,
1.0, 5.0, 1.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "gamma",
_("_Gamma"), NULL,
1.0, 5.0, 1.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "sample-density",
_("Sample _density"), NULL,
0.1, 20.0, 5.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "sample-density",
_("Sample _density"), NULL,
0.1, 20.0, 5.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "spatial-oversample",
_("Spa_tial oversample"), NULL,
1, 4, 2.0,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "spatial-oversample",
_("Spa_tial oversample"), NULL,
1, 4, 2.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "spatial-filter-radius",
_("Spatial _filter radius"), NULL,
0.0, 4.0, 0.75,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "spatial-filter-radius",
_("Spatial _filter radius"), NULL,
0.0, 4.0, 0.75,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "zoom",
_("_Zoom"), NULL,
-4.0, 4.0, 0.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "zoom",
_("_Zoom"), NULL,
-4.0, 4.0, 0.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "x",
_("_X"), NULL,
-2.0, 2.0, 0.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "x",
_("_X"), NULL,
-2.0, 2.0, 0.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "y",
_("_Y"), NULL,
-2.0, 2.0, 0.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "y",
_("_Y"), NULL,
-2.0, 2.0, 0.0,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BYTES (procedure, "settings-data",
"Settings data",
"TODO: eventually we must implement proper args for every settings",
GIMP_PARAM_READWRITE);
gimp_procedure_add_bytes_aux_argument (procedure, "settings-data",
"Settings data",
"TODO: eventually we must implement proper args for every settings",
GIMP_PARAM_READWRITE);
}
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)",
"December, 1998");
GIMP_PROC_ARG_CHOICE (procedure, "fractal-type",
_("Fr_actal Type"),
_("Type of Fractal Pattern"),
gimp_choice_new_with_values ("mandelbrot", 0, _("Mandelbrot"), NULL,
"julia", 1, _("Julia"), NULL,
"barnsley-1", 2, _("Barnsley 1"), NULL,
"barnsley-2", 3, _("Barnsley 2"), NULL,
"barnsley-3", 4, _("Barnsley 3"), NULL,
"spider", 5, _("Spider"), NULL,
"man-o-war", 6, _("Man-o-War"), NULL,
"lambda", 7, _("Lambda"), NULL,
"sierpinski", 8, _("Sierpinski"), NULL,
NULL),
"mandelbrot",
G_PARAM_READWRITE);
gimp_procedure_add_choice_argument (procedure, "fractal-type",
_("Fr_actal Type"),
_("Type of Fractal Pattern"),
gimp_choice_new_with_values ("mandelbrot", 0, _("Mandelbrot"), NULL,
"julia", 1, _("Julia"), NULL,
"barnsley-1", 2, _("Barnsley 1"), NULL,
"barnsley-2", 3, _("Barnsley 2"), NULL,
"barnsley-3", 4, _("Barnsley 3"), NULL,
"spider", 5, _("Spider"), NULL,
"man-o-war", 6, _("Man-o-War"), NULL,
"lambda", 7, _("Lambda"), NULL,
"sierpinski", 8, _("Sierpinski"), NULL,
NULL),
"mandelbrot",
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "xmin",
_("Lef_t"),
_("X min fractal image delimiter"),
-3.000, 3.000, -2.000,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "xmin",
_("Lef_t"),
_("X min fractal image delimiter"),
-3.000, 3.000, -2.000,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "xmax",
_("Ri_ght"),
_("X max fractal image delimiter"),
-3.000, 3.000, 2.000,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "xmax",
_("Ri_ght"),
_("X max fractal image delimiter"),
-3.000, 3.000, 2.000,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "ymin",
_("To_p"),
_("Y min fractal image delimiter"),
-3.000, 3.000, -1.500,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "ymin",
_("To_p"),
_("Y min fractal image delimiter"),
-3.000, 3.000, -1.500,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "ymax",
_("_Bottom"),
_("Y max fractal image delimiter"),
-3.000, 3.000, 1.500,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "ymax",
_("_Bottom"),
_("Y max fractal image delimiter"),
-3.000, 3.000, 1.500,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "iter",
_("Iteratio_ns"),
_("Iteration value"),
1, 1000, 50,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "iter",
_("Iteratio_ns"),
_("Iteration value"),
1, 1000, 50,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "cx",
_("C_X"),
_("cx value"),
-2.5000, 2.5000, -0.75,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "cx",
_("C_X"),
_("cx value"),
-2.5000, 2.5000, -0.75,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "cy",
_("C_Y"),
_("cy value"),
-2.5000, 2.5000, -0.2,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "cy",
_("C_Y"),
_("cy value"),
-2.5000, 2.5000, -0.2,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "color-mode",
_("Color mode"),
_("0: Apply colormap as specified by the parameters "
"above; 1: Apply active gradient to final image"),
0, 1, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "color-mode",
_("Color mode"),
_("0: Apply colormap as specified by the parameters "
"above; 1: Apply active gradient to final image"),
0, 1, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "red-stretch",
_("Red stretch"),
_("Red stretching factor"),
0, 1, 1,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "red-stretch",
_("Red stretch"),
_("Red stretching factor"),
0, 1, 1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "green-stretch",
_("Green stretch"),
_("Green stretching factor"),
0, 1, 1,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "green-stretch",
_("Green stretch"),
_("Green stretching factor"),
0, 1, 1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "blue-stretch",
_("Blue stretch"),
_("Blue stretching factor"),
0, 1, 1,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "blue-stretch",
_("Blue stretch"),
_("Blue stretching factor"),
0, 1, 1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "red-mode",
_("_Red"),
_("Red application mode"),
gimp_choice_new_with_values ("red-sin", 0, _("Sine"), NULL,
"red-cos", 1, _("Cosine"), NULL,
"red-none", 2, _("None"), NULL,
NULL),
"red-cos",
G_PARAM_READWRITE);
gimp_procedure_add_choice_argument (procedure, "red-mode",
_("_Red"),
_("Red application mode"),
gimp_choice_new_with_values ("red-sin", 0, _("Sine"), NULL,
"red-cos", 1, _("Cosine"), NULL,
"red-none", 2, _("None"), NULL,
NULL),
"red-cos",
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "green-mode",
_("_Green"),
_("Green application mode"),
gimp_choice_new_with_values ("green-sin", 0, _("Sine"), NULL,
"green-cos", 1, _("Cosine"), NULL,
"green-none", 2, _("None"), NULL,
NULL),
"green-cos",
G_PARAM_READWRITE);
gimp_procedure_add_choice_argument (procedure, "green-mode",
_("_Green"),
_("Green application mode"),
gimp_choice_new_with_values ("green-sin", 0, _("Sine"), NULL,
"green-cos", 1, _("Cosine"), NULL,
"green-none", 2, _("None"), NULL,
NULL),
"green-cos",
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "blue-mode",
_("_Blue"),
_("Blue application mode"),
gimp_choice_new_with_values ("blue-sin", 0, _("Sine"), NULL,
"blue-cos", 1, _("Cosine"), NULL,
"blue-none", 2, _("None"), NULL,
NULL),
"blue-sin",
G_PARAM_READWRITE);
gimp_procedure_add_choice_argument (procedure, "blue-mode",
_("_Blue"),
_("Blue application mode"),
gimp_choice_new_with_values ("blue-sin", 0, _("Sine"), NULL,
"blue-cos", 1, _("Cosine"), NULL,
"blue-none", 2, _("None"), NULL,
NULL),
"blue-sin",
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "red-invert",
_("In_version"),
_("Red inversion mode"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "red-invert",
_("In_version"),
_("Red inversion mode"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "green-invert",
_("I_nversion"),
_("Green inversion mode"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "green-invert",
_("I_nversion"),
_("Green inversion mode"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "blue-invert",
_("_Inversion"),
_("Blue inversion mode"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "blue-invert",
_("_Inversion"),
_("Blue inversion mode"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "n-colors",
_("_Number of colors"),
_("Number of Colors for mapping"),
2, 8192, 512,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "use-loglog-smoothing",
_("_Use log log smoothing"),
_("Use log log smoothing to eliminate "
"\"banding\" in the result"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "n-colors",
_("_Number of colors"),
_("Number of Colors for mapping"),
2, 8192, 512,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "use-loglog-smoothing",
_("_Use log log smoothing"),
_("Use log log smoothing to eliminate "
"\"banding\" in the result"),
FALSE,
G_PARAM_READWRITE);
}

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

@ -132,16 +132,16 @@ gimpressionist_create_procedure (GimpPlugIn *plug_in,
"Vidar Madsen",
PLUG_IN_VERSION);
GIMP_PROC_ARG_STRING (procedure, "preset",
_("Preset"),
_("Preset Name"),
NULL,
G_PARAM_READWRITE);
gimp_procedure_add_string_argument (procedure, "preset",
_("Preset"),
_("Preset Name"),
NULL,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BYTES (procedure, "settings-data",
"Settings data",
"TODO: eventually we must implement proper args for every settings",
GIMP_PARAM_READWRITE);
gimp_procedure_add_bytes_aux_argument (procedure, "settings-data",
"Settings data",
"TODO: eventually we must implement proper args for every settings",
GIMP_PARAM_READWRITE);
}
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",
"1997");
GIMP_PROC_ARG_STRING (procedure, "gflare-name",
"GFlare name",
"Name of the GFlare to render",
"Default",
G_PARAM_READWRITE);
gimp_procedure_add_string_argument (procedure, "gflare-name",
"GFlare name",
"Name of the GFlare to render",
"Default",
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "center-x",
"Center X",
"X coordinate of center of GFlare",
-GIMP_MAX_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE, 128,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "center-x",
"Center X",
"X coordinate of center of GFlare",
-GIMP_MAX_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE, 128,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "center-y",
"Center Y",
"Y coordinate of center of GFlare",
-GIMP_MAX_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE, 128,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "center-y",
"Center Y",
"Y coordinate of center of GFlare",
-GIMP_MAX_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE, 128,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "radius",
_("Radi_us"),
_("Radius of GFlare (pixel)"),
1, GIMP_MAX_IMAGE_SIZE, 100,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "radius",
_("Radi_us"),
_("Radius of GFlare (pixel)"),
1, GIMP_MAX_IMAGE_SIZE, 100,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "rotation",
_("Ro_tation"),
_("Rotation of GFlare (degree)"),
0, 360, 0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "rotation",
_("Ro_tation"),
_("Rotation of GFlare (degree)"),
0, 360, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "hue",
_("_Hue rotation"),
_("Hue rotation of GFlare (degree)"),
0, 360, 0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "hue",
_("_Hue rotation"),
_("Hue rotation of GFlare (degree)"),
0, 360, 0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "vector-angle",
_("Vector _angle"),
_("Vector angle for second flares (degree)"),
0, 360, 60,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "vector-angle",
_("Vector _angle"),
_("Vector angle for second flares (degree)"),
0, 360, 60,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "vector-length",
_("Vector len_gth"),
_("Vector length for second flares "
"(percentage of Radius)"),
0, 10000, 400,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "vector-length",
_("Vector len_gth"),
_("Vector length for second flares "
"(percentage of Radius)"),
0, 10000, 400,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "use-asupsample",
_("Ada_ptive supersampling"),
_("Use adaptive supersampling while rendering"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "use-asupsample",
_("Ada_ptive supersampling"),
_("Use adaptive supersampling while rendering"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "asupsample-max-depth",
_("_Max depth"),
_("Max depth for adaptive supersampling"),
0, 10, 3,
G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "asupsample-max-depth",
_("_Max depth"),
_("Max depth for adaptive supersampling"),
0, 10, 3,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "asupsample-threshold",
_("Threshol_d"),
_("Threshold for adaptive supersampling"),
0.0, 1.0, 0.2,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "asupsample-threshold",
_("Threshol_d"),
_("Threshold for adaptive supersampling"),
0.0, 1.0, 0.2,
G_PARAM_READWRITE);
}
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",
"1999-2008");
GIMP_PROC_ARG_ENUM (procedure, "run-mode",
"Run mode",
"The run mode",
GIMP_TYPE_RUN_MODE,
GIMP_RUN_INTERACTIVE,
G_PARAM_READWRITE);
gimp_procedure_add_enum_argument (procedure, "run-mode",
"Run mode",
"The run mode",
GIMP_TYPE_RUN_MODE,
GIMP_RUN_INTERACTIVE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRV (procedure, "domain-names",
"Domain names",
"Domain names",
G_PARAM_READWRITE);
gimp_procedure_add_string_array_argument (procedure, "domain-names",
"Domain names",
"Domain names",
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRV (procedure, "domain-uris",
"Domain URIs",
"Domain URIs",
G_PARAM_READWRITE);
gimp_procedure_add_string_array_argument (procedure, "domain-uris",
"Domain URIs",
"Domain URIs",
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BYTES (procedure, "dialog-data",
"Dialog data",
"Remembering dialog's basic features; this is never meant to be a public argument",
GIMP_PARAM_READWRITE);
gimp_procedure_add_bytes_aux_argument (procedure, "dialog-data",
"Dialog data",
"Remembering dialog's basic features; this is never meant to be a public argument",
GIMP_PARAM_READWRITE);
}
return procedure;
@ -220,23 +220,23 @@ temp_proc_install (GimpPlugIn *plug_in)
"Henrik Brix Andersen",
"1999-2008");
GIMP_PROC_ARG_STRING (procedure, "help-domain",
"Help domain",
"Help domain to use",
NULL,
G_PARAM_READWRITE);
gimp_procedure_add_string_argument (procedure, "help-domain",
"Help domain",
"Help domain to use",
NULL,
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "help-locales",
"Help locales",
"Language to use",
NULL,
G_PARAM_READWRITE);
gimp_procedure_add_string_argument (procedure, "help-locales",
"Help locales",
"Language to use",
NULL,
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "help-id",
"Help ID",
"Help ID to open",
NULL,
G_PARAM_READWRITE);
gimp_procedure_add_string_argument (procedure, "help-id",
"Help ID",
"Help ID to open",
NULL,
G_PARAM_READWRITE);
gimp_plug_in_add_temp_procedure (plug_in, 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",
"1999-2008");
GIMP_PROC_ARG_STRV (procedure, "domain-names",
"Domain Names",
"Domain names",
G_PARAM_READWRITE);
gimp_procedure_add_string_array_argument (procedure, "domain-names",
"Domain Names",
"Domain names",
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRV (procedure, "domain-uris",
"Domain URIs",
"Domain URIs",
G_PARAM_READWRITE);
gimp_procedure_add_string_array_argument (procedure, "domain-uris",
"Domain URIs",
"Domain URIs",
G_PARAM_READWRITE);
}
return procedure;
@ -210,25 +210,25 @@ help_temp_proc_install (GimpPlugIn *plug_in)
"Henrik Brix Andersen",
"1999-2008");
GIMP_PROC_ARG_STRING (procedure, "help-proc",
"The procedure of the browser to use",
"The procedure of the browser to use",
NULL,
G_PARAM_READWRITE);
gimp_procedure_add_string_argument (procedure, "help-proc",
"The procedure of the browser to use",
"The procedure of the browser to use",
NULL,
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "help-domain",
"Help domain to use",
"Help domain to use",
NULL,
G_PARAM_READWRITE);
gimp_procedure_add_string_argument (procedure, "help-domain",
"Help domain to use",
"Help domain to use",
NULL,
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "help-locales",
"Language to use",
"Language to use",
NULL,
G_PARAM_READWRITE);
gimp_procedure_add_string_argument (procedure, "help-locales",
"Language to use",
"Language to use",
NULL,
G_PARAM_READWRITE);
GIMP_PROC_ARG_STRING (procedure, "help-id",
gimp_procedure_add_string_argument (procedure, "help-id",
"Help ID to open",
"Help ID to open",
NULL,

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

@ -452,10 +452,10 @@ ifs_create_procedure (GimpPlugIn *plug_in,
"Owen Taylor",
"1997");
GIMP_PROC_AUX_ARG_STRING (procedure, "fractal-str",
"The fractal description serialized as string",
NULL, NULL,
GIMP_PARAM_READWRITE);
gimp_procedure_add_string_aux_argument (procedure, "fractal-str",
"The fractal description serialized as string",
NULL, NULL,
GIMP_PARAM_READWRITE);
}
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",
"Version 0.2.0, March 15 1998");
GIMP_PROC_ARG_DRAWABLE (procedure, "bump-drawable",
_("B_ump map image"),
_("Bumpmap drawable (set to NULL if disabled)"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_drawable_argument (procedure, "bump-drawable",
_("B_ump map image"),
_("Bumpmap drawable (set to NULL if disabled)"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DRAWABLE (procedure, "env-drawable",
_("Enviro_nment map image"),
_("Environmentmap drawable "
"(set to NULL if disabled)"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_drawable_argument (procedure, "env-drawable",
_("Enviro_nment map image"),
_("Environmentmap drawable "
"(set to NULL if disabled)"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "do-bumpmap",
_("Enable bump mappi_ng"),
_("Enable bumpmapping"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "do-bumpmap",
_("Enable bump mappi_ng"),
_("Enable bumpmapping"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "do-envmap",
_("Enable en_vironment mapping"),
_("Enable envmapping"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "do-envmap",
_("Enable en_vironment mapping"),
_("Enable envmapping"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "bumpmap-type",
_("Cur_ve"),
_("Type of mapping"),
gimp_choice_new_with_values ("bumpmap-linear", LINEAR_MAP, _("Linear"), NULL,
"bumpmap-log", LOGARITHMIC_MAP, _("Logarithmic"), NULL,
"bumpmap-sinusoidal", SINUSOIDAL_MAP, _("Sinusoidal"), NULL,
"bumpmap-spherical", SPHERICAL_MAP, _("Spherical"), NULL,
NULL),
"bumpmap-linear",
G_PARAM_READWRITE);
gimp_procedure_add_choice_argument (procedure, "bumpmap-type",
_("Cur_ve"),
_("Type of mapping"),
gimp_choice_new_with_values ("bumpmap-linear", LINEAR_MAP, _("Linear"), NULL,
"bumpmap-log", LOGARITHMIC_MAP, _("Logarithmic"), NULL,
"bumpmap-sinusoidal", SINUSOIDAL_MAP, _("Sinusoidal"), NULL,
"bumpmap-spherical", SPHERICAL_MAP, _("Spherical"), NULL,
NULL),
"bumpmap-linear",
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "bumpmap-max-height",
_("Ma_ximum height"),
_("The maximum height of the bumpmap"),
0.0, G_MAXFLOAT, 0.1,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "bumpmap-max-height",
_("Ma_ximum height"),
_("The maximum height of the bumpmap"),
0.0, G_MAXFLOAT, 0.1,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_CHOICE (procedure, "which-light",
_("Active"),
_("Which light is active in the GUI"),
gimp_choice_new_with_values ("light-1", 0, _("Light 1"), NULL,
"light-2", 1, _("Light 2"), NULL,
"light-3", 2, _("Light 3"), NULL,
"light-4", 3, _("Light 4"), NULL,
"light-5", 4, _("Light 5"), NULL,
"light-6", 5, _("Light 6"), NULL,
NULL),
"light-1",
G_PARAM_READWRITE);
gimp_procedure_add_choice_aux_argument (procedure, "which-light",
_("Active"),
_("Which light is active in the GUI"),
gimp_choice_new_with_values ("light-1", 0, _("Light 1"), NULL,
"light-2", 1, _("Light 2"), NULL,
"light-3", 2, _("Light 3"), NULL,
"light-4", 3, _("Light 4"), NULL,
"light-5", 4, _("Light 5"), NULL,
"light-6", 5, _("Light 6"), NULL,
NULL),
"light-1",
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "isolate",
_("Isolate"),
_("Only show the active lighting in "
"the preview"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_aux_argument (procedure, "isolate",
_("Isolate"),
_("Only show the active lighting in "
"the preview"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "light-type-1",
_("Type"),
_("Type of light source"),
gimp_choice_new_with_values ("light-none", NO_LIGHT, _("None"), NULL,
"light-directional", DIRECTIONAL_LIGHT, _("Directional"), NULL,
"light-point", POINT_LIGHT, _("Point"), NULL,
"light-spot", SPOT_LIGHT, _("Spot"), NULL,
NULL),
"light-point",
G_PARAM_READWRITE);
gimp_procedure_add_choice_argument (procedure, "light-type-1",
_("Type"),
_("Type of light source"),
gimp_choice_new_with_values ("light-none", NO_LIGHT, _("None"), NULL,
"light-directional", DIRECTIONAL_LIGHT, _("Directional"), NULL,
"light-point", POINT_LIGHT, _("Point"), NULL,
"light-spot", SPOT_LIGHT, _("Spot"), NULL,
NULL),
"light-point",
G_PARAM_READWRITE);
GIMP_PROC_ARG_COLOR (procedure, "light-color-1",
_("Color"),
_("Light source color"),
TRUE, default_color_1,
G_PARAM_READWRITE);
gimp_procedure_add_color_argument (procedure, "light-color-1",
_("Color"),
_("Light source color"),
TRUE, default_color_1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "light-intensity-1",
_("Intensity"),
_("Light source intensity"),
0, 100.0, 1.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "light-intensity-1",
_("Intensity"),
_("Light source intensity"),
0, 100.0, 1.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "light-position-x-1",
_("Light position X"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, -1,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "light-position-x-1",
_("Light position X"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, -1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "light-position-y-1",
_("Light position Y"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, -1,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "light-position-y-1",
_("Light position Y"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, -1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "light-position-z-1",
_("Light position Z"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "light-position-z-1",
_("Light position Z"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "light-direction-x-1",
_("Light direction X"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, -1,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "light-direction-x-1",
_("Light direction X"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, -1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "light-direction-y-1",
_("Light direction Y"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, -1,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "light-direction-y-1",
_("Light direction Y"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, -1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "light-direction-z-1",
_("Light direction Z"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "light-direction-z-1",
_("Light direction Z"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "ambient-intensity",
_("Ambient intensity"),
_("Material ambient intensity "
"(Glowing)"),
0, 1, 0.2,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "ambient-intensity",
_("Ambient intensity"),
_("Material ambient intensity "
"(Glowing)"),
0, 1, 0.2,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "diffuse-intensity",
_("Diffuse intensity"),
_("Material diffuse intensity "
"(Bright)"),
0, 1, 0.5,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "diffuse-intensity",
_("Diffuse intensity"),
_("Material diffuse intensity "
"(Bright)"),
0, 1, 0.5,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "diffuse-reflectivity",
_("Diffuse reflectivity"),
_("Material diffuse reflectivity"),
0, 1, 0.4,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "diffuse-reflectivity",
_("Diffuse reflectivity"),
_("Material diffuse reflectivity"),
0, 1, 0.4,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "specular-reflectivity",
_("Specular reflectivity"),
_("Material specular reflectivity"),
0, 1, 0.5,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "specular-reflectivity",
_("Specular reflectivity"),
_("Material specular reflectivity"),
0, 1, 0.5,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "highlight",
_("Highlight"),
_("Material highlight (note, it's exponential) "
"(Polished)"),
0, G_MAXDOUBLE, 27.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "highlight",
_("Highlight"),
_("Material highlight (note, it's exponential) "
"(Polished)"),
0, G_MAXDOUBLE, 27.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "metallic",
_("Metallic"),
_("Make surfaces look metallic"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "metallic",
_("Metallic"),
_("Make surfaces look metallic"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "antialiasing",
_("_Antialiasing"),
_("Apply antialiasing"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "antialiasing",
_("_Antialiasing"),
_("Apply antialiasing"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "new-image",
_("Create new ima_ge"),
_("Create a new image"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "new-image",
_("Create new ima_ge"),
_("Create a new image"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "transparent-background",
_("Trans_parent background"),
_("Make background transparent"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "transparent-background",
_("Trans_parent background"),
_("Make background transparent"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "distance",
_("_Distance"),
_("Distance of observer from surface"),
0, 2.0, 0.25,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "distance",
_("_Distance"),
_("Distance of observer from surface"),
0, 2.0, 0.25,
G_PARAM_READWRITE);
/* GUI-only arguments for additional light sources */
GIMP_PROC_AUX_ARG_CHOICE (procedure, "light-type-2",
_("Type"),
_("Type of light source"),
gimp_choice_new_with_values ("light-none", NO_LIGHT, _("None"), NULL,
"light-directional", DIRECTIONAL_LIGHT, _("Directional"), NULL,
"light-point", POINT_LIGHT, _("Point"), NULL,
"light-spot", SPOT_LIGHT, _("Spot"), NULL,
NULL),
"light-none",
G_PARAM_READWRITE);
gimp_procedure_add_choice_aux_argument (procedure, "light-type-2",
_("Type"),
_("Type of light source"),
gimp_choice_new_with_values ("light-none", NO_LIGHT, _("None"), NULL,
"light-directional", DIRECTIONAL_LIGHT, _("Directional"), NULL,
"light-point", POINT_LIGHT, _("Point"), NULL,
"light-spot", SPOT_LIGHT, _("Spot"), NULL,
NULL),
"light-none",
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_COLOR (procedure, "light-color-2",
_("Color"),
_("Light source color"),
TRUE, default_color_2,
G_PARAM_READWRITE);
gimp_procedure_add_color_aux_argument (procedure, "light-color-2",
_("Color"),
_("Light source color"),
TRUE, default_color_2,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-intensity-2",
_("Intensity"),
_("Light source intensity"),
0, 100.0, 1.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_aux_argument (procedure, "light-intensity-2",
_("Intensity"),
_("Light source intensity"),
0, 100.0, 1.0,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-position-x-2",
_("Light position X"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, -2,
G_PARAM_READWRITE);
gimp_procedure_add_double_aux_argument (procedure, "light-position-x-2",
_("Light position X"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, -2,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-position-y-2",
_("Light position Y"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, -1,
G_PARAM_READWRITE);
gimp_procedure_add_double_aux_argument (procedure, "light-position-y-2",
_("Light position Y"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, -1,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-position-z-2",
_("Light position Z"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,
G_PARAM_READWRITE);
gimp_procedure_add_double_aux_argument (procedure, "light-position-z-2",
_("Light position Z"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-direction-x-2",
_("Light direction X"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,
G_PARAM_READWRITE);
gimp_procedure_add_double_aux_argument (procedure, "light-direction-x-2",
_("Light direction X"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-direction-y-2",
_("Light direction Y"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, -1,
G_PARAM_READWRITE);
gimp_procedure_add_double_aux_argument (procedure, "light-direction-y-2",
_("Light direction Y"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, -1,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-direction-z-2",
_("Light direction Z"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,
G_PARAM_READWRITE);
gimp_procedure_add_double_aux_argument (procedure, "light-direction-z-2",
_("Light direction Z"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_CHOICE (procedure, "light-type-3",
_("Type"),
_("Type of light source"),
gimp_choice_new_with_values ("light-none", NO_LIGHT, _("None"), NULL,
"light-directional", DIRECTIONAL_LIGHT, _("Directional"), NULL,
"light-point", POINT_LIGHT, _("Point"), NULL,
"light-spot", SPOT_LIGHT, _("Spot"), NULL,
NULL),
"light-none",
G_PARAM_READWRITE);
gimp_procedure_add_choice_aux_argument (procedure, "light-type-3",
_("Type"),
_("Type of light source"),
gimp_choice_new_with_values ("light-none", NO_LIGHT, _("None"), NULL,
"light-directional", DIRECTIONAL_LIGHT, _("Directional"), NULL,
"light-point", POINT_LIGHT, _("Point"), NULL,
"light-spot", SPOT_LIGHT, _("Spot"), NULL,
NULL),
"light-none",
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_COLOR (procedure, "light-color-3",
_("Color"),
_("Light source color"),
TRUE, default_color_3,
G_PARAM_READWRITE);
gimp_procedure_add_color_aux_argument (procedure, "light-color-3",
_("Color"),
_("Light source color"),
TRUE, default_color_3,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-intensity-3",
_("Intensity"),
_("Light source intensity"),
0, 100.0, 1.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_aux_argument (procedure, "light-intensity-3",
_("Intensity"),
_("Light source intensity"),
0, 100.0, 1.0,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-position-x-3",
_("Light position X"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,
G_PARAM_READWRITE);
gimp_procedure_add_double_aux_argument (procedure, "light-position-x-3",
_("Light position X"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-position-y-3",
_("Light position Y"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 2,
G_PARAM_READWRITE);
gimp_procedure_add_double_aux_argument (procedure, "light-position-y-3",
_("Light position Y"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 2,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-position-z-3",
_("Light position Z"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,
G_PARAM_READWRITE);
gimp_procedure_add_double_aux_argument (procedure, "light-position-z-3",
_("Light position Z"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-direction-x-3",
_("Light direction X"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE);
gimp_procedure_add_double_aux_argument (procedure, "light-direction-x-3",
_("Light direction X"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-direction-y-3",
_("Light direction Y"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,
G_PARAM_READWRITE);
gimp_procedure_add_double_aux_argument (procedure, "light-direction-y-3",
_("Light direction Y"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-direction-z-3",
_("Light direction Z"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,
G_PARAM_READWRITE);
gimp_procedure_add_double_aux_argument (procedure, "light-direction-z-3",
_("Light direction Z"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_CHOICE (procedure, "light-type-4",
_("Type"),
_("Type of light source"),
gimp_choice_new_with_values ("light-none", NO_LIGHT, _("None"), NULL,
"light-directional", DIRECTIONAL_LIGHT, _("Directional"), NULL,
"light-point", POINT_LIGHT, _("Point"), NULL,
"light-spot", SPOT_LIGHT, _("Spot"), NULL,
NULL),
"light-none",
G_PARAM_READWRITE);
gimp_procedure_add_choice_aux_argument (procedure, "light-type-4",
_("Type"),
_("Type of light source"),
gimp_choice_new_with_values ("light-none", NO_LIGHT, _("None"), NULL,
"light-directional", DIRECTIONAL_LIGHT, _("Directional"), NULL,
"light-point", POINT_LIGHT, _("Point"), NULL,
"light-spot", SPOT_LIGHT, _("Spot"), NULL,
NULL),
"light-none",
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_COLOR (procedure, "light-color-4",
_("Color"),
_("Light source color"),
TRUE, default_color_4,
G_PARAM_READWRITE);
gimp_procedure_add_color_aux_argument (procedure, "light-color-4",
_("Color"),
_("Light source color"),
TRUE, default_color_4,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-intensity-4",
_("Intensity"),
_("Light source intensity"),
0, 100.0, 1.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_aux_argument (procedure, "light-intensity-4",
_("Intensity"),
_("Light source intensity"),
0, 100.0, 1.0,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-position-x-4",
_("Light position X"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE);
gimp_procedure_add_double_aux_argument (procedure, "light-position-x-4",
_("Light position X"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-position-y-4",
_("Light position Y"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE);
gimp_procedure_add_double_aux_argument (procedure, "light-position-y-4",
_("Light position Y"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-position-z-4",
_("Light position Z"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,
G_PARAM_READWRITE);
gimp_procedure_add_double_aux_argument (procedure, "light-position-z-4",
_("Light position Z"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-direction-x-4",
_("Light direction X"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE);
gimp_procedure_add_double_aux_argument (procedure, "light-direction-x-4",
_("Light direction X"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-direction-y-4",
_("Light direction Y"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE);
gimp_procedure_add_double_aux_argument (procedure, "light-direction-y-4",
_("Light direction Y"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-direction-z-4",
_("Light direction Z"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,
G_PARAM_READWRITE);
gimp_procedure_add_double_aux_argument (procedure, "light-direction-z-4",
_("Light direction Z"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_CHOICE (procedure, "light-type-5",
_("Type"),
_("Type of light source"),
gimp_choice_new_with_values ("light-none", NO_LIGHT, _("None"), NULL,
"light-directional", DIRECTIONAL_LIGHT, _("Directional"), NULL,
"light-point", POINT_LIGHT, _("Point"), NULL,
"light-spot", SPOT_LIGHT, _("Spot"), NULL,
NULL),
"light-none",
G_PARAM_READWRITE);
gimp_procedure_add_choice_aux_argument (procedure, "light-type-5",
_("Type"),
_("Type of light source"),
gimp_choice_new_with_values ("light-none", NO_LIGHT, _("None"), NULL,
"light-directional", DIRECTIONAL_LIGHT, _("Directional"), NULL,
"light-point", POINT_LIGHT, _("Point"), NULL,
"light-spot", SPOT_LIGHT, _("Spot"), NULL,
NULL),
"light-none",
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_COLOR (procedure, "light-color-5",
_("Color"),
_("Light source color"),
TRUE, default_color_5,
G_PARAM_READWRITE);
gimp_procedure_add_color_aux_argument (procedure, "light-color-5",
_("Color"),
_("Light source color"),
TRUE, default_color_5,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-intensity-5",
_("Intensity"),
_("Light source intensity"),
0, 100.0, 1.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_aux_argument (procedure, "light-intensity-5",
_("Intensity"),
_("Light source intensity"),
0, 100.0, 1.0,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-position-x-5",
_("Light position X"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE);
gimp_procedure_add_double_aux_argument (procedure, "light-position-x-5",
_("Light position X"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-position-y-5",
_("Light position Y"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE);
gimp_procedure_add_double_aux_argument (procedure, "light-position-y-5",
_("Light position Y"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-position-z-5",
_("Light position Z"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,
G_PARAM_READWRITE);
gimp_procedure_add_double_aux_argument (procedure, "light-position-z-5",
_("Light position Z"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-direction-x-5",
_("Light direction X"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE);
gimp_procedure_add_double_aux_argument (procedure, "light-direction-x-5",
_("Light direction X"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-direction-y-5",
_("Light direction Y"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE);
gimp_procedure_add_double_aux_argument (procedure, "light-direction-y-5",
_("Light direction Y"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-direction-z-5",
_("Light direction Z"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,
G_PARAM_READWRITE);
gimp_procedure_add_double_aux_argument (procedure, "light-direction-z-5",
_("Light direction Z"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_CHOICE (procedure, "light-type-6",
_("Type"),
_("Type of light source"),
gimp_choice_new_with_values ("light-none", NO_LIGHT, _("None"), NULL,
"light-directional", DIRECTIONAL_LIGHT, _("Directional"), NULL,
"light-point", POINT_LIGHT, _("Point"), NULL,
"light-spot", SPOT_LIGHT, _("Spot"), NULL,
NULL),
"light-none",
G_PARAM_READWRITE);
gimp_procedure_add_choice_aux_argument (procedure, "light-type-6",
_("Type"),
_("Type of light source"),
gimp_choice_new_with_values ("light-none", NO_LIGHT, _("None"), NULL,
"light-directional", DIRECTIONAL_LIGHT, _("Directional"), NULL,
"light-point", POINT_LIGHT, _("Point"), NULL,
"light-spot", SPOT_LIGHT, _("Spot"), NULL,
NULL),
"light-none",
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_COLOR (procedure, "light-color-6",
_("Color"),
_("Light source color"),
TRUE, default_color_6,
G_PARAM_READWRITE);
gimp_procedure_add_color_aux_argument (procedure, "light-color-6",
_("Color"),
_("Light source color"),
TRUE, default_color_6,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-intensity-6",
_("Intensity"),
_("Light source intensity"),
0, 100.0, 1.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_aux_argument (procedure, "light-intensity-6",
_("Intensity"),
_("Light source intensity"),
0, 100.0, 1.0,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-position-x-6",
_("Light position X"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE);
gimp_procedure_add_double_aux_argument (procedure, "light-position-x-6",
_("Light position X"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-position-y-6",
_("Light position Y"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE);
gimp_procedure_add_double_aux_argument (procedure, "light-position-y-6",
_("Light position Y"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-position-z-6",
_("Light position Z"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,
G_PARAM_READWRITE);
gimp_procedure_add_double_aux_argument (procedure, "light-position-z-6",
_("Light position Z"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-direction-x-6",
_("Light direction X"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE);
gimp_procedure_add_double_aux_argument (procedure, "light-direction-x-6",
_("Light direction X"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-direction-y-6",
_("Light direction Y"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE);
gimp_procedure_add_double_aux_argument (procedure, "light-direction-y-6",
_("Light direction Y"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
G_PARAM_READWRITE);
GIMP_PROC_AUX_ARG_DOUBLE (procedure, "light-direction-z-6",
_("Light direction Z"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,
G_PARAM_READWRITE);
gimp_procedure_add_double_aux_argument (procedure, "light-direction-z-6",
_("Light direction Z"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1,
G_PARAM_READWRITE);
g_object_unref (default_color_1);
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",
"Version 1.2.0, July 16 1998");
GIMP_PROC_ARG_CHOICE (procedure, "map-type",
_("Map _to"),
_("Type of mapping"),
gimp_choice_new_with_values ("map-plane", MAP_PLANE, _("Plane"), NULL,
"map-sphere", MAP_SPHERE, _("Sphere"), NULL,
"map-box", MAP_BOX, _("Box"), NULL,
"map-cylinder", MAP_CYLINDER, _("Cylinder"), NULL,
NULL),
"map-plane",
G_PARAM_READWRITE);
gimp_procedure_add_choice_argument (procedure, "map-type",
_("Map _to"),
_("Type of mapping"),
gimp_choice_new_with_values ("map-plane", MAP_PLANE, _("Plane"), NULL,
"map-sphere", MAP_SPHERE, _("Sphere"), NULL,
"map-box", MAP_BOX, _("Box"), NULL,
"map-cylinder", MAP_CYLINDER, _("Cylinder"), NULL,
NULL),
"map-plane",
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "viewpoint-x",
_("X"),
_("Position of viewpoint (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0.5,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "viewpoint-y",
_("Y"),
_("Position of viewpoint (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0.5,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "viewpoint-z",
_("Z"),
_("Position of viewpoint (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 2.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "viewpoint-x",
_("X"),
_("Position of viewpoint (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0.5,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "viewpoint-y",
_("Y"),
_("Position of viewpoint (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0.5,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "viewpoint-z",
_("Z"),
_("Position of viewpoint (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 2.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "position-x",
_("Position X"),
_("Object position (x,y,z)"),
-1.0, 2.0, 0.5,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "position-y",
_("Position Y"),
_("Object position (x,y,z)"),
-1.0, 2.0, 0.5,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "position-z",
_("Position Z"),
_("Object position (x,y,z)"),
-1.0, 2.0, 0.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "position-x",
_("Position X"),
_("Object position (x,y,z)"),
-1.0, 2.0, 0.5,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "position-y",
_("Position Y"),
_("Object position (x,y,z)"),
-1.0, 2.0, 0.5,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "position-z",
_("Position Z"),
_("Object position (x,y,z)"),
-1.0, 2.0, 0.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "first-axis-x",
_("X"),
_("First axis of object (x,y,z)"),
-1.0, 2.0, 1.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "first-axis-y",
_("y"),
_("First axis of object (x,y,z)"),
-1.0, 2.0, 0.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "first-axis-z",
_("Z"),
_("First axis of object (x,y,z)"),
-1.0, 2.0, 0.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "first-axis-x",
_("X"),
_("First axis of object (x,y,z)"),
-1.0, 2.0, 1.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "first-axis-y",
_("y"),
_("First axis of object (x,y,z)"),
-1.0, 2.0, 0.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "first-axis-z",
_("Z"),
_("First axis of object (x,y,z)"),
-1.0, 2.0, 0.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "second-axis-x",
_("X"),
_("Second axis of object (x,y,z)"),
-1.0, 2.0, 0.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "second-axis-y",
_("Y"),
_("Second axis of object (x,y,z)"),
-1.0, 2.0, 1.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "second-axis-z",
_("Z"),
_("Second axis of object (x,y,z)"),
-1.0, 2.0, 0.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "second-axis-x",
_("X"),
_("Second axis of object (x,y,z)"),
-1.0, 2.0, 0.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "second-axis-y",
_("Y"),
_("Second axis of object (x,y,z)"),
-1.0, 2.0, 1.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "second-axis-z",
_("Z"),
_("Second axis of object (x,y,z)"),
-1.0, 2.0, 0.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "rotation-angle-x",
_("Angle X"),
_("Rotation about X axis in degrees"),
-360, 360, 0.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "rotation-angle-y",
_("Angle Y"),
_("Rotation about Y axis in degrees"),
-360, 360, 0.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "rotation-angle-z",
_("Angle Z"),
_("Rotation about Z axis in degrees"),
-360, 360, 0.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "rotation-angle-x",
_("Angle X"),
_("Rotation about X axis in degrees"),
-360, 360, 0.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "rotation-angle-y",
_("Angle Y"),
_("Rotation about Y axis in degrees"),
-360, 360, 0.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "rotation-angle-z",
_("Angle Z"),
_("Rotation about Z axis in degrees"),
-360, 360, 0.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "light-type",
_("Light source type"),
_("Type of lightsource"),
gimp_choice_new_with_values ("point-light", POINT_LIGHT, _("Point Light"), NULL,
"directional-light", DIRECTIONAL_LIGHT, _("Directional Light"), NULL,
"no-light", NO_LIGHT, _("No Light"), NULL,
NULL),
"point-light",
G_PARAM_READWRITE);
gimp_procedure_add_choice_argument (procedure, "light-type",
_("Light source type"),
_("Type of lightsource"),
gimp_choice_new_with_values ("point-light", POINT_LIGHT, _("Point Light"), NULL,
"directional-light", DIRECTIONAL_LIGHT, _("Directional Light"), NULL,
"no-light", NO_LIGHT, _("No Light"), NULL,
NULL),
"point-light",
G_PARAM_READWRITE);
GIMP_PROC_ARG_COLOR (procedure, "light-color",
_("Light source _color"),
_("Light source color"),
TRUE, default_color,
G_PARAM_READWRITE);
gimp_procedure_add_color_argument (procedure, "light-color",
_("Light source _color"),
_("Light source color"),
TRUE, default_color,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "light-position-x",
_("Light position X"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, -0.5,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "light-position-y",
_("Light position Y"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, -0.5,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "light-position-z",
_("Light position Z"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 2.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "light-position-x",
_("Light position X"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, -0.5,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "light-position-y",
_("Light position Y"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, -0.5,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "light-position-z",
_("Light position Z"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 2.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "light-direction-x",
_("Light direction X"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, -1.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "light-direction-y",
_("Light direction Y"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, -1.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "light-direction-z",
_("Light direction Z"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "light-direction-x",
_("Light direction X"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, -1.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "light-direction-y",
_("Light direction Y"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, -1.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "light-direction-z",
_("Light direction Z"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "ambient-intensity",
_("Ambie_nt"),
_("Material ambient intensity"),
0, 1, 0.3,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "ambient-intensity",
_("Ambie_nt"),
_("Material ambient intensity"),
0, 1, 0.3,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "diffuse-intensity",
_("D_iffuse"),
_("Material diffuse intensity"),
0, 1, 1.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "diffuse-intensity",
_("D_iffuse"),
_("Material diffuse intensity"),
0, 1, 1.0,
G_PARAM_READWRITE);
/* Reflectivity */
GIMP_PROC_ARG_DOUBLE (procedure, "diffuse-reflectivity",
_("Di_ffuse"),
_("Material diffuse reflectivity"),
0, 1, 0.5,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "diffuse-reflectivity",
_("Di_ffuse"),
_("Material diffuse reflectivity"),
0, 1, 0.5,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "specular-reflectivity",
_("Spec_ular"),
_("Material specular reflectivity"),
0, 1, 0.5,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "specular-reflectivity",
_("Spec_ular"),
_("Material specular reflectivity"),
0, 1, 0.5,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "highlight",
_("Highligh_t"),
_("Material highlight "
"(note, it's exponential)"),
0, G_MAXDOUBLE, 27.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "highlight",
_("Highligh_t"),
_("Material highlight "
"(note, it's exponential)"),
0, G_MAXDOUBLE, 27.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "antialiasing",
_("Antialia_sing"),
_("Apply antialiasing"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "depth",
_("_Depth"),
_("Antialiasing quality. Higher is better, "
"but slower"),
1.0, 5.0, 3.0,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "threshold",
_("Thr_eshold"),
_("Stop when pixel differences are smaller than "
"this value"),
0.001, 1000.0, 0.250,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "antialiasing",
_("Antialia_sing"),
_("Apply antialiasing"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "depth",
_("_Depth"),
_("Antialiasing quality. Higher is better, "
"but slower"),
1.0, 5.0, 3.0,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "threshold",
_("Thr_eshold"),
_("Stop when pixel differences are smaller than "
"this value"),
0.001, 1000.0, 0.250,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "tiled",
_("_Tile source image"),
_("Tile source image"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "tiled",
_("_Tile source image"),
_("Tile source image"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "new-image",
_("Create _new image"),
_("Create a new image"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "new-image",
_("Create _new image"),
_("Create a new image"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "new-layer",
_("Create ne_w layer"),
_("Create a new layer when applying filter"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "new-layer",
_("Create ne_w layer"),
_("Create a new layer when applying filter"),
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "transparent-background",
_("Transparent bac_kground"),
_("Make background transparent"),
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "transparent-background",
_("Transparent bac_kground"),
_("Make background transparent"),
FALSE,
G_PARAM_READWRITE);
/* Sphere Options */
GIMP_PROC_ARG_DOUBLE (procedure, "sphere-radius",
_("Radi_us"),
_("Sphere radius"),
0, G_MAXDOUBLE, 0.25,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "sphere-radius",
_("Radi_us"),
_("Sphere radius"),
0, G_MAXDOUBLE, 0.25,
G_PARAM_READWRITE);
/* Box Options */
GIMP_PROC_ARG_DRAWABLE (procedure, "box-front-drawable",
_("Fro_nt"),
_("Box front face "
"(set this to NULL if not used)"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DRAWABLE (procedure, "box-back-drawable",
_("B_ack"),
_("Box back face"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DRAWABLE (procedure, "box-top-drawable",
_("To_p"),
_("Box top face"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DRAWABLE (procedure, "box-bottom-drawable",
_("Bo_ttom"),
_("Box bottom face"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DRAWABLE (procedure, "box-left-drawable",
_("Le_ft"),
_("Box left face"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DRAWABLE (procedure, "box-right-drawable",
_("Ri_ght"),
_("Box right face"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_drawable_argument (procedure, "box-front-drawable",
_("Fro_nt"),
_("Box front face "
"(set this to NULL if not used)"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_drawable_argument (procedure, "box-back-drawable",
_("B_ack"),
_("Box back face"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_drawable_argument (procedure, "box-top-drawable",
_("To_p"),
_("Box top face"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_drawable_argument (procedure, "box-bottom-drawable",
_("Bo_ttom"),
_("Box bottom face"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_drawable_argument (procedure, "box-left-drawable",
_("Le_ft"),
_("Box left face"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_drawable_argument (procedure, "box-right-drawable",
_("Ri_ght"),
_("Box right face"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "x-scale",
_("Scale X"),
_("Box X size"),
0, G_MAXDOUBLE, 0.5,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "y-scale",
_("Scale Y"),
_("Box Y size"),
0, G_MAXDOUBLE, 0.5,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "z-scale",
_("Scale Z"),
_("Box Z size"),
0, G_MAXDOUBLE, 0.5,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "x-scale",
_("Scale X"),
_("Box X size"),
0, G_MAXDOUBLE, 0.5,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "y-scale",
_("Scale Y"),
_("Box Y size"),
0, G_MAXDOUBLE, 0.5,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "z-scale",
_("Scale Z"),
_("Box Z size"),
0, G_MAXDOUBLE, 0.5,
G_PARAM_READWRITE);
/* Cylinder options */
GIMP_PROC_ARG_DRAWABLE (procedure, "cyl-top-drawable",
_("_Top"),
_("Cylinder top face "
"(set this to NULL if not used)"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DRAWABLE (procedure, "cyl-bottom-drawable",
_("_Bottom"),
_("Cylinder bottom face "
"(set this to NULL if not used)"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "cylinder-radius",
_("Radi_us"),
_("Cylinder radius"),
0, G_MAXDOUBLE, 0.25,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "cylinder-length",
_("Cylin_der length"),
_("Cylinder length"),
0, G_MAXDOUBLE, 0.25,
G_PARAM_READWRITE);
gimp_procedure_add_drawable_argument (procedure, "cyl-top-drawable",
_("_Top"),
_("Cylinder top face "
"(set this to NULL if not used)"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_drawable_argument (procedure, "cyl-bottom-drawable",
_("_Bottom"),
_("Cylinder bottom face "
"(set this to NULL if not used)"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "cylinder-radius",
_("Radi_us"),
_("Cylinder radius"),
0, G_MAXDOUBLE, 0.25,
G_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "cylinder-length",
_("Cylin_der length"),
_("Cylinder length"),
0, G_MAXDOUBLE, 0.25,
G_PARAM_READWRITE);
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",
PLUG_IN_VERSION);
GIMP_PROC_ARG_CHOICE (procedure, "colors",
_("Colors"), NULL,
gimp_choice_new_with_values ("fg-bg", CURL_COLORS_FG_BG, _("Foreground / background colors"), NULL,
"current-gradient", CURL_COLORS_GRADIENT, _("Current gradient"), NULL,
"current-gradient-reversed", CURL_COLORS_GRADIENT_REVERSE, _("Current gradient (reversed)"), NULL,
NULL),
"fg-bg",
G_PARAM_READWRITE);
gimp_procedure_add_choice_argument (procedure, "colors",
_("Colors"), NULL,
gimp_choice_new_with_values ("fg-bg", CURL_COLORS_FG_BG, _("Foreground / background colors"), NULL,
"current-gradient", CURL_COLORS_GRADIENT, _("Current gradient"), NULL,
"current-gradient-reversed", CURL_COLORS_GRADIENT_REVERSE, _("Current gradient (reversed)"), NULL,
NULL),
"fg-bg",
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "edge",
_("Locatio_n"),
_("Corner which is curled"),
gimp_choice_new_with_values ("upper-left", CURL_EDGE_UPPER_LEFT, _("Upper left"), NULL,
"upper-right", CURL_EDGE_UPPER_RIGHT, _("Upper right"), NULL,
"lower-left", CURL_EDGE_LOWER_LEFT, _("Lower left"), NULL,
"lower-right", CURL_EDGE_LOWER_RIGHT, _("Lower right"), NULL,
NULL),
"lower-right",
G_PARAM_READWRITE);
gimp_procedure_add_choice_argument (procedure, "edge",
_("Locatio_n"),
_("Corner which is curled"),
gimp_choice_new_with_values ("upper-left", CURL_EDGE_UPPER_LEFT, _("Upper left"), NULL,
"upper-right", CURL_EDGE_UPPER_RIGHT, _("Upper right"), NULL,
"lower-left", CURL_EDGE_LOWER_LEFT, _("Lower left"), NULL,
"lower-right", CURL_EDGE_LOWER_RIGHT, _("Lower right"), NULL,
NULL),
"lower-right",
G_PARAM_READWRITE);
GIMP_PROC_ARG_CHOICE (procedure, "orientation",
_("Or_ientation"), NULL,
gimp_choice_new_with_values ("vertical", CURL_ORIENTATION_VERTICAL, _("Vertical"), NULL,
"horizontal", CURL_ORIENTATION_HORIZONTAL, _("Horizontal"), NULL,
NULL),
"vertical",
G_PARAM_READWRITE);
gimp_procedure_add_choice_argument (procedure, "orientation",
_("Or_ientation"), NULL,
gimp_choice_new_with_values ("vertical", CURL_ORIENTATION_VERTICAL, _("Vertical"), NULL,
"horizontal", CURL_ORIENTATION_HORIZONTAL, _("Horizontal"), NULL,
NULL),
"vertical",
G_PARAM_READWRITE);
GIMP_PROC_ARG_BOOLEAN (procedure, "shade",
_("Sh_ade"),
_("Shade the region under the curl"),
TRUE,
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "shade",
_("Sh_ade"),
_("Shade the region under the curl"),
TRUE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_DOUBLE (procedure, "opacity",
_("Opaci_ty"),
_("Opacity"),
0.0, 1.0, 0.0,
GIMP_PARAM_READWRITE);
gimp_procedure_add_double_argument (procedure, "opacity",
_("Opaci_ty"),
_("Opacity"),
0.0, 1.0, 0.0,
GIMP_PARAM_READWRITE);
GIMP_PROC_VAL_LAYER (procedure, "curl-layer",
"Curl layer",
"The new layer with the curl.",
FALSE,
G_PARAM_READWRITE);
gimp_procedure_add_layer_return_value (procedure, "curl-layer",
"Curl layer",
"The new layer with the curl.",
FALSE,
G_PARAM_READWRITE);
}
return procedure;

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

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