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

app: port tons of files to the new GIMP_CONFIG_PROP_FOO() macros 

and remove lots of labels from calls to gimp_prop_foo_new(). Also
had to manually remove some unwanted labels that are now added
automatically, fixes bug #761880.
This commit is contained in:
Michael Natterer 2016-02-11 23:44:07 +01:00
parent 0bd4b1dd51
commit e5b6806fe2
77 changed files with 2231 additions and 1789 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

156
app/core/gimpcontext.c
View File

@ -656,90 +656,104 @@ gimp_context_class_init (GimpContextClass *klass)
GIMP_TYPE_OBJECT, GIMP_TYPE_OBJECT,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, GIMP_CONTEXT_PROP_TOOL, GIMP_CONFIG_PROP_OBJECT (object_class, GIMP_CONTEXT_PROP_TOOL,
gimp_context_prop_names[GIMP_CONTEXT_PROP_TOOL], NULL, gimp_context_prop_names[GIMP_CONTEXT_PROP_TOOL],
GIMP_TYPE_TOOL_INFO, NULL, NULL,
GIMP_PARAM_STATIC_STRINGS); GIMP_TYPE_TOOL_INFO,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, GIMP_CONTEXT_PROP_PAINT_INFO, GIMP_CONFIG_PROP_OBJECT (object_class, GIMP_CONTEXT_PROP_PAINT_INFO,
gimp_context_prop_names[GIMP_CONTEXT_PROP_PAINT_INFO], NULL, gimp_context_prop_names[GIMP_CONTEXT_PROP_PAINT_INFO],
GIMP_TYPE_PAINT_INFO, NULL, NULL,
GIMP_PARAM_STATIC_STRINGS); GIMP_TYPE_PAINT_INFO,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_RGB (object_class, GIMP_CONTEXT_PROP_FOREGROUND, GIMP_CONFIG_PROP_RGB (object_class, GIMP_CONTEXT_PROP_FOREGROUND,
gimp_context_prop_names[GIMP_CONTEXT_PROP_FOREGROUND], gimp_context_prop_names[GIMP_CONTEXT_PROP_FOREGROUND],
NULL, _("Foreground"),
FALSE, &black, _("Foreground color"),
GIMP_PARAM_STATIC_STRINGS); FALSE, &black,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_RGB (object_class, GIMP_CONTEXT_PROP_BACKGROUND, GIMP_CONFIG_PROP_RGB (object_class, GIMP_CONTEXT_PROP_BACKGROUND,
gimp_context_prop_names[GIMP_CONTEXT_PROP_BACKGROUND], gimp_context_prop_names[GIMP_CONTEXT_PROP_BACKGROUND],
NULL, _("Background"),
FALSE, &white, _("Background color"),
GIMP_PARAM_STATIC_STRINGS); FALSE, &white,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, GIMP_CONTEXT_PROP_OPACITY, GIMP_CONFIG_PROP_DOUBLE (object_class, GIMP_CONTEXT_PROP_OPACITY,
gimp_context_prop_names[GIMP_CONTEXT_PROP_OPACITY], gimp_context_prop_names[GIMP_CONTEXT_PROP_OPACITY],
_("Opacity"), _("Opacity"),
GIMP_OPACITY_TRANSPARENT, _("Opacity"),
GIMP_OPACITY_OPAQUE, GIMP_OPACITY_TRANSPARENT,
GIMP_OPACITY_OPAQUE, GIMP_OPACITY_OPAQUE,
GIMP_PARAM_STATIC_STRINGS); GIMP_OPACITY_OPAQUE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, GIMP_CONTEXT_PROP_PAINT_MODE, GIMP_CONFIG_PROP_ENUM (object_class, GIMP_CONTEXT_PROP_PAINT_MODE,
gimp_context_prop_names[GIMP_CONTEXT_PROP_PAINT_MODE], gimp_context_prop_names[GIMP_CONTEXT_PROP_PAINT_MODE],
_("Paint Mode"), _("Paint Mode"),
GIMP_TYPE_LAYER_MODE_EFFECTS, _("Paint Mode"),
GIMP_NORMAL_MODE, GIMP_TYPE_LAYER_MODE_EFFECTS,
GIMP_PARAM_STATIC_STRINGS); GIMP_NORMAL_MODE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, GIMP_CONTEXT_PROP_BRUSH, GIMP_CONFIG_PROP_OBJECT (object_class, GIMP_CONTEXT_PROP_BRUSH,
gimp_context_prop_names[GIMP_CONTEXT_PROP_BRUSH], gimp_context_prop_names[GIMP_CONTEXT_PROP_BRUSH],
NULL, _("Brush"),
GIMP_TYPE_BRUSH, _("Brush"),
GIMP_PARAM_STATIC_STRINGS); GIMP_TYPE_BRUSH,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, GIMP_CONTEXT_PROP_DYNAMICS, GIMP_CONFIG_PROP_OBJECT (object_class, GIMP_CONTEXT_PROP_DYNAMICS,
gimp_context_prop_names[GIMP_CONTEXT_PROP_DYNAMICS], gimp_context_prop_names[GIMP_CONTEXT_PROP_DYNAMICS],
NULL, _("Dynamics"),
GIMP_TYPE_DYNAMICS, _("Paint dynamics"),
GIMP_PARAM_STATIC_STRINGS); GIMP_TYPE_DYNAMICS,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, GIMP_CONTEXT_PROP_MYBRUSH, GIMP_CONFIG_PROP_OBJECT (object_class, GIMP_CONTEXT_PROP_MYBRUSH,
gimp_context_prop_names[GIMP_CONTEXT_PROP_MYBRUSH], gimp_context_prop_names[GIMP_CONTEXT_PROP_MYBRUSH],
NULL, _("MyPaint Brush"),
GIMP_TYPE_MYBRUSH, _("MyPaint Brush"),
GIMP_PARAM_STATIC_STRINGS); GIMP_TYPE_MYBRUSH,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, GIMP_CONTEXT_PROP_PATTERN, GIMP_CONFIG_PROP_OBJECT (object_class, GIMP_CONTEXT_PROP_PATTERN,
gimp_context_prop_names[GIMP_CONTEXT_PROP_PATTERN], gimp_context_prop_names[GIMP_CONTEXT_PROP_PATTERN],
NULL, _("Pattern"),
GIMP_TYPE_PATTERN, _("Pattern"),
GIMP_PARAM_STATIC_STRINGS); GIMP_TYPE_PATTERN,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, GIMP_CONTEXT_PROP_GRADIENT, GIMP_CONFIG_PROP_OBJECT (object_class, GIMP_CONTEXT_PROP_GRADIENT,
gimp_context_prop_names[GIMP_CONTEXT_PROP_GRADIENT], gimp_context_prop_names[GIMP_CONTEXT_PROP_GRADIENT],
NULL, _("Gradient"),
GIMP_TYPE_GRADIENT, _("Gradient"),
GIMP_PARAM_STATIC_STRINGS); GIMP_TYPE_GRADIENT,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, GIMP_CONTEXT_PROP_PALETTE, GIMP_CONFIG_PROP_OBJECT (object_class, GIMP_CONTEXT_PROP_PALETTE,
gimp_context_prop_names[GIMP_CONTEXT_PROP_PALETTE], gimp_context_prop_names[GIMP_CONTEXT_PROP_PALETTE],
NULL, _("Palette"),
GIMP_TYPE_PALETTE, _("Palette"),
GIMP_PARAM_STATIC_STRINGS); GIMP_TYPE_PALETTE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, GIMP_CONTEXT_PROP_TOOL_PRESET, GIMP_CONFIG_PROP_OBJECT (object_class, GIMP_CONTEXT_PROP_TOOL_PRESET,
gimp_context_prop_names[GIMP_CONTEXT_PROP_TOOL_PRESET], gimp_context_prop_names[GIMP_CONTEXT_PROP_TOOL_PRESET],
NULL, _("Tool Preset"),
GIMP_TYPE_TOOL_PRESET, _("Tool Preset"),
GIMP_PARAM_STATIC_STRINGS); GIMP_TYPE_TOOL_PRESET,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, GIMP_CONTEXT_PROP_FONT, GIMP_CONFIG_PROP_OBJECT (object_class, GIMP_CONTEXT_PROP_FONT,
gimp_context_prop_names[GIMP_CONTEXT_PROP_FONT], gimp_context_prop_names[GIMP_CONTEXT_PROP_FONT],
NULL, _("Font"),
GIMP_TYPE_FONT, _("Font"),
GIMP_PARAM_STATIC_STRINGS); GIMP_TYPE_FONT,
GIMP_PARAM_STATIC_STRINGS);
g_object_class_install_property (object_class, GIMP_CONTEXT_PROP_BUFFER, g_object_class_install_property (object_class, GIMP_CONTEXT_PROP_BUFFER,
g_param_spec_object (gimp_context_prop_names[GIMP_CONTEXT_PROP_BUFFER], g_param_spec_object (gimp_context_prop_names[GIMP_CONTEXT_PROP_BUFFER],

29
app/core/gimpcurve.c
View File

@ -143,16 +143,18 @@ gimp_curve_class_init (GimpCurveClass *klass)
data_class->get_extension = gimp_curve_get_extension; data_class->get_extension = gimp_curve_get_extension;
data_class->duplicate = gimp_curve_duplicate; data_class->duplicate = gimp_curve_duplicate;
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_CURVE_TYPE, GIMP_CONFIG_PROP_ENUM (object_class, PROP_CURVE_TYPE,
"curve-type", "curve-type",
"The curve type", "Curve Type",
GIMP_TYPE_CURVE_TYPE, "The curve type",
GIMP_CURVE_SMOOTH, 0); GIMP_TYPE_CURVE_TYPE,
GIMP_CURVE_SMOOTH, 0);
GIMP_CONFIG_INSTALL_PROP_INT (object_class, PROP_N_POINTS, GIMP_CONFIG_PROP_INT (object_class, PROP_N_POINTS,
"n-points", "n-points",
"The number of points", "Number of Points",
17, 17, 17, 0); "The number of points",
17, 17, 17, 0);
array_spec = g_param_spec_double ("point", NULL, NULL, array_spec = g_param_spec_double ("point", NULL, NULL,
-1.0, 1.0, 0.0, GIMP_PARAM_READWRITE); -1.0, 1.0, 0.0, GIMP_PARAM_READWRITE);
@ -163,10 +165,11 @@ gimp_curve_class_init (GimpCurveClass *klass)
GIMP_PARAM_STATIC_STRINGS | GIMP_PARAM_STATIC_STRINGS |
GIMP_CONFIG_PARAM_FLAGS)); GIMP_CONFIG_PARAM_FLAGS));
GIMP_CONFIG_INSTALL_PROP_INT (object_class, PROP_N_SAMPLES, GIMP_CONFIG_PROP_INT (object_class, PROP_N_SAMPLES,
"n-samples", "n-samples",
"The number of samples", "Number of Samples",
256, 256, 256, 0); "The number of samples",
256, 256, 256, 0);
array_spec = g_param_spec_double ("sample", NULL, NULL, array_spec = g_param_spec_double ("sample", NULL, NULL,
0.0, 1.0, 0.0, GIMP_PARAM_READWRITE); 0.0, 1.0, 0.0, GIMP_PARAM_READWRITE);

108
app/core/gimpdynamics.c
View File

@ -129,65 +129,77 @@ gimp_dynamics_class_init (GimpDynamicsClass *klass)
data_class->get_extension = gimp_dynamics_get_extension; data_class->get_extension = gimp_dynamics_get_extension;
data_class->duplicate = gimp_dynamics_duplicate; data_class->duplicate = gimp_dynamics_duplicate;
GIMP_CONFIG_INSTALL_PROP_STRING (object_class, PROP_NAME, GIMP_CONFIG_PROP_STRING (object_class, PROP_NAME,
"name", NULL, "name",
DEFAULT_NAME, NULL, NULL,
GIMP_PARAM_STATIC_STRINGS); DEFAULT_NAME,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_OPACITY_OUTPUT, GIMP_CONFIG_PROP_OBJECT (object_class, PROP_OPACITY_OUTPUT,
"opacity-output", NULL, "opacity-output",
GIMP_TYPE_DYNAMICS_OUTPUT, NULL, NULL,
GIMP_CONFIG_PARAM_AGGREGATE); GIMP_TYPE_DYNAMICS_OUTPUT,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_FORCE_OUTPUT, GIMP_CONFIG_PROP_OBJECT (object_class, PROP_FORCE_OUTPUT,
"force-output", NULL, "force-output",
GIMP_TYPE_DYNAMICS_OUTPUT, NULL, NULL,
GIMP_CONFIG_PARAM_AGGREGATE); GIMP_TYPE_DYNAMICS_OUTPUT,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_HARDNESS_OUTPUT, GIMP_CONFIG_PROP_OBJECT (object_class, PROP_HARDNESS_OUTPUT,
"hardness-output", NULL, "hardness-output",
GIMP_TYPE_DYNAMICS_OUTPUT, NULL, NULL,
GIMP_CONFIG_PARAM_AGGREGATE); GIMP_TYPE_DYNAMICS_OUTPUT,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_RATE_OUTPUT, GIMP_CONFIG_PROP_OBJECT (object_class, PROP_RATE_OUTPUT,
"rate-output", NULL, "rate-output",
GIMP_TYPE_DYNAMICS_OUTPUT, NULL, NULL,
GIMP_CONFIG_PARAM_AGGREGATE); GIMP_TYPE_DYNAMICS_OUTPUT,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_FLOW_OUTPUT, GIMP_CONFIG_PROP_OBJECT (object_class, PROP_FLOW_OUTPUT,
"flow-output", NULL, "flow-output",
GIMP_TYPE_DYNAMICS_OUTPUT, NULL, NULL,
GIMP_CONFIG_PARAM_AGGREGATE); GIMP_TYPE_DYNAMICS_OUTPUT,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_SIZE_OUTPUT, GIMP_CONFIG_PROP_OBJECT (object_class, PROP_SIZE_OUTPUT,
"size-output", NULL, "size-output",
GIMP_TYPE_DYNAMICS_OUTPUT, NULL, NULL,
GIMP_CONFIG_PARAM_AGGREGATE); GIMP_TYPE_DYNAMICS_OUTPUT,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_ASPECT_RATIO_OUTPUT, GIMP_CONFIG_PROP_OBJECT (object_class, PROP_ASPECT_RATIO_OUTPUT,
"aspect-ratio-output", NULL, "aspect-ratio-output",
GIMP_TYPE_DYNAMICS_OUTPUT, NULL, NULL,
GIMP_CONFIG_PARAM_AGGREGATE); GIMP_TYPE_DYNAMICS_OUTPUT,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_COLOR_OUTPUT, GIMP_CONFIG_PROP_OBJECT (object_class, PROP_COLOR_OUTPUT,
"color-output", NULL, "color-output",
GIMP_TYPE_DYNAMICS_OUTPUT, NULL, NULL,
GIMP_CONFIG_PARAM_AGGREGATE); GIMP_TYPE_DYNAMICS_OUTPUT,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_ANGLE_OUTPUT, GIMP_CONFIG_PROP_OBJECT (object_class, PROP_ANGLE_OUTPUT,
"angle-output", NULL, "angle-output",
GIMP_TYPE_DYNAMICS_OUTPUT, NULL, NULL,
GIMP_CONFIG_PARAM_AGGREGATE); GIMP_TYPE_DYNAMICS_OUTPUT,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_JITTER_OUTPUT, GIMP_CONFIG_PROP_OBJECT (object_class, PROP_JITTER_OUTPUT,
"jitter-output", NULL, "jitter-output",
GIMP_TYPE_DYNAMICS_OUTPUT, NULL, NULL,
GIMP_CONFIG_PARAM_AGGREGATE); GIMP_TYPE_DYNAMICS_OUTPUT,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_SPACING_OUTPUT, GIMP_CONFIG_PROP_OBJECT (object_class, PROP_SPACING_OUTPUT,
"spacing-output", NULL, "spacing-output",
GIMP_TYPE_DYNAMICS_OUTPUT, NULL, NULL,
GIMP_CONFIG_PARAM_AGGREGATE); GIMP_TYPE_DYNAMICS_OUTPUT,
GIMP_CONFIG_PARAM_AGGREGATE);
g_type_class_add_private (klass, sizeof (GimpDynamicsPrivate)); g_type_class_add_private (klass, sizeof (GimpDynamicsPrivate));
} }

127
app/core/gimpdynamicsoutput.c
View File

@ -139,76 +139,89 @@ gimp_dynamics_output_class_init (GimpDynamicsOutputClass *klass)
GIMP_PARAM_READWRITE | GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT)); G_PARAM_CONSTRUCT));
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_USE_PRESSURE, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_USE_PRESSURE,
"use-pressure", NULL, "use-pressure",
DEFAULT_USE_PRESSURE, NULL, NULL,
GIMP_PARAM_STATIC_STRINGS); DEFAULT_USE_PRESSURE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_USE_VELOCITY, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_USE_VELOCITY,
"use-velocity", NULL, "use-velocity",
DEFAULT_USE_VELOCITY, NULL, NULL,
GIMP_PARAM_STATIC_STRINGS); DEFAULT_USE_VELOCITY,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_USE_DIRECTION, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_USE_DIRECTION,
"use-direction", NULL, "use-direction",
DEFAULT_USE_DIRECTION, NULL, NULL,
GIMP_PARAM_STATIC_STRINGS); DEFAULT_USE_DIRECTION,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_USE_TILT, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_USE_TILT,
"use-tilt", NULL, "use-tilt",
DEFAULT_USE_TILT, NULL, NULL,
GIMP_PARAM_STATIC_STRINGS); DEFAULT_USE_TILT,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_USE_WHEEL,
"use-wheel",
NULL, NULL,
DEFAULT_USE_TILT,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_USE_WHEEL, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_USE_RANDOM,
"use-wheel", NULL, "use-random",
DEFAULT_USE_TILT, NULL, NULL,
GIMP_PARAM_STATIC_STRINGS); DEFAULT_USE_RANDOM,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_USE_RANDOM, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_USE_FADE,
"use-random", NULL, "use-fade",
DEFAULT_USE_RANDOM, NULL, NULL,
GIMP_PARAM_STATIC_STRINGS); DEFAULT_USE_FADE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_USE_FADE, GIMP_CONFIG_PROP_OBJECT (object_class, PROP_PRESSURE_CURVE,
"use-fade", NULL, "pressure-curve",
DEFAULT_USE_FADE, NULL, NULL,
GIMP_PARAM_STATIC_STRINGS); GIMP_TYPE_CURVE,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_PRESSURE_CURVE, GIMP_CONFIG_PROP_OBJECT (object_class, PROP_VELOCITY_CURVE,
"pressure-curve", NULL, "velocity-curve",
GIMP_TYPE_CURVE, NULL, NULL,
GIMP_CONFIG_PARAM_AGGREGATE); GIMP_TYPE_CURVE,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_VELOCITY_CURVE, GIMP_CONFIG_PROP_OBJECT (object_class, PROP_DIRECTION_CURVE,
"velocity-curve", NULL, "direction-curve",
GIMP_TYPE_CURVE, NULL, NULL,
GIMP_CONFIG_PARAM_AGGREGATE); GIMP_TYPE_CURVE,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_DIRECTION_CURVE, GIMP_CONFIG_PROP_OBJECT (object_class, PROP_TILT_CURVE,
"direction-curve", NULL, "tilt-curve",
GIMP_TYPE_CURVE, NULL, NULL,
GIMP_CONFIG_PARAM_AGGREGATE); GIMP_TYPE_CURVE,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_TILT_CURVE, GIMP_CONFIG_PROP_OBJECT (object_class, PROP_WHEEL_CURVE,
"tilt-curve", NULL, "wheel-curve",
GIMP_TYPE_CURVE, NULL, NULL,
GIMP_CONFIG_PARAM_AGGREGATE); GIMP_TYPE_CURVE,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_WHEEL_CURVE, GIMP_CONFIG_PROP_OBJECT (object_class, PROP_RANDOM_CURVE,
"wheel-curve", NULL, "random-curve",
GIMP_TYPE_CURVE, NULL, NULL,
GIMP_CONFIG_PARAM_AGGREGATE); GIMP_TYPE_CURVE,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_RANDOM_CURVE, GIMP_CONFIG_PROP_OBJECT (object_class, PROP_FADE_CURVE,
"random-curve", NULL, "fade-curve",
GIMP_TYPE_CURVE, NULL, NULL,
GIMP_CONFIG_PARAM_AGGREGATE); GIMP_TYPE_CURVE,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_FADE_CURVE,
"fade-curve", NULL,
GIMP_TYPE_CURVE,
GIMP_CONFIG_PARAM_AGGREGATE);
g_type_class_add_private (klass, sizeof (GimpDynamicsOutputPrivate)); g_type_class_add_private (klass, sizeof (GimpDynamicsOutputPrivate));
} }

24
app/core/gimpfilloptions.c
View File

@ -32,6 +32,8 @@
#include "gimpfilloptions.h" #include "gimpfilloptions.h"
#include "gimpviewable.h" #include "gimpviewable.h"
#include "gimp-intl.h"
enum enum
{ {
@ -82,16 +84,20 @@ gimp_fill_options_class_init (GimpFillOptionsClass *klass)
object_class->set_property = gimp_fill_options_set_property; object_class->set_property = gimp_fill_options_set_property;
object_class->get_property = gimp_fill_options_get_property; object_class->get_property = gimp_fill_options_get_property;
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_STYLE, GIMP_CONFIG_PROP_ENUM (object_class, PROP_STYLE,
"style", NULL, "style",
GIMP_TYPE_FILL_STYLE, _("Style"),
GIMP_FILL_STYLE_SOLID, NULL,
GIMP_PARAM_STATIC_STRINGS); GIMP_TYPE_FILL_STYLE,
GIMP_FILL_STYLE_SOLID,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_ANTIALIAS, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_ANTIALIAS,
"antialias", NULL, "antialias",
TRUE, _("Antialiasing"),
GIMP_PARAM_STATIC_STRINGS); NULL,
TRUE,
GIMP_PARAM_STATIC_STRINGS);
g_object_class_install_property (object_class, PROP_PATTERN_VIEW_TYPE, g_object_class_install_property (object_class, PROP_PATTERN_VIEW_TYPE,
g_param_spec_enum ("pattern-view-type", g_param_spec_enum ("pattern-view-type",

117
app/core/gimpgrid.c
View File

@ -81,55 +81,74 @@ gimp_grid_class_init (GimpGridClass *klass)
gimp_rgba_set (&black, 0.0, 0.0, 0.0, GIMP_OPACITY_OPAQUE); gimp_rgba_set (&black, 0.0, 0.0, 0.0, GIMP_OPACITY_OPAQUE);
gimp_rgba_set (&white, 1.0, 1.0, 1.0, GIMP_OPACITY_OPAQUE); gimp_rgba_set (&white, 1.0, 1.0, 1.0, GIMP_OPACITY_OPAQUE);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_STYLE, GIMP_CONFIG_PROP_ENUM (object_class, PROP_STYLE,
"style", "style",
N_("Line style used for the grid."), _("Line style"),
GIMP_TYPE_GRID_STYLE, _("Line style used for the grid."),
GIMP_GRID_SOLID, GIMP_TYPE_GRID_STYLE,
GIMP_PARAM_STATIC_STRINGS); GIMP_GRID_SOLID,
GIMP_CONFIG_INSTALL_PROP_RGB (object_class, PROP_FGCOLOR, GIMP_PARAM_STATIC_STRINGS);
"fgcolor",
N_("The foreground color of the grid."), GIMP_CONFIG_PROP_RGB (object_class, PROP_FGCOLOR,
TRUE, &black, "fgcolor",
GIMP_PARAM_STATIC_STRINGS); _("Foreground color"),
GIMP_CONFIG_INSTALL_PROP_RGB (object_class, PROP_BGCOLOR, _("The foreground color of the grid."),
"bgcolor", TRUE, &black,
N_("The background color of the grid; " GIMP_PARAM_STATIC_STRINGS);
"only used in double dashed line style."),
TRUE, &white, GIMP_CONFIG_PROP_RGB (object_class, PROP_BGCOLOR,
GIMP_PARAM_STATIC_STRINGS); "bgcolor",
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_XSPACING, _("Background color"),
"xspacing", _("The background color of the grid; "
N_("Horizontal spacing of grid lines."), "only used in double dashed line style."),
1.0, GIMP_MAX_IMAGE_SIZE, 10.0, TRUE, &white,
GIMP_PARAM_STATIC_STRINGS); GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_YSPACING,
"yspacing", GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_XSPACING,
N_("Vertical spacing of grid lines."), "xspacing",
1.0, GIMP_MAX_IMAGE_SIZE, 10.0, _("Spacing X"),
GIMP_PARAM_STATIC_STRINGS); _("Horizontal spacing of grid lines."),
GIMP_CONFIG_INSTALL_PROP_UNIT (object_class, PROP_SPACING_UNIT, 1.0, GIMP_MAX_IMAGE_SIZE, 10.0,
"spacing-unit", NULL, GIMP_PARAM_STATIC_STRINGS);
FALSE, FALSE, GIMP_UNIT_INCH,
GIMP_PARAM_STATIC_STRINGS); GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_YSPACING,
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_XOFFSET, "yspacing",
"xoffset", _("Spacing Y"),
N_("Horizontal offset of the first grid " _("Vertical spacing of grid lines."),
"line; this may be a negative number."), 1.0, GIMP_MAX_IMAGE_SIZE, 10.0,
- GIMP_MAX_IMAGE_SIZE, GIMP_PARAM_STATIC_STRINGS);
GIMP_MAX_IMAGE_SIZE, 0.0,
GIMP_PARAM_STATIC_STRINGS); GIMP_CONFIG_PROP_UNIT (object_class, PROP_SPACING_UNIT,
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_YOFFSET, "spacing-unit",
"yoffset", _("Spacing unit"),
N_("Vertical offset of the first grid " NULL,
"line; this may be a negative number."), FALSE, FALSE, GIMP_UNIT_INCH,
- GIMP_MAX_IMAGE_SIZE, GIMP_PARAM_STATIC_STRINGS);
GIMP_MAX_IMAGE_SIZE, 0.0,
GIMP_PARAM_STATIC_STRINGS); GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_XOFFSET,
GIMP_CONFIG_INSTALL_PROP_UNIT (object_class, PROP_OFFSET_UNIT, "xoffset",
"offset-unit", NULL, _("Offset X"),
FALSE, FALSE, GIMP_UNIT_INCH, _("Horizontal offset of the first grid "
GIMP_PARAM_STATIC_STRINGS); "line; this may be a negative number."),
- GIMP_MAX_IMAGE_SIZE,
GIMP_MAX_IMAGE_SIZE, 0.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_YOFFSET,
"yoffset",
_("Offset Y"),
_("Vertical offset of the first grid "
"line; this may be a negative number."),
- GIMP_MAX_IMAGE_SIZE,
GIMP_MAX_IMAGE_SIZE, 0.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_UNIT (object_class, PROP_OFFSET_UNIT,
"offset-unit",
_("Offset unit"),
NULL,
FALSE, FALSE, GIMP_UNIT_INCH,
GIMP_PARAM_STATIC_STRINGS);
} }
static void static void

36
app/core/gimpguide.c
View File

@ -102,23 +102,27 @@ gimp_guide_class_init (GimpGuideClass *klass)
G_PARAM_CONSTRUCT_ONLY | G_PARAM_CONSTRUCT_ONLY |
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_ORIENTATION, GIMP_CONFIG_PROP_ENUM (object_class, PROP_ORIENTATION,
"orientation", NULL, "orientation",
GIMP_TYPE_ORIENTATION_TYPE, NULL, NULL,
GIMP_ORIENTATION_UNKNOWN, GIMP_TYPE_ORIENTATION_TYPE,
0); GIMP_ORIENTATION_UNKNOWN,
GIMP_CONFIG_INSTALL_PROP_INT (object_class, PROP_POSITION, 0);
"position", NULL,
GIMP_GUIDE_POSITION_UNDEFINED,
GIMP_MAX_IMAGE_SIZE,
GIMP_GUIDE_POSITION_UNDEFINED,
0);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_STYLE, GIMP_CONFIG_PROP_INT (object_class, PROP_POSITION,
"style", NULL, "position",
GIMP_TYPE_GUIDE_STYLE, NULL, NULL,
GIMP_GUIDE_STYLE_NONE, GIMP_GUIDE_POSITION_UNDEFINED,
0); GIMP_MAX_IMAGE_SIZE,
GIMP_GUIDE_POSITION_UNDEFINED,
0);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_STYLE,
"style",
NULL, NULL,
GIMP_TYPE_GUIDE_STYLE,
GIMP_GUIDE_STYLE_NONE,
0);
g_type_class_add_private (klass, sizeof (GimpGuidePrivate)); g_type_class_add_private (klass, sizeof (GimpGuidePrivate));
} }

9
app/core/gimpsettings.c
View File

@ -62,10 +62,11 @@ gimp_settings_class_init (GimpSettingsClass *klass)
object_class->set_property = gimp_settings_set_property; object_class->set_property = gimp_settings_set_property;
object_class->get_property = gimp_settings_get_property; object_class->get_property = gimp_settings_get_property;
GIMP_CONFIG_INSTALL_PROP_UINT (object_class, PROP_TIME, GIMP_CONFIG_PROP_UINT (object_class, PROP_TIME,
"time", "time",
"Time of settings creation", "Time",
0, G_MAXUINT, 0, 0); "Time of settings creation",
0, G_MAXUINT, 0, 0);
} }
static void static void

98
app/core/gimpstrokeoptions.c
View File

@ -151,45 +151,58 @@ gimp_stroke_options_class_init (GimpStrokeOptionsClass *klass)
G_TYPE_NONE, 1, G_TYPE_NONE, 1,
GIMP_TYPE_DASH_PRESET); GIMP_TYPE_DASH_PRESET);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_METHOD, GIMP_CONFIG_PROP_ENUM (object_class, PROP_METHOD,
"method", NULL, "method",
GIMP_TYPE_STROKE_METHOD, _("Method"),
GIMP_STROKE_LINE, NULL,
GIMP_PARAM_STATIC_STRINGS); GIMP_TYPE_STROKE_METHOD,
GIMP_STROKE_LINE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_WIDTH, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_WIDTH,
"width", NULL, "width",
0.0, 2000.0, 6.0, _("Line width"),
GIMP_PARAM_STATIC_STRINGS); NULL,
0.0, 2000.0, 6.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_UNIT (object_class, PROP_UNIT, GIMP_CONFIG_PROP_UNIT (object_class, PROP_UNIT,
"unit", NULL, "unit",
TRUE, FALSE, GIMP_UNIT_PIXEL, _("Unit"),
GIMP_PARAM_STATIC_STRINGS); NULL,
TRUE, FALSE, GIMP_UNIT_PIXEL,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_CAP_STYLE, GIMP_CONFIG_PROP_ENUM (object_class, PROP_CAP_STYLE,
"cap-style", NULL, "cap-style",
GIMP_TYPE_CAP_STYLE, GIMP_CAP_BUTT, _("Cap style"),
GIMP_PARAM_STATIC_STRINGS); NULL,
GIMP_TYPE_CAP_STYLE, GIMP_CAP_BUTT,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_JOIN_STYLE, GIMP_CONFIG_PROP_ENUM (object_class, PROP_JOIN_STYLE,
"join-style", NULL, "join-style",
GIMP_TYPE_JOIN_STYLE, GIMP_JOIN_MITER, _("Join style"),
GIMP_PARAM_STATIC_STRINGS); NULL,
GIMP_TYPE_JOIN_STYLE, GIMP_JOIN_MITER,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_MITER_LIMIT, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_MITER_LIMIT,
"miter-limit", "miter-limit",
_("Convert a mitered join to a bevelled " _("Miter limit"),
"join if the miter would extend to a " _("Convert a mitered join to a bevelled "
"distance of more than miter-limit * " "join if the miter would extend to a "
"line-width from the actual join point."), "distance of more than miter-limit * "
0.0, 100.0, 10.0, "line-width from the actual join point."),
GIMP_PARAM_STATIC_STRINGS); 0.0, 100.0, 10.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_DASH_OFFSET, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_DASH_OFFSET,
"dash-offset", NULL, "dash-offset",
0.0, 2000.0, 0.0, _("Dash offset"),
GIMP_PARAM_STATIC_STRINGS); NULL,
0.0, 2000.0, 0.0,
GIMP_PARAM_STATIC_STRINGS);
array_spec = g_param_spec_double ("dash-length", NULL, NULL, array_spec = g_param_spec_double ("dash-length", NULL, NULL,
0.0, 2000.0, 1.0, GIMP_PARAM_READWRITE); 0.0, 2000.0, 1.0, GIMP_PARAM_READWRITE);
@ -200,15 +213,18 @@ gimp_stroke_options_class_init (GimpStrokeOptionsClass *klass)
GIMP_PARAM_STATIC_STRINGS | GIMP_PARAM_STATIC_STRINGS |
GIMP_CONFIG_PARAM_FLAGS)); GIMP_CONFIG_PARAM_FLAGS));
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_PAINT_OPTIONS, GIMP_CONFIG_PROP_OBJECT (object_class, PROP_PAINT_OPTIONS,
"paint-options", NULL, "paint-options",
GIMP_TYPE_PAINT_OPTIONS, NULL, NULL,
GIMP_PARAM_STATIC_STRINGS); GIMP_TYPE_PAINT_OPTIONS,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_EMULATE_DYNAMICS, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_EMULATE_DYNAMICS,
"emulate-brush-dynamics", NULL, "emulate-brush-dynamics",
FALSE, _("Emulate brush dynamics"),
GIMP_PARAM_STATIC_STRINGS); NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
g_type_class_add_private (klass, sizeof (GimpStrokeOptionsPrivate)); g_type_class_add_private (klass, sizeof (GimpStrokeOptionsPrivate));
} }

32
app/core/gimpsymmetry-mandala.c
View File

@ -114,28 +114,26 @@ gimp_mandala_class_init (GimpMandalaClass *klass)
symmetry_class->get_operation = gimp_mandala_get_operation; symmetry_class->get_operation = gimp_mandala_get_operation;
symmetry_class->active_changed = gimp_mandala_active_changed; symmetry_class->active_changed = gimp_mandala_active_changed;
g_object_class_install_property (object_class, PROP_CENTER_X, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_CENTER_X,
g_param_spec_double ("center-x", "center-x",
_("Center abscisse"), _("Center abscisse"),
_("Center abscisse"), NULL,
0.0, 10000.0, 0.0, 0.0, 10000.0, 0.0,
GIMP_CONFIG_PARAM_FLAGS | GIMP_PARAM_STATIC_STRINGS |
GIMP_PARAM_STATIC_STRINGS | GIMP_SYMMETRY_PARAM_GUI);
GIMP_SYMMETRY_PARAM_GUI));
g_object_class_install_property (object_class, PROP_CENTER_Y, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_CENTER_Y,
g_param_spec_double ("center-y", "center-y",
_("Center ordinate"), _("Center ordinate"),
_("Center ordinate"), NULL,
0.0, 10000.0, 0.0, 0.0, 10000.0, 0.0,
GIMP_CONFIG_PARAM_FLAGS | GIMP_PARAM_STATIC_STRINGS |
GIMP_PARAM_STATIC_STRINGS | GIMP_SYMMETRY_PARAM_GUI);
GIMP_SYMMETRY_PARAM_GUI));
GIMP_CONFIG_PROP_INT (object_class, PROP_SIZE, GIMP_CONFIG_PROP_INT (object_class, PROP_SIZE,
"size", "size",
_("Number of points"), _("Number of points"),
_("Number of points"), NULL,
1, 100, 6.0, 1, 100, 6.0,
GIMP_PARAM_STATIC_STRINGS | GIMP_PARAM_STATIC_STRINGS |
GIMP_SYMMETRY_PARAM_GUI); GIMP_SYMMETRY_PARAM_GUI);

33
app/core/gimpsymmetry-mirror.c
View File

@ -116,7 +116,6 @@ gimp_mirror_class_init (GimpMirrorClass *klass)
symmetry_class->get_operation = gimp_mirror_get_operation; symmetry_class->get_operation = gimp_mirror_get_operation;
symmetry_class->active_changed = gimp_mirror_active_changed; symmetry_class->active_changed = gimp_mirror_active_changed;
/* Properties for user settings */
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_HORIZONTAL_SYMMETRY, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_HORIZONTAL_SYMMETRY,
"horizontal-symmetry", "horizontal-symmetry",
_("Horizontal Mirror"), _("Horizontal Mirror"),
@ -149,23 +148,21 @@ gimp_mirror_class_init (GimpMirrorClass *klass)
GIMP_PARAM_STATIC_STRINGS | GIMP_PARAM_STATIC_STRINGS |
GIMP_SYMMETRY_PARAM_GUI); GIMP_SYMMETRY_PARAM_GUI);
/* Properties for XCF serialization only */ GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_HORIZONTAL_POSITION,
g_object_class_install_property (object_class, PROP_HORIZONTAL_POSITION, "horizontal-position",
g_param_spec_double ("horizontal-position", _("Horizontal axis position"),
_("Horizontal axis position"), NULL,
_("Horizontal axis position"), 0.0, G_MAXDOUBLE, 0.0,
0.0, G_MAXDOUBLE, 0.0, GIMP_PARAM_STATIC_STRINGS |
GIMP_CONFIG_PARAM_FLAGS | GIMP_SYMMETRY_PARAM_GUI);
GIMP_PARAM_STATIC_STRINGS |
GIMP_SYMMETRY_PARAM_GUI)); GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_VERTICAL_POSITION,
g_object_class_install_property (object_class, PROP_VERTICAL_POSITION, "vertical-position",
g_param_spec_double ("vertical-position", _("Vertical axis position"),
_("Vertical axis position"), NULL,
_("Vertical axis position"), 0.0, G_MAXDOUBLE, 0.0,
0.0, G_MAXDOUBLE, 0.0, GIMP_PARAM_STATIC_STRINGS |
GIMP_CONFIG_PARAM_FLAGS | GIMP_SYMMETRY_PARAM_GUI);
GIMP_PARAM_STATIC_STRINGS |
GIMP_SYMMETRY_PARAM_GUI));
} }
static void static void

11
app/core/gimpsymmetry.c
View File

@ -140,11 +140,12 @@ gimp_symmetry_class_init (GimpSymmetryClass *klass)
GIMP_TYPE_IMAGE, GIMP_TYPE_IMAGE,
GIMP_PARAM_READWRITE | GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY)); G_PARAM_CONSTRUCT_ONLY));
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_ACTIVE, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_ACTIVE,
"active", "active",
_("Activate symmetry painting"), _("Active"),
FALSE, _("Activate symmetry painting"),
GIMP_PARAM_STATIC_STRINGS); FALSE,
GIMP_PARAM_STATIC_STRINGS);
} }
static void static void

136
app/core/gimptemplate.c
View File

@ -40,8 +40,7 @@
#include "gimp-intl.h" #include "gimp-intl.h"
#define DEFAULT_RESOLUTION 72.0 #define DEFAULT_RESOLUTION 72.0
enum enum
{ {
@ -121,68 +120,87 @@ gimp_template_class_init (GimpTemplateClass *klass)
viewable_class->default_icon_name = "gimp-template"; viewable_class->default_icon_name = "gimp-template";
GIMP_CONFIG_INSTALL_PROP_INT (object_class, PROP_WIDTH, "width", GIMP_CONFIG_PROP_INT (object_class, PROP_WIDTH,
NULL, "width",
GIMP_MIN_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE, _("Width"),
GIMP_DEFAULT_IMAGE_WIDTH, NULL,
GIMP_PARAM_STATIC_STRINGS); GIMP_MIN_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE,
GIMP_CONFIG_INSTALL_PROP_INT (object_class, PROP_HEIGHT, "height", GIMP_DEFAULT_IMAGE_WIDTH,
NULL, GIMP_PARAM_STATIC_STRINGS);
GIMP_MIN_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE,
GIMP_DEFAULT_IMAGE_HEIGHT,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_UNIT (object_class, PROP_UNIT, "unit",
_("The unit used for coordinate display "
"when not in dot-for-dot mode."),
TRUE, FALSE, GIMP_UNIT_PIXEL,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_RESOLUTION (object_class, PROP_XRESOLUTION, GIMP_CONFIG_PROP_INT (object_class, PROP_HEIGHT,
"xresolution", "height",
_("The horizontal image resolution."), _("Height"),
DEFAULT_RESOLUTION, NULL,
GIMP_PARAM_STATIC_STRINGS | GIMP_MIN_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE,
GIMP_TEMPLATE_PARAM_COPY_FIRST); GIMP_DEFAULT_IMAGE_HEIGHT,
GIMP_CONFIG_INSTALL_PROP_RESOLUTION (object_class, PROP_YRESOLUTION, GIMP_PARAM_STATIC_STRINGS);
"yresolution",
_("The vertical image resolution."),
DEFAULT_RESOLUTION,
GIMP_PARAM_STATIC_STRINGS |
GIMP_TEMPLATE_PARAM_COPY_FIRST);
GIMP_CONFIG_INSTALL_PROP_UNIT (object_class, PROP_RESOLUTION_UNIT,
"resolution-unit",
NULL,
FALSE, FALSE, GIMP_UNIT_INCH,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_BASE_TYPE, GIMP_CONFIG_PROP_UNIT (object_class, PROP_UNIT,
"image-type", /* serialized name */ "unit",
NULL, _("Unit"),
GIMP_TYPE_IMAGE_BASE_TYPE, GIMP_RGB, _("The unit used for coordinate display "
GIMP_PARAM_STATIC_STRINGS); "when not in dot-for-dot mode."),
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_PRECISION, TRUE, FALSE, GIMP_UNIT_PIXEL,
"precision", GIMP_PARAM_STATIC_STRINGS);
NULL,
GIMP_TYPE_PRECISION, GIMP_PRECISION_U8_GAMMA,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_FILL_TYPE, GIMP_CONFIG_PROP_RESOLUTION (object_class, PROP_XRESOLUTION,
"fill-type", "xresolution",
NULL, _("Resolution X"),
GIMP_TYPE_FILL_TYPE, GIMP_FILL_BACKGROUND, _("The horizontal image resolution."),
GIMP_PARAM_STATIC_STRINGS); DEFAULT_RESOLUTION,
GIMP_PARAM_STATIC_STRINGS |
GIMP_TEMPLATE_PARAM_COPY_FIRST);
GIMP_CONFIG_INSTALL_PROP_STRING (object_class, PROP_COMMENT, GIMP_CONFIG_PROP_RESOLUTION (object_class, PROP_YRESOLUTION,
"comment", "yresolution",
NULL, _("Resolution X"),
NULL, _("The vertical image resolution."),
GIMP_PARAM_STATIC_STRINGS); DEFAULT_RESOLUTION,
GIMP_PARAM_STATIC_STRINGS |
GIMP_TEMPLATE_PARAM_COPY_FIRST);
GIMP_CONFIG_INSTALL_PROP_STRING (object_class, PROP_FILENAME, GIMP_CONFIG_PROP_UNIT (object_class, PROP_RESOLUTION_UNIT,
"filename", "resolution-unit",
NULL, _("Resolution unit"),
NULL, NULL,
GIMP_PARAM_STATIC_STRINGS); FALSE, FALSE, GIMP_UNIT_INCH,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_BASE_TYPE,
"image-type", /* serialized name */
_("Image type"),
NULL,
GIMP_TYPE_IMAGE_BASE_TYPE, GIMP_RGB,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_PRECISION,
"precision",
_("Precision"),
NULL,
GIMP_TYPE_PRECISION, GIMP_PRECISION_U8_GAMMA,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_FILL_TYPE,
"fill-type",
_("Fill type"),
NULL,
GIMP_TYPE_FILL_TYPE, GIMP_FILL_BACKGROUND,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_STRING (object_class, PROP_COMMENT,
"comment",
_("Comment"),
NULL,
NULL,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_STRING (object_class, PROP_FILENAME,
"filename",
_("Filename"),
NULL,
NULL,
GIMP_PARAM_STATIC_STRINGS);
g_type_class_add_private (klass, sizeof (GimpTemplatePrivate)); g_type_class_add_private (klass, sizeof (GimpTemplatePrivate));
} }

11
app/core/gimptoolinfo.c
View File

@ -35,6 +35,8 @@
#include "gimptooloptions.h" #include "gimptooloptions.h"
#include "gimptoolpreset.h" #include "gimptoolpreset.h"
#include "gimp-intl.h"
enum enum
{ {
@ -75,9 +77,12 @@ gimp_tool_info_class_init (GimpToolInfoClass *klass)
viewable_class->get_description = gimp_tool_info_get_description; viewable_class->get_description = gimp_tool_info_get_description;
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_VISIBLE, "visible", GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_VISIBLE,
NULL, TRUE, "visible",
GIMP_PARAM_STATIC_STRINGS); _("Visible"),
NULL,
TRUE,
GIMP_PARAM_STATIC_STRINGS);
} }
static void static void

105
app/core/gimptoolpreset.c
View File

@ -119,10 +119,11 @@ gimp_tool_preset_class_init (GimpToolPresetClass *klass)
data_class->save = gimp_tool_preset_save; data_class->save = gimp_tool_preset_save;
data_class->get_extension = gimp_tool_preset_get_extension; data_class->get_extension = gimp_tool_preset_get_extension;
GIMP_CONFIG_INSTALL_PROP_STRING (object_class, PROP_NAME, GIMP_CONFIG_PROP_STRING (object_class, PROP_NAME,
"name", NULL, "name",
"Unnamed", NULL, NULL,
GIMP_PARAM_STATIC_STRINGS); "Unnamed",
GIMP_PARAM_STATIC_STRINGS);
g_object_class_install_property (object_class, PROP_GIMP, g_object_class_install_property (object_class, PROP_GIMP,
g_param_spec_object ("gimp", g_param_spec_object ("gimp",
@ -131,43 +132,67 @@ gimp_tool_preset_class_init (GimpToolPresetClass *klass)
GIMP_PARAM_READWRITE | GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY)); G_PARAM_CONSTRUCT_ONLY));
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_TOOL_OPTIONS, GIMP_CONFIG_PROP_OBJECT (object_class, PROP_TOOL_OPTIONS,
"tool-options", NULL, "tool-options",
GIMP_TYPE_TOOL_OPTIONS, NULL, NULL,
GIMP_PARAM_STATIC_STRINGS); GIMP_TYPE_TOOL_OPTIONS,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_USE_FG_BG, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_USE_FG_BG,
"use-fg-bg", NULL, "use-fg-bg",
DEFAULT_USE_FG_BG, _("Apply stored FG/BG"),
GIMP_PARAM_STATIC_STRINGS); NULL,
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_USE_BRUSH, DEFAULT_USE_FG_BG,
"use-brush", NULL, GIMP_PARAM_STATIC_STRINGS);
DEFAULT_USE_BRUSH,
GIMP_PARAM_STATIC_STRINGS); GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_USE_BRUSH,
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_USE_DYNAMICS, "use-brush",
"use-dynamics", NULL, _("Apply stored brush"),
DEFAULT_USE_DYNAMICS, NULL,
GIMP_PARAM_STATIC_STRINGS); DEFAULT_USE_BRUSH,
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_USE_MYBRUSH, GIMP_PARAM_STATIC_STRINGS);
"use-mypaint-brush", NULL,
DEFAULT_USE_MYBRUSH, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_USE_DYNAMICS,
GIMP_PARAM_STATIC_STRINGS); "use-dynamics",
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_USE_PATTERN, _("Apply stored dynamics"),
"use-pattern", NULL, NULL,
TRUE, DEFAULT_USE_DYNAMICS,
GIMP_PARAM_STATIC_STRINGS); GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_USE_PALETTE,
"use-palette", NULL, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_USE_MYBRUSH,
DEFAULT_USE_PALETTE, "use-mypaint-brush",
GIMP_PARAM_STATIC_STRINGS); _("Apply stored MyPaint brush"),
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_USE_GRADIENT, NULL,
"use-gradient", NULL, DEFAULT_USE_MYBRUSH,
DEFAULT_USE_GRADIENT, GIMP_PARAM_STATIC_STRINGS);
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_USE_FONT, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_USE_PATTERN,
"use-font", NULL, "use-pattern",
DEFAULT_USE_FONT, _("Apply stored pattern"),
GIMP_PARAM_STATIC_STRINGS); NULL,
TRUE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_USE_PALETTE,
"use-palette",
_("Apply stored palette"),
NULL,
DEFAULT_USE_PALETTE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_USE_GRADIENT,
"use-gradient",
_("Apply stored gradient"),
NULL,
DEFAULT_USE_GRADIENT,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_USE_FONT,
"use-font",
_("Apply stored font"),
NULL,
DEFAULT_USE_FONT,
GIMP_PARAM_STATIC_STRINGS);
} }
static void static void

25
app/core/gimpviewable.c
View File

@ -184,19 +184,22 @@ gimp_viewable_class_init (GimpViewableClass *klass)
klass->get_expanded = NULL; klass->get_expanded = NULL;
/* compat property */ /* compat property */
GIMP_CONFIG_INSTALL_PROP_STRING (object_class, PROP_STOCK_ID, "stock-id", GIMP_CONFIG_PROP_STRING (object_class, PROP_STOCK_ID, "stock-id",
NULL, NULL, NULL, NULL,
GIMP_PARAM_STATIC_STRINGS); NULL,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_STRING (object_class, PROP_ICON_NAME, "icon-name", GIMP_CONFIG_PROP_STRING (object_class, PROP_ICON_NAME, "icon-name",
NULL, NULL, NULL, NULL,
GIMP_PARAM_STATIC_STRINGS); NULL,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_ICON_PIXBUF, GIMP_CONFIG_PROP_OBJECT (object_class, PROP_ICON_PIXBUF,
"icon-pixbuf", NULL, "icon-pixbuf",
GDK_TYPE_PIXBUF, NULL, NULL,
G_PARAM_CONSTRUCT | GDK_TYPE_PIXBUF,
GIMP_PARAM_STATIC_STRINGS); G_PARAM_CONSTRUCT |
GIMP_PARAM_STATIC_STRINGS);
g_object_class_install_property (object_class, PROP_FROZEN, g_object_class_install_property (object_class, PROP_FROZEN,
g_param_spec_boolean ("frozen", g_param_spec_boolean ("frozen",

18
app/operations/gimpbrightnesscontrastconfig.c
View File

@ -77,15 +77,17 @@ gimp_brightness_contrast_config_class_init (GimpBrightnessContrastConfigClass *k
viewable_class->default_icon_name = "gimp-tool-brightness-contrast"; viewable_class->default_icon_name = "gimp-tool-brightness-contrast";
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_BRIGHTNESS, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_BRIGHTNESS,
"brightness", "brightness",
_("Brightness"), _("Brightness"),
-1.0, 1.0, 0.0, 0); _("Brightness"),
-1.0, 1.0, 0.0, 0);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_CONTRAST, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_CONTRAST,
"contrast", "contrast",
_("Contrast"), _("Contrast"),
-1.0, 1.0, 0.0, 0); _("Contrast"),
-1.0, 1.0, 0.0, 0);
} }
static void static void

47
app/operations/gimpcolorbalanceconfig.c
View File

@ -91,31 +91,36 @@ gimp_color_balance_config_class_init (GimpColorBalanceConfigClass *klass)
viewable_class->default_icon_name = "gimp-tool-color-balance"; viewable_class->default_icon_name = "gimp-tool-color-balance";
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_RANGE, GIMP_CONFIG_PROP_ENUM (object_class, PROP_RANGE,
"range", "range",
_("The affected range"), _("Range"),
GIMP_TYPE_TRANSFER_MODE, _("The affected range"),
GIMP_TRANSFER_MIDTONES, 0); GIMP_TYPE_TRANSFER_MODE,
GIMP_TRANSFER_MIDTONES, 0);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_CYAN_RED, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_CYAN_RED,
"cyan-red", "cyan-red",
_("Cyan-Red"), _("Cyan-Red"),
-1.0, 1.0, 0.0, 0); _("Cyan-Red"),
-1.0, 1.0, 0.0, 0);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_MAGENTA_GREEN, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_MAGENTA_GREEN,
"magenta-green", "magenta-green",
_("Magenta-Green"), _("Magenta-Green"),
-1.0, 1.0, 0.0, 0); _("Magenta-Green"),
-1.0, 1.0, 0.0, 0);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_YELLOW_BLUE, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_YELLOW_BLUE,
"yellow-blue", "yellow-blue",
_("Yellow-Blue"), _("Yellow-Blue"),
-1.0, 1.0, 0.0, 0); _("Yellow-Blue"),
-1.0, 1.0, 0.0, 0);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_PRESERVE_LUMINOSITY, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_PRESERVE_LUMINOSITY,
"preserve-luminosity", "preserve-luminosity",
_("Preserve Luminosity"), _("Preserve Luminosity"),
TRUE, 0); _("Preserve Luminosity"),
TRUE, 0);
} }
static void static void

27
app/operations/gimpcolorizeconfig.c
View File

@ -80,20 +80,23 @@ gimp_colorize_config_class_init (GimpColorizeConfigClass *klass)
viewable_class->default_icon_name = "gimp-tool-colorize"; viewable_class->default_icon_name = "gimp-tool-colorize";
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_HUE, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_HUE,
"hue", "hue",
_("Hue"), _("Hue"),
0.0, 1.0, 0.5, 0); _("Hue"),
0.0, 1.0, 0.5, 0);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_SATURATION, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_SATURATION,
"saturation", "saturation",
_("Saturation"), _("Saturation"),
0.0, 1.0, 0.5, 0); _("Saturation"),
0.0, 1.0, 0.5, 0);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_LIGHTNESS, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_LIGHTNESS,
"lightness", "lightness",
_("Lightness"), _("Lightness"),
-1.0, 1.0, 0.0, 0); _("Lightness"),
-1.0, 1.0, 0.0, 0);
gimp_hsl_set (&hsl, 0.5, 0.5, 0.5); gimp_hsl_set (&hsl, 0.5, 0.5, 0.5);
gimp_hsl_set_alpha (&hsl, 1.0); gimp_hsl_set_alpha (&hsl, 1.0);

22
app/operations/gimpcurvesconfig.c
View File

@ -99,17 +99,19 @@ gimp_curves_config_class_init (GimpCurvesConfigClass *klass)
viewable_class->default_icon_name = "gimp-tool-curves"; viewable_class->default_icon_name = "gimp-tool-curves";
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_CHANNEL, GIMP_CONFIG_PROP_ENUM (object_class, PROP_CHANNEL,
"channel", "channel",
_("The affected channel"), _("Channel"),
GIMP_TYPE_HISTOGRAM_CHANNEL, _("The affected channel"),
GIMP_HISTOGRAM_VALUE, 0); GIMP_TYPE_HISTOGRAM_CHANNEL,
GIMP_HISTOGRAM_VALUE, 0);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_CURVE, GIMP_CONFIG_PROP_OBJECT (object_class, PROP_CURVE,
"curve", "curve",
_("Curve"), _("Curve"),
GIMP_TYPE_CURVE, _("Curve"),
GIMP_CONFIG_PARAM_AGGREGATE); GIMP_TYPE_CURVE,
GIMP_CONFIG_PARAM_AGGREGATE);
} }
static void static void

47
app/operations/gimphuesaturationconfig.c
View File

@ -89,31 +89,36 @@ gimp_hue_saturation_config_class_init (GimpHueSaturationConfigClass *klass)
viewable_class->default_icon_name = "gimp-tool-hue-saturation"; viewable_class->default_icon_name = "gimp-tool-hue-saturation";
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_RANGE, GIMP_CONFIG_PROP_ENUM (object_class, PROP_RANGE,
"range", "range",
_("The affected range"), _("Range"),
GIMP_TYPE_HUE_RANGE, _("The affected range"),
GIMP_ALL_HUES, 0); GIMP_TYPE_HUE_RANGE,
GIMP_ALL_HUES, 0);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_HUE, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_HUE,
"hue", "hue",
_("Hue"), _("Hue"),
-1.0, 1.0, 0.0, 0); _("Hue"),
-1.0, 1.0, 0.0, 0);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_SATURATION, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_SATURATION,
"saturation", "saturation",
_("Saturation"), _("Saturation"),
-1.0, 1.0, 0.0, 0); _("Saturation"),
-1.0, 1.0, 0.0, 0);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_LIGHTNESS, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_LIGHTNESS,
"lightness", "lightness",
_("Lightness"), _("Lightness"),
-1.0, 1.0, 0.0, 0); _("Lightness"),
-1.0, 1.0, 0.0, 0);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_OVERLAP, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_OVERLAP,
"overlap", "overlap",
_("Overlap"), _("Overlap"),
0.0, 1.0, 0.0, 0); _("Overlap"),
0.0, 1.0, 0.0, 0);
} }
static void static void

56
app/operations/gimplevelsconfig.c
View File

@ -100,36 +100,42 @@ gimp_levels_config_class_init (GimpLevelsConfigClass *klass)
viewable_class->default_icon_name = "gimp-tool-levels"; viewable_class->default_icon_name = "gimp-tool-levels";
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_CHANNEL, GIMP_CONFIG_PROP_ENUM (object_class, PROP_CHANNEL,
"channel", "channel",
_("The affected channel"), _("Channel"),
GIMP_TYPE_HISTOGRAM_CHANNEL, _("The affected channel"),
GIMP_HISTOGRAM_VALUE, 0); GIMP_TYPE_HISTOGRAM_CHANNEL,
GIMP_HISTOGRAM_VALUE, 0);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_GAMMA, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_GAMMA,
"gamma", "gamma",
_("Gamma"), _("Gamma"),
0.1, 10.0, 1.0, 0); _("Gamma"),
0.1, 10.0, 1.0, 0);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_LOW_INPUT, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_LOW_INPUT,
"low-input", "low-input",
_("Low Input"), _("Low Input"),
0.0, 1.0, 0.0, 0); _("Low Input"),
0.0, 1.0, 0.0, 0);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_HIGH_INPUT, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_HIGH_INPUT,
"high-input", "high-input",
_("High Input"), _("High Input"),
0.0, 1.0, 1.0, 0); _("High Input"),
0.0, 1.0, 1.0, 0);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_LOW_OUTPUT, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_LOW_OUTPUT,
"low-output", "low-output",
_("Low Output"), _("Low Output"),
0.0, 1.0, 0.0, 0); _("Low Output"),
0.0, 1.0, 0.0, 0);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_HIGH_OUTPUT, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_HIGH_OUTPUT,
"high-output", "high-output",
_("High Output"), _("High Output"),
0.0, 1.0, 1.0, 0); _("High Output"),
0.0, 1.0, 1.0, 0);
} }
static void static void

43
app/paint/gimpairbrushoptions.c
View File

@ -26,6 +26,8 @@
#include "gimpairbrushoptions.h" #include "gimpairbrushoptions.h"
#include "gimp-intl.h"
#define AIRBRUSH_DEFAULT_RATE 80.0 #define AIRBRUSH_DEFAULT_RATE 80.0
#define AIRBRUSH_DEFAULT_FLOW 10.0 #define AIRBRUSH_DEFAULT_FLOW 10.0
@ -63,27 +65,34 @@ gimp_airbrush_options_class_init (GimpAirbrushOptionsClass *klass)
object_class->set_property = gimp_airbrush_options_set_property; object_class->set_property = gimp_airbrush_options_set_property;
object_class->get_property = gimp_airbrush_options_get_property; object_class->get_property = gimp_airbrush_options_get_property;
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_RATE, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_RATE,
"rate", NULL, "rate",
0.0, 150.0, AIRBRUSH_DEFAULT_RATE, C_("airbrush-tool", "Rate"),
GIMP_PARAM_STATIC_STRINGS); NULL,
0.0, 150.0, AIRBRUSH_DEFAULT_RATE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_MOTION_ONLY, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_MOTION_ONLY,
"motion-only", NULL, "motion-only",
AIRBRUSH_DEFAULT_MOTION_ONLY, _("Motion only"),
GIMP_PARAM_STATIC_STRINGS); NULL,
AIRBRUSH_DEFAULT_MOTION_ONLY,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_FLOW, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_FLOW,
"flow", NULL, "flow",
0.0, 100.0, AIRBRUSH_DEFAULT_FLOW, _("Flow"),
GIMP_PARAM_STATIC_STRINGS); NULL,
0.0, 100.0, AIRBRUSH_DEFAULT_FLOW,
GIMP_PARAM_STATIC_STRINGS);
/*backwads-compadibility prop for flow fomerly known as pressure*/ /* backwads-compadibility prop for flow fomerly known as pressure */
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_PRESSURE, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_PRESSURE,
"pressure", NULL, "pressure",
0.0, 100.0, AIRBRUSH_DEFAULT_FLOW, NULL, NULL,
GIMP_CONFIG_PARAM_IGNORE); 0.0, 100.0, AIRBRUSH_DEFAULT_FLOW,
GIMP_CONFIG_PARAM_IGNORE);
} }
static void static void

14
app/paint/gimpcloneoptions.c
View File

@ -28,6 +28,8 @@
#include "gimpcloneoptions.h" #include "gimpcloneoptions.h"
#include "gimp-intl.h"
enum enum
{ {
@ -59,11 +61,13 @@ gimp_clone_options_class_init (GimpCloneOptionsClass *klass)
object_class->set_property = gimp_clone_options_set_property; object_class->set_property = gimp_clone_options_set_property;
object_class->get_property = gimp_clone_options_get_property; object_class->get_property = gimp_clone_options_get_property;
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_CLONE_TYPE, GIMP_CONFIG_PROP_ENUM (object_class, PROP_CLONE_TYPE,
"clone-type", NULL, "clone-type",
GIMP_TYPE_CLONE_TYPE, _("Source"),
GIMP_CLONE_IMAGE, NULL,
GIMP_PARAM_STATIC_STRINGS); GIMP_TYPE_CLONE_TYPE,
GIMP_CLONE_IMAGE,
GIMP_PARAM_STATIC_STRINGS);
} }
static void static void

25
app/paint/gimpconvolveoptions.c
View File

@ -26,6 +26,8 @@
#include "gimpconvolveoptions.h" #include "gimpconvolveoptions.h"
#include "gimp-intl.h"
#define DEFAULT_CONVOLVE_TYPE GIMP_CONVOLVE_BLUR #define DEFAULT_CONVOLVE_TYPE GIMP_CONVOLVE_BLUR
#define DEFAULT_CONVOLVE_RATE 50.0 #define DEFAULT_CONVOLVE_RATE 50.0
@ -61,15 +63,20 @@ gimp_convolve_options_class_init (GimpConvolveOptionsClass *klass)
object_class->set_property = gimp_convolve_options_set_property; object_class->set_property = gimp_convolve_options_set_property;
object_class->get_property = gimp_convolve_options_get_property; object_class->get_property = gimp_convolve_options_get_property;
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_TYPE, GIMP_CONFIG_PROP_ENUM (object_class, PROP_TYPE,
"type", NULL, "type",
GIMP_TYPE_CONVOLVE_TYPE, _("Convolve Type"),
DEFAULT_CONVOLVE_TYPE, NULL,
GIMP_PARAM_STATIC_STRINGS); GIMP_TYPE_CONVOLVE_TYPE,
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_RATE, DEFAULT_CONVOLVE_TYPE,
"rate", NULL, GIMP_PARAM_STATIC_STRINGS);
0.0, 100.0, DEFAULT_CONVOLVE_RATE,
GIMP_PARAM_STATIC_STRINGS); GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_RATE,
"rate",
C_("convolve-tool", "Rate"),
NULL,
0.0, 100.0, DEFAULT_CONVOLVE_RATE,
GIMP_PARAM_STATIC_STRINGS);
} }
static void static void

38
app/paint/gimpdodgeburnoptions.c
View File

@ -26,6 +26,8 @@
#include "gimpdodgeburnoptions.h" #include "gimpdodgeburnoptions.h"
#include "gimp-intl.h"
#define DODGE_BURN_DEFAULT_TYPE GIMP_DODGE_BURN_TYPE_DODGE #define DODGE_BURN_DEFAULT_TYPE GIMP_DODGE_BURN_TYPE_DODGE
#define DODGE_BURN_DEFAULT_MODE GIMP_TRANSFER_MIDTONES #define DODGE_BURN_DEFAULT_MODE GIMP_TRANSFER_MIDTONES
@ -63,20 +65,28 @@ gimp_dodge_burn_options_class_init (GimpDodgeBurnOptionsClass *klass)
object_class->set_property = gimp_dodge_burn_options_set_property; object_class->set_property = gimp_dodge_burn_options_set_property;
object_class->get_property = gimp_dodge_burn_options_get_property; object_class->get_property = gimp_dodge_burn_options_get_property;
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_TYPE, GIMP_CONFIG_PROP_ENUM (object_class, PROP_TYPE,
"type", NULL, "type",
GIMP_TYPE_DODGE_BURN_TYPE, _("Type"),
DODGE_BURN_DEFAULT_TYPE, NULL,
GIMP_PARAM_STATIC_STRINGS); GIMP_TYPE_DODGE_BURN_TYPE,
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_MODE, DODGE_BURN_DEFAULT_TYPE,
"mode", NULL, GIMP_PARAM_STATIC_STRINGS);
GIMP_TYPE_TRANSFER_MODE,
DODGE_BURN_DEFAULT_MODE, GIMP_CONFIG_PROP_ENUM (object_class, PROP_MODE,
GIMP_PARAM_STATIC_STRINGS); "mode",
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_EXPOSURE, _("Range"),
"exposure", NULL, NULL,
0.0, 100.0, DODGE_BURN_DEFAULT_EXPOSURE, GIMP_TYPE_TRANSFER_MODE,
GIMP_PARAM_STATIC_STRINGS); DODGE_BURN_DEFAULT_MODE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_EXPOSURE,
"exposure",
_("Exposure"),
NULL,
0.0, 100.0, DODGE_BURN_DEFAULT_EXPOSURE,
GIMP_PARAM_STATIC_STRINGS);
} }
static void static void

12
app/paint/gimperaseroptions.c
View File

@ -26,6 +26,8 @@
#include "gimperaseroptions.h" #include "gimperaseroptions.h"
#include "gimp-intl.h"
#define ERASER_DEFAULT_ANTI_ERASE FALSE #define ERASER_DEFAULT_ANTI_ERASE FALSE
@ -59,10 +61,12 @@ gimp_eraser_options_class_init (GimpEraserOptionsClass *klass)
object_class->set_property = gimp_eraser_options_set_property; object_class->set_property = gimp_eraser_options_set_property;
object_class->get_property = gimp_eraser_options_get_property; object_class->get_property = gimp_eraser_options_get_property;
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_ANTI_ERASE, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_ANTI_ERASE,
"anti-erase", NULL, "anti-erase",
ERASER_DEFAULT_ANTI_ERASE, _("Anti erase"),
GIMP_PARAM_STATIC_STRINGS); NULL,
ERASER_DEFAULT_ANTI_ERASE,
GIMP_PARAM_STATIC_STRINGS);
} }
static void static void

82
app/paint/gimpinkoptions.c
View File

@ -69,41 +69,57 @@ gimp_ink_options_class_init (GimpInkOptionsClass *klass)
object_class->set_property = gimp_ink_options_set_property; object_class->set_property = gimp_ink_options_set_property;
object_class->get_property = gimp_ink_options_get_property; object_class->get_property = gimp_ink_options_get_property;
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_SIZE, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_SIZE,
"size", _("Ink Blob Size"), "size",
0.0, 200.0, 16.0, _("Size"),
GIMP_PARAM_STATIC_STRINGS); _("Ink Blob Size"),
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_TILT_ANGLE, 0.0, 200.0, 16.0,
"tilt-angle", NULL, GIMP_PARAM_STATIC_STRINGS);
-90.0, 90.0, 0.0, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_TILT_ANGLE,
GIMP_PARAM_STATIC_STRINGS); "tilt-angle",
_("Angle"),
NULL,
-90.0, 90.0, 0.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_SIZE_SENSITIVITY, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_SIZE_SENSITIVITY,
"size-sensitivity", NULL, "size-sensitivity",
0.0, 1.0, 1.0, _("Size"),
GIMP_PARAM_STATIC_STRINGS); NULL,
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_VEL_SENSITIVITY, 0.0, 1.0, 1.0,
"vel-sensitivity", NULL, GIMP_PARAM_STATIC_STRINGS);
0.0, 1.0, 0.8, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_VEL_SENSITIVITY,
GIMP_PARAM_STATIC_STRINGS); "vel-sensitivity",
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_TILT_SENSITIVITY, _("Speed"),
"tilt-sensitivity", NULL, NULL,
0.0, 1.0, 0.4, 0.0, 1.0, 0.8,
GIMP_PARAM_STATIC_STRINGS); GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_TILT_SENSITIVITY,
"tilt-sensitivity",
_("Tilt"),
NULL,
0.0, 1.0, 0.4,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_BLOB_TYPE, GIMP_CONFIG_PROP_ENUM (object_class, PROP_BLOB_TYPE,
"blob-type", NULL, "blob-type",
GIMP_TYPE_INK_BLOB_TYPE, _("Shape"),
GIMP_INK_BLOB_TYPE_CIRCLE, NULL,
GIMP_PARAM_STATIC_STRINGS); GIMP_TYPE_INK_BLOB_TYPE,
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_BLOB_ASPECT, GIMP_INK_BLOB_TYPE_CIRCLE,
"blob-aspect", _("Ink Blob Aspect Ratio"), GIMP_PARAM_STATIC_STRINGS);
1.0, 10.0, 1.0, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_BLOB_ASPECT,
GIMP_PARAM_STATIC_STRINGS); "blob-aspect",
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_BLOB_ANGLE, _("Aspect ratio"),
"blob-angle", _("Ink Blob Angle"), _("Ink Blob Aspect Ratio"),
-90.0, 90.0, 0.0, 1.0, 10.0, 1.0,
GIMP_PARAM_STATIC_STRINGS); GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_BLOB_ANGLE,
"blob-angle",
_("Angle"),
_("Ink Blob Angle"),
-90.0, 90.0, 0.0,
GIMP_PARAM_STATIC_STRINGS);
} }
static void static void

44
app/paint/gimpmybrushoptions.c
View File

@ -43,6 +43,7 @@ enum
PROP_ERASER PROP_ERASER
}; };
static void gimp_mybrush_options_config_iface_init (GimpConfigInterface *config_iface); static void gimp_mybrush_options_config_iface_init (GimpConfigInterface *config_iface);
static void gimp_mybrush_options_set_property (GObject *object, static void gimp_mybrush_options_set_property (GObject *object,
@ -79,22 +80,33 @@ gimp_mybrush_options_class_init (GimpMybrushOptionsClass *klass)
context_class->mybrush_changed = gimp_mybrush_options_mybrush_changed; context_class->mybrush_changed = gimp_mybrush_options_mybrush_changed;
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_RADIUS, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_RADIUS,
"radius", _("Radius"), "radius",
-2.0, 6.0, 1.0, _("Radius"),
GIMP_PARAM_STATIC_STRINGS); NULL,
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_OPAQUE, -2.0, 6.0, 1.0,
"opaque", _("Base Opacity"), GIMP_PARAM_STATIC_STRINGS);
0.0, 2.0, 1.0,
GIMP_PARAM_STATIC_STRINGS); GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_OPAQUE,
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_HARDNESS, "opaque",
"hardness", NULL, _("Base Opacity"),
0.0, 1.0, 1.0, NULL,
GIMP_PARAM_STATIC_STRINGS); 0.0, 2.0, 1.0,
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_ERASER, GIMP_PARAM_STATIC_STRINGS);
"eraser", NULL,
FALSE, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_HARDNESS,
GIMP_PARAM_STATIC_STRINGS); "hardness",
_("Hardness"),
NULL,
0.0, 1.0, 1.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_ERASER,
"eraser",
_("Erase with this brush"),
NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
} }
static void static void

364
app/paint/gimppaintoptions.c
View File

@ -179,188 +179,240 @@ gimp_paint_options_class_init (GimpPaintOptionsClass *klass)
g_object_class_install_property (object_class, PROP_USE_APPLICATOR, g_object_class_install_property (object_class, PROP_USE_APPLICATOR,
g_param_spec_boolean ("use-applicator", g_param_spec_boolean ("use-applicator",
NULL, NULL, "Use GimpApplicator",
NULL,
FALSE, FALSE,
G_PARAM_READWRITE | G_PARAM_READWRITE |
G_PARAM_CONSTRUCT)); G_PARAM_CONSTRUCT));
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_BRUSH_SIZE, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_BRUSH_SIZE,
"brush-size", _("Brush Size"), "brush-size",
1.0, GIMP_BRUSH_MAX_SIZE, DEFAULT_BRUSH_SIZE, _("Size"),
GIMP_PARAM_STATIC_STRINGS); _("Brush Size"),
1.0, GIMP_BRUSH_MAX_SIZE, DEFAULT_BRUSH_SIZE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_BRUSH_ZOOM, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_BRUSH_ZOOM,
"brush-zoom", _("Link brush size with canvas zoom"), "brush-zoom",
DEFAULT_BRUSH_ZOOM, _("Brush Zoom"),
GIMP_PARAM_STATIC_STRINGS); _("Link brush size with canvas zoom"),
DEFAULT_BRUSH_ZOOM,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_BRUSH_ASPECT_RATIO, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_BRUSH_ASPECT_RATIO,
"brush-aspect-ratio", _("Brush Aspect Ratio"), "brush-aspect-ratio",
-20.0, 20.0, DEFAULT_BRUSH_ASPECT_RATIO, _("Aspect Ratio"),
GIMP_PARAM_STATIC_STRINGS); _("Brush Aspect Ratio"),
-20.0, 20.0, DEFAULT_BRUSH_ASPECT_RATIO,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_BRUSH_ANGLE, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_BRUSH_ANGLE,
"brush-angle", _("Brush Angle"), "brush-angle",
-180.0, 180.0, DEFAULT_BRUSH_ANGLE, _("Angle"),
GIMP_PARAM_STATIC_STRINGS); _("Brush Angle"),
-180.0, 180.0, DEFAULT_BRUSH_ANGLE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_BRUSH_SPACING, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_BRUSH_SPACING,
"brush-spacing", _("Brush Spacing"), "brush-spacing",
0.01, 50.0, DEFAULT_BRUSH_SPACING, _("Spacing"),
GIMP_PARAM_STATIC_STRINGS); _("Brush Spacing"),
0.01, 50.0, DEFAULT_BRUSH_SPACING,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_BRUSH_HARDNESS, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_BRUSH_HARDNESS,
"brush-hardness", _("Brush Hardness"), "brush-hardness",
0.0, 1.0, DEFAULT_BRUSH_HARDNESS, _("Hardness"),
GIMP_PARAM_STATIC_STRINGS); _("Brush Hardness"),
0.0, 1.0, DEFAULT_BRUSH_HARDNESS,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_BRUSH_FORCE, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_BRUSH_FORCE,
"brush-force", _("Brush Force"), "brush-force",
0.0, 1.0, DEFAULT_BRUSH_FORCE, _("Force"),
GIMP_PARAM_STATIC_STRINGS); _("Brush Force"),
0.0, 1.0, DEFAULT_BRUSH_FORCE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_BRUSH_LINK_SIZE, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_BRUSH_LINK_SIZE,
"brush-link-size", "brush-link-size",
_("Link brush size to brush native"), _("Link Size"),
DEFAULT_BRUSH_LINK_SIZE, _("Link brush size to brush native"),
GIMP_PARAM_STATIC_STRINGS); DEFAULT_BRUSH_LINK_SIZE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_BRUSH_LINK_ASPECT_RATIO, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_BRUSH_LINK_ASPECT_RATIO,
"brush-link-aspect-ratio", "brush-link-aspect-ratio",
_("Link brush aspect ratio to brush native"), _("Link Aspect Ratio"),
DEFAULT_BRUSH_LINK_ASPECT_RATIO, _("Link brush aspect ratio to brush native"),
GIMP_PARAM_STATIC_STRINGS); DEFAULT_BRUSH_LINK_ASPECT_RATIO,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_BRUSH_LINK_ANGLE, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_BRUSH_LINK_ANGLE,
"brush-link-angle", "brush-link-angle",
_("Link brush angle to brush native"), _("Link Angle"),
DEFAULT_BRUSH_LINK_ANGLE, _("Link brush angle to brush native"),
GIMP_PARAM_STATIC_STRINGS); DEFAULT_BRUSH_LINK_ANGLE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_BRUSH_LINK_SPACING, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_BRUSH_LINK_SPACING,
"brush-link-spacing", "brush-link-spacing",
_("Link brush spacing to brush native"), _("Link Spacing"),
DEFAULT_BRUSH_LINK_SPACING, _("Link brush spacing to brush native"),
GIMP_PARAM_STATIC_STRINGS); DEFAULT_BRUSH_LINK_SPACING,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_BRUSH_LINK_HARDNESS, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_BRUSH_LINK_HARDNESS,
"brush-link-hardness", "brush-link-hardness",
_("Link brush hardness to brush native"), _("Link Hardness"),
DEFAULT_BRUSH_LINK_HARDNESS, _("Link brush hardness to brush native"),
GIMP_PARAM_STATIC_STRINGS); DEFAULT_BRUSH_LINK_HARDNESS,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_APPLICATION_MODE, GIMP_CONFIG_PROP_ENUM (object_class, PROP_APPLICATION_MODE,
"application-mode", _("Every stamp has its own opacity"), "application-mode",
GIMP_TYPE_PAINT_APPLICATION_MODE, _("Incremental"),
DEFAULT_APPLICATION_MODE, _("Every stamp has its own opacity"),
GIMP_PARAM_STATIC_STRINGS); GIMP_TYPE_PAINT_APPLICATION_MODE,
DEFAULT_APPLICATION_MODE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_HARD, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_HARD,
"hard", _("Ignore fuzziness of the current brush"), "hard",
DEFAULT_HARD, _("Hard edge"),
GIMP_PARAM_STATIC_STRINGS); _("Ignore fuzziness of the current brush"),
DEFAULT_HARD,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_USE_JITTER, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_USE_JITTER,
"use-jitter", _("Scatter brush as you paint"), "use-jitter",
DEFAULT_USE_JITTER, _("Apply Jitter"),
GIMP_PARAM_STATIC_STRINGS); _("Scatter brush as you paint"),
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_JITTER_AMOUNT, DEFAULT_USE_JITTER,
"jitter-amount", _("Distance of scattering"), GIMP_PARAM_STATIC_STRINGS);
0.0, 50.0, DEFAULT_JITTER_AMOUNT, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_JITTER_AMOUNT,
GIMP_PARAM_STATIC_STRINGS); "jitter-amount",
_("Amount"),
_("Distance of scattering"),
0.0, 50.0, DEFAULT_JITTER_AMOUNT,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_DYNAMICS_EXPANDED, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_DYNAMICS_EXPANDED,
"dynamics-expanded", NULL, "dynamics-expanded",
DEFAULT_DYNAMICS_EXPANDED, _("Dynamics Options"),
GIMP_PARAM_STATIC_STRINGS); NULL,
DEFAULT_DYNAMICS_EXPANDED,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_FADE_LENGTH, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_FADE_LENGTH,
"fade-length", _("Distance over which strokes fade out"), "fade-length",
0.0, 32767.0, DEFAULT_FADE_LENGTH, _("Fade length"),
GIMP_PARAM_STATIC_STRINGS); _("Distance over which strokes fade out"),
GIMP_CONFIG_INSTALL_PROP_UNIT (object_class, PROP_FADE_UNIT, 0.0, 32767.0, DEFAULT_FADE_LENGTH,
"fade-unit", NULL, GIMP_PARAM_STATIC_STRINGS);
TRUE, TRUE, DEFAULT_FADE_UNIT, GIMP_CONFIG_PROP_UNIT (object_class, PROP_FADE_UNIT,
GIMP_PARAM_STATIC_STRINGS); "fade-unit",
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_FADE_REVERSE, NULL, NULL,
"fade-reverse", _("Reverse direction of fading"), TRUE, TRUE, DEFAULT_FADE_UNIT,
DEFAULT_FADE_REVERSE, GIMP_PARAM_STATIC_STRINGS);
GIMP_PARAM_STATIC_STRINGS); GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_FADE_REVERSE,
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_FADE_REPEAT, "fade-reverse",
"fade-repeat", _("How fade is repeated as you paint"), _("Reverse"),
GIMP_TYPE_REPEAT_MODE, _("Reverse direction of fading"),
DEFAULT_FADE_REPEAT, DEFAULT_FADE_REVERSE,
GIMP_PARAM_STATIC_STRINGS); GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_FADE_REPEAT,
"fade-repeat",
_("Repeat"),
_("How fade is repeated as you paint"),
GIMP_TYPE_REPEAT_MODE,
DEFAULT_FADE_REPEAT,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_GRADIENT_REVERSE, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_GRADIENT_REVERSE,
"gradient-reverse", NULL, "gradient-reverse",
DEFAULT_GRADIENT_REVERSE, NULL, NULL,
GIMP_PARAM_STATIC_STRINGS); DEFAULT_GRADIENT_REVERSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_BRUSH_VIEW_TYPE, GIMP_CONFIG_PROP_ENUM (object_class, PROP_BRUSH_VIEW_TYPE,
"brush-view-type", NULL, "brush-view-type",
GIMP_TYPE_VIEW_TYPE, NULL, NULL,
GIMP_VIEW_TYPE_GRID, GIMP_TYPE_VIEW_TYPE,
GIMP_PARAM_STATIC_STRINGS); GIMP_VIEW_TYPE_GRID,
GIMP_CONFIG_INSTALL_PROP_INT (object_class, PROP_BRUSH_VIEW_SIZE, GIMP_PARAM_STATIC_STRINGS);
"brush-view-size", NULL, GIMP_CONFIG_PROP_INT (object_class, PROP_BRUSH_VIEW_SIZE,
GIMP_VIEW_SIZE_TINY, "brush-view-size",
GIMP_VIEWABLE_MAX_BUTTON_SIZE, NULL, NULL,
GIMP_VIEW_SIZE_SMALL, GIMP_VIEW_SIZE_TINY,
GIMP_PARAM_STATIC_STRINGS); GIMP_VIEWABLE_MAX_BUTTON_SIZE,
GIMP_VIEW_SIZE_SMALL,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_DYNAMICS_VIEW_TYPE, GIMP_CONFIG_PROP_ENUM (object_class, PROP_DYNAMICS_VIEW_TYPE,
"dynamics-view-type", NULL, "dynamics-view-type",
GIMP_TYPE_VIEW_TYPE, NULL, NULL,
GIMP_VIEW_TYPE_LIST, GIMP_TYPE_VIEW_TYPE,
GIMP_PARAM_STATIC_STRINGS); GIMP_VIEW_TYPE_LIST,
GIMP_CONFIG_INSTALL_PROP_INT (object_class, PROP_DYNAMICS_VIEW_SIZE, GIMP_PARAM_STATIC_STRINGS);
"dynamics-view-size", NULL, GIMP_CONFIG_PROP_INT (object_class, PROP_DYNAMICS_VIEW_SIZE,
GIMP_VIEW_SIZE_TINY, "dynamics-view-size",
GIMP_VIEWABLE_MAX_BUTTON_SIZE, NULL, NULL,
GIMP_VIEW_SIZE_SMALL, GIMP_VIEW_SIZE_TINY,
GIMP_PARAM_STATIC_STRINGS); GIMP_VIEWABLE_MAX_BUTTON_SIZE,
GIMP_VIEW_SIZE_SMALL,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_PATTERN_VIEW_TYPE, GIMP_CONFIG_PROP_ENUM (object_class, PROP_PATTERN_VIEW_TYPE,
"pattern-view-type", NULL, "pattern-view-type",
GIMP_TYPE_VIEW_TYPE, NULL, NULL,
GIMP_VIEW_TYPE_GRID, GIMP_TYPE_VIEW_TYPE,
GIMP_PARAM_STATIC_STRINGS); GIMP_VIEW_TYPE_GRID,
GIMP_CONFIG_INSTALL_PROP_INT (object_class, PROP_PATTERN_VIEW_SIZE, GIMP_PARAM_STATIC_STRINGS);
"pattern-view-size", NULL, GIMP_CONFIG_PROP_INT (object_class, PROP_PATTERN_VIEW_SIZE,
GIMP_VIEW_SIZE_TINY, "pattern-view-size",
GIMP_VIEWABLE_MAX_BUTTON_SIZE, NULL, NULL,
GIMP_VIEW_SIZE_SMALL, GIMP_VIEW_SIZE_TINY,
GIMP_PARAM_STATIC_STRINGS); GIMP_VIEWABLE_MAX_BUTTON_SIZE,
GIMP_VIEW_SIZE_SMALL,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_GRADIENT_VIEW_TYPE, GIMP_CONFIG_PROP_ENUM (object_class, PROP_GRADIENT_VIEW_TYPE,
"gradient-view-type", NULL, "gradient-view-type",
GIMP_TYPE_VIEW_TYPE, NULL, NULL,
GIMP_VIEW_TYPE_LIST, GIMP_TYPE_VIEW_TYPE,
GIMP_PARAM_STATIC_STRINGS); GIMP_VIEW_TYPE_LIST,
GIMP_CONFIG_INSTALL_PROP_INT (object_class, PROP_GRADIENT_VIEW_SIZE, GIMP_PARAM_STATIC_STRINGS);
"gradient-view-size", NULL, GIMP_CONFIG_PROP_INT (object_class, PROP_GRADIENT_VIEW_SIZE,
GIMP_VIEW_SIZE_TINY, "gradient-view-size",
GIMP_VIEWABLE_MAX_BUTTON_SIZE, NULL, NULL,
GIMP_VIEW_SIZE_LARGE, GIMP_VIEW_SIZE_TINY,
GIMP_PARAM_STATIC_STRINGS); GIMP_VIEWABLE_MAX_BUTTON_SIZE,
GIMP_VIEW_SIZE_LARGE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_USE_SMOOTHING, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_USE_SMOOTHING,
"use-smoothing", _("Paint smoother strokes"), "use-smoothing",
FALSE, _("Smooth stroke"),
GIMP_PARAM_STATIC_STRINGS); _("Paint smoother strokes"),
GIMP_CONFIG_INSTALL_PROP_INT (object_class, PROP_SMOOTHING_QUALITY, FALSE,
"smoothing-quality", _("Depth of smoothing"), GIMP_PARAM_STATIC_STRINGS);
1, 100, DEFAULT_SMOOTHING_QUALITY, GIMP_CONFIG_PROP_INT (object_class, PROP_SMOOTHING_QUALITY,
GIMP_PARAM_STATIC_STRINGS); "smoothing-quality",
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_SMOOTHING_FACTOR, _("Quality"),
"smoothing-factor", _("Gravity of the pen"), _("Depth of smoothing"),
3.0, 1000.0, DEFAULT_SMOOTHING_FACTOR, 1, 100, DEFAULT_SMOOTHING_QUALITY,
/* Max velocity is set at 3. GIMP_PARAM_STATIC_STRINGS);
* Allowing for smoothing factor to be GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_SMOOTHING_FACTOR,
* less than velcoty results in numeric "smoothing-factor",
* instablility */ _("Weight"),
GIMP_PARAM_STATIC_STRINGS); _("Gravity of the pen"),
/* Max velocity is set to 3; allowing for
* smoothing factor to be less than velcoty
* results in numeric instablility
*/
3.0, 1000.0, DEFAULT_SMOOTHING_FACTOR,
GIMP_PARAM_STATIC_STRINGS);
} }
static void static void

9
app/paint/gimppenciloptions.c
View File

@ -59,10 +59,11 @@ gimp_pencil_options_class_init (GimpPencilOptionsClass *klass)
object_class->set_property = gimp_pencil_options_set_property; object_class->set_property = gimp_pencil_options_set_property;
object_class->get_property = gimp_pencil_options_get_property; object_class->get_property = gimp_pencil_options_get_property;
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_HARD, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_HARD,
"hard", NULL, "hard",
PENCIL_DEFAULT_HARD, NULL, NULL,
GIMP_PARAM_STATIC_STRINGS); PENCIL_DEFAULT_HARD,
GIMP_PARAM_STATIC_STRINGS);
} }
static void static void

13
app/paint/gimpperspectivecloneoptions.c
View File

@ -26,6 +26,8 @@
#include "gimpperspectivecloneoptions.h" #include "gimpperspectivecloneoptions.h"
#include "gimp-intl.h"
enum enum
{ {
@ -56,11 +58,12 @@ gimp_perspective_clone_options_class_init (GimpPerspectiveCloneOptionsClass *kla
object_class->set_property = gimp_perspective_clone_options_set_property; object_class->set_property = gimp_perspective_clone_options_set_property;
object_class->get_property = gimp_perspective_clone_options_get_property; object_class->get_property = gimp_perspective_clone_options_get_property;
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_CLONE_MODE, GIMP_CONFIG_PROP_ENUM (object_class, PROP_CLONE_MODE,
"clone-mode", NULL, "clone-mode",
GIMP_TYPE_PERSPECTIVE_CLONE_MODE, NULL, NULL,
GIMP_PERSPECTIVE_CLONE_MODE_ADJUST, GIMP_TYPE_PERSPECTIVE_CLONE_MODE,
GIMP_PARAM_STATIC_STRINGS); GIMP_PERSPECTIVE_CLONE_MODE_ADJUST,
GIMP_PARAM_STATIC_STRINGS);
} }
static void static void

12
app/paint/gimpsmudgeoptions.c
View File

@ -26,6 +26,8 @@
#include "gimpsmudgeoptions.h" #include "gimpsmudgeoptions.h"
#include "gimp-intl.h"
#define SMUDGE_DEFAULT_RATE 50.0 #define SMUDGE_DEFAULT_RATE 50.0
@ -59,10 +61,12 @@ gimp_smudge_options_class_init (GimpSmudgeOptionsClass *klass)
object_class->set_property = gimp_smudge_options_set_property; object_class->set_property = gimp_smudge_options_set_property;
object_class->get_property = gimp_smudge_options_get_property; object_class->get_property = gimp_smudge_options_get_property;
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_RATE, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_RATE,
"rate", NULL, "rate",
0.0, 100.0, SMUDGE_DEFAULT_RATE, C_("smudge-tool", "Rate"),
GIMP_PARAM_STATIC_STRINGS); NULL,
0.0, 100.0, SMUDGE_DEFAULT_RATE,
GIMP_PARAM_STATIC_STRINGS);
} }
static void static void

24
app/paint/gimpsourceoptions.c
View File

@ -26,6 +26,8 @@
#include "gimpsourceoptions.h" #include "gimpsourceoptions.h"
#include "gimp-intl.h"
enum enum
{ {
@ -56,16 +58,20 @@ gimp_source_options_class_init (GimpSourceOptionsClass *klass)
object_class->set_property = gimp_source_options_set_property; object_class->set_property = gimp_source_options_set_property;
object_class->get_property = gimp_source_options_get_property; object_class->get_property = gimp_source_options_get_property;
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_ALIGN_MODE, GIMP_CONFIG_PROP_ENUM (object_class, PROP_ALIGN_MODE,
"align-mode", NULL, "align-mode",
GIMP_TYPE_SOURCE_ALIGN_MODE, _("Alignment"),
GIMP_SOURCE_ALIGN_NO, NULL,
GIMP_PARAM_STATIC_STRINGS); GIMP_TYPE_SOURCE_ALIGN_MODE,
GIMP_SOURCE_ALIGN_NO,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_SAMPLE_MERGED, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_SAMPLE_MERGED,
"sample-merged", NULL, "sample-merged",
FALSE, _("Sample merged"),
GIMP_PARAM_STATIC_STRINGS); NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
} }
static void static void

129
app/pdb/gimppdbcontext.c
View File

@ -94,70 +94,93 @@ gimp_pdb_context_class_init (GimpPDBContextClass *klass)
object_class->set_property = gimp_pdb_context_set_property; object_class->set_property = gimp_pdb_context_set_property;
object_class->get_property = gimp_pdb_context_get_property; object_class->get_property = gimp_pdb_context_get_property;
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_ANTIALIAS, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_ANTIALIAS,
"antialias", "antialias",
N_("Smooth edges"), _("Antialiasing"),
TRUE, _("Smooth edges"),
GIMP_PARAM_STATIC_STRINGS); TRUE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_FEATHER, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_FEATHER,
"feather", NULL, "feather",
FALSE, _("Feather"),
GIMP_PARAM_STATIC_STRINGS); NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_FEATHER_RADIUS_X, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_FEATHER_RADIUS_X,
"feather-radius-x", NULL, "feather-radius-x",
0.0, 1000.0, 10.0, _("Feather radius X"),
GIMP_PARAM_STATIC_STRINGS); NULL,
0.0, 1000.0, 10.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_FEATHER_RADIUS_Y, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_FEATHER_RADIUS_Y,
"feather-radius-y", NULL, "feather-radius-y",
0.0, 1000.0, 10.0, _("Feather radius Y"),
GIMP_PARAM_STATIC_STRINGS); NULL,
0.0, 1000.0, 10.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_SAMPLE_MERGED, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_SAMPLE_MERGED,
"sample-merged", NULL, "sample-merged",
FALSE, _("Sample merged"),
GIMP_PARAM_STATIC_STRINGS); NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_SAMPLE_CRITERION, GIMP_CONFIG_PROP_ENUM (object_class, PROP_SAMPLE_CRITERION,
"sample-criterion", NULL, "sample-criterion",
GIMP_TYPE_SELECT_CRITERION, _("Sample criterion"),
GIMP_SELECT_CRITERION_COMPOSITE, NULL,
GIMP_PARAM_STATIC_STRINGS); GIMP_TYPE_SELECT_CRITERION,
GIMP_SELECT_CRITERION_COMPOSITE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_SAMPLE_THRESHOLD, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_SAMPLE_THRESHOLD,
"sample-threshold", NULL, "sample-threshold",
0.0, 1.0, 0.0, _("Sample threshold"),
GIMP_PARAM_STATIC_STRINGS); NULL,
0.0, 1.0, 0.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_SAMPLE_TRANSPARENT, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_SAMPLE_TRANSPARENT,
"sample-transparent", NULL, "sample-transparent",
FALSE, _("Sample transparent"),
GIMP_PARAM_STATIC_STRINGS); NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_DIAGONAL_NEIGHBORS, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_DIAGONAL_NEIGHBORS,
"diagonal-neighbors", NULL, "diagonal-neighbors",
FALSE, _("Diagonal neighbors"),
GIMP_PARAM_STATIC_STRINGS); NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_INTERPOLATION, GIMP_CONFIG_PROP_ENUM (object_class, PROP_INTERPOLATION,
"interpolation", NULL, "interpolation",
GIMP_TYPE_INTERPOLATION_TYPE, _("Interpolation"),
GIMP_INTERPOLATION_CUBIC, NULL,
GIMP_PARAM_STATIC_STRINGS); GIMP_TYPE_INTERPOLATION_TYPE,
GIMP_INTERPOLATION_CUBIC,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_TRANSFORM_DIRECTION, GIMP_CONFIG_PROP_ENUM (object_class, PROP_TRANSFORM_DIRECTION,
"transform-direction", NULL, "transform-direction",
GIMP_TYPE_TRANSFORM_DIRECTION, _("Transform direction"),
GIMP_TRANSFORM_FORWARD, NULL,
GIMP_PARAM_STATIC_STRINGS); GIMP_TYPE_TRANSFORM_DIRECTION,
GIMP_TRANSFORM_FORWARD,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_TRANSFORM_RESIZE, GIMP_CONFIG_PROP_ENUM (object_class, PROP_TRANSFORM_RESIZE,
"transform-resize", NULL, "transform-resize",
GIMP_TYPE_TRANSFORM_RESIZE, _("Transform resize"),
GIMP_TRANSFORM_RESIZE_ADJUST, NULL,
GIMP_PARAM_STATIC_STRINGS); GIMP_TYPE_TRANSFORM_RESIZE,
GIMP_TRANSFORM_RESIZE_ADJUST,
GIMP_PARAM_STATIC_STRINGS);
} }
static void static void

280
app/text/gimptext.c
View File

@ -132,121 +132,166 @@ gimp_text_class_init (GimpTextClass *klass)
gimp_rgba_set (&black, 0.0, 0.0, 0.0, GIMP_OPACITY_OPAQUE); gimp_rgba_set (&black, 0.0, 0.0, 0.0, GIMP_OPACITY_OPAQUE);
gimp_matrix2_identity (&identity); gimp_matrix2_identity (&identity);
language = gimp_get_default_language (NULL); GIMP_CONFIG_PROP_STRING (object_class, PROP_TEXT,
"text",
NULL, NULL,
NULL,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_STRING (object_class, PROP_TEXT, GIMP_CONFIG_PROP_STRING (object_class, PROP_MARKUP,
"text", NULL, "markup",
NULL, NULL, NULL,
GIMP_PARAM_STATIC_STRINGS); NULL,
GIMP_CONFIG_INSTALL_PROP_STRING (object_class, PROP_MARKUP, GIMP_PARAM_STATIC_STRINGS);
"markup", NULL,
NULL, GIMP_CONFIG_PROP_STRING (object_class, PROP_FONT,
GIMP_PARAM_STATIC_STRINGS); "font",
GIMP_CONFIG_INSTALL_PROP_STRING (object_class, PROP_FONT, NULL, NULL,
"font", NULL, "Sans-serif",
"Sans-serif", GIMP_PARAM_STATIC_STRINGS);
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_FONT_SIZE, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_FONT_SIZE,
"font-size", NULL, "font-size",
0.0, 8192.0, 24.0, NULL, NULL,
GIMP_PARAM_STATIC_STRINGS); 0.0, 8192.0, 24.0,
/* GIMP_PARAM_STATIC_STRINGS);
* We use the name "font-size-unit" for backward compatibility.
/* We use the name "font-size-unit" for backward compatibility.
* The unit is also used for other sizes in the text object. * The unit is also used for other sizes in the text object.
*/ */
GIMP_CONFIG_INSTALL_PROP_UNIT (object_class, PROP_UNIT, GIMP_CONFIG_PROP_UNIT (object_class, PROP_UNIT,
"font-size-unit", NULL, "font-size-unit",
TRUE, FALSE, GIMP_UNIT_PIXEL, NULL, NULL,
GIMP_PARAM_STATIC_STRINGS); TRUE, FALSE, GIMP_UNIT_PIXEL,
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_ANTIALIAS, GIMP_PARAM_STATIC_STRINGS);
"antialias", NULL,
TRUE, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_ANTIALIAS,
GIMP_PARAM_STATIC_STRINGS); "antialias",
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_HINT_STYLE, NULL, NULL,
"hint-style", NULL, TRUE,
GIMP_TYPE_TEXT_HINT_STYLE, GIMP_PARAM_STATIC_STRINGS);
GIMP_TEXT_HINT_STYLE_MEDIUM,
GIMP_PARAM_STATIC_STRINGS | GIMP_CONFIG_PROP_ENUM (object_class, PROP_HINT_STYLE,
GIMP_CONFIG_PARAM_DEFAULTS); "hint-style",
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_KERNING, NULL, NULL,
"kerning", NULL, GIMP_TYPE_TEXT_HINT_STYLE,
FALSE, GIMP_TEXT_HINT_STYLE_MEDIUM,
GIMP_PARAM_STATIC_STRINGS | GIMP_PARAM_STATIC_STRINGS |
GIMP_CONFIG_PARAM_DEFAULTS); GIMP_CONFIG_PARAM_DEFAULTS);
GIMP_CONFIG_INSTALL_PROP_STRING (object_class, PROP_LANGUAGE,
"language", NULL, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_KERNING,
language, "kerning",
GIMP_PARAM_STATIC_STRINGS); NULL, NULL,
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_BASE_DIR, FALSE,
"base-direction", NULL, GIMP_PARAM_STATIC_STRINGS |
GIMP_TYPE_TEXT_DIRECTION, GIMP_CONFIG_PARAM_DEFAULTS);
GIMP_TEXT_DIRECTION_LTR,
GIMP_PARAM_STATIC_STRINGS); language = gimp_get_default_language (NULL);
GIMP_CONFIG_INSTALL_PROP_RGB (object_class, PROP_COLOR,
"color", NULL, GIMP_CONFIG_PROP_STRING (object_class, PROP_LANGUAGE,
FALSE, &black, "language",
GIMP_PARAM_STATIC_STRINGS); NULL, NULL,
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_OUTLINE, language,
"outline", NULL, GIMP_PARAM_STATIC_STRINGS);
GIMP_TYPE_TEXT_OUTLINE,
GIMP_TEXT_OUTLINE_NONE, g_free (language);
GIMP_PARAM_STATIC_STRINGS |
GIMP_CONFIG_PARAM_DEFAULTS); GIMP_CONFIG_PROP_ENUM (object_class, PROP_BASE_DIR,
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_JUSTIFICATION, "base-direction",
"justify", NULL, NULL, NULL,
GIMP_TYPE_TEXT_JUSTIFICATION, GIMP_TYPE_TEXT_DIRECTION,
GIMP_TEXT_JUSTIFY_LEFT, GIMP_TEXT_DIRECTION_LTR,
GIMP_PARAM_STATIC_STRINGS); GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_INDENTATION,
"indent", NULL, GIMP_CONFIG_PROP_RGB (object_class, PROP_COLOR,
-8192.0, 8192.0, 0.0, "color",
GIMP_PARAM_STATIC_STRINGS | NULL, NULL,
GIMP_CONFIG_PARAM_DEFAULTS); FALSE, &black,
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_LINE_SPACING, GIMP_PARAM_STATIC_STRINGS);
"line-spacing", NULL,
-8192.0, 8192.0, 0.0, GIMP_CONFIG_PROP_ENUM (object_class, PROP_OUTLINE,
GIMP_PARAM_STATIC_STRINGS | "outline",
GIMP_CONFIG_PARAM_DEFAULTS); NULL, NULL,
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_LETTER_SPACING, GIMP_TYPE_TEXT_OUTLINE,
"letter-spacing", NULL, GIMP_TEXT_OUTLINE_NONE,
-8192.0, 8192.0, 0.0, GIMP_PARAM_STATIC_STRINGS |
GIMP_PARAM_STATIC_STRINGS | GIMP_CONFIG_PARAM_DEFAULTS);
GIMP_CONFIG_PARAM_DEFAULTS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_BOX_MODE, GIMP_CONFIG_PROP_ENUM (object_class, PROP_JUSTIFICATION,
"box-mode", "justify",
NULL, NULL, NULL,
GIMP_TYPE_TEXT_BOX_MODE, GIMP_TYPE_TEXT_JUSTIFICATION,
GIMP_TEXT_BOX_DYNAMIC, GIMP_TEXT_JUSTIFY_LEFT,
GIMP_PARAM_STATIC_STRINGS); GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_BOX_WIDTH,
"box-width", NULL, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_INDENTATION,
0.0, GIMP_MAX_IMAGE_SIZE, 0.0, "indent",
GIMP_PARAM_STATIC_STRINGS | NULL, NULL,
GIMP_CONFIG_PARAM_DEFAULTS); -8192.0, 8192.0, 0.0,
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_BOX_HEIGHT, GIMP_PARAM_STATIC_STRINGS |
"box-height", NULL, GIMP_CONFIG_PARAM_DEFAULTS);
0.0, GIMP_MAX_IMAGE_SIZE, 0.0,
GIMP_PARAM_STATIC_STRINGS | GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_LINE_SPACING,
GIMP_CONFIG_PARAM_DEFAULTS); "line-spacing",
GIMP_CONFIG_INSTALL_PROP_UNIT (object_class, PROP_BOX_UNIT, NULL, NULL,
"box-unit", NULL, -8192.0, 8192.0, 0.0,
TRUE, FALSE, GIMP_UNIT_PIXEL, GIMP_PARAM_STATIC_STRINGS |
GIMP_PARAM_STATIC_STRINGS); GIMP_CONFIG_PARAM_DEFAULTS);
GIMP_CONFIG_INSTALL_PROP_MATRIX2 (object_class, PROP_TRANSFORMATION,
"transformation", NULL, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_LETTER_SPACING,
&identity, "letter-spacing",
GIMP_PARAM_STATIC_STRINGS | NULL, NULL,
GIMP_CONFIG_PARAM_DEFAULTS); -8192.0, 8192.0, 0.0,
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_OFFSET_X, GIMP_PARAM_STATIC_STRINGS |
"offset-x", NULL, GIMP_CONFIG_PARAM_DEFAULTS);
-G_MAXDOUBLE, G_MAXDOUBLE, 0.0,
GIMP_PARAM_STATIC_STRINGS | GIMP_CONFIG_PROP_ENUM (object_class, PROP_BOX_MODE,
GIMP_CONFIG_PARAM_DEFAULTS); "box-mode",
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_OFFSET_Y, NULL, NULL,
"offset-y", NULL, GIMP_TYPE_TEXT_BOX_MODE,
-G_MAXDOUBLE, G_MAXDOUBLE, 0.0, GIMP_TEXT_BOX_DYNAMIC,
GIMP_PARAM_STATIC_STRINGS | GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PARAM_DEFAULTS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_BOX_WIDTH,
"box-width",
NULL, NULL,
0.0, GIMP_MAX_IMAGE_SIZE, 0.0,
GIMP_PARAM_STATIC_STRINGS |
GIMP_CONFIG_PARAM_DEFAULTS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_BOX_HEIGHT,
"box-height",
NULL, NULL,
0.0, GIMP_MAX_IMAGE_SIZE, 0.0,
GIMP_PARAM_STATIC_STRINGS |
GIMP_CONFIG_PARAM_DEFAULTS);
GIMP_CONFIG_PROP_UNIT (object_class, PROP_BOX_UNIT,
"box-unit",
NULL, NULL,
TRUE, FALSE, GIMP_UNIT_PIXEL,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_MATRIX2 (object_class, PROP_TRANSFORMATION,
"transformation",
NULL, NULL,
&identity,
GIMP_PARAM_STATIC_STRINGS |
GIMP_CONFIG_PARAM_DEFAULTS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_OFFSET_X,
"offset-x",
NULL, NULL,
-G_MAXDOUBLE, G_MAXDOUBLE, 0.0,
GIMP_PARAM_STATIC_STRINGS |
GIMP_CONFIG_PARAM_DEFAULTS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_OFFSET_Y,
"offset-y",
NULL, NULL,
-G_MAXDOUBLE, G_MAXDOUBLE, 0.0,
GIMP_PARAM_STATIC_STRINGS |
GIMP_CONFIG_PARAM_DEFAULTS);
/* border does only exist to implement the old text API */ /* border does only exist to implement the old text API */
g_object_class_install_property (object_class, PROP_BORDER, g_object_class_install_property (object_class, PROP_BORDER,
@ -256,12 +301,11 @@ gimp_text_class_init (GimpTextClass *klass)
GIMP_PARAM_WRITABLE)); GIMP_PARAM_WRITABLE));
/* the old hinting options have been replaced by 'hint-style' */ /* the old hinting options have been replaced by 'hint-style' */
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_HINTING, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_HINTING,
"hinting", NULL, "hinting",
TRUE, NULL, NULL,
GIMP_PARAM_STATIC_STRINGS); TRUE,
GIMP_PARAM_STATIC_STRINGS);
g_free (language);
} }
static void static void

27
app/text/gimptextlayer.c
View File

@ -159,20 +159,23 @@ gimp_text_layer_class_init (GimpTextLayerClass *klass)
drawable_class->set_buffer = gimp_text_layer_set_buffer; drawable_class->set_buffer = gimp_text_layer_set_buffer;
drawable_class->push_undo = gimp_text_layer_push_undo; drawable_class->push_undo = gimp_text_layer_push_undo;
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_TEXT, GIMP_CONFIG_PROP_OBJECT (object_class, PROP_TEXT,
"text", NULL, "text",
GIMP_TYPE_TEXT, NULL, NULL,
GIMP_PARAM_STATIC_STRINGS); GIMP_TYPE_TEXT,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_AUTO_RENAME, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_AUTO_RENAME,
"auto-rename", NULL, "auto-rename",
TRUE, NULL, NULL,
GIMP_PARAM_STATIC_STRINGS); TRUE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_MODIFIED, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_MODIFIED,
"modified", NULL, "modified",
FALSE, NULL, NULL,
GIMP_PARAM_STATIC_STRINGS); FALSE,
GIMP_PARAM_STATIC_STRINGS);
} }
static void static void

8
app/tools/gimpairbrushtool.c
View File

@ -84,18 +84,16 @@ gimp_airbrush_options_gui (GimpToolOptions *tool_options)
GtkWidget *button; GtkWidget *button;
GtkWidget *scale; GtkWidget *scale;
button = gimp_prop_check_button_new (config, "motion-only", _("Motion only")); button = gimp_prop_check_button_new (config, "motion-only", NULL);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button); gtk_widget_show (button);
scale = gimp_prop_spin_scale_new (config, "rate", scale = gimp_prop_spin_scale_new (config, "rate", NULL,
C_("airbrush-tool", "Rate"),
1.0, 10.0, 1); 1.0, 10.0, 1);
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
gtk_widget_show (scale); gtk_widget_show (scale);
scale = gimp_prop_spin_scale_new (config, "flow", scale = gimp_prop_spin_scale_new (config, "flow", NULL,
_("Flow"),
1.0, 10.0, 1); 1.0, 10.0, 1);
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
gtk_widget_show (scale); gtk_widget_show (scale);

35
app/tools/gimpalignoptions.c
View File

@ -87,24 +87,27 @@ gimp_align_options_class_init (GimpAlignOptionsClass *klass)
G_TYPE_NONE, 1, G_TYPE_NONE, 1,
GIMP_TYPE_ALIGNMENT_TYPE); GIMP_TYPE_ALIGNMENT_TYPE);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_ALIGN_REFERENCE, GIMP_CONFIG_PROP_ENUM (object_class, PROP_ALIGN_REFERENCE,
"align-reference", "align-reference",
_("Reference image object a layer will be aligned on"), _("Relative to"),
GIMP_TYPE_ALIGN_REFERENCE_TYPE, _("Reference image object a layer will be aligned on"),
GIMP_ALIGN_REFERENCE_FIRST, GIMP_TYPE_ALIGN_REFERENCE_TYPE,
GIMP_PARAM_STATIC_STRINGS); GIMP_ALIGN_REFERENCE_FIRST,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_OFFSET_X, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_OFFSET_X,
"offset-x", "offset-x",
_("Horizontal offset for distribution"), _("Offset"),
-GIMP_MAX_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE, 0, _("Horizontal offset for distribution"),
GIMP_PARAM_STATIC_STRINGS); -GIMP_MAX_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE, 0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_OFFSET_Y, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_OFFSET_Y,
"offset-y", "offset-y",
_("Vertical offset for distribution"), _("Offset"),
-GIMP_MAX_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE, 0, _("Vertical offset for distribution"),
GIMP_PARAM_STATIC_STRINGS); -GIMP_MAX_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE, 0,
GIMP_PARAM_STATIC_STRINGS);
} }
static void static void

89
app/tools/gimpblendoptions.c
View File

@ -74,38 +74,52 @@ gimp_blend_options_class_init (GimpBlendOptionsClass *klass)
object_class->set_property = gimp_blend_options_set_property; object_class->set_property = gimp_blend_options_set_property;
object_class->get_property = gimp_blend_options_get_property; object_class->get_property = gimp_blend_options_get_property;
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_OFFSET, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_OFFSET,
"offset", NULL, "offset",
0.0, 100.0, 0.0, _("Offset"),
GIMP_PARAM_STATIC_STRINGS); NULL,
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_GRADIENT_TYPE, 0.0, 100.0, 0.0,
"gradient-type", NULL, GIMP_PARAM_STATIC_STRINGS);
GIMP_TYPE_GRADIENT_TYPE, GIMP_CONFIG_PROP_ENUM (object_class, PROP_GRADIENT_TYPE,
GIMP_GRADIENT_LINEAR, "gradient-type",
GIMP_PARAM_STATIC_STRINGS); _("Shape"),
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_GRADIENT_REPEAT, NULL,
"gradient-repeat", NULL, GIMP_TYPE_GRADIENT_TYPE,
GIMP_TYPE_REPEAT_MODE, GIMP_GRADIENT_LINEAR,
GIMP_REPEAT_NONE, GIMP_PARAM_STATIC_STRINGS);
GIMP_PARAM_STATIC_STRINGS); GIMP_CONFIG_PROP_ENUM (object_class, PROP_GRADIENT_REPEAT,
"gradient-repeat",
_("Repeat"),
NULL,
GIMP_TYPE_REPEAT_MODE,
GIMP_REPEAT_NONE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_SUPERSAMPLE, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_SUPERSAMPLE,
"supersample", NULL, "supersample",
FALSE, _("Adaptive Supersampling"),
GIMP_PARAM_STATIC_STRINGS); NULL,
GIMP_CONFIG_INSTALL_PROP_INT (object_class, PROP_SUPERSAMPLE_DEPTH, FALSE,
"supersample-depth", NULL, GIMP_PARAM_STATIC_STRINGS);
1, 9, 3, GIMP_CONFIG_PROP_INT (object_class, PROP_SUPERSAMPLE_DEPTH,
GIMP_PARAM_STATIC_STRINGS); "supersample-depth",
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_SUPERSAMPLE_THRESHOLD, _("Max depth"),
"supersample-threshold", NULL, NULL,
0.0, 4.0, 0.2, 1, 9, 3,
GIMP_PARAM_STATIC_STRINGS); GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_SUPERSAMPLE_THRESHOLD,
"supersample-threshold",
_("Threshold"),
NULL,
0.0, 4.0, 0.2,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_DITHER, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_DITHER,
"dither", NULL, "dither",
TRUE, _("Dithering"),
GIMP_PARAM_STATIC_STRINGS); NULL,
TRUE,
GIMP_PARAM_STATIC_STRINGS);
} }
static void static void
@ -237,36 +251,31 @@ gimp_blend_options_gui (GimpToolOptions *tool_options)
combo); combo);
/* the offset scale */ /* the offset scale */
scale = gimp_prop_spin_scale_new (config, "offset", scale = gimp_prop_spin_scale_new (config, "offset", NULL,
_("Offset"),
1.0, 10.0, 1); 1.0, 10.0, 1);
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
gtk_widget_show (scale); gtk_widget_show (scale);
/* the dither toggle */ /* the dither toggle */
button = gimp_prop_check_button_new (config, "dither", button = gimp_prop_check_button_new (config, "dither", NULL);
_("Dithering"));
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button); gtk_widget_show (button);
/* supersampling options */ /* supersampling options */
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
frame = gimp_prop_expanding_frame_new (config, "supersample", frame = gimp_prop_expanding_frame_new (config, "supersample", NULL,
_("Adaptive supersampling"),
vbox2, NULL); vbox2, NULL);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame); gtk_widget_show (frame);
/* max depth scale */ /* max depth scale */
scale = gimp_prop_spin_scale_new (config, "supersample-depth", scale = gimp_prop_spin_scale_new (config, "supersample-depth", NULL,
_("Max depth"),
1.0, 1.0, 0); 1.0, 1.0, 0);
gtk_box_pack_start (GTK_BOX (vbox2), scale, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox2), scale, FALSE, FALSE, 0);
gtk_widget_show (scale); gtk_widget_show (scale);
/* threshold scale */ /* threshold scale */
scale = gimp_prop_spin_scale_new (config, "supersample-threshold", scale = gimp_prop_spin_scale_new (config, "supersample-threshold", NULL,
_("Threshold"),
0.01, 0.1, 2); 0.01, 0.1, 2);
gtk_box_pack_start (GTK_BOX (vbox2), scale, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox2), scale, FALSE, FALSE, 0);
gtk_widget_show (scale); gtk_widget_show (scale);

97
app/tools/gimpbucketfilloptions.c
View File

@ -88,45 +88,52 @@ gimp_bucket_fill_options_class_init (GimpBucketFillOptionsClass *klass)
object_class->set_property = gimp_bucket_fill_options_set_property; object_class->set_property = gimp_bucket_fill_options_set_property;
object_class->get_property = gimp_bucket_fill_options_get_property; object_class->get_property = gimp_bucket_fill_options_get_property;
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_FILL_MODE, GIMP_CONFIG_PROP_ENUM (object_class, PROP_FILL_MODE,
"fill-mode", NULL, "fill-mode",
GIMP_TYPE_BUCKET_FILL_MODE, _("Fill type"),
GIMP_BUCKET_FILL_FG, NULL,
GIMP_PARAM_STATIC_STRINGS); GIMP_TYPE_BUCKET_FILL_MODE,
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_FILL_SELECTION, GIMP_BUCKET_FILL_FG,
"fill-selection", GIMP_PARAM_STATIC_STRINGS);
_("Which area will be filled"), GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_FILL_SELECTION,
FALSE, "fill-selection",
GIMP_PARAM_STATIC_STRINGS); _("Fill selection"),
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_FILL_TRANSPARENT, _("Which area will be filled"),
"fill-transparent", FALSE,
_("Allow completely transparent regions " GIMP_PARAM_STATIC_STRINGS);
"to be filled"), GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_FILL_TRANSPARENT,
TRUE, "fill-transparent",
GIMP_PARAM_STATIC_STRINGS); _("Fill transparent areas"),
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_SAMPLE_MERGED, _("Allow completely transparent regions "
"sample-merged", "to be filled"),
_("Base filled area on all visible " TRUE,
"layers"), GIMP_PARAM_STATIC_STRINGS);
FALSE, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_SAMPLE_MERGED,
GIMP_PARAM_STATIC_STRINGS); "sample-merged",
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_DIAGONAL_NEIGHBORS, _("Sample merged"),
"diagonal-neighbors", _("Base filled area on all visible layers"),
_("Treat diagonally neighboring pixels as " FALSE,
"connected"), GIMP_PARAM_STATIC_STRINGS);
FALSE, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_DIAGONAL_NEIGHBORS,
GIMP_PARAM_STATIC_STRINGS); "diagonal-neighbors",
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_THRESHOLD, _("Diagonal neighbors"),
"threshold", _("Treat diagonally neighboring pixels as "
_("Maximum color difference"), "connected"),
0.0, 255.0, 15.0, FALSE,
GIMP_PARAM_STATIC_STRINGS); GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_FILL_CRITERION, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_THRESHOLD,
"fill-criterion", "threshold",
_("Criterion used for determining color similarity"), _("Threshold"),
GIMP_TYPE_SELECT_CRITERION, _("Maximum color difference"),
GIMP_SELECT_CRITERION_COMPOSITE, 0.0, 255.0, 15.0,
GIMP_PARAM_STATIC_STRINGS); GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_FILL_CRITERION,
"fill-criterion",
_("Fill by"),
_("Criterion used for determining color similarity"),
GIMP_TYPE_SELECT_CRITERION,
GIMP_SELECT_CRITERION_COMPOSITE,
GIMP_PARAM_STATIC_STRINGS);
} }
static void static void
@ -293,26 +300,22 @@ gimp_bucket_fill_options_gui (GimpToolOptions *tool_options)
gtk_widget_show (vbox2); gtk_widget_show (vbox2);
/* the fill transparent areas toggle */ /* the fill transparent areas toggle */
button = gimp_prop_check_button_new (config, "fill-transparent", button = gimp_prop_check_button_new (config, "fill-transparent", NULL);
_("Fill transparent areas"));
gtk_box_pack_start (GTK_BOX (vbox2), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox2), button, FALSE, FALSE, 0);
gtk_widget_show (button); gtk_widget_show (button);
/* the sample merged toggle */ /* the sample merged toggle */
button = gimp_prop_check_button_new (config, "sample-merged", button = gimp_prop_check_button_new (config, "sample-merged", NULL);
_("Sample merged"));
gtk_box_pack_start (GTK_BOX (vbox2), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox2), button, FALSE, FALSE, 0);
gtk_widget_show (button); gtk_widget_show (button);
/* the diagonal neighbors toggle */ /* the diagonal neighbors toggle */
button = gimp_prop_check_button_new (config, "diagonal-neighbors", button = gimp_prop_check_button_new (config, "diagonal-neighbors", NULL);
_("Diagonal neighbors"));
gtk_box_pack_start (GTK_BOX (vbox2), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox2), button, FALSE, FALSE, 0);
gtk_widget_show (button); gtk_widget_show (button);
/* the threshold scale */ /* the threshold scale */
scale = gimp_prop_spin_scale_new (config, "threshold", scale = gimp_prop_spin_scale_new (config, "threshold", NULL,
_("Threshold"),
1.0, 16.0, 1); 1.0, 16.0, 1);
gtk_box_pack_start (GTK_BOX (vbox2), scale, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox2), scale, FALSE, FALSE, 0);
gtk_widget_show (scale); gtk_widget_show (scale);

26
app/tools/gimpcageoptions.c
View File

@ -65,16 +65,20 @@ gimp_cage_options_class_init (GimpCageOptionsClass *klass)
object_class->set_property = gimp_cage_options_set_property; object_class->set_property = gimp_cage_options_set_property;
object_class->get_property = gimp_cage_options_get_property; object_class->get_property = gimp_cage_options_get_property;
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_CAGE_MODE, GIMP_CONFIG_PROP_ENUM (object_class, PROP_CAGE_MODE,
"cage-mode", NULL, "cage-mode",
GIMP_TYPE_CAGE_MODE, NULL, NULL,
GIMP_CAGE_MODE_CAGE_CHANGE, GIMP_TYPE_CAGE_MODE,
GIMP_PARAM_STATIC_STRINGS); GIMP_CAGE_MODE_CAGE_CHANGE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_FILL_PLAIN_COLOR, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_FILL_PLAIN_COLOR,
"fill-plain-color", NULL, "fill-plain-color",
FALSE, _("Fill the original position\n"
GIMP_PARAM_STATIC_STRINGS); "of the cage with a color"),
NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
} }
static void static void
@ -140,9 +144,7 @@ gimp_cage_options_gui (GimpToolOptions *tool_options)
gtk_box_pack_start (GTK_BOX (vbox), mode, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), mode, FALSE, FALSE, 0);
gtk_widget_show (mode); gtk_widget_show (mode);
button = gimp_prop_check_button_new (config, "fill-plain-color", button = gimp_prop_check_button_new (config, "fill-plain-color", NULL);
_("Fill the original position\n"
"of the cage with a color"));
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button); gtk_widget_show (button);

3
app/tools/gimpcloneoptions-gui.c
View File

@ -76,8 +76,7 @@ gimp_clone_options_gui (GimpToolOptions *tool_options)
gtk_container_add (GTK_CONTAINER (frame), source_vbox); gtk_container_add (GTK_CONTAINER (frame), source_vbox);
gtk_widget_show (source_vbox); gtk_widget_show (source_vbox);
button = gimp_prop_check_button_new (config, "sample-merged", button = gimp_prop_check_button_new (config, "sample-merged", NULL);
_("Sample merged"));
gtk_box_pack_start (GTK_BOX (source_vbox), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (source_vbox), button, FALSE, FALSE, 0);
g_object_bind_property_full (config, "clone-type", g_object_bind_property_full (config, "clone-type",

39
app/tools/gimpcoloroptions.c
View File

@ -65,19 +65,26 @@ gimp_color_options_class_init (GimpColorOptionsClass *klass)
object_class->set_property = gimp_color_options_set_property; object_class->set_property = gimp_color_options_set_property;
object_class->get_property = gimp_color_options_get_property; object_class->get_property = gimp_color_options_get_property;
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_SAMPLE_MERGED, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_SAMPLE_MERGED,
"sample-merged", NULL, "sample-merged",
FALSE, _("Sample merged"),
GIMP_PARAM_STATIC_STRINGS); NULL,
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_SAMPLE_AVERAGE, FALSE,
"sample-average", NULL, GIMP_PARAM_STATIC_STRINGS);
TRUE,
GIMP_PARAM_STATIC_STRINGS); GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_SAMPLE_AVERAGE,
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_AVERAGE_RADIUS, "sample-average",
"average-radius", _("Sample average"),
_("Color Picker Average Radius"), NULL,
1.0, 300.0, 3.0, TRUE,
GIMP_PARAM_STATIC_STRINGS); GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_AVERAGE_RADIUS,
"average-radius",
_("Radius"),
_("Color Picker Average Radius"),
1.0, 300.0, 3.0,
GIMP_PARAM_STATIC_STRINGS);
} }
static void static void
@ -154,14 +161,12 @@ gimp_color_options_gui (GimpToolOptions *tool_options)
gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame); gtk_widget_show (frame);
scale = gimp_prop_spin_scale_new (config, "average-radius", scale = gimp_prop_spin_scale_new (config, "average-radius", NULL,
_("Radius"),
1.0, 10.0, 0); 1.0, 10.0, 0);
gtk_container_add (GTK_CONTAINER (frame), scale); gtk_container_add (GTK_CONTAINER (frame), scale);
gtk_widget_show (scale); gtk_widget_show (scale);
button = gimp_prop_check_button_new (config, "sample-average", button = gimp_prop_check_button_new (config, "sample-average", NULL);
_("Sample average"));
gtk_frame_set_label_widget (GTK_FRAME (frame), button); gtk_frame_set_label_widget (GTK_FRAME (frame), button);
gtk_widget_show (button); gtk_widget_show (button);

42
app/tools/gimpcolorpickeroptions.c
View File

@ -64,24 +64,29 @@ gimp_color_picker_options_class_init (GimpColorPickerOptionsClass *klass)
object_class->get_property = gimp_color_picker_options_get_property; object_class->get_property = gimp_color_picker_options_get_property;
/* override a GimpColorOptions property to get a different default value */ /* override a GimpColorOptions property to get a different default value */
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_SAMPLE_AVERAGE, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_SAMPLE_AVERAGE,
"sample-average", "sample-average",
_("Use accumulated color value from " _("Sample average"),
"all composited visible layers"), _("Use accumulated color value from "
FALSE, "all composited visible layers"),
GIMP_PARAM_STATIC_STRINGS); FALSE,
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_PICK_MODE,
"pick-mode",
_("Choose what color picker will do"),
GIMP_TYPE_COLOR_PICK_MODE,
GIMP_COLOR_PICK_MODE_FOREGROUND,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_USE_INFO_WINDOW,
"use-info-window",
_("Open a floating dialog to view picked "
"color values in various color models"),
FALSE,
GIMP_PARAM_STATIC_STRINGS); GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_PICK_MODE,
"pick-mode",
_("Pick Mode"),
_("Choose what color picker will do"),
GIMP_TYPE_COLOR_PICK_MODE,
GIMP_COLOR_PICK_MODE_FOREGROUND,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_USE_INFO_WINDOW,
"use-info-window",
_("Use info window"),
_("Open a floating dialog to view picked "
"color values in various color models"),
FALSE,
GIMP_PARAM_STATIC_STRINGS);
} }
static void static void
@ -154,8 +159,7 @@ gimp_color_picker_options_gui (GimpToolOptions *tool_options)
GdkModifierType toggle_mask = gimp_get_toggle_behavior_mask (); GdkModifierType toggle_mask = gimp_get_toggle_behavior_mask ();
/* the sample merged toggle button */ /* the sample merged toggle button */
button = gimp_prop_check_button_new (config, "sample-merged", button = gimp_prop_check_button_new (config, "sample-merged", NULL);
_("Sample merged"));
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button); gtk_widget_show (button);

3
app/tools/gimpconvolvetool.c
View File

@ -221,8 +221,7 @@ gimp_convolve_options_gui (GimpToolOptions *tool_options)
g_free (str); g_free (str);
/* the rate scale */ /* the rate scale */
scale = gimp_prop_spin_scale_new (config, "rate", scale = gimp_prop_spin_scale_new (config, "rate", NULL,
C_("convolve-tool", "Rate"),
1.0, 10.0, 1); 1.0, 10.0, 1);
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
gtk_widget_show (scale); gtk_widget_show (scale);

43
app/tools/gimpcropoptions.c
View File

@ -71,25 +71,28 @@ gimp_crop_options_class_init (GimpCropOptionsClass *klass)
/* The 'highlight' property is defined here because we want different /* The 'highlight' property is defined here because we want different
* default values for the Crop and the Rectangle Select tools. * default values for the Crop and the Rectangle Select tools.
*/ */
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, GIMP_CONFIG_PROP_BOOLEAN (object_class,
GIMP_RECTANGLE_OPTIONS_PROP_HIGHLIGHT, GIMP_RECTANGLE_OPTIONS_PROP_HIGHLIGHT,
"highlight", "highlight",
_("Dim everything outside selection"), _("Highlight"),
TRUE, _("Dim everything outside selection"),
GIMP_PARAM_STATIC_STRINGS); TRUE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_LAYER_ONLY, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_LAYER_ONLY,
"layer-only", "layer-only",
_("Crop only currently selected layer"), _("Current layer only"),
FALSE, _("Crop only currently selected layer"),
GIMP_PARAM_STATIC_STRINGS); FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_ALLOW_GROWING, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_ALLOW_GROWING,
"allow-growing", "allow-growing",
_("Allow resizing canvas by dragging cropping frame " _("Allow growing"),
"beyond image boundary"), _("Allow resizing canvas by dragging cropping frame "
FALSE, "beyond image boundary"),
GIMP_PARAM_STATIC_STRINGS); FALSE,
GIMP_PARAM_STATIC_STRINGS);
gimp_rectangle_options_install_properties (object_class); gimp_rectangle_options_install_properties (object_class);
} }
@ -161,14 +164,12 @@ gimp_crop_options_gui (GimpToolOptions *tool_options)
GtkWidget *button; GtkWidget *button;
/* layer toggle */ /* layer toggle */
button = gimp_prop_check_button_new (config, "layer-only", button = gimp_prop_check_button_new (config, "layer-only", NULL);
_("Current layer only"));
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button); gtk_widget_show (button);
/* allow growing toggle */ /* allow growing toggle */
button = gimp_prop_check_button_new (config, "allow-growing", button = gimp_prop_check_button_new (config, "allow-growing", NULL);
_("Allow growing"));
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button); gtk_widget_show (button);

6
app/tools/gimpdodgeburntool.c
View File

@ -228,13 +228,13 @@ gimp_dodge_burn_options_gui (GimpToolOptions *tool_options)
g_free (str); g_free (str);
/* mode (highlights, midtones, or shadows) */ /* mode (highlights, midtones, or shadows) */
frame = gimp_prop_enum_radio_frame_new (config, "mode", _("Range"), 0, 0); frame = gimp_prop_enum_radio_frame_new (config, "mode", NULL,
0, 0);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame); gtk_widget_show (frame);
/* the exposure scale */ /* the exposure scale */
scale = gimp_prop_spin_scale_new (config, "exposure", scale = gimp_prop_spin_scale_new (config, "exposure", NULL,
_("Exposure"),
1.0, 10.0, 1); 1.0, 10.0, 1);
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
gtk_widget_show (scale); gtk_widget_show (scale);

13
app/tools/gimpflipoptions.c
View File

@ -62,12 +62,13 @@ gimp_flip_options_class_init (GimpFlipOptionsClass *klass)
object_class->set_property = gimp_flip_options_set_property; object_class->set_property = gimp_flip_options_set_property;
object_class->get_property = gimp_flip_options_get_property; object_class->get_property = gimp_flip_options_get_property;
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_FLIP_TYPE, GIMP_CONFIG_PROP_ENUM (object_class, PROP_FLIP_TYPE,
"flip-type", "flip-type",
N_("Direction of flipping"), _("Flip Type"),
GIMP_TYPE_ORIENTATION_TYPE, _("Direction of flipping"),
GIMP_ORIENTATION_HORIZONTAL, GIMP_TYPE_ORIENTATION_TYPE,
GIMP_PARAM_STATIC_STRINGS); GIMP_ORIENTATION_HORIZONTAL,
GIMP_PARAM_STATIC_STRINGS);
} }
static void static void

101
app/tools/gimpforegroundselectoptions.c
View File

@ -79,51 +79,58 @@ gimp_foreground_select_options_class_init (GimpForegroundSelectOptionsClass *kla
/* override the antialias default value from GimpSelectionOptions */ /* override the antialias default value from GimpSelectionOptions */
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_DRAW_MODE, GIMP_CONFIG_PROP_ENUM (object_class, PROP_DRAW_MODE,
"draw-mode", "draw-mode",
_("Paint over areas to mark color values for " _("Draw Mode"),
"inclusion or exclusion from selection"), _("Paint over areas to mark color values for "
GIMP_TYPE_MATTING_DRAW_MODE, "inclusion or exclusion from selection"),
GIMP_MATTING_DRAW_MODE_FOREGROUND, GIMP_TYPE_MATTING_DRAW_MODE,
GIMP_PARAM_STATIC_STRINGS); GIMP_MATTING_DRAW_MODE_FOREGROUND,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_INT (object_class, PROP_STROKE_WIDTH, GIMP_CONFIG_PROP_INT (object_class, PROP_STROKE_WIDTH,
"stroke-width", "stroke-width",
_("Size of the brush used for refinements"), _("Stroke width"),
1, 6000, 10, _("Size of the brush used for refinements"),
GIMP_PARAM_STATIC_STRINGS); 1, 6000, 10,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_MASK_COLOR, GIMP_CONFIG_PROP_ENUM (object_class, PROP_MASK_COLOR,
"mask-color", "mask-color",
_("Color of selection preview mask"), _("Preview color"),
GIMP_TYPE_CHANNEL_TYPE, _("Color of selection preview mask"),
GIMP_BLUE_CHANNEL, GIMP_TYPE_CHANNEL_TYPE,
GIMP_PARAM_STATIC_STRINGS); GIMP_BLUE_CHANNEL,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_ENGINE, GIMP_CONFIG_PROP_ENUM (object_class, PROP_ENGINE,
"engine", "engine",
_("Matting engine to use"), _("Engine"),
GIMP_TYPE_MATTING_ENGINE, _("Matting engine to use"),
GIMP_MATTING_ENGINE_GLOBAL, GIMP_TYPE_MATTING_ENGINE,
GIMP_PARAM_STATIC_STRINGS); GIMP_MATTING_ENGINE_GLOBAL,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_INT (object_class, PROP_LEVELS, GIMP_CONFIG_PROP_INT (object_class, PROP_LEVELS,
"levels", "levels",
_("Number of downsampled levels to use"), _("Levels"),
1, 10, 2, _("Number of downsampled levels to use"),
GIMP_PARAM_STATIC_STRINGS); 1, 10, 2,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_INT (object_class, PROP_ACTIVE_LEVELS, GIMP_CONFIG_PROP_INT (object_class, PROP_ACTIVE_LEVELS,
"active-levels", "active-levels",
_("Number of levels to perform solving"), _("Active levels"),
1, 10, 2, _("Number of levels to perform solving"),
GIMP_PARAM_STATIC_STRINGS); 1, 10, 2,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_INT (object_class, PROP_ITERATIONS, GIMP_CONFIG_PROP_INT (object_class, PROP_ITERATIONS,
"iterations", "iterations",
_("Number of iterations to perform"), _("Iterations"),
1, 10, 2, _("Number of iterations to perform"),
GIMP_PARAM_STATIC_STRINGS); 1, 10, 2,
GIMP_PARAM_STATIC_STRINGS);
} }
static void static void
@ -261,8 +268,8 @@ gimp_foreground_select_options_gui (GimpToolOptions *tool_options)
antialias_toggle = GIMP_SELECTION_OPTIONS (tool_options)->antialias_toggle; antialias_toggle = GIMP_SELECTION_OPTIONS (tool_options)->antialias_toggle;
gtk_widget_hide (antialias_toggle); gtk_widget_hide (antialias_toggle);
frame = gimp_prop_enum_radio_frame_new (config, "draw-mode", _("Draw Mode"), frame = gimp_prop_enum_radio_frame_new (config, "draw-mode", NULL,
0,0); 0, 0);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame); gtk_widget_show (frame);
@ -271,8 +278,7 @@ gimp_foreground_select_options_gui (GimpToolOptions *tool_options)
gtk_widget_show (hbox); gtk_widget_show (hbox);
/* stroke width */ /* stroke width */
scale = gimp_prop_spin_scale_new (config, "stroke-width", scale = gimp_prop_spin_scale_new (config, "stroke-width", NULL,
_("Stroke width"),
1.0, 10.0, 2); 1.0, 10.0, 2);
gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (scale), 1.0, 1000.0); gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (scale), 1.0, 1000.0);
gimp_spin_scale_set_gamma (GIMP_SPIN_SCALE (scale), 1.7); gimp_spin_scale_set_gamma (GIMP_SPIN_SCALE (scale), 1.7);
@ -320,8 +326,7 @@ gimp_foreground_select_options_gui (GimpToolOptions *tool_options)
gtk_widget_show (inner_vbox); gtk_widget_show (inner_vbox);
/* engine parameters */ /* engine parameters */
scale = gimp_prop_spin_scale_new (config, "levels", scale = gimp_prop_spin_scale_new (config, "levels", NULL,
_("Levels"),
1.0, 1.0, 0); 1.0, 1.0, 0);
gtk_box_pack_start (GTK_BOX (inner_vbox), scale, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (inner_vbox), scale, FALSE, FALSE, 0);
@ -333,8 +338,7 @@ gimp_foreground_select_options_gui (GimpToolOptions *tool_options)
GINT_TO_POINTER (GIMP_MATTING_ENGINE_LEVIN), GINT_TO_POINTER (GIMP_MATTING_ENGINE_LEVIN),
NULL); NULL);
scale = gimp_prop_spin_scale_new (config, "active-levels", scale = gimp_prop_spin_scale_new (config, "active-levels", NULL,
_("Active levels"),
1.0, 1.0, 0); 1.0, 1.0, 0);
gtk_box_pack_start (GTK_BOX (inner_vbox), scale, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (inner_vbox), scale, FALSE, FALSE, 0);
@ -346,8 +350,7 @@ gimp_foreground_select_options_gui (GimpToolOptions *tool_options)
GINT_TO_POINTER (GIMP_MATTING_ENGINE_LEVIN), GINT_TO_POINTER (GIMP_MATTING_ENGINE_LEVIN),
NULL); NULL);
scale = gimp_prop_spin_scale_new (config, "iterations", scale = gimp_prop_spin_scale_new (config, "iterations", NULL,
_("Iterations"),
1.0, 1.0, 0); 1.0, 1.0, 0);
gtk_box_pack_start (GTK_BOX (inner_vbox), scale, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (inner_vbox), scale, FALSE, FALSE, 0);

17
app/tools/gimphandletransformoptions.c
View File

@ -68,12 +68,13 @@ gimp_handle_transform_options_class_init (GimpHandleTransformOptionsClass *klass
object_class->set_property = gimp_handle_transform_options_set_property; object_class->set_property = gimp_handle_transform_options_set_property;
object_class->get_property = gimp_handle_transform_options_get_property; object_class->get_property = gimp_handle_transform_options_get_property;
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_HANDLE_MODE, GIMP_CONFIG_PROP_ENUM (object_class, PROP_HANDLE_MODE,
"handle-mode", "handle-mode",
N_("Handle mode"), _("Handle mode"),
GIMP_TYPE_TRANSFORM_HANDLE_MODE, _("Handle mode"),
GIMP_HANDLE_MODE_ADD_TRANSFORM, GIMP_TYPE_TRANSFORM_HANDLE_MODE,
GIMP_PARAM_STATIC_STRINGS); GIMP_HANDLE_MODE_ADD_TRANSFORM,
GIMP_PARAM_STATIC_STRINGS);
} }
static void static void
@ -138,8 +139,8 @@ gimp_handle_transform_options_gui (GimpToolOptions *tool_options)
GtkWidget *button; GtkWidget *button;
gint i; gint i;
frame = gimp_prop_enum_radio_frame_new (config, "handle-mode", frame = gimp_prop_enum_radio_frame_new (config, "handle-mode", NULL,
_("Handle mode"), 0, 0); 0, 0);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame); gtk_widget_show (frame);

16
app/tools/gimphistogramoptions.c
View File

@ -64,11 +64,13 @@ gimp_histogram_options_class_init (GimpHistogramOptionsClass *klass)
object_class->set_property = gimp_histogram_options_set_property; object_class->set_property = gimp_histogram_options_set_property;
object_class->get_property = gimp_histogram_options_get_property; object_class->get_property = gimp_histogram_options_get_property;
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_SCALE, GIMP_CONFIG_PROP_ENUM (object_class, PROP_SCALE,
"histogram-scale", NULL, "histogram-scale",
GIMP_TYPE_HISTOGRAM_SCALE, _("Histogram Scale"),
GIMP_HISTOGRAM_SCALE_LINEAR, NULL,
GIMP_PARAM_STATIC_STRINGS); GIMP_TYPE_HISTOGRAM_SCALE,
GIMP_HISTOGRAM_SCALE_LINEAR,
GIMP_PARAM_STATIC_STRINGS);
} }
static void static void
@ -123,8 +125,8 @@ gimp_histogram_options_gui (GimpToolOptions *tool_options)
GtkWidget *vbox = gimp_tool_options_gui (tool_options); GtkWidget *vbox = gimp_tool_options_gui (tool_options);
GtkWidget *frame; GtkWidget *frame;
frame = gimp_prop_enum_radio_frame_new (config, "histogram-scale", frame = gimp_prop_enum_radio_frame_new (config, "histogram-scale", NULL,
_("Histogram Scale"), 0, 0); 0, 0);
gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame); gtk_widget_show (frame);

12
app/tools/gimpimagemapoptions.c
View File

@ -26,6 +26,8 @@
#include "gimpimagemapoptions.h" #include "gimpimagemapoptions.h"
#include "gimp-intl.h"
enum enum
{ {
@ -62,10 +64,12 @@ gimp_image_map_options_class_init (GimpImageMapOptionsClass *klass)
object_class->set_property = gimp_image_map_options_set_property; object_class->set_property = gimp_image_map_options_set_property;
object_class->get_property = gimp_image_map_options_get_property; object_class->get_property = gimp_image_map_options_get_property;
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_PREVIEW, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_PREVIEW,
"preview", NULL, "preview",
TRUE, _("_Preview"),
GIMP_PARAM_STATIC_STRINGS); NULL,
TRUE,
GIMP_PARAM_STATIC_STRINGS);
g_object_class_install_property (object_class, PROP_REGION, g_object_class_install_property (object_class, PROP_REGION,
g_param_spec_enum ("region", g_param_spec_enum ("region",

3
app/tools/gimpimagemaptool.c
View File

@ -425,8 +425,7 @@ gimp_image_map_tool_initialize (GimpTool *tool,
/* The preview toggle */ /* The preview toggle */
toggle = gimp_prop_check_button_new (G_OBJECT (tool_info->tool_options), toggle = gimp_prop_check_button_new (G_OBJECT (tool_info->tool_options),
"preview", "preview", NULL);
_("_Preview"));
gtk_box_pack_end (GTK_BOX (vbox), toggle, FALSE, FALSE, 0); gtk_box_pack_end (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
gtk_widget_show (toggle); gtk_widget_show (toggle);

15
app/tools/gimpinkoptions-gui.c
View File

@ -61,15 +61,13 @@ gimp_ink_options_gui (GimpToolOptions *tool_options)
gtk_widget_show (vbox2); gtk_widget_show (vbox2);
/* size slider */ /* size slider */
scale = gimp_prop_spin_scale_new (config, "size", scale = gimp_prop_spin_scale_new (config, "size", NULL,
_("Size"),
1.0, 2.0, 1); 1.0, 2.0, 1);
gtk_box_pack_start (GTK_BOX (vbox2), scale, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox2), scale, FALSE, FALSE, 0);
gtk_widget_show (scale); gtk_widget_show (scale);
/* angle adjust slider */ /* angle adjust slider */
scale = gimp_prop_spin_scale_new (config, "tilt-angle", scale = gimp_prop_spin_scale_new (config, "tilt-angle", NULL,
_("Angle"),
1.0, 10.0, 1); 1.0, 10.0, 1);
gtk_box_pack_start (GTK_BOX (vbox2), scale, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox2), scale, FALSE, FALSE, 0);
gtk_widget_show (scale); gtk_widget_show (scale);
@ -84,22 +82,19 @@ gimp_ink_options_gui (GimpToolOptions *tool_options)
gtk_widget_show (vbox2); gtk_widget_show (vbox2);
/* size sens slider */ /* size sens slider */
scale = gimp_prop_spin_scale_new (config, "size-sensitivity", scale = gimp_prop_spin_scale_new (config, "size-sensitivity", NULL,
_("Size"),
0.01, 0.1, 2); 0.01, 0.1, 2);
gtk_box_pack_start (GTK_BOX (vbox2), scale, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox2), scale, FALSE, FALSE, 0);
gtk_widget_show (scale); gtk_widget_show (scale);
/* tilt sens slider */ /* tilt sens slider */
scale = gimp_prop_spin_scale_new (config, "tilt-sensitivity", scale = gimp_prop_spin_scale_new (config, "tilt-sensitivity", NULL,
_("Tilt"),
0.01, 0.1, 2); 0.01, 0.1, 2);
gtk_box_pack_start (GTK_BOX (vbox2), scale, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox2), scale, FALSE, FALSE, 0);
gtk_widget_show (scale); gtk_widget_show (scale);
/* velocity sens slider */ /* velocity sens slider */
scale = gimp_prop_spin_scale_new (config, "vel-sensitivity", scale = gimp_prop_spin_scale_new (config, "vel-sensitivity", NULL,
_("Speed"),
0.01, 0.1, 2); 0.01, 0.1, 2);
gtk_box_pack_start (GTK_BOX (vbox2), scale, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox2), scale, FALSE, FALSE, 0);
gtk_widget_show (scale); gtk_widget_show (scale);

16
app/tools/gimpiscissorsoptions.c
View File

@ -64,12 +64,13 @@ gimp_iscissors_options_class_init (GimpIscissorsOptionsClass *klass)
object_class->set_property = gimp_iscissors_options_set_property; object_class->set_property = gimp_iscissors_options_set_property;
object_class->get_property = gimp_iscissors_options_get_property; object_class->get_property = gimp_iscissors_options_get_property;
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_INTERACTIVE, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_INTERACTIVE,
"interactive", "interactive",
N_("Display future selection segment " _("Interactive boundary"),
"as you drag a control node"), _("Display future selection segment "
FALSE, "as you drag a control node"),
GIMP_PARAM_STATIC_STRINGS); FALSE,
GIMP_PARAM_STATIC_STRINGS);
} }
static void static void
@ -124,8 +125,7 @@ gimp_iscissors_options_gui (GimpToolOptions *tool_options)
GtkWidget *vbox = gimp_selection_options_gui (tool_options); GtkWidget *vbox = gimp_selection_options_gui (tool_options);
GtkWidget *button; GtkWidget *button;
button = gimp_prop_check_button_new (config, "interactive", button = gimp_prop_check_button_new (config, "interactive", NULL);
_("Interactive boundary"));
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button); gtk_widget_show (button);

29
app/tools/gimpmagnifyoptions.c
View File

@ -78,19 +78,21 @@ gimp_magnify_options_class_init (GimpMagnifyOptionsClass *klass)
object_class->set_property = gimp_magnify_options_set_property; object_class->set_property = gimp_magnify_options_set_property;
object_class->get_property = gimp_magnify_options_get_property; object_class->get_property = gimp_magnify_options_get_property;
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_AUTO_RESIZE, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_AUTO_RESIZE,
"auto-resize", "auto-resize",
_("Resize image window to accommodate " _("Auto-resize window"),
"new zoom level"), _("Resize image window to accommodate "
FALSE, "new zoom level"),
GIMP_PARAM_STATIC_STRINGS); FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_ZOOM_TYPE, GIMP_CONFIG_PROP_ENUM (object_class, PROP_ZOOM_TYPE,
"zoom-type", "zoom-type",
_("Direction of magnification"), _("Direction"),
GIMP_TYPE_ZOOM_TYPE, _("Direction of magnification"),
GIMP_ZOOM_IN, GIMP_TYPE_ZOOM_TYPE,
GIMP_PARAM_STATIC_STRINGS); GIMP_ZOOM_IN,
GIMP_PARAM_STATIC_STRINGS);
} }
static void static void
@ -181,8 +183,7 @@ gimp_magnify_options_gui (GimpToolOptions *tool_options)
toggle_mask = gimp_get_toggle_behavior_mask (); toggle_mask = gimp_get_toggle_behavior_mask ();
/* the auto_resize toggle button */ /* the auto_resize toggle button */
button = gimp_prop_check_button_new (config, "auto-resize", button = gimp_prop_check_button_new (config, "auto-resize", NULL);
_("Auto-resize window"));
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button); gtk_widget_show (button);

16
app/tools/gimpmeasureoptions.c
View File

@ -63,12 +63,13 @@ gimp_measure_options_class_init (GimpMeasureOptionsClass *klass)
object_class->set_property = gimp_measure_options_set_property; object_class->set_property = gimp_measure_options_set_property;
object_class->get_property = gimp_measure_options_get_property; object_class->get_property = gimp_measure_options_get_property;
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_USE_INFO_WINDOW, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_USE_INFO_WINDOW,
"use-info-window", "use-info-window",
N_("Open a floating dialog to view details " _("Use info window"),
"about measurements"), _("Open a floating dialog to view details "
FALSE, "about measurements"),
GIMP_PARAM_STATIC_STRINGS); FALSE,
GIMP_PARAM_STATIC_STRINGS);
} }
static void static void
@ -122,8 +123,7 @@ gimp_measure_options_gui (GimpToolOptions *tool_options)
GtkWidget *button; GtkWidget *button;
/* the use_info_window toggle button */ /* the use_info_window toggle button */
button = gimp_prop_check_button_new (config, "use-info-window", button = gimp_prop_check_button_new (config, "use-info-window", NULL);
_("Use info window"));
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button); gtk_widget_show (button);

21
app/tools/gimpmoveoptions.c
View File

@ -62,15 +62,18 @@ gimp_move_options_class_init (GimpMoveOptionsClass *klass)
object_class->set_property = gimp_move_options_set_property; object_class->set_property = gimp_move_options_set_property;
object_class->get_property = gimp_move_options_get_property; object_class->get_property = gimp_move_options_get_property;
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_MOVE_TYPE, GIMP_CONFIG_PROP_ENUM (object_class, PROP_MOVE_TYPE,
"move-type", NULL, "move-type",
GIMP_TYPE_TRANSFORM_TYPE, NULL, NULL,
GIMP_TRANSFORM_TYPE_LAYER, GIMP_TYPE_TRANSFORM_TYPE,
GIMP_PARAM_STATIC_STRINGS); GIMP_TRANSFORM_TYPE_LAYER,
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_MOVE_CURRENT, GIMP_PARAM_STATIC_STRINGS);
"move-current", NULL,
FALSE, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_MOVE_CURRENT,
GIMP_PARAM_STATIC_STRINGS); "move-current",
NULL, NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
} }
static void static void

12
app/tools/gimpmybrushoptions-gui.c
View File

@ -57,28 +57,24 @@ gimp_mybrush_options_gui (GimpToolOptions *tool_options)
gtk_widget_show (button); gtk_widget_show (button);
/* erase mode */ /* erase mode */
scale = gimp_prop_check_button_new (config, "eraser", scale = gimp_prop_check_button_new (config, "eraser", NULL);
_("Erase with this brush"));
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
gtk_widget_show (scale); gtk_widget_show (scale);
/* radius */ /* radius */
scale = gimp_prop_spin_scale_new (config, "radius", scale = gimp_prop_spin_scale_new (config, "radius", NULL,
_("Radius"),
0.1, 1.0, 2); 0.1, 1.0, 2);
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
gtk_widget_show (scale); gtk_widget_show (scale);
/* opaque */ /* opaque */
scale = gimp_prop_spin_scale_new (config, "opaque", scale = gimp_prop_spin_scale_new (config, "opaque", NULL,
_("Base Opacity"),
0.1, 1.0, 2); 0.1, 1.0, 2);
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
gtk_widget_show (scale); gtk_widget_show (scale);
/* hardness */ /* hardness */
scale = gimp_prop_spin_scale_new (config, "hardness", scale = gimp_prop_spin_scale_new (config, "hardness", NULL,
_("Hardness"),
0.1, 1.0, 2); 0.1, 1.0, 2);
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
gtk_widget_show (scale); gtk_widget_show (scale);

80
app/tools/gimpnpointdeformationoptions.c
View File

@ -72,36 +72,47 @@ gimp_n_point_deformation_options_class_init (GimpNPointDeformationOptionsClass *
object_class->set_property = gimp_n_point_deformation_options_set_property; object_class->set_property = gimp_n_point_deformation_options_set_property;
object_class->get_property = gimp_n_point_deformation_options_get_property; object_class->get_property = gimp_n_point_deformation_options_get_property;
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_SQUARE_SIZE, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_SQUARE_SIZE,
"square-size", _("Density"), "square-size",
5.0, 1000.0, 20.0, _("Density"),
GIMP_PARAM_STATIC_STRINGS); _("Density"),
5.0, 1000.0, 20.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_RIGIDITY, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_RIGIDITY,
"rigidity", _("Rigidity"), "rigidity",
1.0, 10000.0, 100.0, _("Rigidity"),
GIMP_PARAM_STATIC_STRINGS); _("Rigidity"),
1.0, 10000.0, 100.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_ASAP_DEFORMATION, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_ASAP_DEFORMATION,
"asap-deformation", _("Deformation mode"), "asap-deformation",
FALSE, _("Deformation mode"),
GIMP_PARAM_STATIC_STRINGS); _("Deformation mode"),
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_MLS_WEIGHTS, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_MLS_WEIGHTS,
"mls-weights", _("Use weights"), "mls-weights",
FALSE, _("Use weights"),
GIMP_PARAM_STATIC_STRINGS); _("Use weights"),
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_MLS_WEIGHTS_ALPHA, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_MLS_WEIGHTS_ALPHA,
"mls-weights-alpha", "mls-weights-alpha",
_("Amount of control points' influence"), _("Control points influence"),
0.1, 2.0, 1.0, _("Amount of control points' influence"),
GIMP_PARAM_STATIC_STRINGS); 0.1, 2.0, 1.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_MESH_VISIBLE, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_MESH_VISIBLE,
"mesh-visible", _("Show lattice"), "mesh-visible",
TRUE, _("Show lattice"),
GIMP_PARAM_STATIC_STRINGS); _("Show lattice"),
TRUE,
GIMP_PARAM_STATIC_STRINGS);
} }
static void static void
@ -193,44 +204,41 @@ gimp_n_point_deformation_options_gui (GimpToolOptions *tool_options)
npd_options = GIMP_N_POINT_DEFORMATION_OPTIONS (tool_options); npd_options = GIMP_N_POINT_DEFORMATION_OPTIONS (tool_options);
widget = gimp_prop_check_button_new (config, "mesh-visible", widget = gimp_prop_check_button_new (config, "mesh-visible", NULL);
_("Show lattice"));
npd_options->check_mesh_visible = widget; npd_options->check_mesh_visible = widget;
gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
gtk_widget_set_can_focus (widget, FALSE); gtk_widget_set_can_focus (widget, FALSE);
gtk_widget_show (widget); gtk_widget_show (widget);
widget = gimp_prop_spin_scale_new (config, "square-size", widget = gimp_prop_spin_scale_new (config, "square-size", NULL,
_("Density"), 1.0, 10.0, 0); 1.0, 10.0, 0);
npd_options->scale_square_size = widget; npd_options->scale_square_size = widget;
gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (widget), 10.0, 100.0); gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (widget), 10.0, 100.0);
gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
gtk_widget_set_can_focus (widget, FALSE); gtk_widget_set_can_focus (widget, FALSE);
gtk_widget_show (widget); gtk_widget_show (widget);
widget = gimp_prop_spin_scale_new (config, "rigidity", widget = gimp_prop_spin_scale_new (config, "rigidity", NULL,
_("Rigidity"), 1.0, 10.0, 0); 1.0, 10.0, 0);
gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (widget), 1.0, 2000.0); gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (widget), 1.0, 2000.0);
gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
gtk_widget_set_can_focus (widget, FALSE); gtk_widget_set_can_focus (widget, FALSE);
gtk_widget_show (widget); gtk_widget_show (widget);
widget = gimp_prop_boolean_radio_frame_new (config, "asap-deformation", widget = gimp_prop_boolean_radio_frame_new (config, "asap-deformation",
_("Deformation mode"), NULL,
_("Scale"), _("Scale"),
_("Rigid (Rubber)")); _("Rigid (Rubber)"));
gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
gtk_widget_set_can_focus (widget, FALSE); gtk_widget_set_can_focus (widget, FALSE);
gtk_widget_show (widget); gtk_widget_show (widget);
widget = gimp_prop_check_button_new (config, "mls-weights", widget = gimp_prop_check_button_new (config, "mls-weights", NULL);
_("Use weights"));
gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
gtk_widget_set_can_focus (widget, FALSE); gtk_widget_set_can_focus (widget, FALSE);
gtk_widget_show (widget); gtk_widget_show (widget);
widget = gimp_prop_spin_scale_new (config, "mls-weights-alpha", widget = gimp_prop_spin_scale_new (config, "mls-weights-alpha", NULL,
_("Amount of control points' influence"),
0.1, 0.1, 1); 0.1, 0.1, 1);
gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (widget), 0.1, 2.0); gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (widget), 0.1, 2.0);
gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);

58
app/tools/gimppaintoptions-gui.c
View File

@ -81,7 +81,6 @@ static GtkWidget * smoothing_options_gui (GimpPaintOptions *paint_options,
static GtkWidget * gimp_paint_options_gui_scale_with_buttons static GtkWidget * gimp_paint_options_gui_scale_with_buttons
(GObject *config, (GObject *config,
gchar *prop_name, gchar *prop_name,
gchar *prop_descr,
gchar *link_prop_name, gchar *link_prop_name,
gchar *reset_tooltip, gchar *reset_tooltip,
gdouble step_increment, gdouble step_increment,
@ -127,8 +126,7 @@ gimp_paint_options_gui (GimpToolOptions *tool_options)
} }
/* the opacity scale */ /* the opacity scale */
scale = gimp_prop_spin_scale_new (config, "opacity", scale = gimp_prop_spin_scale_new (config, "opacity", NULL,
_("Opacity"),
0.01, 0.1, 0); 0.01, 0.1, 0);
gimp_prop_widget_set_factor (scale, 100.0, 0.0, 0.0, 1); gimp_prop_widget_set_factor (scale, 100.0, 0.0, 0.0, 1);
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
@ -140,8 +138,7 @@ gimp_paint_options_gui (GimpToolOptions *tool_options)
{ {
GtkWidget *button; GtkWidget *button;
button = gimp_prop_check_button_new (config, "use-applicator", button = gimp_prop_check_button_new (config, "use-applicator", NULL);
"Use GimpApplicator");
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button); gtk_widget_show (button);
} }
@ -164,7 +161,7 @@ gimp_paint_options_gui (GimpToolOptions *tool_options)
link_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); link_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
hbox = gimp_paint_options_gui_scale_with_buttons hbox = gimp_paint_options_gui_scale_with_buttons
(config, "brush-size", _("Size"), "brush-link-size", (config, "brush-size", "brush-link-size",
_("Reset size to brush's native size"), _("Reset size to brush's native size"),
1.0, 10.0, 2, 1.0, 1000.0, 1.0, 1.7, 1.0, 10.0, 2, 1.0, 1000.0, 1.0, 1.7,
G_CALLBACK (gimp_paint_options_gui_reset_size), link_group); G_CALLBACK (gimp_paint_options_gui_reset_size), link_group);
@ -172,7 +169,7 @@ gimp_paint_options_gui (GimpToolOptions *tool_options)
gtk_widget_show (hbox); gtk_widget_show (hbox);
hbox = gimp_paint_options_gui_scale_with_buttons hbox = gimp_paint_options_gui_scale_with_buttons
(config, "brush-aspect-ratio", _("Aspect Ratio"), "brush-link-aspect-ratio", (config, "brush-aspect-ratio", "brush-link-aspect-ratio",
_("Reset aspect ratio to brush's native"), _("Reset aspect ratio to brush's native"),
0.1, 1.0, 2, -20.0, 20.0, 1.0, 1.0, 0.1, 1.0, 2, -20.0, 20.0, 1.0, 1.0,
G_CALLBACK (gimp_paint_options_gui_reset_aspect_ratio), link_group); G_CALLBACK (gimp_paint_options_gui_reset_aspect_ratio), link_group);
@ -180,7 +177,7 @@ gimp_paint_options_gui (GimpToolOptions *tool_options)
gtk_widget_show (hbox); gtk_widget_show (hbox);
hbox = gimp_paint_options_gui_scale_with_buttons hbox = gimp_paint_options_gui_scale_with_buttons
(config, "brush-angle", _("Angle"), "brush-link-angle", (config, "brush-angle", "brush-link-angle",
_("Reset angle to zero"), _("Reset angle to zero"),
0.1, 1.0, 2, -180.0, 180.0, 1.0, 1.0, 0.1, 1.0, 2, -180.0, 180.0, 1.0, 1.0,
G_CALLBACK (gimp_paint_options_gui_reset_angle), link_group); G_CALLBACK (gimp_paint_options_gui_reset_angle), link_group);
@ -188,7 +185,7 @@ gimp_paint_options_gui (GimpToolOptions *tool_options)
gtk_widget_show (hbox); gtk_widget_show (hbox);
hbox = gimp_paint_options_gui_scale_with_buttons hbox = gimp_paint_options_gui_scale_with_buttons
(config, "brush-spacing", _("Spacing"), "brush-link-spacing", (config, "brush-spacing", "brush-link-spacing",
_("Reset spacing to brush's native spacing"), _("Reset spacing to brush's native spacing"),
0.1, 1.0, 1, 1.0, 200.0, 100.0, 1.7, 0.1, 1.0, 1, 1.0, 200.0, 100.0, 1.7,
G_CALLBACK (gimp_paint_options_gui_reset_spacing), link_group); G_CALLBACK (gimp_paint_options_gui_reset_spacing), link_group);
@ -196,7 +193,7 @@ gimp_paint_options_gui (GimpToolOptions *tool_options)
gtk_widget_show (hbox); gtk_widget_show (hbox);
hbox = gimp_paint_options_gui_scale_with_buttons hbox = gimp_paint_options_gui_scale_with_buttons
(config, "brush-hardness", _("Hardness"), "brush-link-hardness", (config, "brush-hardness", "brush-link-hardness",
_("Reset hardness to default"), _("Reset hardness to default"),
0.1, 1.0, 1, 0.0, 100.0, 100.0, 1.0, 0.1, 1.0, 1, 0.0, 100.0, 100.0, 1.0,
G_CALLBACK (gimp_paint_options_gui_reset_hardness), link_group); G_CALLBACK (gimp_paint_options_gui_reset_hardness), link_group);
@ -204,7 +201,7 @@ gimp_paint_options_gui (GimpToolOptions *tool_options)
gtk_widget_show (hbox); gtk_widget_show (hbox);
hbox = gimp_paint_options_gui_scale_with_buttons hbox = gimp_paint_options_gui_scale_with_buttons
(config, "brush-force", _("Force"), NULL, (config, "brush-force", NULL,
_("Reset force to default"), _("Reset force to default"),
0.1, 1.0, 1, 0.0, 100.0, 100.0, 1.0, 0.1, 1.0, 1, 0.0, 100.0, 100.0, 1.0,
G_CALLBACK (gimp_paint_options_gui_reset_force), link_group); G_CALLBACK (gimp_paint_options_gui_reset_force), link_group);
@ -249,8 +246,7 @@ gimp_paint_options_gui (GimpToolOptions *tool_options)
{ {
GtkWidget *button; GtkWidget *button;
button = gimp_prop_check_button_new (config, button = gimp_prop_check_button_new (config, "brush-zoom",
"brush-zoom",
_("Lock brush size to zoom")); _("Lock brush size to zoom"));
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button); gtk_widget_show (button);
@ -263,9 +259,8 @@ gimp_paint_options_gui (GimpToolOptions *tool_options)
{ {
GtkWidget *button; GtkWidget *button;
button = gimp_prop_enum_check_button_new (config, button = gimp_prop_enum_check_button_new (config, "application-mode",
"application-mode", NULL,
_("Incremental"),
GIMP_PAINT_CONSTANT, GIMP_PAINT_CONSTANT,
GIMP_PAINT_INCREMENTAL); GIMP_PAINT_INCREMENTAL);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
@ -283,7 +278,7 @@ gimp_paint_options_gui (GimpToolOptions *tool_options)
{ {
GtkWidget *button; GtkWidget *button;
button = gimp_prop_check_button_new (config, "hard", _("Hard edge")); button = gimp_prop_check_button_new (config, "hard", NULL);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button); gtk_widget_show (button);
} }
@ -310,8 +305,7 @@ dynamics_options_gui (GimpPaintOptions *paint_options,
GtkWidget *hbox; GtkWidget *hbox;
GtkWidget *box; GtkWidget *box;
frame = gimp_prop_expander_new (config, "dynamics-expanded", frame = gimp_prop_expander_new (config, "dynamics-expanded", NULL);
_("Dynamics Options"));
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_container_add (GTK_CONTAINER (frame), vbox);
@ -330,8 +324,8 @@ dynamics_options_gui (GimpPaintOptions *paint_options,
gtk_box_pack_start (GTK_BOX (inner_vbox), hbox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (inner_vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox); gtk_widget_show (hbox);
scale = gimp_prop_spin_scale_new (config, "fade-length", scale = gimp_prop_spin_scale_new (config, "fade-length", NULL,
_("Fade length"), 1.0, 50.0, 0); 1.0, 50.0, 0);
gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (scale), 1.0, 1000.0); gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (scale), 1.0, 1000.0);
gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0);
gtk_widget_show (scale); gtk_widget_show (scale);
@ -353,8 +347,7 @@ dynamics_options_gui (GimpPaintOptions *paint_options,
gtk_box_pack_start (GTK_BOX (inner_vbox), combo, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (inner_vbox), combo, TRUE, TRUE, 0);
gtk_widget_show (combo); gtk_widget_show (combo);
checkbox = gimp_prop_check_button_new (config, "fade-reverse", checkbox = gimp_prop_check_button_new (config, "fade-reverse", NULL);
_("Reverse"));
gtk_box_pack_start (GTK_BOX (inner_vbox), checkbox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (inner_vbox), checkbox, FALSE, FALSE, 0);
gtk_widget_show (checkbox); gtk_widget_show (checkbox);
@ -386,12 +379,10 @@ jitter_options_gui (GimpPaintOptions *paint_options,
GtkWidget *frame; GtkWidget *frame;
GtkWidget *scale; GtkWidget *scale;
scale = gimp_prop_spin_scale_new (config, "jitter-amount", scale = gimp_prop_spin_scale_new (config, "jitter-amount", NULL,
_("Amount"),
0.01, 1.0, 2); 0.01, 1.0, 2);
frame = gimp_prop_expanding_frame_new (config, "use-jitter", frame = gimp_prop_expanding_frame_new (config, "use-jitter", NULL,
_("Apply Jitter"),
scale, NULL); scale, NULL);
return frame; return frame;
@ -408,18 +399,15 @@ smoothing_options_gui (GimpPaintOptions *paint_options,
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
frame = gimp_prop_expanding_frame_new (config, "use-smoothing", frame = gimp_prop_expanding_frame_new (config, "use-smoothing", NULL,
_("Smooth stroke"),
vbox, NULL); vbox, NULL);
scale = gimp_prop_spin_scale_new (config, "smoothing-quality", scale = gimp_prop_spin_scale_new (config, "smoothing-quality", NULL,
_("Quality"),
1, 10, 1); 1, 10, 1);
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
gtk_widget_show (scale); gtk_widget_show (scale);
scale = gimp_prop_spin_scale_new (config, "smoothing-factor", scale = gimp_prop_spin_scale_new (config, "smoothing-factor", NULL,
_("Weight"),
1, 10, 1); 1, 10, 1);
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
gtk_widget_show (scale); gtk_widget_show (scale);
@ -516,7 +504,6 @@ gimp_paint_options_gui_reset_force (GtkWidget *button,
static GtkWidget * static GtkWidget *
gimp_paint_options_gui_scale_with_buttons (GObject *config, gimp_paint_options_gui_scale_with_buttons (GObject *config,
gchar *prop_name, gchar *prop_name,
gchar *prop_descr,
gchar *link_prop_name, gchar *link_prop_name,
gchar *reset_tooltip, gchar *reset_tooltip,
gdouble step_increment, gdouble step_increment,
@ -535,8 +522,7 @@ gimp_paint_options_gui_scale_with_buttons (GObject *config,
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
scale = gimp_prop_spin_scale_new (config, prop_name, scale = gimp_prop_spin_scale_new (config, prop_name, NULL,
prop_descr,
step_increment, page_increment, digits); step_increment, page_increment, digits);
gimp_prop_widget_set_factor (scale, factor, gimp_prop_widget_set_factor (scale, factor,
step_increment, page_increment, digits); step_increment, page_increment, digits);

4
app/tools/gimpperspectiveclonetool.c
View File

@ -877,7 +877,9 @@ gimp_perspective_clone_options_gui (GimpToolOptions *tool_options)
GtkWidget *vbox = gimp_clone_options_gui (tool_options); GtkWidget *vbox = gimp_clone_options_gui (tool_options);
GtkWidget *mode; GtkWidget *mode;
/* radio buttons to set if you are modifying perspe plane or painting */ /* radio buttons to set if you are modifying the perspective plane
* or painting
*/
mode = gimp_prop_enum_radio_box_new (config, "clone-mode", 0, 0); mode = gimp_prop_enum_radio_box_new (config, "clone-mode", 0, 0);
gtk_box_pack_start (GTK_BOX (vbox), mode, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), mode, FALSE, FALSE, 0);
gtk_box_reorder_child (GTK_BOX (vbox), mode, 0); gtk_box_reorder_child (GTK_BOX (vbox), mode, 0);

20
app/tools/gimprectangleoptions.c
View File

@ -110,9 +110,9 @@ gimp_rectangle_options_iface_base_init (GimpRectangleOptionsInterface *iface)
g_object_interface_install_property (iface, g_object_interface_install_property (iface,
g_param_spec_boolean ("shrink-merged", g_param_spec_boolean ("shrink-merged",
NULL, _("Shrink merged"),
N_("Use all visible layers when shrinking " _("Use all visible layers when shrinking "
"the selection"), "the selection"),
FALSE, FALSE,
GIMP_CONFIG_PARAM_FLAGS | GIMP_CONFIG_PARAM_FLAGS |
GIMP_PARAM_STATIC_STRINGS)); GIMP_PARAM_STATIC_STRINGS));
@ -314,8 +314,8 @@ gimp_rectangle_options_iface_base_init (GimpRectangleOptionsInterface *iface)
g_object_interface_install_property (iface, g_object_interface_install_property (iface,
g_param_spec_boolean ("fixed-center", g_param_spec_boolean ("fixed-center",
NULL, _("Expand from center"),
N_("Expand selection from center outwards"), _("Expand selection from center outwards"),
FALSE, FALSE,
GIMP_CONFIG_PARAM_FLAGS | GIMP_CONFIG_PARAM_FLAGS |
GIMP_PARAM_STATIC_STRINGS)); GIMP_PARAM_STATIC_STRINGS));
@ -836,8 +836,7 @@ gimp_rectangle_options_gui (GimpToolOptions *tool_options)
private = GIMP_RECTANGLE_OPTIONS_GET_PRIVATE (tool_options); private = GIMP_RECTANGLE_OPTIONS_GET_PRIVATE (tool_options);
/* Fixed Center */ /* Fixed Center */
button = gimp_prop_check_button_new (config, "fixed-center", button = gimp_prop_check_button_new (config, "fixed-center", NULL);
_("Expand from center"));
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button); gtk_widget_show (button);
@ -860,6 +859,7 @@ gimp_rectangle_options_gui (GimpToolOptions *tool_options)
gtk_widget_show (hbox); gtk_widget_show (hbox);
button = gimp_prop_check_button_new (config, "fixed-rule-active", NULL); button = gimp_prop_check_button_new (config, "fixed-rule-active", NULL);
gtk_widget_destroy (gtk_bin_get_child (GTK_BIN (button)));
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, TRUE, 0); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, TRUE, 0);
gtk_widget_show (button); gtk_widget_show (button);
@ -1026,8 +1026,7 @@ gimp_rectangle_options_gui (GimpToolOptions *tool_options)
gtk_widget_show (frame); gtk_widget_show (frame);
/* Highlight */ /* Highlight */
button = gimp_prop_check_button_new (config, "highlight", button = gimp_prop_check_button_new (config, "highlight", NULL);
_("Highlight"));
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button); gtk_widget_show (button);
@ -1048,8 +1047,7 @@ gimp_rectangle_options_gui (GimpToolOptions *tool_options)
g_object_add_weak_pointer (G_OBJECT (private->auto_shrink_button), g_object_add_weak_pointer (G_OBJECT (private->auto_shrink_button),
(gpointer) &private->auto_shrink_button); (gpointer) &private->auto_shrink_button);
button = gimp_prop_check_button_new (config, "shrink-merged", button = gimp_prop_check_button_new (config, "shrink-merged", NULL);
_("Shrink merged"));
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button); gtk_widget_show (button);

41
app/tools/gimprectangleselectoptions.c
View File

@ -72,24 +72,27 @@ gimp_rectangle_select_options_class_init (GimpRectangleSelectOptionsClass *klass
/* The 'highlight' property is defined here because we want different /* The 'highlight' property is defined here because we want different
* default values for the Crop and the Rectangle Select tools. * default values for the Crop and the Rectangle Select tools.
*/ */
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, GIMP_CONFIG_PROP_BOOLEAN (object_class,
GIMP_RECTANGLE_OPTIONS_PROP_HIGHLIGHT, GIMP_RECTANGLE_OPTIONS_PROP_HIGHLIGHT,
"highlight", "highlight",
_("Dim everything outside selection"), _("Highlight"),
FALSE, _("Dim everything outside selection"),
GIMP_PARAM_STATIC_STRINGS); FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_ROUND_CORNERS, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_ROUND_CORNERS,
"round-corners", "round-corners",
_("Round corners of selection"), _("Rounded corners"),
FALSE, _("Round corners of selection"),
GIMP_PARAM_STATIC_STRINGS); FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_CORNER_RADIUS, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_CORNER_RADIUS,
"corner-radius", "corner-radius",
_("Radius of rounding in pixels"), _("Radius"),
0.0, 100.0, 5.0, _("Radius of rounding in pixels"),
GIMP_PARAM_STATIC_STRINGS); 0.0, 100.0, 5.0,
GIMP_PARAM_STATIC_STRINGS);
gimp_rectangle_options_install_properties (object_class); gimp_rectangle_options_install_properties (object_class);
} }
@ -160,12 +163,10 @@ gimp_rectangle_select_options_gui (GimpToolOptions *tool_options)
GtkWidget *scale; GtkWidget *scale;
GtkWidget *toggle; GtkWidget *toggle;
scale = gimp_prop_spin_scale_new (config, "corner-radius", scale = gimp_prop_spin_scale_new (config, "corner-radius", NULL,
_("Radius"),
1.0, 10.0, 1); 1.0, 10.0, 1);
frame = gimp_prop_expanding_frame_new (config, "round-corners", frame = gimp_prop_expanding_frame_new (config, "round-corners", NULL,
_("Rounded corners"),
scale, NULL); scale, NULL);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame); gtk_widget_show (frame);

78
app/tools/gimpregionselectoptions.c
View File

@ -84,42 +84,47 @@ gimp_region_select_options_class_init (GimpRegionSelectOptionsClass *klass)
object_class->set_property = gimp_region_select_options_set_property; object_class->set_property = gimp_region_select_options_set_property;
object_class->get_property = gimp_region_select_options_get_property; object_class->get_property = gimp_region_select_options_get_property;
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_SELECT_TRANSPARENT, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_SELECT_TRANSPARENT,
"select-transparent", "select-transparent",
_("Allow completely transparent regions " _("Select transparent areas"),
"to be selected"), _("Allow completely transparent regions "
TRUE, "to be selected"),
GIMP_PARAM_STATIC_STRINGS); TRUE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_SAMPLE_MERGED, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_SAMPLE_MERGED,
"sample-merged", "sample-merged",
_("Base selection on all visible layers"), _("Sample merged"),
FALSE, _("Base selection on all visible layers"),
GIMP_PARAM_STATIC_STRINGS); FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_DIAGONAL_NEIGHBORS, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_DIAGONAL_NEIGHBORS,
"diagonal-neighbors", "diagonal-neighbors",
_("Treat diagonally neighboring pixels as " _("Diagonal neighbors"),
"connected"), _("Treat diagonally neighboring pixels as "
FALSE, "connected"),
GIMP_PARAM_STATIC_STRINGS); FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_THRESHOLD, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_THRESHOLD,
"threshold", "threshold",
_("Maximum color difference"), _("Threshold"),
0.0, 255.0, 15.0, _("Maximum color difference"),
GIMP_PARAM_STATIC_STRINGS); 0.0, 255.0, 15.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_SELECT_CRITERION, GIMP_CONFIG_PROP_ENUM (object_class, PROP_SELECT_CRITERION,
"select-criterion", "select-criterion",
_("Selection criterion"), _("Select by"),
GIMP_TYPE_SELECT_CRITERION, _("Selection criterion"),
GIMP_SELECT_CRITERION_COMPOSITE, GIMP_TYPE_SELECT_CRITERION,
GIMP_PARAM_STATIC_STRINGS); GIMP_SELECT_CRITERION_COMPOSITE,
GIMP_PARAM_STATIC_STRINGS);
g_object_class_install_property (object_class, PROP_DRAW_MASK, g_object_class_install_property (object_class, PROP_DRAW_MASK,
g_param_spec_boolean ("draw-mask", g_param_spec_boolean ("draw-mask",
"Draw mask", _("Draw mask"),
_("Draw the selected region's mask"), _("Draw the selected region's mask"),
FALSE, FALSE,
G_PARAM_READWRITE | G_PARAM_READWRITE |
@ -248,29 +253,25 @@ gimp_region_select_options_gui (GimpToolOptions *tool_options)
tool_type = tool_options->tool_info->tool_type; tool_type = tool_options->tool_info->tool_type;
/* the select transparent areas toggle */ /* the select transparent areas toggle */
button = gimp_prop_check_button_new (config, "select-transparent", button = gimp_prop_check_button_new (config, "select-transparent", NULL);
_("Select transparent areas"));
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button); gtk_widget_show (button);
/* the sample merged toggle */ /* the sample merged toggle */
button = gimp_prop_check_button_new (config, "sample-merged", button = gimp_prop_check_button_new (config, "sample-merged", NULL);
_("Sample merged"));
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button); gtk_widget_show (button);
/* the diagonal neighbors toggle */ /* the diagonal neighbors toggle */
if (tool_type == GIMP_TYPE_FUZZY_SELECT_TOOL) if (tool_type == GIMP_TYPE_FUZZY_SELECT_TOOL)
{ {
button = gimp_prop_check_button_new (config, "diagonal-neighbors", button = gimp_prop_check_button_new (config, "diagonal-neighbors", NULL);
_("Diagonal neighbors"));
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button); gtk_widget_show (button);
} }
/* the threshold scale */ /* the threshold scale */
scale = gimp_prop_spin_scale_new (config, "threshold", scale = gimp_prop_spin_scale_new (config, "threshold", NULL,
_("Threshold"),
1.0, 16.0, 1); 1.0, 16.0, 1);
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
gtk_widget_show (scale); gtk_widget_show (scale);
@ -282,8 +283,7 @@ gimp_region_select_options_gui (GimpToolOptions *tool_options)
gtk_widget_show (combo); gtk_widget_show (combo);
/* the show mask toggle */ /* the show mask toggle */
button = gimp_prop_check_button_new (config, "draw-mask", button = gimp_prop_check_button_new (config, "draw-mask", NULL);
_("Draw Mask"));
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button); gtk_widget_show (button);

15
app/tools/gimpseamlesscloneoptions.c
View File

@ -67,11 +67,13 @@ gimp_seamless_clone_options_class_init (GimpSeamlessCloneOptionsClass *klass)
object_class->set_property = gimp_seamless_clone_options_set_property; object_class->set_property = gimp_seamless_clone_options_set_property;
object_class->get_property = gimp_seamless_clone_options_get_property; object_class->get_property = gimp_seamless_clone_options_get_property;
GIMP_CONFIG_INSTALL_PROP_INT (object_class, PROP_MAX_REFINE_SCALE, GIMP_CONFIG_PROP_INT (object_class, PROP_MAX_REFINE_SCALE,
"max-refine-scale", "max-refine-scale",
_("Maximal scale of refinement points to be used for the interpolation mesh"), _("Refinement scale"),
0, 50, 5, _("Maximal scale of refinement points to be "
GIMP_PARAM_STATIC_STRINGS); "used for the interpolation mesh"),
0, 50, 5,
GIMP_PARAM_STATIC_STRINGS);
} }
static void static void
@ -126,8 +128,7 @@ gimp_seamless_clone_options_gui (GimpToolOptions *tool_options)
GtkWidget *vbox = gimp_tool_options_gui (tool_options); GtkWidget *vbox = gimp_tool_options_gui (tool_options);
GtkWidget *scale; GtkWidget *scale;
scale = gimp_prop_spin_scale_new (config, "max-refine-scale", scale = gimp_prop_spin_scale_new (config, "max-refine-scale", NULL,
_("Refinement scale"),
1.0, 10.0, 0); 1.0, 10.0, 0);
gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (scale), 0.0, 50.0); gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (scale), 0.0, 50.0);
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);

53
app/tools/gimpselectionoptions.c
View File

@ -68,29 +68,33 @@ gimp_selection_options_class_init (GimpSelectionOptionsClass *klass)
object_class->set_property = gimp_selection_options_set_property; object_class->set_property = gimp_selection_options_set_property;
object_class->get_property = gimp_selection_options_get_property; object_class->get_property = gimp_selection_options_get_property;
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_OPERATION, GIMP_CONFIG_PROP_ENUM (object_class, PROP_OPERATION,
"operation", NULL, "operation",
GIMP_TYPE_CHANNEL_OPS, NULL, NULL,
GIMP_CHANNEL_OP_REPLACE, GIMP_TYPE_CHANNEL_OPS,
GIMP_PARAM_STATIC_STRINGS); GIMP_CHANNEL_OP_REPLACE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_ANTIALIAS, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_ANTIALIAS,
"antialias", "antialias",
_("Smooth edges"), _("Antialiasing"),
TRUE, _("Smooth edges"),
GIMP_PARAM_STATIC_STRINGS); TRUE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_FEATHER, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_FEATHER,
"feather", "feather",
_("Enable feathering of selection edges"), _("Feather edges"),
FALSE, _("Enable feathering of selection edges"),
GIMP_PARAM_STATIC_STRINGS); FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_FEATHER_RADIUS, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_FEATHER_RADIUS,
"feather-radius", "feather-radius",
_("Radius of feathering"), _("Radius"),
0.0, 100.0, 10.0, _("Radius of feathering"),
GIMP_PARAM_STATIC_STRINGS); 0.0, 100.0, 10.0,
GIMP_PARAM_STATIC_STRINGS);
} }
static void static void
@ -261,8 +265,7 @@ gimp_selection_options_gui (GimpToolOptions *tool_options)
} }
/* the antialias toggle button */ /* the antialias toggle button */
button = gimp_prop_check_button_new (config, "antialias", button = gimp_prop_check_button_new (config, "antialias", NULL);
_("Antialiasing"));
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button); gtk_widget_show (button);
@ -274,12 +277,10 @@ gimp_selection_options_gui (GimpToolOptions *tool_options)
GtkWidget *scale; GtkWidget *scale;
/* the feather radius scale */ /* the feather radius scale */
scale = gimp_prop_spin_scale_new (config, "feather-radius", scale = gimp_prop_spin_scale_new (config, "feather-radius", NULL,
_("Radius"),
1.0, 10.0, 1); 1.0, 10.0, 1);
frame = gimp_prop_expanding_frame_new (config, "feather", frame = gimp_prop_expanding_frame_new (config, "feather", NULL,
_("Feather edges"),
scale, NULL); scale, NULL);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame); gtk_widget_show (frame);

3
app/tools/gimpsmudgetool.c
View File

@ -88,8 +88,7 @@ gimp_smudge_options_gui (GimpToolOptions *tool_options)
GtkWidget *scale; GtkWidget *scale;
/* the rate scale */ /* the rate scale */
scale = gimp_prop_spin_scale_new (config, "rate", scale = gimp_prop_spin_scale_new (config, "rate", NULL,
C_("smudge-tool", "Rate"),
1.0, 10.0, 1); 1.0, 10.0, 1);
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
gtk_widget_show (scale); gtk_widget_show (scale);

201
app/tools/gimptextoptions.c
View File

@ -124,95 +124,120 @@ gimp_text_options_class_init (GimpTextOptionsClass *klass)
/* The 'highlight' property is defined here because we want different /* The 'highlight' property is defined here because we want different
* default values for the Crop, Text and the Rectangle Select tools. * default values for the Crop, Text and the Rectangle Select tools.
*/ */
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, GIMP_CONFIG_PROP_BOOLEAN (object_class,
GIMP_RECTANGLE_OPTIONS_PROP_HIGHLIGHT, GIMP_RECTANGLE_OPTIONS_PROP_HIGHLIGHT,
"highlight", NULL, "highlight",
FALSE, _("Highlight"),
GIMP_PARAM_STATIC_STRINGS); NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_UNIT (object_class, PROP_UNIT, GIMP_CONFIG_PROP_UNIT (object_class, PROP_UNIT,
"font-size-unit", "font-size-unit",
_("Font size unit"), _("Unit"),
TRUE, FALSE, GIMP_UNIT_PIXEL, _("Font size unit"),
GIMP_PARAM_STATIC_STRINGS); TRUE, FALSE, GIMP_UNIT_PIXEL,
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_FONT_SIZE, GIMP_PARAM_STATIC_STRINGS);
"font-size", GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_FONT_SIZE,
_("Font size"), "font-size",
0.0, 8192.0, 18.0, _("Font size"),
GIMP_PARAM_STATIC_STRINGS); _("Font size"),
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_ANTIALIAS, 0.0, 8192.0, 18.0,
"antialias", NULL, GIMP_PARAM_STATIC_STRINGS);
TRUE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_HINT_STYLE,
"hint-style",
_("Hinting alters the font outline to "
"produce a crisp bitmap at small "
"sizes"),
GIMP_TYPE_TEXT_HINT_STYLE,
GIMP_TEXT_HINT_STYLE_MEDIUM,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_STRING (object_class, PROP_LANGUAGE,
"language",
_("The text language may have an effect "
"on the way the text is rendered."),
(const gchar *) gtk_get_default_language (),
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_BASE_DIR,
"base-direction", NULL,
GIMP_TYPE_TEXT_DIRECTION,
GIMP_TEXT_DIRECTION_LTR,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_JUSTIFICATION,
"justify",
_("Text alignment"),
GIMP_TYPE_TEXT_JUSTIFICATION,
GIMP_TEXT_JUSTIFY_LEFT,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_INDENTATION,
"indent",
_("Indentation of the first line"),
-8192.0, 8192.0, 0.0,
GIMP_PARAM_STATIC_STRINGS |
GIMP_CONFIG_PARAM_DEFAULTS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_LINE_SPACING,
"line-spacing",
_("Adjust line spacing"),
-8192.0, 8192.0, 0.0,
GIMP_PARAM_STATIC_STRINGS |
GIMP_CONFIG_PARAM_DEFAULTS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_LETTER_SPACING,
"letter-spacing",
_("Adjust letter spacing"),
-8192.0, 8192.0, 0.0,
GIMP_PARAM_STATIC_STRINGS |
GIMP_CONFIG_PARAM_DEFAULTS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_BOX_MODE,
"box-mode",
_("Whether text flows into rectangular shape or "
"moves into a new line when you press Enter"),
GIMP_TYPE_TEXT_BOX_MODE,
GIMP_TEXT_BOX_DYNAMIC,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_USE_EDITOR, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_ANTIALIAS,
"use-editor", "antialias",
_("Use an external editor window for text " _("Antialiasing"),
"entry"), NULL,
FALSE, TRUE,
GIMP_PARAM_STATIC_STRINGS); GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_FONT_VIEW_TYPE, GIMP_CONFIG_PROP_ENUM (object_class, PROP_HINT_STYLE,
"font-view-type", NULL, "hint-style",
GIMP_TYPE_VIEW_TYPE, _("Hinting"),
GIMP_VIEW_TYPE_LIST, _("Hinting alters the font outline to "
GIMP_PARAM_STATIC_STRINGS); "produce a crisp bitmap at small "
GIMP_CONFIG_INSTALL_PROP_INT (object_class, PROP_FONT_VIEW_SIZE, "sizes"),
"font-view-size", NULL, GIMP_TYPE_TEXT_HINT_STYLE,
GIMP_VIEW_SIZE_TINY, GIMP_TEXT_HINT_STYLE_MEDIUM,
GIMP_VIEWABLE_MAX_BUTTON_SIZE, GIMP_PARAM_STATIC_STRINGS);
GIMP_VIEW_SIZE_SMALL,
GIMP_PARAM_STATIC_STRINGS); GIMP_CONFIG_PROP_STRING (object_class, PROP_LANGUAGE,
"language",
_("Language"),
_("The text language may have an effect "
"on the way the text is rendered."),
(const gchar *) gtk_get_default_language (),
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_BASE_DIR,
"base-direction",
NULL, NULL,
GIMP_TYPE_TEXT_DIRECTION,
GIMP_TEXT_DIRECTION_LTR,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_JUSTIFICATION,
"justify",
_("Justify"),
_("Text alignment"),
GIMP_TYPE_TEXT_JUSTIFICATION,
GIMP_TEXT_JUSTIFY_LEFT,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_INDENTATION,
"indent",
_("Indentation"),
_("Indentation of the first line"),
-8192.0, 8192.0, 0.0,
GIMP_PARAM_STATIC_STRINGS |
GIMP_CONFIG_PARAM_DEFAULTS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_LINE_SPACING,
"line-spacing",
_("Line spacing"),
_("Adjust line spacing"),
-8192.0, 8192.0, 0.0,
GIMP_PARAM_STATIC_STRINGS |
GIMP_CONFIG_PARAM_DEFAULTS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_LETTER_SPACING,
"letter-spacing",
_("Letter spacing"),
_("Adjust letter spacing"),
-8192.0, 8192.0, 0.0,
GIMP_PARAM_STATIC_STRINGS |
GIMP_CONFIG_PARAM_DEFAULTS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_BOX_MODE,
"box-mode",
_("Box"),
_("Whether text flows into rectangular shape or "
"moves into a new line when you press Enter"),
GIMP_TYPE_TEXT_BOX_MODE,
GIMP_TEXT_BOX_DYNAMIC,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_USE_EDITOR,
"use-editor",
_("Use editor"),
_("Use an external editor window for text entry"),
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_FONT_VIEW_TYPE,
"font-view-type",
NULL, NULL,
GIMP_TYPE_VIEW_TYPE,
GIMP_VIEW_TYPE_LIST,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_INT (object_class, PROP_FONT_VIEW_SIZE,
"font-view-size",
NULL, NULL,
GIMP_VIEW_SIZE_TINY,
GIMP_VIEWABLE_MAX_BUTTON_SIZE,
GIMP_VIEW_SIZE_SMALL,
GIMP_PARAM_STATIC_STRINGS);
gimp_rectangle_options_install_properties (object_class); gimp_rectangle_options_install_properties (object_class);
} }
@ -544,11 +569,11 @@ gimp_text_options_gui (GimpToolOptions *tool_options)
gtk_box_pack_start (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0);
gtk_widget_show (vbox); gtk_widget_show (vbox);
button = gimp_prop_check_button_new (config, "use-editor", _("Use editor")); button = gimp_prop_check_button_new (config, "use-editor", NULL);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button); gtk_widget_show (button);
button = gimp_prop_check_button_new (config, "antialias", _("Antialiasing")); button = gimp_prop_check_button_new (config, "antialias", NULL);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button); gtk_widget_show (button);

225
app/tools/gimptransformoptions.c
View File

@ -104,101 +104,126 @@ gimp_transform_options_class_init (GimpTransformOptionsClass *klass)
object_class->set_property = gimp_transform_options_set_property; object_class->set_property = gimp_transform_options_set_property;
object_class->get_property = gimp_transform_options_get_property; object_class->get_property = gimp_transform_options_get_property;
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_TYPE, GIMP_CONFIG_PROP_ENUM (object_class, PROP_TYPE,
"type", NULL, "type",
GIMP_TYPE_TRANSFORM_TYPE, NULL, NULL,
GIMP_TRANSFORM_TYPE_LAYER, GIMP_TYPE_TRANSFORM_TYPE,
GIMP_PARAM_STATIC_STRINGS); GIMP_TRANSFORM_TYPE_LAYER,
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_DIRECTION, GIMP_PARAM_STATIC_STRINGS);
"direction",
_("Direction of transformation"), GIMP_CONFIG_PROP_ENUM (object_class, PROP_DIRECTION,
GIMP_TYPE_TRANSFORM_DIRECTION, "direction",
GIMP_TRANSFORM_FORWARD, _("Direction"),
GIMP_PARAM_STATIC_STRINGS); _("Direction of transformation"),
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_INTERPOLATION, GIMP_TYPE_TRANSFORM_DIRECTION,
"interpolation", GIMP_TRANSFORM_FORWARD,
_("Interpolation method"), GIMP_PARAM_STATIC_STRINGS);
GIMP_TYPE_INTERPOLATION_TYPE,
GIMP_INTERPOLATION_LINEAR, GIMP_CONFIG_PROP_ENUM (object_class, PROP_INTERPOLATION,
GIMP_PARAM_STATIC_STRINGS); "interpolation",
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_CLIP, _("Interpolation"),
"clip", _("Interpolation method"),
_("How to clip"), GIMP_TYPE_INTERPOLATION_TYPE,
GIMP_TYPE_TRANSFORM_RESIZE, GIMP_INTERPOLATION_LINEAR,
GIMP_TRANSFORM_RESIZE_ADJUST, GIMP_PARAM_STATIC_STRINGS);
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_SHOW_PREVIEW, GIMP_CONFIG_PROP_ENUM (object_class, PROP_CLIP,
"show-preview", "clip",
_("Show a preview of the transformed image"), _("Clipping"),
TRUE, _("How to clip"),
GIMP_PARAM_STATIC_STRINGS); GIMP_TYPE_TRANSFORM_RESIZE,
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_PREVIEW_OPACITY, GIMP_TRANSFORM_RESIZE_ADJUST,
"preview-opacity", GIMP_PARAM_STATIC_STRINGS);
_("Opacity of the preview image"),
0.0, 1.0, 1.0, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_SHOW_PREVIEW,
GIMP_PARAM_STATIC_STRINGS); "show-preview",
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_GRID_TYPE, _("Show image preview"),
"grid-type", _("Show a preview of the transformed image"),
_("Composition guides such as rule of thirds"), TRUE,
GIMP_TYPE_GUIDES_TYPE, GIMP_PARAM_STATIC_STRINGS);
GIMP_GUIDES_N_LINES,
GIMP_PARAM_STATIC_STRINGS); GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_PREVIEW_OPACITY,
GIMP_CONFIG_INSTALL_PROP_INT (object_class, PROP_GRID_SIZE, "preview-opacity",
"grid-size", _("Image opacity"),
_("Size of a grid cell for variable number " _("Opacity of the preview image"),
"of composition guides"), 0.0, 1.0, 1.0,
1, 128, 15, GIMP_PARAM_STATIC_STRINGS);
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_CONSTRAIN_MOVE, GIMP_CONFIG_PROP_ENUM (object_class, PROP_GRID_TYPE,
"constrain-move", "grid-type",
NULL, _("Guides"),
FALSE, _("Composition guides such as rule of thirds"),
GIMP_PARAM_STATIC_STRINGS); GIMP_TYPE_GUIDES_TYPE,
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_CONSTRAIN_SCALE, GIMP_GUIDES_N_LINES,
"constrain-scale", GIMP_PARAM_STATIC_STRINGS);
NULL,
FALSE, GIMP_CONFIG_PROP_INT (object_class, PROP_GRID_SIZE,
GIMP_PARAM_STATIC_STRINGS); "grid-size",
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_CONSTRAIN_ROTATE, NULL,
"constrain-rotate", _("Size of a grid cell for variable number "
NULL, "of composition guides"),
FALSE, 1, 128, 15,
GIMP_PARAM_STATIC_STRINGS); GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_CONSTRAIN_SHEAR,
"constrain-shear", GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_CONSTRAIN_MOVE,
NULL, "constrain-move",
TRUE, NULL, NULL,
GIMP_PARAM_STATIC_STRINGS); FALSE,
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_CONSTRAIN_PERSPECTIVE, GIMP_PARAM_STATIC_STRINGS);
"constrain-perspective",
NULL, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_CONSTRAIN_SCALE,
FALSE, "constrain-scale",
GIMP_PARAM_STATIC_STRINGS); NULL, NULL,
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_FROMPIVOT_SCALE, FALSE,
"frompivot-scale", GIMP_PARAM_STATIC_STRINGS);
NULL,
FALSE, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_CONSTRAIN_ROTATE,
GIMP_PARAM_STATIC_STRINGS); "constrain-rotate",
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_FROMPIVOT_SHEAR, NULL, NULL,
"frompivot-shear", FALSE,
NULL, GIMP_PARAM_STATIC_STRINGS);
FALSE,
GIMP_PARAM_STATIC_STRINGS); GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_CONSTRAIN_SHEAR,
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_FROMPIVOT_PERSPECTIVE, "constrain-shear",
"frompivot-perspective", NULL, NULL,
NULL, TRUE,
FALSE, GIMP_PARAM_STATIC_STRINGS);
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_CORNERSNAP, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_CONSTRAIN_PERSPECTIVE,
"cornersnap", "constrain-perspective",
NULL, NULL, NULL,
FALSE, FALSE,
GIMP_PARAM_STATIC_STRINGS); GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_FIXEDPIVOT,
"fixedpivot", GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_FROMPIVOT_SCALE,
NULL, "frompivot-scale",
FALSE, NULL, NULL,
GIMP_PARAM_STATIC_STRINGS); FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_FROMPIVOT_SHEAR,
"frompivot-shear",
NULL, NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_FROMPIVOT_PERSPECTIVE,
"frompivot-perspective",
NULL, NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_CORNERSNAP,
"cornersnap",
NULL, NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_FIXEDPIVOT,
"fixedpivot",
NULL, NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
} }
static void static void
@ -406,8 +431,8 @@ gimp_transform_options_gui (GimpToolOptions *tool_options)
gtk_box_pack_start (GTK_BOX (hbox), box, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), box, FALSE, FALSE, 0);
gtk_widget_show (box); gtk_widget_show (box);
frame = gimp_prop_enum_radio_frame_new (config, "direction", frame = gimp_prop_enum_radio_frame_new (config, "direction", NULL,
_("Direction"), 0, 0); 0, 0);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame); gtk_widget_show (frame);
@ -426,12 +451,10 @@ gimp_transform_options_gui (GimpToolOptions *tool_options)
gtk_widget_show (combo); gtk_widget_show (combo);
/* the preview frame */ /* the preview frame */
scale = gimp_prop_spin_scale_new (config, "preview-opacity", scale = gimp_prop_spin_scale_new (config, "preview-opacity", NULL,
_("Image opacity"),
0.01, 0.1, 0); 0.01, 0.1, 0);
gimp_prop_widget_set_factor (scale, 100.0, 0.0, 0.0, 1); gimp_prop_widget_set_factor (scale, 100.0, 0.0, 0.0, 1);
frame = gimp_prop_expanding_frame_new (config, "show-preview", frame = gimp_prop_expanding_frame_new (config, "show-preview", NULL,
_("Show image preview"),
scale, NULL); scale, NULL);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame); gtk_widget_show (frame);

30
app/tools/gimpvectoroptions.c
View File

@ -66,17 +66,20 @@ gimp_vector_options_class_init (GimpVectorOptionsClass *klass)
object_class->set_property = gimp_vector_options_set_property; object_class->set_property = gimp_vector_options_set_property;
object_class->get_property = gimp_vector_options_get_property; object_class->get_property = gimp_vector_options_get_property;
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_VECTORS_EDIT_MODE, GIMP_CONFIG_PROP_ENUM (object_class, PROP_VECTORS_EDIT_MODE,
"vectors-edit-mode", NULL, "vectors-edit-mode",
GIMP_TYPE_VECTOR_MODE, _("Edit Mode"),
GIMP_VECTOR_MODE_DESIGN, NULL,
GIMP_PARAM_STATIC_STRINGS); GIMP_TYPE_VECTOR_MODE,
GIMP_VECTOR_MODE_DESIGN,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_VECTORS_POLYGONAL, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_VECTORS_POLYGONAL,
"vectors-polygonal", "vectors-polygonal",
N_("Restrict editing to polygons"), _("Polygonal"),
FALSE, _("Restrict editing to polygons"),
GIMP_PARAM_STATIC_STRINGS); FALSE,
GIMP_PARAM_STATIC_STRINGS);
} }
static void static void
@ -152,8 +155,8 @@ gimp_vector_options_gui (GimpToolOptions *tool_options)
gchar *str; gchar *str;
/* tool toggle */ /* tool toggle */
frame = gimp_prop_enum_radio_frame_new (config, "vectors-edit-mode", frame = gimp_prop_enum_radio_frame_new (config, "vectors-edit-mode", NULL,
_("Edit Mode"), 0, 0); 0, 0);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame); gtk_widget_show (frame);
@ -171,8 +174,7 @@ gimp_vector_options_gui (GimpToolOptions *tool_options)
gimp_get_toggle_behavior_mask ()); gimp_get_toggle_behavior_mask ());
} }
button = gimp_prop_check_button_new (config, "vectors-polygonal", button = gimp_prop_check_button_new (config, "vectors-polygonal", NULL);
_("Polygonal"));
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button); gtk_widget_show (button);

69
app/tools/gimpwarpoptions.c
View File

@ -71,36 +71,41 @@ gimp_warp_options_class_init (GimpWarpOptionsClass *klass)
object_class->set_property = gimp_warp_options_set_property; object_class->set_property = gimp_warp_options_set_property;
object_class->get_property = gimp_warp_options_get_property; object_class->get_property = gimp_warp_options_get_property;
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_BEHAVIOR, GIMP_CONFIG_PROP_ENUM (object_class, PROP_BEHAVIOR,
"behavior", "behavior",
_("Behavior"), _("Behavior"),
GIMP_TYPE_WARP_BEHAVIOR, _("Behavior"),
GIMP_WARP_BEHAVIOR_MOVE, GIMP_TYPE_WARP_BEHAVIOR,
GIMP_PARAM_STATIC_STRINGS); GIMP_WARP_BEHAVIOR_MOVE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_EFFECT_STRENGTH, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_EFFECT_STRENGTH,
"effect-strength", "effect-strength",
_("Effect Strength"), _("Strength"),
1.0, 100.0, 50.0, _("Effect Strength"),
GIMP_PARAM_STATIC_STRINGS); 1.0, 100.0, 50.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_EFFECT_SIZE, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_EFFECT_SIZE,
"effect-size", "effect-size",
_("Effect Size"), _("Size"),
1.0, 10000.0, 40.0, _("Effect Size"),
GIMP_PARAM_STATIC_STRINGS); 1.0, 10000.0, 40.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_EFFECT_HARDNESS, GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_EFFECT_HARDNESS,
"effect-hardness", "effect-hardness",
_("Effect Hardness"), _("Hardness"),
0.0, 1.0, 0.5, _("Effect Hardness"),
GIMP_PARAM_STATIC_STRINGS); 0.0, 1.0, 0.5,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_INT (object_class, PROP_N_ANIMATION_FRAMES, GIMP_CONFIG_PROP_INT (object_class, PROP_N_ANIMATION_FRAMES,
"n-animation-frames", "n-animation-frames",
_("Number of animation frames"), _("Frames"),
3, 1000, 10, _("Number of animation frames"),
GIMP_PARAM_STATIC_STRINGS); 3, 1000, 10,
GIMP_PARAM_STATIC_STRINGS);
} }
static void static void
@ -188,22 +193,19 @@ gimp_warp_options_gui (GimpToolOptions *tool_options)
gtk_box_pack_start (GTK_BOX (vbox), combo, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), combo, FALSE, FALSE, 0);
gtk_widget_show (combo); gtk_widget_show (combo);
scale = gimp_prop_spin_scale_new (config, "effect-strength", scale = gimp_prop_spin_scale_new (config, "effect-strength", NULL,
_("Strength"),
1, 10, 1); 1, 10, 1);
gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (scale), 1.0, 100.0); gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (scale), 1.0, 100.0);
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
gtk_widget_show (scale); gtk_widget_show (scale);
scale = gimp_prop_spin_scale_new (config, "effect-size", scale = gimp_prop_spin_scale_new (config, "effect-size", NULL,
_("Size"),
0.01, 1.0, 2); 0.01, 1.0, 2);
gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (scale), 1.0, 1000.0); gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (scale), 1.0, 1000.0);
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
gtk_widget_show (scale); gtk_widget_show (scale);
scale = gimp_prop_spin_scale_new (config, "effect-hardness", scale = gimp_prop_spin_scale_new (config, "effect-hardness", NULL,
_("Hardness"),
0.01, 1.0, 2); 0.01, 1.0, 2);
gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (scale), 0.0, 1.0); gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (scale), 0.0, 1.0);
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
@ -218,8 +220,7 @@ gimp_warp_options_gui (GimpToolOptions *tool_options)
gtk_container_add (GTK_CONTAINER (frame), anim_vbox); gtk_container_add (GTK_CONTAINER (frame), anim_vbox);
gtk_widget_show (anim_vbox); gtk_widget_show (anim_vbox);
scale = gimp_prop_spin_scale_new (config, "n-animation-frames", scale = gimp_prop_spin_scale_new (config, "n-animation-frames", NULL,
_("Frames"),
1.0, 10.0, 0); 1.0, 10.0, 0);
gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (scale), 3.0, 100.0); gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (scale), 3.0, 100.0);
gtk_box_pack_start (GTK_BOX (anim_vbox), scale, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (anim_vbox), scale, FALSE, FALSE, 0);

43
app/widgets/gimpcontrollerinfo.c
View File

@ -107,22 +107,33 @@ gimp_controller_info_class_init (GimpControllerInfoClass *klass)
viewable_class->default_icon_name = GIMP_STOCK_CONTROLLER; viewable_class->default_icon_name = GIMP_STOCK_CONTROLLER;
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_ENABLED, GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_ENABLED,
"enabled", NULL, "enabled",
TRUE, _("Enabled"),
GIMP_PARAM_STATIC_STRINGS); NULL,
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_DEBUG_EVENTS, TRUE,
"debug-events", NULL, GIMP_PARAM_STATIC_STRINGS);
FALSE,
GIMP_PARAM_STATIC_STRINGS); GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_DEBUG_EVENTS,
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_CONTROLLER, "debug-events",
"controller", NULL, _("Debug events"),
GIMP_TYPE_CONTROLLER, NULL,
GIMP_PARAM_STATIC_STRINGS); FALSE,
GIMP_CONFIG_INSTALL_PROP_BOXED (object_class, PROP_MAPPING, GIMP_PARAM_STATIC_STRINGS);
"mapping", NULL,
G_TYPE_HASH_TABLE, GIMP_CONFIG_PROP_OBJECT (object_class, PROP_CONTROLLER,
GIMP_PARAM_STATIC_STRINGS); "controller",
"Controller",
NULL,
GIMP_TYPE_CONTROLLER,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOXED (object_class, PROP_MAPPING,
"mapping",
"Mapping",
NULL,
G_TYPE_HASH_TABLE,
GIMP_PARAM_STATIC_STRINGS);
info_signals[EVENT_MAPPED] = info_signals[EVENT_MAPPED] =
g_signal_new ("event-mapped", g_signal_new ("event-mapped",

23
app/widgets/gimpdeviceinfo.c
View File

@ -41,6 +41,8 @@
#include "gimpdeviceinfo.h" #include "gimpdeviceinfo.h"
#include "gimp-intl.h"
#define GIMP_DEVICE_INFO_DATA_KEY "gimp-device-info" #define GIMP_DEVICE_INFO_DATA_KEY "gimp-device-info"
@ -125,10 +127,13 @@ gimp_device_info_class_init (GimpDeviceInfoClass *klass)
G_PARAM_READWRITE | G_PARAM_READWRITE |
G_PARAM_CONSTRUCT)); G_PARAM_CONSTRUCT));
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_MODE, "mode", NULL, GIMP_CONFIG_PROP_ENUM (object_class, PROP_MODE,
GDK_TYPE_INPUT_MODE, "mode",
GDK_MODE_DISABLED, _("Mode"),
GIMP_PARAM_STATIC_STRINGS); NULL,
GDK_TYPE_INPUT_MODE,
GDK_MODE_DISABLED,
GIMP_PARAM_STATIC_STRINGS);
param_spec = g_param_spec_enum ("axis", param_spec = g_param_spec_enum ("axis",
NULL, NULL, NULL, NULL,
@ -153,10 +158,12 @@ gimp_device_info_class_init (GimpDeviceInfoClass *klass)
GIMP_PARAM_STATIC_STRINGS | GIMP_PARAM_STATIC_STRINGS |
GIMP_CONFIG_PARAM_FLAGS)); GIMP_CONFIG_PARAM_FLAGS));
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_PRESSURE_CURVE, GIMP_CONFIG_PROP_OBJECT (object_class, PROP_PRESSURE_CURVE,
"pressure-curve", NULL, "pressure-curve",
GIMP_TYPE_CURVE, _("Pressure curve"),
GIMP_CONFIG_PARAM_AGGREGATE); NULL,
GIMP_TYPE_CURVE,
GIMP_CONFIG_PARAM_AGGREGATE);
} }
static void static void

1
app/widgets/gimpdynamicseditor.c
View File

@ -352,6 +352,7 @@ dynamics_check_button_new (GObject *config,
GtkWidget *button; GtkWidget *button;
button = gimp_prop_check_button_new (config, property_name, NULL); button = gimp_prop_check_button_new (config, property_name, NULL);
gtk_widget_destroy (gtk_bin_get_child (GTK_BIN (button)));
gtk_table_attach (table, button, column, column + 1, row, row + 1, gtk_table_attach (table, button, column, column + 1, row, row + 1,
GTK_SHRINK, GTK_SHRINK, 0, 0); GTK_SHRINK, GTK_SHRINK, 0, 0);
gtk_widget_show (button); gtk_widget_show (button);

24
app/widgets/gimptoolpreseteditor.c
View File

@ -156,50 +156,42 @@ gimp_tool_preset_editor_constructed (GObject *object)
gtk_widget_show (button); gtk_widget_show (button);
button = editor->priv->fg_bg_toggle = button = editor->priv->fg_bg_toggle =
gimp_prop_check_button_new (G_OBJECT (preset), "use-fg-bg", gimp_prop_check_button_new (G_OBJECT (preset), "use-fg-bg", NULL);
_("Apply stored FG/BG"));
gtk_box_pack_start (GTK_BOX (data_editor), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (data_editor), button, FALSE, FALSE, 0);
gtk_widget_show (button); gtk_widget_show (button);
button = editor->priv->brush_toggle = button = editor->priv->brush_toggle =
gimp_prop_check_button_new (G_OBJECT (preset), "use-brush", gimp_prop_check_button_new (G_OBJECT (preset), "use-brush", NULL);
_("Apply stored brush"));
gtk_box_pack_start (GTK_BOX (data_editor), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (data_editor), button, FALSE, FALSE, 0);
gtk_widget_show (button); gtk_widget_show (button);
button = editor->priv->dynamics_toggle = button = editor->priv->dynamics_toggle =
gimp_prop_check_button_new (G_OBJECT (preset), "use-dynamics", gimp_prop_check_button_new (G_OBJECT (preset), "use-dynamics", NULL);
_("Apply stored dynamics"));
gtk_box_pack_start (GTK_BOX (data_editor), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (data_editor), button, FALSE, FALSE, 0);
gtk_widget_show (button); gtk_widget_show (button);
button = editor->priv->mybrush_toggle = button = editor->priv->mybrush_toggle =
gimp_prop_check_button_new (G_OBJECT (preset), "use-mypaint-brush", gimp_prop_check_button_new (G_OBJECT (preset), "use-mypaint-brush", NULL);
_("Apply stored MyPaint brush"));
gtk_box_pack_start (GTK_BOX (data_editor), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (data_editor), button, FALSE, FALSE, 0);
gtk_widget_show (button); gtk_widget_show (button);
button = editor->priv->gradient_toggle = button = editor->priv->gradient_toggle =
gimp_prop_check_button_new (G_OBJECT (preset), "use-gradient", gimp_prop_check_button_new (G_OBJECT (preset), "use-gradient", NULL);
_("Apply stored gradient"));
gtk_box_pack_start (GTK_BOX (data_editor), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (data_editor), button, FALSE, FALSE, 0);
gtk_widget_show (button); gtk_widget_show (button);
button = editor->priv->pattern_toggle = button = editor->priv->pattern_toggle =
gimp_prop_check_button_new (G_OBJECT (preset), "use-pattern", gimp_prop_check_button_new (G_OBJECT (preset), "use-pattern", NULL);
_("Apply stored pattern"));
gtk_box_pack_start (GTK_BOX (data_editor), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (data_editor), button, FALSE, FALSE, 0);
gtk_widget_show (button); gtk_widget_show (button);
button = editor->priv->palette_toggle = button = editor->priv->palette_toggle =
gimp_prop_check_button_new (G_OBJECT (preset), "use-palette", gimp_prop_check_button_new (G_OBJECT (preset), "use-palette", NULL);
_("Apply stored palette"));
gtk_box_pack_start (GTK_BOX (data_editor), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (data_editor), button, FALSE, FALSE, 0);
gtk_widget_show (button); gtk_widget_show (button);
button = editor->priv->font_toggle = button = editor->priv->font_toggle =
gimp_prop_check_button_new (G_OBJECT (preset), "use-font", gimp_prop_check_button_new (G_OBJECT (preset), "use-font", NULL);
_("Apply stored font"));
gtk_box_pack_start (GTK_BOX (data_editor), button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (data_editor), button, FALSE, FALSE, 0);
gtk_widget_show (button); gtk_widget_show (button);