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_PARAM_READWRITE));
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, GIMP_CONTEXT_PROP_TOOL,
gimp_context_prop_names[GIMP_CONTEXT_PROP_TOOL], NULL,
GIMP_TYPE_TOOL_INFO,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_OBJECT (object_class, GIMP_CONTEXT_PROP_TOOL,
gimp_context_prop_names[GIMP_CONTEXT_PROP_TOOL],
NULL, NULL,
GIMP_TYPE_TOOL_INFO,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, GIMP_CONTEXT_PROP_PAINT_INFO,
gimp_context_prop_names[GIMP_CONTEXT_PROP_PAINT_INFO], NULL,
GIMP_TYPE_PAINT_INFO,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_OBJECT (object_class, GIMP_CONTEXT_PROP_PAINT_INFO,
gimp_context_prop_names[GIMP_CONTEXT_PROP_PAINT_INFO],
NULL, NULL,
GIMP_TYPE_PAINT_INFO,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_RGB (object_class, GIMP_CONTEXT_PROP_FOREGROUND,
gimp_context_prop_names[GIMP_CONTEXT_PROP_FOREGROUND],
NULL,
FALSE, &black,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_RGB (object_class, GIMP_CONTEXT_PROP_FOREGROUND,
gimp_context_prop_names[GIMP_CONTEXT_PROP_FOREGROUND],
_("Foreground"),
_("Foreground color"),
FALSE, &black,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_RGB (object_class, GIMP_CONTEXT_PROP_BACKGROUND,
gimp_context_prop_names[GIMP_CONTEXT_PROP_BACKGROUND],
NULL,
FALSE, &white,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_RGB (object_class, GIMP_CONTEXT_PROP_BACKGROUND,
gimp_context_prop_names[GIMP_CONTEXT_PROP_BACKGROUND],
_("Background"),
_("Background color"),
FALSE, &white,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, GIMP_CONTEXT_PROP_OPACITY,
gimp_context_prop_names[GIMP_CONTEXT_PROP_OPACITY],
_("Opacity"),
GIMP_OPACITY_TRANSPARENT,
GIMP_OPACITY_OPAQUE,
GIMP_OPACITY_OPAQUE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, GIMP_CONTEXT_PROP_OPACITY,
gimp_context_prop_names[GIMP_CONTEXT_PROP_OPACITY],
_("Opacity"),
_("Opacity"),
GIMP_OPACITY_TRANSPARENT,
GIMP_OPACITY_OPAQUE,
GIMP_OPACITY_OPAQUE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, GIMP_CONTEXT_PROP_PAINT_MODE,
gimp_context_prop_names[GIMP_CONTEXT_PROP_PAINT_MODE],
_("Paint Mode"),
GIMP_TYPE_LAYER_MODE_EFFECTS,
GIMP_NORMAL_MODE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, GIMP_CONTEXT_PROP_PAINT_MODE,
gimp_context_prop_names[GIMP_CONTEXT_PROP_PAINT_MODE],
_("Paint Mode"),
_("Paint Mode"),
GIMP_TYPE_LAYER_MODE_EFFECTS,
GIMP_NORMAL_MODE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, GIMP_CONTEXT_PROP_BRUSH,
gimp_context_prop_names[GIMP_CONTEXT_PROP_BRUSH],
NULL,
GIMP_TYPE_BRUSH,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_OBJECT (object_class, GIMP_CONTEXT_PROP_BRUSH,
gimp_context_prop_names[GIMP_CONTEXT_PROP_BRUSH],
_("Brush"),
_("Brush"),
GIMP_TYPE_BRUSH,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, GIMP_CONTEXT_PROP_DYNAMICS,
gimp_context_prop_names[GIMP_CONTEXT_PROP_DYNAMICS],
NULL,
GIMP_TYPE_DYNAMICS,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_OBJECT (object_class, GIMP_CONTEXT_PROP_DYNAMICS,
gimp_context_prop_names[GIMP_CONTEXT_PROP_DYNAMICS],
_("Dynamics"),
_("Paint dynamics"),
GIMP_TYPE_DYNAMICS,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, GIMP_CONTEXT_PROP_MYBRUSH,
gimp_context_prop_names[GIMP_CONTEXT_PROP_MYBRUSH],
NULL,
GIMP_TYPE_MYBRUSH,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_OBJECT (object_class, GIMP_CONTEXT_PROP_MYBRUSH,
gimp_context_prop_names[GIMP_CONTEXT_PROP_MYBRUSH],
_("MyPaint Brush"),
_("MyPaint Brush"),
GIMP_TYPE_MYBRUSH,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, GIMP_CONTEXT_PROP_PATTERN,
gimp_context_prop_names[GIMP_CONTEXT_PROP_PATTERN],
NULL,
GIMP_TYPE_PATTERN,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_OBJECT (object_class, GIMP_CONTEXT_PROP_PATTERN,
gimp_context_prop_names[GIMP_CONTEXT_PROP_PATTERN],
_("Pattern"),
_("Pattern"),
GIMP_TYPE_PATTERN,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, GIMP_CONTEXT_PROP_GRADIENT,
gimp_context_prop_names[GIMP_CONTEXT_PROP_GRADIENT],
NULL,
GIMP_TYPE_GRADIENT,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_OBJECT (object_class, GIMP_CONTEXT_PROP_GRADIENT,
gimp_context_prop_names[GIMP_CONTEXT_PROP_GRADIENT],
_("Gradient"),
_("Gradient"),
GIMP_TYPE_GRADIENT,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, GIMP_CONTEXT_PROP_PALETTE,
gimp_context_prop_names[GIMP_CONTEXT_PROP_PALETTE],
NULL,
GIMP_TYPE_PALETTE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_OBJECT (object_class, GIMP_CONTEXT_PROP_PALETTE,
gimp_context_prop_names[GIMP_CONTEXT_PROP_PALETTE],
_("Palette"),
_("Palette"),
GIMP_TYPE_PALETTE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, GIMP_CONTEXT_PROP_TOOL_PRESET,
gimp_context_prop_names[GIMP_CONTEXT_PROP_TOOL_PRESET],
NULL,
GIMP_TYPE_TOOL_PRESET,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_OBJECT (object_class, GIMP_CONTEXT_PROP_TOOL_PRESET,
gimp_context_prop_names[GIMP_CONTEXT_PROP_TOOL_PRESET],
_("Tool Preset"),
_("Tool Preset"),
GIMP_TYPE_TOOL_PRESET,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, GIMP_CONTEXT_PROP_FONT,
gimp_context_prop_names[GIMP_CONTEXT_PROP_FONT],
NULL,
GIMP_TYPE_FONT,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_OBJECT (object_class, GIMP_CONTEXT_PROP_FONT,
gimp_context_prop_names[GIMP_CONTEXT_PROP_FONT],
_("Font"),
_("Font"),
GIMP_TYPE_FONT,
GIMP_PARAM_STATIC_STRINGS);
g_object_class_install_property (object_class, 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->duplicate = gimp_curve_duplicate;
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_CURVE_TYPE,
"curve-type",
"The curve type",
GIMP_TYPE_CURVE_TYPE,
GIMP_CURVE_SMOOTH, 0);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_CURVE_TYPE,
"curve-type",
"Curve Type",
"The curve type",
GIMP_TYPE_CURVE_TYPE,
GIMP_CURVE_SMOOTH, 0);
GIMP_CONFIG_INSTALL_PROP_INT (object_class, PROP_N_POINTS,
"n-points",
"The number of points",
17, 17, 17, 0);
GIMP_CONFIG_PROP_INT (object_class, PROP_N_POINTS,
"n-points",
"Number of Points",
"The number of points",
17, 17, 17, 0);
array_spec = g_param_spec_double ("point", NULL, NULL,
-1.0, 1.0, 0.0, GIMP_PARAM_READWRITE);
@ -163,10 +165,11 @@ gimp_curve_class_init (GimpCurveClass *klass)
GIMP_PARAM_STATIC_STRINGS |
GIMP_CONFIG_PARAM_FLAGS));
GIMP_CONFIG_INSTALL_PROP_INT (object_class, PROP_N_SAMPLES,
"n-samples",
"The number of samples",
256, 256, 256, 0);
GIMP_CONFIG_PROP_INT (object_class, PROP_N_SAMPLES,
"n-samples",
"Number of Samples",
"The number of samples",
256, 256, 256, 0);
array_spec = g_param_spec_double ("sample", NULL, NULL,
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->duplicate = gimp_dynamics_duplicate;
GIMP_CONFIG_INSTALL_PROP_STRING (object_class, PROP_NAME,
"name", NULL,
DEFAULT_NAME,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_STRING (object_class, PROP_NAME,
"name",
NULL, NULL,
DEFAULT_NAME,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_OPACITY_OUTPUT,
"opacity-output", NULL,
GIMP_TYPE_DYNAMICS_OUTPUT,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_PROP_OBJECT (object_class, PROP_OPACITY_OUTPUT,
"opacity-output",
NULL, NULL,
GIMP_TYPE_DYNAMICS_OUTPUT,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_FORCE_OUTPUT,
"force-output", NULL,
GIMP_TYPE_DYNAMICS_OUTPUT,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_PROP_OBJECT (object_class, PROP_FORCE_OUTPUT,
"force-output",
NULL, NULL,
GIMP_TYPE_DYNAMICS_OUTPUT,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_HARDNESS_OUTPUT,
"hardness-output", NULL,
GIMP_TYPE_DYNAMICS_OUTPUT,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_PROP_OBJECT (object_class, PROP_HARDNESS_OUTPUT,
"hardness-output",
NULL, NULL,
GIMP_TYPE_DYNAMICS_OUTPUT,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_RATE_OUTPUT,
"rate-output", NULL,
GIMP_TYPE_DYNAMICS_OUTPUT,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_PROP_OBJECT (object_class, PROP_RATE_OUTPUT,
"rate-output",
NULL, NULL,
GIMP_TYPE_DYNAMICS_OUTPUT,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_FLOW_OUTPUT,
"flow-output", NULL,
GIMP_TYPE_DYNAMICS_OUTPUT,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_PROP_OBJECT (object_class, PROP_FLOW_OUTPUT,
"flow-output",
NULL, NULL,
GIMP_TYPE_DYNAMICS_OUTPUT,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_SIZE_OUTPUT,
"size-output", NULL,
GIMP_TYPE_DYNAMICS_OUTPUT,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_PROP_OBJECT (object_class, PROP_SIZE_OUTPUT,
"size-output",
NULL, NULL,
GIMP_TYPE_DYNAMICS_OUTPUT,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_ASPECT_RATIO_OUTPUT,
"aspect-ratio-output", NULL,
GIMP_TYPE_DYNAMICS_OUTPUT,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_PROP_OBJECT (object_class, PROP_ASPECT_RATIO_OUTPUT,
"aspect-ratio-output",
NULL, NULL,
GIMP_TYPE_DYNAMICS_OUTPUT,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_COLOR_OUTPUT,
"color-output", NULL,
GIMP_TYPE_DYNAMICS_OUTPUT,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_PROP_OBJECT (object_class, PROP_COLOR_OUTPUT,
"color-output",
NULL, NULL,
GIMP_TYPE_DYNAMICS_OUTPUT,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_ANGLE_OUTPUT,
"angle-output", NULL,
GIMP_TYPE_DYNAMICS_OUTPUT,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_PROP_OBJECT (object_class, PROP_ANGLE_OUTPUT,
"angle-output",
NULL, NULL,
GIMP_TYPE_DYNAMICS_OUTPUT,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_JITTER_OUTPUT,
"jitter-output", NULL,
GIMP_TYPE_DYNAMICS_OUTPUT,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_PROP_OBJECT (object_class, PROP_JITTER_OUTPUT,
"jitter-output",
NULL, NULL,
GIMP_TYPE_DYNAMICS_OUTPUT,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_SPACING_OUTPUT,
"spacing-output", NULL,
GIMP_TYPE_DYNAMICS_OUTPUT,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_PROP_OBJECT (object_class, PROP_SPACING_OUTPUT,
"spacing-output",
NULL, NULL,
GIMP_TYPE_DYNAMICS_OUTPUT,
GIMP_CONFIG_PARAM_AGGREGATE);
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 |
G_PARAM_CONSTRUCT));
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_USE_PRESSURE,
"use-pressure", NULL,
DEFAULT_USE_PRESSURE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_USE_PRESSURE,
"use-pressure",
NULL, NULL,
DEFAULT_USE_PRESSURE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_USE_VELOCITY,
"use-velocity", NULL,
DEFAULT_USE_VELOCITY,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_USE_VELOCITY,
"use-velocity",
NULL, NULL,
DEFAULT_USE_VELOCITY,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_USE_DIRECTION,
"use-direction", NULL,
DEFAULT_USE_DIRECTION,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_USE_DIRECTION,
"use-direction",
NULL, NULL,
DEFAULT_USE_DIRECTION,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_USE_TILT,
"use-tilt", NULL,
DEFAULT_USE_TILT,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_USE_TILT,
"use-tilt",
NULL, NULL,
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,
"use-wheel", NULL,
DEFAULT_USE_TILT,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_USE_RANDOM,
"use-random",
NULL, NULL,
DEFAULT_USE_RANDOM,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_USE_RANDOM,
"use-random", NULL,
DEFAULT_USE_RANDOM,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_USE_FADE,
"use-fade",
NULL, NULL,
DEFAULT_USE_FADE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_USE_FADE,
"use-fade", NULL,
DEFAULT_USE_FADE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_OBJECT (object_class, PROP_PRESSURE_CURVE,
"pressure-curve",
NULL, NULL,
GIMP_TYPE_CURVE,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_PRESSURE_CURVE,
"pressure-curve", NULL,
GIMP_TYPE_CURVE,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_PROP_OBJECT (object_class, PROP_VELOCITY_CURVE,
"velocity-curve",
NULL, NULL,
GIMP_TYPE_CURVE,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_VELOCITY_CURVE,
"velocity-curve", NULL,
GIMP_TYPE_CURVE,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_PROP_OBJECT (object_class, PROP_DIRECTION_CURVE,
"direction-curve",
NULL, NULL,
GIMP_TYPE_CURVE,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_DIRECTION_CURVE,
"direction-curve", NULL,
GIMP_TYPE_CURVE,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_PROP_OBJECT (object_class, PROP_TILT_CURVE,
"tilt-curve",
NULL, NULL,
GIMP_TYPE_CURVE,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_TILT_CURVE,
"tilt-curve", NULL,
GIMP_TYPE_CURVE,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_PROP_OBJECT (object_class, PROP_WHEEL_CURVE,
"wheel-curve",
NULL, NULL,
GIMP_TYPE_CURVE,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_WHEEL_CURVE,
"wheel-curve", NULL,
GIMP_TYPE_CURVE,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_PROP_OBJECT (object_class, PROP_RANDOM_CURVE,
"random-curve",
NULL, NULL,
GIMP_TYPE_CURVE,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_RANDOM_CURVE,
"random-curve", NULL,
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);
GIMP_CONFIG_PROP_OBJECT (object_class, PROP_FADE_CURVE,
"fade-curve",
NULL, NULL,
GIMP_TYPE_CURVE,
GIMP_CONFIG_PARAM_AGGREGATE);
g_type_class_add_private (klass, sizeof (GimpDynamicsOutputPrivate));
}

24
app/core/gimpfilloptions.c
View File

@ -32,6 +32,8 @@
#include "gimpfilloptions.h"
#include "gimpviewable.h"
#include "gimp-intl.h"
enum
{
@ -82,16 +84,20 @@ gimp_fill_options_class_init (GimpFillOptionsClass *klass)
object_class->set_property = gimp_fill_options_set_property;
object_class->get_property = gimp_fill_options_get_property;
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_STYLE,
"style", NULL,
GIMP_TYPE_FILL_STYLE,
GIMP_FILL_STYLE_SOLID,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_STYLE,
"style",
_("Style"),
NULL,
GIMP_TYPE_FILL_STYLE,
GIMP_FILL_STYLE_SOLID,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_ANTIALIAS,
"antialias", NULL,
TRUE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_ANTIALIAS,
"antialias",
_("Antialiasing"),
NULL,
TRUE,
GIMP_PARAM_STATIC_STRINGS);
g_object_class_install_property (object_class, PROP_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 (&white, 1.0, 1.0, 1.0, GIMP_OPACITY_OPAQUE);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_STYLE,
"style",
N_("Line style used for the grid."),
GIMP_TYPE_GRID_STYLE,
GIMP_GRID_SOLID,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_RGB (object_class, PROP_FGCOLOR,
"fgcolor",
N_("The foreground color of the grid."),
TRUE, &black,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_RGB (object_class, PROP_BGCOLOR,
"bgcolor",
N_("The background color of the grid; "
"only used in double dashed line style."),
TRUE, &white,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_XSPACING,
"xspacing",
N_("Horizontal spacing of grid lines."),
1.0, GIMP_MAX_IMAGE_SIZE, 10.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_YSPACING,
"yspacing",
N_("Vertical spacing of grid lines."),
1.0, GIMP_MAX_IMAGE_SIZE, 10.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_UNIT (object_class, PROP_SPACING_UNIT,
"spacing-unit", NULL,
FALSE, FALSE, GIMP_UNIT_INCH,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_XOFFSET,
"xoffset",
N_("Horizontal 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_INSTALL_PROP_DOUBLE (object_class, PROP_YOFFSET,
"yoffset",
N_("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_INSTALL_PROP_UNIT (object_class, PROP_OFFSET_UNIT,
"offset-unit", NULL,
FALSE, FALSE, GIMP_UNIT_INCH,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_STYLE,
"style",
_("Line style"),
_("Line style used for the grid."),
GIMP_TYPE_GRID_STYLE,
GIMP_GRID_SOLID,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_RGB (object_class, PROP_FGCOLOR,
"fgcolor",
_("Foreground color"),
_("The foreground color of the grid."),
TRUE, &black,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_RGB (object_class, PROP_BGCOLOR,
"bgcolor",
_("Background color"),
_("The background color of the grid; "
"only used in double dashed line style."),
TRUE, &white,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_XSPACING,
"xspacing",
_("Spacing X"),
_("Horizontal spacing of grid lines."),
1.0, GIMP_MAX_IMAGE_SIZE, 10.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_YSPACING,
"yspacing",
_("Spacing Y"),
_("Vertical spacing of grid lines."),
1.0, GIMP_MAX_IMAGE_SIZE, 10.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_UNIT (object_class, PROP_SPACING_UNIT,
"spacing-unit",
_("Spacing unit"),
NULL,
FALSE, FALSE, GIMP_UNIT_INCH,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_XOFFSET,
"xoffset",
_("Offset X"),
_("Horizontal 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_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

36
app/core/gimpguide.c
View File

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

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->get_property = gimp_settings_get_property;
GIMP_CONFIG_INSTALL_PROP_UINT (object_class, PROP_TIME,
"time",
"Time of settings creation",
0, G_MAXUINT, 0, 0);
GIMP_CONFIG_PROP_UINT (object_class, PROP_TIME,
"time",
"Time",
"Time of settings creation",
0, G_MAXUINT, 0, 0);
}
static void

98
app/core/gimpstrokeoptions.c
View File

@ -151,45 +151,58 @@ gimp_stroke_options_class_init (GimpStrokeOptionsClass *klass)
G_TYPE_NONE, 1,
GIMP_TYPE_DASH_PRESET);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_METHOD,
"method", NULL,
GIMP_TYPE_STROKE_METHOD,
GIMP_STROKE_LINE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_METHOD,
"method",
_("Method"),
NULL,
GIMP_TYPE_STROKE_METHOD,
GIMP_STROKE_LINE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_WIDTH,
"width", NULL,
0.0, 2000.0, 6.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_WIDTH,
"width",
_("Line width"),
NULL,
0.0, 2000.0, 6.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_UNIT (object_class, PROP_UNIT,
"unit", NULL,
TRUE, FALSE, GIMP_UNIT_PIXEL,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_UNIT (object_class, PROP_UNIT,
"unit",
_("Unit"),
NULL,
TRUE, FALSE, GIMP_UNIT_PIXEL,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_CAP_STYLE,
"cap-style", NULL,
GIMP_TYPE_CAP_STYLE, GIMP_CAP_BUTT,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_CAP_STYLE,
"cap-style",
_("Cap style"),
NULL,
GIMP_TYPE_CAP_STYLE, GIMP_CAP_BUTT,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_JOIN_STYLE,
"join-style", NULL,
GIMP_TYPE_JOIN_STYLE, GIMP_JOIN_MITER,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_JOIN_STYLE,
"join-style",
_("Join style"),
NULL,
GIMP_TYPE_JOIN_STYLE, GIMP_JOIN_MITER,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_MITER_LIMIT,
"miter-limit",
_("Convert a mitered join to a bevelled "
"join if the miter would extend to a "
"distance of more than miter-limit * "
"line-width from the actual join point."),
0.0, 100.0, 10.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_MITER_LIMIT,
"miter-limit",
_("Miter limit"),
_("Convert a mitered join to a bevelled "
"join if the miter would extend to a "
"distance of more than miter-limit * "
"line-width from the actual join point."),
0.0, 100.0, 10.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_DASH_OFFSET,
"dash-offset", NULL,
0.0, 2000.0, 0.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_DASH_OFFSET,
"dash-offset",
_("Dash offset"),
NULL,
0.0, 2000.0, 0.0,
GIMP_PARAM_STATIC_STRINGS);
array_spec = g_param_spec_double ("dash-length", NULL, NULL,
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_CONFIG_PARAM_FLAGS));
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_PAINT_OPTIONS,
"paint-options", NULL,
GIMP_TYPE_PAINT_OPTIONS,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_OBJECT (object_class, PROP_PAINT_OPTIONS,
"paint-options",
NULL, NULL,
GIMP_TYPE_PAINT_OPTIONS,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_EMULATE_DYNAMICS,
"emulate-brush-dynamics", NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_EMULATE_DYNAMICS,
"emulate-brush-dynamics",
_("Emulate brush dynamics"),
NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
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->active_changed = gimp_mandala_active_changed;
g_object_class_install_property (object_class, PROP_CENTER_X,
g_param_spec_double ("center-x",
_("Center abscisse"),
_("Center abscisse"),
0.0, 10000.0, 0.0,
GIMP_CONFIG_PARAM_FLAGS |
GIMP_PARAM_STATIC_STRINGS |
GIMP_SYMMETRY_PARAM_GUI));
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_CENTER_X,
"center-x",
_("Center abscisse"),
NULL,
0.0, 10000.0, 0.0,
GIMP_PARAM_STATIC_STRINGS |
GIMP_SYMMETRY_PARAM_GUI);
g_object_class_install_property (object_class, PROP_CENTER_Y,
g_param_spec_double ("center-y",
_("Center ordinate"),
_("Center ordinate"),
0.0, 10000.0, 0.0,
GIMP_CONFIG_PARAM_FLAGS |
GIMP_PARAM_STATIC_STRINGS |
GIMP_SYMMETRY_PARAM_GUI));
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_CENTER_Y,
"center-y",
_("Center ordinate"),
NULL,
0.0, 10000.0, 0.0,
GIMP_PARAM_STATIC_STRINGS |
GIMP_SYMMETRY_PARAM_GUI);
GIMP_CONFIG_PROP_INT (object_class, PROP_SIZE,
"size",
_("Number of points"),
_("Number of points"),
NULL,
1, 100, 6.0,
GIMP_PARAM_STATIC_STRINGS |
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->active_changed = gimp_mirror_active_changed;
/* Properties for user settings */
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_HORIZONTAL_SYMMETRY,
"horizontal-symmetry",
_("Horizontal Mirror"),
@ -149,23 +148,21 @@ gimp_mirror_class_init (GimpMirrorClass *klass)
GIMP_PARAM_STATIC_STRINGS |
GIMP_SYMMETRY_PARAM_GUI);
/* Properties for XCF serialization only */
g_object_class_install_property (object_class, PROP_HORIZONTAL_POSITION,
g_param_spec_double ("horizontal-position",
_("Horizontal axis position"),
_("Horizontal axis position"),
0.0, G_MAXDOUBLE, 0.0,
GIMP_CONFIG_PARAM_FLAGS |
GIMP_PARAM_STATIC_STRINGS |
GIMP_SYMMETRY_PARAM_GUI));
g_object_class_install_property (object_class, PROP_VERTICAL_POSITION,
g_param_spec_double ("vertical-position",
_("Vertical axis position"),
_("Vertical axis position"),
0.0, G_MAXDOUBLE, 0.0,
GIMP_CONFIG_PARAM_FLAGS |
GIMP_PARAM_STATIC_STRINGS |
GIMP_SYMMETRY_PARAM_GUI));
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_HORIZONTAL_POSITION,
"horizontal-position",
_("Horizontal axis position"),
NULL,
0.0, G_MAXDOUBLE, 0.0,
GIMP_PARAM_STATIC_STRINGS |
GIMP_SYMMETRY_PARAM_GUI);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_VERTICAL_POSITION,
"vertical-position",
_("Vertical axis position"),
NULL,
0.0, G_MAXDOUBLE, 0.0,
GIMP_PARAM_STATIC_STRINGS |
GIMP_SYMMETRY_PARAM_GUI);
}
static void

11
app/core/gimpsymmetry.c
View File

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

136
app/core/gimptemplate.c
View File

@ -40,8 +40,7 @@
#include "gimp-intl.h"
#define DEFAULT_RESOLUTION 72.0
#define DEFAULT_RESOLUTION 72.0
enum
{
@ -121,68 +120,87 @@ gimp_template_class_init (GimpTemplateClass *klass)
viewable_class->default_icon_name = "gimp-template";
GIMP_CONFIG_INSTALL_PROP_INT (object_class, PROP_WIDTH, "width",
NULL,
GIMP_MIN_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE,
GIMP_DEFAULT_IMAGE_WIDTH,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_INT (object_class, PROP_HEIGHT, "height",
NULL,
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_PROP_INT (object_class, PROP_WIDTH,
"width",
_("Width"),
NULL,
GIMP_MIN_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE,
GIMP_DEFAULT_IMAGE_WIDTH,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_RESOLUTION (object_class, PROP_XRESOLUTION,
"xresolution",
_("The horizontal image resolution."),
DEFAULT_RESOLUTION,
GIMP_PARAM_STATIC_STRINGS |
GIMP_TEMPLATE_PARAM_COPY_FIRST);
GIMP_CONFIG_INSTALL_PROP_RESOLUTION (object_class, PROP_YRESOLUTION,
"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_PROP_INT (object_class, PROP_HEIGHT,
"height",
_("Height"),
NULL,
GIMP_MIN_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE,
GIMP_DEFAULT_IMAGE_HEIGHT,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_BASE_TYPE,
"image-type", /* serialized name */
NULL,
GIMP_TYPE_IMAGE_BASE_TYPE, GIMP_RGB,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_PRECISION,
"precision",
NULL,
GIMP_TYPE_PRECISION, GIMP_PRECISION_U8_GAMMA,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_UNIT (object_class, PROP_UNIT,
"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_ENUM (object_class, PROP_FILL_TYPE,
"fill-type",
NULL,
GIMP_TYPE_FILL_TYPE, GIMP_FILL_BACKGROUND,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_RESOLUTION (object_class, PROP_XRESOLUTION,
"xresolution",
_("Resolution X"),
_("The horizontal image resolution."),
DEFAULT_RESOLUTION,
GIMP_PARAM_STATIC_STRINGS |
GIMP_TEMPLATE_PARAM_COPY_FIRST);
GIMP_CONFIG_INSTALL_PROP_STRING (object_class, PROP_COMMENT,
"comment",
NULL,
NULL,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_RESOLUTION (object_class, PROP_YRESOLUTION,
"yresolution",
_("Resolution X"),
_("The vertical image resolution."),
DEFAULT_RESOLUTION,
GIMP_PARAM_STATIC_STRINGS |
GIMP_TEMPLATE_PARAM_COPY_FIRST);
GIMP_CONFIG_INSTALL_PROP_STRING (object_class, PROP_FILENAME,
"filename",
NULL,
NULL,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_UNIT (object_class, PROP_RESOLUTION_UNIT,
"resolution-unit",
_("Resolution unit"),
NULL,
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));
}

11
app/core/gimptoolinfo.c
View File

@ -35,6 +35,8 @@
#include "gimptooloptions.h"
#include "gimptoolpreset.h"
#include "gimp-intl.h"
enum
{
@ -75,9 +77,12 @@ gimp_tool_info_class_init (GimpToolInfoClass *klass)
viewable_class->get_description = gimp_tool_info_get_description;
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_VISIBLE, "visible",
NULL, TRUE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_VISIBLE,
"visible",
_("Visible"),
NULL,
TRUE,
GIMP_PARAM_STATIC_STRINGS);
}
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->get_extension = gimp_tool_preset_get_extension;
GIMP_CONFIG_INSTALL_PROP_STRING (object_class, PROP_NAME,
"name", NULL,
"Unnamed",
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_STRING (object_class, PROP_NAME,
"name",
NULL, NULL,
"Unnamed",
GIMP_PARAM_STATIC_STRINGS);
g_object_class_install_property (object_class, PROP_GIMP,
g_param_spec_object ("gimp",
@ -131,43 +132,67 @@ gimp_tool_preset_class_init (GimpToolPresetClass *klass)
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY));
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_TOOL_OPTIONS,
"tool-options", NULL,
GIMP_TYPE_TOOL_OPTIONS,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_OBJECT (object_class, PROP_TOOL_OPTIONS,
"tool-options",
NULL, NULL,
GIMP_TYPE_TOOL_OPTIONS,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_USE_FG_BG,
"use-fg-bg", NULL,
DEFAULT_USE_FG_BG,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_USE_BRUSH,
"use-brush", NULL,
DEFAULT_USE_BRUSH,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_USE_DYNAMICS,
"use-dynamics", NULL,
DEFAULT_USE_DYNAMICS,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_USE_MYBRUSH,
"use-mypaint-brush", NULL,
DEFAULT_USE_MYBRUSH,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_USE_PATTERN,
"use-pattern", NULL,
TRUE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_USE_PALETTE,
"use-palette", NULL,
DEFAULT_USE_PALETTE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_USE_GRADIENT,
"use-gradient", NULL,
DEFAULT_USE_GRADIENT,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_USE_FONT,
"use-font", NULL,
DEFAULT_USE_FONT,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_USE_FG_BG,
"use-fg-bg",
_("Apply stored FG/BG"),
NULL,
DEFAULT_USE_FG_BG,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_USE_BRUSH,
"use-brush",
_("Apply stored brush"),
NULL,
DEFAULT_USE_BRUSH,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_USE_DYNAMICS,
"use-dynamics",
_("Apply stored dynamics"),
NULL,
DEFAULT_USE_DYNAMICS,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_USE_MYBRUSH,
"use-mypaint-brush",
_("Apply stored MyPaint brush"),
NULL,
DEFAULT_USE_MYBRUSH,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_USE_PATTERN,
"use-pattern",
_("Apply stored pattern"),
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

25
app/core/gimpviewable.c
View File

@ -184,19 +184,22 @@ gimp_viewable_class_init (GimpViewableClass *klass)
klass->get_expanded = NULL;
/* compat property */
GIMP_CONFIG_INSTALL_PROP_STRING (object_class, PROP_STOCK_ID, "stock-id",
NULL, NULL,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_STRING (object_class, PROP_STOCK_ID, "stock-id",
NULL, NULL,
NULL,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_STRING (object_class, PROP_ICON_NAME, "icon-name",
NULL, NULL,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_STRING (object_class, PROP_ICON_NAME, "icon-name",
NULL, NULL,
NULL,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_ICON_PIXBUF,
"icon-pixbuf", NULL,
GDK_TYPE_PIXBUF,
G_PARAM_CONSTRUCT |
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_OBJECT (object_class, PROP_ICON_PIXBUF,
"icon-pixbuf",
NULL, NULL,
GDK_TYPE_PIXBUF,
G_PARAM_CONSTRUCT |
GIMP_PARAM_STATIC_STRINGS);
g_object_class_install_property (object_class, PROP_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";
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_BRIGHTNESS,
"brightness",
_("Brightness"),
-1.0, 1.0, 0.0, 0);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_BRIGHTNESS,
"brightness",
_("Brightness"),
_("Brightness"),
-1.0, 1.0, 0.0, 0);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_CONTRAST,
"contrast",
_("Contrast"),
-1.0, 1.0, 0.0, 0);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_CONTRAST,
"contrast",
_("Contrast"),
_("Contrast"),
-1.0, 1.0, 0.0, 0);
}
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";
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_RANGE,
"range",
_("The affected range"),
GIMP_TYPE_TRANSFER_MODE,
GIMP_TRANSFER_MIDTONES, 0);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_RANGE,
"range",
_("Range"),
_("The affected range"),
GIMP_TYPE_TRANSFER_MODE,
GIMP_TRANSFER_MIDTONES, 0);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_CYAN_RED,
"cyan-red",
_("Cyan-Red"),
-1.0, 1.0, 0.0, 0);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_CYAN_RED,
"cyan-red",
_("Cyan-Red"),
_("Cyan-Red"),
-1.0, 1.0, 0.0, 0);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_MAGENTA_GREEN,
"magenta-green",
_("Magenta-Green"),
-1.0, 1.0, 0.0, 0);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_MAGENTA_GREEN,
"magenta-green",
_("Magenta-Green"),
_("Magenta-Green"),
-1.0, 1.0, 0.0, 0);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_YELLOW_BLUE,
"yellow-blue",
_("Yellow-Blue"),
-1.0, 1.0, 0.0, 0);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_YELLOW_BLUE,
"yellow-blue",
_("Yellow-Blue"),
_("Yellow-Blue"),
-1.0, 1.0, 0.0, 0);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_PRESERVE_LUMINOSITY,
"preserve-luminosity",
_("Preserve Luminosity"),
TRUE, 0);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_PRESERVE_LUMINOSITY,
"preserve-luminosity",
_("Preserve Luminosity"),
_("Preserve Luminosity"),
TRUE, 0);
}
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";
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_HUE,
"hue",
_("Hue"),
0.0, 1.0, 0.5, 0);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_HUE,
"hue",
_("Hue"),
_("Hue"),
0.0, 1.0, 0.5, 0);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_SATURATION,
"saturation",
_("Saturation"),
0.0, 1.0, 0.5, 0);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_SATURATION,
"saturation",
_("Saturation"),
_("Saturation"),
0.0, 1.0, 0.5, 0);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_LIGHTNESS,
"lightness",
_("Lightness"),
-1.0, 1.0, 0.0, 0);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_LIGHTNESS,
"lightness",
_("Lightness"),
_("Lightness"),
-1.0, 1.0, 0.0, 0);
gimp_hsl_set (&hsl, 0.5, 0.5, 0.5);
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";
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_CHANNEL,
"channel",
_("The affected channel"),
GIMP_TYPE_HISTOGRAM_CHANNEL,
GIMP_HISTOGRAM_VALUE, 0);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_CHANNEL,
"channel",
_("Channel"),
_("The affected channel"),
GIMP_TYPE_HISTOGRAM_CHANNEL,
GIMP_HISTOGRAM_VALUE, 0);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_CURVE,
"curve",
_("Curve"),
GIMP_TYPE_CURVE,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_PROP_OBJECT (object_class, PROP_CURVE,
"curve",
_("Curve"),
_("Curve"),
GIMP_TYPE_CURVE,
GIMP_CONFIG_PARAM_AGGREGATE);
}
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";
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_RANGE,
"range",
_("The affected range"),
GIMP_TYPE_HUE_RANGE,
GIMP_ALL_HUES, 0);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_RANGE,
"range",
_("Range"),
_("The affected range"),
GIMP_TYPE_HUE_RANGE,
GIMP_ALL_HUES, 0);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_HUE,
"hue",
_("Hue"),
-1.0, 1.0, 0.0, 0);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_HUE,
"hue",
_("Hue"),
_("Hue"),
-1.0, 1.0, 0.0, 0);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_SATURATION,
"saturation",
_("Saturation"),
-1.0, 1.0, 0.0, 0);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_SATURATION,
"saturation",
_("Saturation"),
_("Saturation"),
-1.0, 1.0, 0.0, 0);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_LIGHTNESS,
"lightness",
_("Lightness"),
-1.0, 1.0, 0.0, 0);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_LIGHTNESS,
"lightness",
_("Lightness"),
_("Lightness"),
-1.0, 1.0, 0.0, 0);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_OVERLAP,
"overlap",
_("Overlap"),
0.0, 1.0, 0.0, 0);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_OVERLAP,
"overlap",
_("Overlap"),
_("Overlap"),
0.0, 1.0, 0.0, 0);
}
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";
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_CHANNEL,
"channel",
_("The affected channel"),
GIMP_TYPE_HISTOGRAM_CHANNEL,
GIMP_HISTOGRAM_VALUE, 0);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_CHANNEL,
"channel",
_("Channel"),
_("The affected channel"),
GIMP_TYPE_HISTOGRAM_CHANNEL,
GIMP_HISTOGRAM_VALUE, 0);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_GAMMA,
"gamma",
_("Gamma"),
0.1, 10.0, 1.0, 0);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_GAMMA,
"gamma",
_("Gamma"),
_("Gamma"),
0.1, 10.0, 1.0, 0);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_LOW_INPUT,
"low-input",
_("Low Input"),
0.0, 1.0, 0.0, 0);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_LOW_INPUT,
"low-input",
_("Low Input"),
_("Low Input"),
0.0, 1.0, 0.0, 0);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_HIGH_INPUT,
"high-input",
_("High Input"),
0.0, 1.0, 1.0, 0);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_HIGH_INPUT,
"high-input",
_("High Input"),
_("High Input"),
0.0, 1.0, 1.0, 0);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_LOW_OUTPUT,
"low-output",
_("Low Output"),
0.0, 1.0, 0.0, 0);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_LOW_OUTPUT,
"low-output",
_("Low Output"),
_("Low Output"),
0.0, 1.0, 0.0, 0);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_HIGH_OUTPUT,
"high-output",
_("High Output"),
0.0, 1.0, 1.0, 0);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_HIGH_OUTPUT,
"high-output",
_("High Output"),
_("High Output"),
0.0, 1.0, 1.0, 0);
}
static void

43
app/paint/gimpairbrushoptions.c
View File

@ -26,6 +26,8 @@
#include "gimpairbrushoptions.h"
#include "gimp-intl.h"
#define AIRBRUSH_DEFAULT_RATE 80.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->get_property = gimp_airbrush_options_get_property;
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_RATE,
"rate", NULL,
0.0, 150.0, AIRBRUSH_DEFAULT_RATE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_RATE,
"rate",
C_("airbrush-tool", "Rate"),
NULL,
0.0, 150.0, AIRBRUSH_DEFAULT_RATE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_MOTION_ONLY,
"motion-only", NULL,
AIRBRUSH_DEFAULT_MOTION_ONLY,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_MOTION_ONLY,
"motion-only",
_("Motion only"),
NULL,
AIRBRUSH_DEFAULT_MOTION_ONLY,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_FLOW,
"flow", NULL,
0.0, 100.0, AIRBRUSH_DEFAULT_FLOW,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_FLOW,
"flow",
_("Flow"),
NULL,
0.0, 100.0, AIRBRUSH_DEFAULT_FLOW,
GIMP_PARAM_STATIC_STRINGS);
/*backwads-compadibility prop for flow fomerly known as pressure*/
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_PRESSURE,
"pressure", NULL,
0.0, 100.0, AIRBRUSH_DEFAULT_FLOW,
GIMP_CONFIG_PARAM_IGNORE);
/* backwads-compadibility prop for flow fomerly known as pressure */
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_PRESSURE,
"pressure",
NULL, NULL,
0.0, 100.0, AIRBRUSH_DEFAULT_FLOW,
GIMP_CONFIG_PARAM_IGNORE);
}
static void

14
app/paint/gimpcloneoptions.c
View File

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

25
app/paint/gimpconvolveoptions.c
View File

@ -26,6 +26,8 @@
#include "gimpconvolveoptions.h"
#include "gimp-intl.h"
#define DEFAULT_CONVOLVE_TYPE GIMP_CONVOLVE_BLUR
#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->get_property = gimp_convolve_options_get_property;
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_TYPE,
"type", NULL,
GIMP_TYPE_CONVOLVE_TYPE,
DEFAULT_CONVOLVE_TYPE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_RATE,
"rate", NULL,
0.0, 100.0, DEFAULT_CONVOLVE_RATE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_TYPE,
"type",
_("Convolve Type"),
NULL,
GIMP_TYPE_CONVOLVE_TYPE,
DEFAULT_CONVOLVE_TYPE,
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

38
app/paint/gimpdodgeburnoptions.c
View File

@ -26,6 +26,8 @@
#include "gimpdodgeburnoptions.h"
#include "gimp-intl.h"
#define DODGE_BURN_DEFAULT_TYPE GIMP_DODGE_BURN_TYPE_DODGE
#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->get_property = gimp_dodge_burn_options_get_property;
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_TYPE,
"type", NULL,
GIMP_TYPE_DODGE_BURN_TYPE,
DODGE_BURN_DEFAULT_TYPE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_MODE,
"mode", NULL,
GIMP_TYPE_TRANSFER_MODE,
DODGE_BURN_DEFAULT_MODE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_EXPOSURE,
"exposure", NULL,
0.0, 100.0, DODGE_BURN_DEFAULT_EXPOSURE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_TYPE,
"type",
_("Type"),
NULL,
GIMP_TYPE_DODGE_BURN_TYPE,
DODGE_BURN_DEFAULT_TYPE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_MODE,
"mode",
_("Range"),
NULL,
GIMP_TYPE_TRANSFER_MODE,
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

12
app/paint/gimperaseroptions.c
View File

@ -26,6 +26,8 @@
#include "gimperaseroptions.h"
#include "gimp-intl.h"
#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->get_property = gimp_eraser_options_get_property;
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_ANTI_ERASE,
"anti-erase", NULL,
ERASER_DEFAULT_ANTI_ERASE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_ANTI_ERASE,
"anti-erase",
_("Anti erase"),
NULL,
ERASER_DEFAULT_ANTI_ERASE,
GIMP_PARAM_STATIC_STRINGS);
}
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->get_property = gimp_ink_options_get_property;
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_SIZE,
"size", _("Ink Blob Size"),
0.0, 200.0, 16.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_TILT_ANGLE,
"tilt-angle", NULL,
-90.0, 90.0, 0.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_SIZE,
"size",
_("Size"),
_("Ink Blob Size"),
0.0, 200.0, 16.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_TILT_ANGLE,
"tilt-angle",
_("Angle"),
NULL,
-90.0, 90.0, 0.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_SIZE_SENSITIVITY,
"size-sensitivity", NULL,
0.0, 1.0, 1.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_VEL_SENSITIVITY,
"vel-sensitivity", NULL,
0.0, 1.0, 0.8,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_TILT_SENSITIVITY,
"tilt-sensitivity", NULL,
0.0, 1.0, 0.4,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_SIZE_SENSITIVITY,
"size-sensitivity",
_("Size"),
NULL,
0.0, 1.0, 1.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_VEL_SENSITIVITY,
"vel-sensitivity",
_("Speed"),
NULL,
0.0, 1.0, 0.8,
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,
"blob-type", NULL,
GIMP_TYPE_INK_BLOB_TYPE,
GIMP_INK_BLOB_TYPE_CIRCLE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_BLOB_ASPECT,
"blob-aspect", _("Ink Blob Aspect Ratio"),
1.0, 10.0, 1.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_BLOB_ANGLE,
"blob-angle", _("Ink Blob Angle"),
-90.0, 90.0, 0.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_BLOB_TYPE,
"blob-type",
_("Shape"),
NULL,
GIMP_TYPE_INK_BLOB_TYPE,
GIMP_INK_BLOB_TYPE_CIRCLE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_BLOB_ASPECT,
"blob-aspect",
_("Aspect ratio"),
_("Ink Blob Aspect Ratio"),
1.0, 10.0, 1.0,
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

44
app/paint/gimpmybrushoptions.c
View File

@ -43,6 +43,7 @@ enum
PROP_ERASER
};
static void gimp_mybrush_options_config_iface_init (GimpConfigInterface *config_iface);
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;
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_RADIUS,
"radius", _("Radius"),
-2.0, 6.0, 1.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_OPAQUE,
"opaque", _("Base Opacity"),
0.0, 2.0, 1.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_HARDNESS,
"hardness", NULL,
0.0, 1.0, 1.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_ERASER,
"eraser", NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_RADIUS,
"radius",
_("Radius"),
NULL,
-2.0, 6.0, 1.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_OPAQUE,
"opaque",
_("Base Opacity"),
NULL,
0.0, 2.0, 1.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_HARDNESS,
"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

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

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->get_property = gimp_pencil_options_get_property;
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_HARD,
"hard", NULL,
PENCIL_DEFAULT_HARD,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_HARD,
"hard",
NULL, NULL,
PENCIL_DEFAULT_HARD,
GIMP_PARAM_STATIC_STRINGS);
}
static void

13
app/paint/gimpperspectivecloneoptions.c
View File

@ -26,6 +26,8 @@
#include "gimpperspectivecloneoptions.h"
#include "gimp-intl.h"
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->get_property = gimp_perspective_clone_options_get_property;
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_CLONE_MODE,
"clone-mode", NULL,
GIMP_TYPE_PERSPECTIVE_CLONE_MODE,
GIMP_PERSPECTIVE_CLONE_MODE_ADJUST,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_CLONE_MODE,
"clone-mode",
NULL, NULL,
GIMP_TYPE_PERSPECTIVE_CLONE_MODE,
GIMP_PERSPECTIVE_CLONE_MODE_ADJUST,
GIMP_PARAM_STATIC_STRINGS);
}
static void

12
app/paint/gimpsmudgeoptions.c
View File

@ -26,6 +26,8 @@
#include "gimpsmudgeoptions.h"
#include "gimp-intl.h"
#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->get_property = gimp_smudge_options_get_property;
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_RATE,
"rate", NULL,
0.0, 100.0, SMUDGE_DEFAULT_RATE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_RATE,
"rate",
C_("smudge-tool", "Rate"),
NULL,
0.0, 100.0, SMUDGE_DEFAULT_RATE,
GIMP_PARAM_STATIC_STRINGS);
}
static void

24
app/paint/gimpsourceoptions.c
View File

@ -26,6 +26,8 @@
#include "gimpsourceoptions.h"
#include "gimp-intl.h"
enum
{
@ -56,16 +58,20 @@ gimp_source_options_class_init (GimpSourceOptionsClass *klass)
object_class->set_property = gimp_source_options_set_property;
object_class->get_property = gimp_source_options_get_property;
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_ALIGN_MODE,
"align-mode", NULL,
GIMP_TYPE_SOURCE_ALIGN_MODE,
GIMP_SOURCE_ALIGN_NO,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_ALIGN_MODE,
"align-mode",
_("Alignment"),
NULL,
GIMP_TYPE_SOURCE_ALIGN_MODE,
GIMP_SOURCE_ALIGN_NO,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_SAMPLE_MERGED,
"sample-merged", NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_SAMPLE_MERGED,
"sample-merged",
_("Sample merged"),
NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
}
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->get_property = gimp_pdb_context_get_property;
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_ANTIALIAS,
"antialias",
N_("Smooth edges"),
TRUE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_ANTIALIAS,
"antialias",
_("Antialiasing"),
_("Smooth edges"),
TRUE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_FEATHER,
"feather", NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_FEATHER,
"feather",
_("Feather"),
NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_FEATHER_RADIUS_X,
"feather-radius-x", NULL,
0.0, 1000.0, 10.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_FEATHER_RADIUS_X,
"feather-radius-x",
_("Feather radius X"),
NULL,
0.0, 1000.0, 10.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_FEATHER_RADIUS_Y,
"feather-radius-y", NULL,
0.0, 1000.0, 10.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_FEATHER_RADIUS_Y,
"feather-radius-y",
_("Feather radius Y"),
NULL,
0.0, 1000.0, 10.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_SAMPLE_MERGED,
"sample-merged", NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_SAMPLE_MERGED,
"sample-merged",
_("Sample merged"),
NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_SAMPLE_CRITERION,
"sample-criterion", NULL,
GIMP_TYPE_SELECT_CRITERION,
GIMP_SELECT_CRITERION_COMPOSITE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_SAMPLE_CRITERION,
"sample-criterion",
_("Sample criterion"),
NULL,
GIMP_TYPE_SELECT_CRITERION,
GIMP_SELECT_CRITERION_COMPOSITE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_SAMPLE_THRESHOLD,
"sample-threshold", NULL,
0.0, 1.0, 0.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_SAMPLE_THRESHOLD,
"sample-threshold",
_("Sample threshold"),
NULL,
0.0, 1.0, 0.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_SAMPLE_TRANSPARENT,
"sample-transparent", NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_SAMPLE_TRANSPARENT,
"sample-transparent",
_("Sample transparent"),
NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_DIAGONAL_NEIGHBORS,
"diagonal-neighbors", NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_DIAGONAL_NEIGHBORS,
"diagonal-neighbors",
_("Diagonal neighbors"),
NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_INTERPOLATION,
"interpolation", NULL,
GIMP_TYPE_INTERPOLATION_TYPE,
GIMP_INTERPOLATION_CUBIC,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_INTERPOLATION,
"interpolation",
_("Interpolation"),
NULL,
GIMP_TYPE_INTERPOLATION_TYPE,
GIMP_INTERPOLATION_CUBIC,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_TRANSFORM_DIRECTION,
"transform-direction", NULL,
GIMP_TYPE_TRANSFORM_DIRECTION,
GIMP_TRANSFORM_FORWARD,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_TRANSFORM_DIRECTION,
"transform-direction",
_("Transform direction"),
NULL,
GIMP_TYPE_TRANSFORM_DIRECTION,
GIMP_TRANSFORM_FORWARD,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_TRANSFORM_RESIZE,
"transform-resize", NULL,
GIMP_TYPE_TRANSFORM_RESIZE,
GIMP_TRANSFORM_RESIZE_ADJUST,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_TRANSFORM_RESIZE,
"transform-resize",
_("Transform resize"),
NULL,
GIMP_TYPE_TRANSFORM_RESIZE,
GIMP_TRANSFORM_RESIZE_ADJUST,
GIMP_PARAM_STATIC_STRINGS);
}
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_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,
"text", NULL,
NULL,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_STRING (object_class, PROP_MARKUP,
"markup", NULL,
NULL,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_STRING (object_class, PROP_FONT,
"font", NULL,
"Sans-serif",
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_FONT_SIZE,
"font-size", NULL,
0.0, 8192.0, 24.0,
GIMP_PARAM_STATIC_STRINGS);
/*
* We use the name "font-size-unit" for backward compatibility.
GIMP_CONFIG_PROP_STRING (object_class, PROP_MARKUP,
"markup",
NULL, NULL,
NULL,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_STRING (object_class, PROP_FONT,
"font",
NULL, NULL,
"Sans-serif",
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_FONT_SIZE,
"font-size",
NULL, NULL,
0.0, 8192.0, 24.0,
GIMP_PARAM_STATIC_STRINGS);
/* We use the name "font-size-unit" for backward compatibility.
* The unit is also used for other sizes in the text object.
*/
GIMP_CONFIG_INSTALL_PROP_UNIT (object_class, PROP_UNIT,
"font-size-unit", NULL,
TRUE, FALSE, GIMP_UNIT_PIXEL,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_ANTIALIAS,
"antialias", NULL,
TRUE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_HINT_STYLE,
"hint-style", NULL,
GIMP_TYPE_TEXT_HINT_STYLE,
GIMP_TEXT_HINT_STYLE_MEDIUM,
GIMP_PARAM_STATIC_STRINGS |
GIMP_CONFIG_PARAM_DEFAULTS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_KERNING,
"kerning", NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS |
GIMP_CONFIG_PARAM_DEFAULTS);
GIMP_CONFIG_INSTALL_PROP_STRING (object_class, PROP_LANGUAGE,
"language", NULL,
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_RGB (object_class, PROP_COLOR,
"color", NULL,
FALSE, &black,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_OUTLINE,
"outline", NULL,
GIMP_TYPE_TEXT_OUTLINE,
GIMP_TEXT_OUTLINE_NONE,
GIMP_PARAM_STATIC_STRINGS |
GIMP_CONFIG_PARAM_DEFAULTS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_JUSTIFICATION,
"justify", NULL,
GIMP_TYPE_TEXT_JUSTIFICATION,
GIMP_TEXT_JUSTIFY_LEFT,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_INDENTATION,
"indent", NULL,
-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", NULL,
-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", NULL,
-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",
NULL,
GIMP_TYPE_TEXT_BOX_MODE,
GIMP_TEXT_BOX_DYNAMIC,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_BOX_WIDTH,
"box-width", NULL,
0.0, GIMP_MAX_IMAGE_SIZE, 0.0,
GIMP_PARAM_STATIC_STRINGS |
GIMP_CONFIG_PARAM_DEFAULTS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_BOX_HEIGHT,
"box-height", NULL,
0.0, GIMP_MAX_IMAGE_SIZE, 0.0,
GIMP_PARAM_STATIC_STRINGS |
GIMP_CONFIG_PARAM_DEFAULTS);
GIMP_CONFIG_INSTALL_PROP_UNIT (object_class, PROP_BOX_UNIT,
"box-unit", NULL,
TRUE, FALSE, GIMP_UNIT_PIXEL,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_MATRIX2 (object_class, PROP_TRANSFORMATION,
"transformation", NULL,
&identity,
GIMP_PARAM_STATIC_STRINGS |
GIMP_CONFIG_PARAM_DEFAULTS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_OFFSET_X,
"offset-x", NULL,
-G_MAXDOUBLE, G_MAXDOUBLE, 0.0,
GIMP_PARAM_STATIC_STRINGS |
GIMP_CONFIG_PARAM_DEFAULTS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_OFFSET_Y,
"offset-y", NULL,
-G_MAXDOUBLE, G_MAXDOUBLE, 0.0,
GIMP_PARAM_STATIC_STRINGS |
GIMP_CONFIG_PARAM_DEFAULTS);
GIMP_CONFIG_PROP_UNIT (object_class, PROP_UNIT,
"font-size-unit",
NULL, NULL,
TRUE, FALSE, GIMP_UNIT_PIXEL,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_ANTIALIAS,
"antialias",
NULL, NULL,
TRUE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_HINT_STYLE,
"hint-style",
NULL, NULL,
GIMP_TYPE_TEXT_HINT_STYLE,
GIMP_TEXT_HINT_STYLE_MEDIUM,
GIMP_PARAM_STATIC_STRINGS |
GIMP_CONFIG_PARAM_DEFAULTS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_KERNING,
"kerning",
NULL, NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS |
GIMP_CONFIG_PARAM_DEFAULTS);
language = gimp_get_default_language (NULL);
GIMP_CONFIG_PROP_STRING (object_class, PROP_LANGUAGE,
"language",
NULL, NULL,
language,
GIMP_PARAM_STATIC_STRINGS);
g_free (language);
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_RGB (object_class, PROP_COLOR,
"color",
NULL, NULL,
FALSE, &black,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_OUTLINE,
"outline",
NULL, NULL,
GIMP_TYPE_TEXT_OUTLINE,
GIMP_TEXT_OUTLINE_NONE,
GIMP_PARAM_STATIC_STRINGS |
GIMP_CONFIG_PARAM_DEFAULTS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_JUSTIFICATION,
"justify",
NULL, NULL,
GIMP_TYPE_TEXT_JUSTIFICATION,
GIMP_TEXT_JUSTIFY_LEFT,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_INDENTATION,
"indent",
NULL, NULL,
-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",
NULL, NULL,
-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",
NULL, NULL,
-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",
NULL, NULL,
GIMP_TYPE_TEXT_BOX_MODE,
GIMP_TEXT_BOX_DYNAMIC,
GIMP_PARAM_STATIC_STRINGS);
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 */
g_object_class_install_property (object_class, PROP_BORDER,
@ -256,12 +301,11 @@ gimp_text_class_init (GimpTextClass *klass)
GIMP_PARAM_WRITABLE));
/* the old hinting options have been replaced by 'hint-style' */
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_HINTING,
"hinting", NULL,
TRUE,
GIMP_PARAM_STATIC_STRINGS);
g_free (language);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_HINTING,
"hinting",
NULL, NULL,
TRUE,
GIMP_PARAM_STATIC_STRINGS);
}
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->push_undo = gimp_text_layer_push_undo;
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_TEXT,
"text", NULL,
GIMP_TYPE_TEXT,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_OBJECT (object_class, PROP_TEXT,
"text",
NULL, NULL,
GIMP_TYPE_TEXT,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_AUTO_RENAME,
"auto-rename", NULL,
TRUE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_AUTO_RENAME,
"auto-rename",
NULL, NULL,
TRUE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_MODIFIED,
"modified", NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_MODIFIED,
"modified",
NULL, NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
}
static void

8
app/tools/gimpairbrushtool.c
View File

@ -84,18 +84,16 @@ gimp_airbrush_options_gui (GimpToolOptions *tool_options)
GtkWidget *button;
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_widget_show (button);
scale = gimp_prop_spin_scale_new (config, "rate",
C_("airbrush-tool", "Rate"),
scale = gimp_prop_spin_scale_new (config, "rate", NULL,
1.0, 10.0, 1);
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
gtk_widget_show (scale);
scale = gimp_prop_spin_scale_new (config, "flow",
_("Flow"),
scale = gimp_prop_spin_scale_new (config, "flow", NULL,
1.0, 10.0, 1);
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
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,
GIMP_TYPE_ALIGNMENT_TYPE);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_ALIGN_REFERENCE,
"align-reference",
_("Reference image object a layer will be aligned on"),
GIMP_TYPE_ALIGN_REFERENCE_TYPE,
GIMP_ALIGN_REFERENCE_FIRST,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_ALIGN_REFERENCE,
"align-reference",
_("Relative to"),
_("Reference image object a layer will be aligned on"),
GIMP_TYPE_ALIGN_REFERENCE_TYPE,
GIMP_ALIGN_REFERENCE_FIRST,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_OFFSET_X,
"offset-x",
_("Horizontal offset for distribution"),
-GIMP_MAX_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE, 0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_OFFSET_X,
"offset-x",
_("Offset"),
_("Horizontal offset for distribution"),
-GIMP_MAX_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE, 0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_OFFSET_Y,
"offset-y",
_("Vertical offset for distribution"),
-GIMP_MAX_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE, 0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_OFFSET_Y,
"offset-y",
_("Offset"),
_("Vertical offset for distribution"),
-GIMP_MAX_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE, 0,
GIMP_PARAM_STATIC_STRINGS);
}
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->get_property = gimp_blend_options_get_property;
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_OFFSET,
"offset", NULL,
0.0, 100.0, 0.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_GRADIENT_TYPE,
"gradient-type", NULL,
GIMP_TYPE_GRADIENT_TYPE,
GIMP_GRADIENT_LINEAR,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_GRADIENT_REPEAT,
"gradient-repeat", NULL,
GIMP_TYPE_REPEAT_MODE,
GIMP_REPEAT_NONE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_OFFSET,
"offset",
_("Offset"),
NULL,
0.0, 100.0, 0.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_GRADIENT_TYPE,
"gradient-type",
_("Shape"),
NULL,
GIMP_TYPE_GRADIENT_TYPE,
GIMP_GRADIENT_LINEAR,
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,
"supersample", NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_INT (object_class, PROP_SUPERSAMPLE_DEPTH,
"supersample-depth", NULL,
1, 9, 3,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_SUPERSAMPLE_THRESHOLD,
"supersample-threshold", NULL,
0.0, 4.0, 0.2,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_SUPERSAMPLE,
"supersample",
_("Adaptive Supersampling"),
NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_INT (object_class, PROP_SUPERSAMPLE_DEPTH,
"supersample-depth",
_("Max depth"),
NULL,
1, 9, 3,
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,
"dither", NULL,
TRUE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_DITHER,
"dither",
_("Dithering"),
NULL,
TRUE,
GIMP_PARAM_STATIC_STRINGS);
}
static void
@ -237,36 +251,31 @@ gimp_blend_options_gui (GimpToolOptions *tool_options)
combo);
/* the offset scale */
scale = gimp_prop_spin_scale_new (config, "offset",
_("Offset"),
scale = gimp_prop_spin_scale_new (config, "offset", NULL,
1.0, 10.0, 1);
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
gtk_widget_show (scale);
/* the dither toggle */
button = gimp_prop_check_button_new (config, "dither",
_("Dithering"));
button = gimp_prop_check_button_new (config, "dither", NULL);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
/* supersampling options */
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
frame = gimp_prop_expanding_frame_new (config, "supersample",
_("Adaptive supersampling"),
frame = gimp_prop_expanding_frame_new (config, "supersample", NULL,
vbox2, NULL);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
/* max depth scale */
scale = gimp_prop_spin_scale_new (config, "supersample-depth",
_("Max depth"),
scale = gimp_prop_spin_scale_new (config, "supersample-depth", NULL,
1.0, 1.0, 0);
gtk_box_pack_start (GTK_BOX (vbox2), scale, FALSE, FALSE, 0);
gtk_widget_show (scale);
/* threshold scale */
scale = gimp_prop_spin_scale_new (config, "supersample-threshold",
_("Threshold"),
scale = gimp_prop_spin_scale_new (config, "supersample-threshold", NULL,
0.01, 0.1, 2);
gtk_box_pack_start (GTK_BOX (vbox2), scale, FALSE, FALSE, 0);
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->get_property = gimp_bucket_fill_options_get_property;
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_FILL_MODE,
"fill-mode", NULL,
GIMP_TYPE_BUCKET_FILL_MODE,
GIMP_BUCKET_FILL_FG,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_FILL_SELECTION,
"fill-selection",
_("Which area will be filled"),
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_FILL_TRANSPARENT,
"fill-transparent",
_("Allow completely transparent regions "
"to be filled"),
TRUE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_SAMPLE_MERGED,
"sample-merged",
_("Base filled area on all visible "
"layers"),
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_DIAGONAL_NEIGHBORS,
"diagonal-neighbors",
_("Treat diagonally neighboring pixels as "
"connected"),
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_THRESHOLD,
"threshold",
_("Maximum color difference"),
0.0, 255.0, 15.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_FILL_CRITERION,
"fill-criterion",
_("Criterion used for determining color similarity"),
GIMP_TYPE_SELECT_CRITERION,
GIMP_SELECT_CRITERION_COMPOSITE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_FILL_MODE,
"fill-mode",
_("Fill type"),
NULL,
GIMP_TYPE_BUCKET_FILL_MODE,
GIMP_BUCKET_FILL_FG,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_FILL_SELECTION,
"fill-selection",
_("Fill selection"),
_("Which area will be filled"),
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_FILL_TRANSPARENT,
"fill-transparent",
_("Fill transparent areas"),
_("Allow completely transparent regions "
"to be filled"),
TRUE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_SAMPLE_MERGED,
"sample-merged",
_("Sample merged"),
_("Base filled area on all visible layers"),
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_DIAGONAL_NEIGHBORS,
"diagonal-neighbors",
_("Diagonal neighbors"),
_("Treat diagonally neighboring pixels as "
"connected"),
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_THRESHOLD,
"threshold",
_("Threshold"),
_("Maximum color difference"),
0.0, 255.0, 15.0,
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
@ -293,26 +300,22 @@ gimp_bucket_fill_options_gui (GimpToolOptions *tool_options)
gtk_widget_show (vbox2);
/* the fill transparent areas toggle */
button = gimp_prop_check_button_new (config, "fill-transparent",
_("Fill transparent areas"));
button = gimp_prop_check_button_new (config, "fill-transparent", NULL);
gtk_box_pack_start (GTK_BOX (vbox2), button, FALSE, FALSE, 0);
gtk_widget_show (button);
/* the sample merged toggle */
button = gimp_prop_check_button_new (config, "sample-merged",
_("Sample merged"));
button = gimp_prop_check_button_new (config, "sample-merged", NULL);
gtk_box_pack_start (GTK_BOX (vbox2), button, FALSE, FALSE, 0);
gtk_widget_show (button);
/* the diagonal neighbors toggle */
button = gimp_prop_check_button_new (config, "diagonal-neighbors",
_("Diagonal neighbors"));
button = gimp_prop_check_button_new (config, "diagonal-neighbors", NULL);
gtk_box_pack_start (GTK_BOX (vbox2), button, FALSE, FALSE, 0);
gtk_widget_show (button);
/* the threshold scale */
scale = gimp_prop_spin_scale_new (config, "threshold",
_("Threshold"),
scale = gimp_prop_spin_scale_new (config, "threshold", NULL,
1.0, 16.0, 1);
gtk_box_pack_start (GTK_BOX (vbox2), scale, FALSE, FALSE, 0);
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->get_property = gimp_cage_options_get_property;
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_CAGE_MODE,
"cage-mode", NULL,
GIMP_TYPE_CAGE_MODE,
GIMP_CAGE_MODE_CAGE_CHANGE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_CAGE_MODE,
"cage-mode",
NULL, NULL,
GIMP_TYPE_CAGE_MODE,
GIMP_CAGE_MODE_CAGE_CHANGE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_FILL_PLAIN_COLOR,
"fill-plain-color", NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_FILL_PLAIN_COLOR,
"fill-plain-color",
_("Fill the original position\n"
"of the cage with a color"),
NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
}
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_widget_show (mode);
button = gimp_prop_check_button_new (config, "fill-plain-color",
_("Fill the original position\n"
"of the cage with a color"));
button = gimp_prop_check_button_new (config, "fill-plain-color", NULL);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
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_widget_show (source_vbox);
button = gimp_prop_check_button_new (config, "sample-merged",
_("Sample merged"));
button = gimp_prop_check_button_new (config, "sample-merged", NULL);
gtk_box_pack_start (GTK_BOX (source_vbox), button, FALSE, FALSE, 0);
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->get_property = gimp_color_options_get_property;
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_SAMPLE_MERGED,
"sample-merged", NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_SAMPLE_AVERAGE,
"sample-average", NULL,
TRUE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_AVERAGE_RADIUS,
"average-radius",
_("Color Picker Average Radius"),
1.0, 300.0, 3.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_SAMPLE_MERGED,
"sample-merged",
_("Sample merged"),
NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_SAMPLE_AVERAGE,
"sample-average",
_("Sample average"),
NULL,
TRUE,
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
@ -154,14 +161,12 @@ gimp_color_options_gui (GimpToolOptions *tool_options)
gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
scale = gimp_prop_spin_scale_new (config, "average-radius",
_("Radius"),
scale = gimp_prop_spin_scale_new (config, "average-radius", NULL,
1.0, 10.0, 0);
gtk_container_add (GTK_CONTAINER (frame), scale);
gtk_widget_show (scale);
button = gimp_prop_check_button_new (config, "sample-average",
_("Sample average"));
button = gimp_prop_check_button_new (config, "sample-average", NULL);
gtk_frame_set_label_widget (GTK_FRAME (frame), 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;
/* override a GimpColorOptions property to get a different default value */
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_SAMPLE_AVERAGE,
"sample-average",
_("Use accumulated color value from "
"all composited visible layers"),
FALSE,
GIMP_PARAM_STATIC_STRINGS);
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_CONFIG_PROP_BOOLEAN (object_class, PROP_SAMPLE_AVERAGE,
"sample-average",
_("Sample average"),
_("Use accumulated color value from "
"all composited visible layers"),
FALSE,
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
@ -154,8 +159,7 @@ gimp_color_picker_options_gui (GimpToolOptions *tool_options)
GdkModifierType toggle_mask = gimp_get_toggle_behavior_mask ();
/* the sample merged toggle button */
button = gimp_prop_check_button_new (config, "sample-merged",
_("Sample merged"));
button = gimp_prop_check_button_new (config, "sample-merged", NULL);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
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);
/* the rate scale */
scale = gimp_prop_spin_scale_new (config, "rate",
C_("convolve-tool", "Rate"),
scale = gimp_prop_spin_scale_new (config, "rate", NULL,
1.0, 10.0, 1);
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
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
* default values for the Crop and the Rectangle Select tools.
*/
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class,
GIMP_RECTANGLE_OPTIONS_PROP_HIGHLIGHT,
"highlight",
_("Dim everything outside selection"),
TRUE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class,
GIMP_RECTANGLE_OPTIONS_PROP_HIGHLIGHT,
"highlight",
_("Highlight"),
_("Dim everything outside selection"),
TRUE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_LAYER_ONLY,
"layer-only",
_("Crop only currently selected layer"),
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_LAYER_ONLY,
"layer-only",
_("Current layer only"),
_("Crop only currently selected layer"),
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_ALLOW_GROWING,
"allow-growing",
_("Allow resizing canvas by dragging cropping frame "
"beyond image boundary"),
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_ALLOW_GROWING,
"allow-growing",
_("Allow growing"),
_("Allow resizing canvas by dragging cropping frame "
"beyond image boundary"),
FALSE,
GIMP_PARAM_STATIC_STRINGS);
gimp_rectangle_options_install_properties (object_class);
}
@ -161,14 +164,12 @@ gimp_crop_options_gui (GimpToolOptions *tool_options)
GtkWidget *button;
/* layer toggle */
button = gimp_prop_check_button_new (config, "layer-only",
_("Current layer only"));
button = gimp_prop_check_button_new (config, "layer-only", NULL);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
/* allow growing toggle */
button = gimp_prop_check_button_new (config, "allow-growing",
_("Allow growing"));
button = gimp_prop_check_button_new (config, "allow-growing", NULL);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
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);
/* 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_widget_show (frame);
/* the exposure scale */
scale = gimp_prop_spin_scale_new (config, "exposure",
_("Exposure"),
scale = gimp_prop_spin_scale_new (config, "exposure", NULL,
1.0, 10.0, 1);
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
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->get_property = gimp_flip_options_get_property;
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_FLIP_TYPE,
"flip-type",
N_("Direction of flipping"),
GIMP_TYPE_ORIENTATION_TYPE,
GIMP_ORIENTATION_HORIZONTAL,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_FLIP_TYPE,
"flip-type",
_("Flip Type"),
_("Direction of flipping"),
GIMP_TYPE_ORIENTATION_TYPE,
GIMP_ORIENTATION_HORIZONTAL,
GIMP_PARAM_STATIC_STRINGS);
}
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 */
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_DRAW_MODE,
"draw-mode",
_("Paint over areas to mark color values for "
"inclusion or exclusion from selection"),
GIMP_TYPE_MATTING_DRAW_MODE,
GIMP_MATTING_DRAW_MODE_FOREGROUND,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_DRAW_MODE,
"draw-mode",
_("Draw Mode"),
_("Paint over areas to mark color values for "
"inclusion or exclusion from selection"),
GIMP_TYPE_MATTING_DRAW_MODE,
GIMP_MATTING_DRAW_MODE_FOREGROUND,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_INT (object_class, PROP_STROKE_WIDTH,
"stroke-width",
_("Size of the brush used for refinements"),
1, 6000, 10,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_INT (object_class, PROP_STROKE_WIDTH,
"stroke-width",
_("Stroke width"),
_("Size of the brush used for refinements"),
1, 6000, 10,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_MASK_COLOR,
"mask-color",
_("Color of selection preview mask"),
GIMP_TYPE_CHANNEL_TYPE,
GIMP_BLUE_CHANNEL,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_MASK_COLOR,
"mask-color",
_("Preview color"),
_("Color of selection preview mask"),
GIMP_TYPE_CHANNEL_TYPE,
GIMP_BLUE_CHANNEL,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_ENGINE,
"engine",
_("Matting engine to use"),
GIMP_TYPE_MATTING_ENGINE,
GIMP_MATTING_ENGINE_GLOBAL,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_ENGINE,
"engine",
_("Engine"),
_("Matting engine to use"),
GIMP_TYPE_MATTING_ENGINE,
GIMP_MATTING_ENGINE_GLOBAL,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_INT (object_class, PROP_LEVELS,
"levels",
_("Number of downsampled levels to use"),
1, 10, 2,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_INT (object_class, PROP_LEVELS,
"levels",
_("Levels"),
_("Number of downsampled levels to use"),
1, 10, 2,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_INT (object_class, PROP_ACTIVE_LEVELS,
"active-levels",
_("Number of levels to perform solving"),
1, 10, 2,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_INT (object_class, PROP_ACTIVE_LEVELS,
"active-levels",
_("Active levels"),
_("Number of levels to perform solving"),
1, 10, 2,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_INT (object_class, PROP_ITERATIONS,
"iterations",
_("Number of iterations to perform"),
1, 10, 2,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_INT (object_class, PROP_ITERATIONS,
"iterations",
_("Iterations"),
_("Number of iterations to perform"),
1, 10, 2,
GIMP_PARAM_STATIC_STRINGS);
}
static void
@ -261,8 +268,8 @@ gimp_foreground_select_options_gui (GimpToolOptions *tool_options)
antialias_toggle = GIMP_SELECTION_OPTIONS (tool_options)->antialias_toggle;
gtk_widget_hide (antialias_toggle);
frame = gimp_prop_enum_radio_frame_new (config, "draw-mode", _("Draw Mode"),
0,0);
frame = gimp_prop_enum_radio_frame_new (config, "draw-mode", NULL,
0, 0);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
@ -271,8 +278,7 @@ gimp_foreground_select_options_gui (GimpToolOptions *tool_options)
gtk_widget_show (hbox);
/* stroke width */
scale = gimp_prop_spin_scale_new (config, "stroke-width",
_("Stroke width"),
scale = gimp_prop_spin_scale_new (config, "stroke-width", NULL,
1.0, 10.0, 2);
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);
@ -320,8 +326,7 @@ gimp_foreground_select_options_gui (GimpToolOptions *tool_options)
gtk_widget_show (inner_vbox);
/* engine parameters */
scale = gimp_prop_spin_scale_new (config, "levels",
_("Levels"),
scale = gimp_prop_spin_scale_new (config, "levels", NULL,
1.0, 1.0, 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),
NULL);
scale = gimp_prop_spin_scale_new (config, "active-levels",
_("Active levels"),
scale = gimp_prop_spin_scale_new (config, "active-levels", NULL,
1.0, 1.0, 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),
NULL);
scale = gimp_prop_spin_scale_new (config, "iterations",
_("Iterations"),
scale = gimp_prop_spin_scale_new (config, "iterations", NULL,
1.0, 1.0, 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->get_property = gimp_handle_transform_options_get_property;
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_HANDLE_MODE,
"handle-mode",
N_("Handle mode"),
GIMP_TYPE_TRANSFORM_HANDLE_MODE,
GIMP_HANDLE_MODE_ADD_TRANSFORM,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_HANDLE_MODE,
"handle-mode",
_("Handle mode"),
_("Handle mode"),
GIMP_TYPE_TRANSFORM_HANDLE_MODE,
GIMP_HANDLE_MODE_ADD_TRANSFORM,
GIMP_PARAM_STATIC_STRINGS);
}
static void
@ -138,8 +139,8 @@ gimp_handle_transform_options_gui (GimpToolOptions *tool_options)
GtkWidget *button;
gint i;
frame = gimp_prop_enum_radio_frame_new (config, "handle-mode",
_("Handle mode"), 0, 0);
frame = gimp_prop_enum_radio_frame_new (config, "handle-mode", NULL,
0, 0);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
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->get_property = gimp_histogram_options_get_property;
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_SCALE,
"histogram-scale", NULL,
GIMP_TYPE_HISTOGRAM_SCALE,
GIMP_HISTOGRAM_SCALE_LINEAR,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_SCALE,
"histogram-scale",
_("Histogram Scale"),
NULL,
GIMP_TYPE_HISTOGRAM_SCALE,
GIMP_HISTOGRAM_SCALE_LINEAR,
GIMP_PARAM_STATIC_STRINGS);
}
static void
@ -123,8 +125,8 @@ gimp_histogram_options_gui (GimpToolOptions *tool_options)
GtkWidget *vbox = gimp_tool_options_gui (tool_options);
GtkWidget *frame;
frame = gimp_prop_enum_radio_frame_new (config, "histogram-scale",
_("Histogram Scale"), 0, 0);
frame = gimp_prop_enum_radio_frame_new (config, "histogram-scale", NULL,
0, 0);
gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);

12
app/tools/gimpimagemapoptions.c
View File

@ -26,6 +26,8 @@
#include "gimpimagemapoptions.h"
#include "gimp-intl.h"
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->get_property = gimp_image_map_options_get_property;
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_PREVIEW,
"preview", NULL,
TRUE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_PREVIEW,
"preview",
_("_Preview"),
NULL,
TRUE,
GIMP_PARAM_STATIC_STRINGS);
g_object_class_install_property (object_class, PROP_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 */
toggle = gimp_prop_check_button_new (G_OBJECT (tool_info->tool_options),
"preview",
_("_Preview"));
"preview", NULL);
gtk_box_pack_end (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
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);
/* size slider */
scale = gimp_prop_spin_scale_new (config, "size",
_("Size"),
scale = gimp_prop_spin_scale_new (config, "size", NULL,
1.0, 2.0, 1);
gtk_box_pack_start (GTK_BOX (vbox2), scale, FALSE, FALSE, 0);
gtk_widget_show (scale);
/* angle adjust slider */
scale = gimp_prop_spin_scale_new (config, "tilt-angle",
_("Angle"),
scale = gimp_prop_spin_scale_new (config, "tilt-angle", NULL,
1.0, 10.0, 1);
gtk_box_pack_start (GTK_BOX (vbox2), scale, FALSE, FALSE, 0);
gtk_widget_show (scale);
@ -84,22 +82,19 @@ gimp_ink_options_gui (GimpToolOptions *tool_options)
gtk_widget_show (vbox2);
/* size sens slider */
scale = gimp_prop_spin_scale_new (config, "size-sensitivity",
_("Size"),
scale = gimp_prop_spin_scale_new (config, "size-sensitivity", NULL,
0.01, 0.1, 2);
gtk_box_pack_start (GTK_BOX (vbox2), scale, FALSE, FALSE, 0);
gtk_widget_show (scale);
/* tilt sens slider */
scale = gimp_prop_spin_scale_new (config, "tilt-sensitivity",
_("Tilt"),
scale = gimp_prop_spin_scale_new (config, "tilt-sensitivity", NULL,
0.01, 0.1, 2);
gtk_box_pack_start (GTK_BOX (vbox2), scale, FALSE, FALSE, 0);
gtk_widget_show (scale);
/* velocity sens slider */
scale = gimp_prop_spin_scale_new (config, "vel-sensitivity",
_("Speed"),
scale = gimp_prop_spin_scale_new (config, "vel-sensitivity", NULL,
0.01, 0.1, 2);
gtk_box_pack_start (GTK_BOX (vbox2), scale, FALSE, FALSE, 0);
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->get_property = gimp_iscissors_options_get_property;
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_INTERACTIVE,
"interactive",
N_("Display future selection segment "
"as you drag a control node"),
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_INTERACTIVE,
"interactive",
_("Interactive boundary"),
_("Display future selection segment "
"as you drag a control node"),
FALSE,
GIMP_PARAM_STATIC_STRINGS);
}
static void
@ -124,8 +125,7 @@ gimp_iscissors_options_gui (GimpToolOptions *tool_options)
GtkWidget *vbox = gimp_selection_options_gui (tool_options);
GtkWidget *button;
button = gimp_prop_check_button_new (config, "interactive",
_("Interactive boundary"));
button = gimp_prop_check_button_new (config, "interactive", NULL);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
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->get_property = gimp_magnify_options_get_property;
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_AUTO_RESIZE,
"auto-resize",
_("Resize image window to accommodate "
"new zoom level"),
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_AUTO_RESIZE,
"auto-resize",
_("Auto-resize window"),
_("Resize image window to accommodate "
"new zoom level"),
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_ZOOM_TYPE,
"zoom-type",
_("Direction of magnification"),
GIMP_TYPE_ZOOM_TYPE,
GIMP_ZOOM_IN,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_ZOOM_TYPE,
"zoom-type",
_("Direction"),
_("Direction of magnification"),
GIMP_TYPE_ZOOM_TYPE,
GIMP_ZOOM_IN,
GIMP_PARAM_STATIC_STRINGS);
}
static void
@ -181,8 +183,7 @@ gimp_magnify_options_gui (GimpToolOptions *tool_options)
toggle_mask = gimp_get_toggle_behavior_mask ();
/* the auto_resize toggle button */
button = gimp_prop_check_button_new (config, "auto-resize",
_("Auto-resize window"));
button = gimp_prop_check_button_new (config, "auto-resize", NULL);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
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->get_property = gimp_measure_options_get_property;
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_USE_INFO_WINDOW,
"use-info-window",
N_("Open a floating dialog to view details "
"about measurements"),
FALSE,
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 details "
"about measurements"),
FALSE,
GIMP_PARAM_STATIC_STRINGS);
}
static void
@ -122,8 +123,7 @@ gimp_measure_options_gui (GimpToolOptions *tool_options)
GtkWidget *button;
/* the use_info_window toggle button */
button = gimp_prop_check_button_new (config, "use-info-window",
_("Use info window"));
button = gimp_prop_check_button_new (config, "use-info-window", NULL);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
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->get_property = gimp_move_options_get_property;
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_MOVE_TYPE,
"move-type", NULL,
GIMP_TYPE_TRANSFORM_TYPE,
GIMP_TRANSFORM_TYPE_LAYER,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_MOVE_CURRENT,
"move-current", NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_MOVE_TYPE,
"move-type",
NULL, NULL,
GIMP_TYPE_TRANSFORM_TYPE,
GIMP_TRANSFORM_TYPE_LAYER,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_MOVE_CURRENT,
"move-current",
NULL, NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
}
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);
/* erase mode */
scale = gimp_prop_check_button_new (config, "eraser",
_("Erase with this brush"));
scale = gimp_prop_check_button_new (config, "eraser", NULL);
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
gtk_widget_show (scale);
/* radius */
scale = gimp_prop_spin_scale_new (config, "radius",
_("Radius"),
scale = gimp_prop_spin_scale_new (config, "radius", NULL,
0.1, 1.0, 2);
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
gtk_widget_show (scale);
/* opaque */
scale = gimp_prop_spin_scale_new (config, "opaque",
_("Base Opacity"),
scale = gimp_prop_spin_scale_new (config, "opaque", NULL,
0.1, 1.0, 2);
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
gtk_widget_show (scale);
/* hardness */
scale = gimp_prop_spin_scale_new (config, "hardness",
_("Hardness"),
scale = gimp_prop_spin_scale_new (config, "hardness", NULL,
0.1, 1.0, 2);
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
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->get_property = gimp_n_point_deformation_options_get_property;
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_SQUARE_SIZE,
"square-size", _("Density"),
5.0, 1000.0, 20.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_SQUARE_SIZE,
"square-size",
_("Density"),
_("Density"),
5.0, 1000.0, 20.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_RIGIDITY,
"rigidity", _("Rigidity"),
1.0, 10000.0, 100.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_RIGIDITY,
"rigidity",
_("Rigidity"),
_("Rigidity"),
1.0, 10000.0, 100.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_ASAP_DEFORMATION,
"asap-deformation", _("Deformation mode"),
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_ASAP_DEFORMATION,
"asap-deformation",
_("Deformation mode"),
_("Deformation mode"),
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_MLS_WEIGHTS,
"mls-weights", _("Use weights"),
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_MLS_WEIGHTS,
"mls-weights",
_("Use weights"),
_("Use weights"),
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_MLS_WEIGHTS_ALPHA,
"mls-weights-alpha",
_("Amount of control points' influence"),
0.1, 2.0, 1.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_MLS_WEIGHTS_ALPHA,
"mls-weights-alpha",
_("Control points influence"),
_("Amount of control points' influence"),
0.1, 2.0, 1.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_MESH_VISIBLE,
"mesh-visible", _("Show lattice"),
TRUE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_MESH_VISIBLE,
"mesh-visible",
_("Show lattice"),
_("Show lattice"),
TRUE,
GIMP_PARAM_STATIC_STRINGS);
}
static void
@ -193,44 +204,41 @@ gimp_n_point_deformation_options_gui (GimpToolOptions *tool_options)
npd_options = GIMP_N_POINT_DEFORMATION_OPTIONS (tool_options);
widget = gimp_prop_check_button_new (config, "mesh-visible",
_("Show lattice"));
widget = gimp_prop_check_button_new (config, "mesh-visible", NULL);
npd_options->check_mesh_visible = widget;
gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
gtk_widget_set_can_focus (widget, FALSE);
gtk_widget_show (widget);
widget = gimp_prop_spin_scale_new (config, "square-size",
_("Density"), 1.0, 10.0, 0);
widget = gimp_prop_spin_scale_new (config, "square-size", NULL,
1.0, 10.0, 0);
npd_options->scale_square_size = widget;
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_widget_set_can_focus (widget, FALSE);
gtk_widget_show (widget);
widget = gimp_prop_spin_scale_new (config, "rigidity",
_("Rigidity"), 1.0, 10.0, 0);
widget = gimp_prop_spin_scale_new (config, "rigidity", NULL,
1.0, 10.0, 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_widget_set_can_focus (widget, FALSE);
gtk_widget_show (widget);
widget = gimp_prop_boolean_radio_frame_new (config, "asap-deformation",
_("Deformation mode"),
NULL,
_("Scale"),
_("Rigid (Rubber)"));
gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
gtk_widget_set_can_focus (widget, FALSE);
gtk_widget_show (widget);
widget = gimp_prop_check_button_new (config, "mls-weights",
_("Use weights"));
widget = gimp_prop_check_button_new (config, "mls-weights", NULL);
gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
gtk_widget_set_can_focus (widget, FALSE);
gtk_widget_show (widget);
widget = gimp_prop_spin_scale_new (config, "mls-weights-alpha",
_("Amount of control points' influence"),
widget = gimp_prop_spin_scale_new (config, "mls-weights-alpha", NULL,
0.1, 0.1, 1);
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);

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
(GObject *config,
gchar *prop_name,
gchar *prop_descr,
gchar *link_prop_name,
gchar *reset_tooltip,
gdouble step_increment,
@ -127,8 +126,7 @@ gimp_paint_options_gui (GimpToolOptions *tool_options)
}
/* the opacity scale */
scale = gimp_prop_spin_scale_new (config, "opacity",
_("Opacity"),
scale = gimp_prop_spin_scale_new (config, "opacity", NULL,
0.01, 0.1, 0);
gimp_prop_widget_set_factor (scale, 100.0, 0.0, 0.0, 1);
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
@ -140,8 +138,7 @@ gimp_paint_options_gui (GimpToolOptions *tool_options)
{
GtkWidget *button;
button = gimp_prop_check_button_new (config, "use-applicator",
"Use GimpApplicator");
button = gimp_prop_check_button_new (config, "use-applicator", NULL);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
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);
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"),
1.0, 10.0, 2, 1.0, 1000.0, 1.0, 1.7,
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);
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"),
0.1, 1.0, 2, -20.0, 20.0, 1.0, 1.0,
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);
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"),
0.1, 1.0, 2, -180.0, 180.0, 1.0, 1.0,
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);
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"),
0.1, 1.0, 1, 1.0, 200.0, 100.0, 1.7,
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);
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"),
0.1, 1.0, 1, 0.0, 100.0, 100.0, 1.0,
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);
hbox = gimp_paint_options_gui_scale_with_buttons
(config, "brush-force", _("Force"), NULL,
(config, "brush-force", NULL,
_("Reset force to default"),
0.1, 1.0, 1, 0.0, 100.0, 100.0, 1.0,
G_CALLBACK (gimp_paint_options_gui_reset_force), link_group);
@ -249,8 +246,7 @@ gimp_paint_options_gui (GimpToolOptions *tool_options)
{
GtkWidget *button;
button = gimp_prop_check_button_new (config,
"brush-zoom",
button = gimp_prop_check_button_new (config, "brush-zoom",
_("Lock brush size to zoom"));
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
@ -263,9 +259,8 @@ gimp_paint_options_gui (GimpToolOptions *tool_options)
{
GtkWidget *button;
button = gimp_prop_enum_check_button_new (config,
"application-mode",
_("Incremental"),
button = gimp_prop_enum_check_button_new (config, "application-mode",
NULL,
GIMP_PAINT_CONSTANT,
GIMP_PAINT_INCREMENTAL);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
@ -283,7 +278,7 @@ gimp_paint_options_gui (GimpToolOptions *tool_options)
{
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_widget_show (button);
}
@ -310,8 +305,7 @@ dynamics_options_gui (GimpPaintOptions *paint_options,
GtkWidget *hbox;
GtkWidget *box;
frame = gimp_prop_expander_new (config, "dynamics-expanded",
_("Dynamics Options"));
frame = gimp_prop_expander_new (config, "dynamics-expanded", NULL);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
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_widget_show (hbox);
scale = gimp_prop_spin_scale_new (config, "fade-length",
_("Fade length"), 1.0, 50.0, 0);
scale = gimp_prop_spin_scale_new (config, "fade-length", NULL,
1.0, 50.0, 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_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_widget_show (combo);
checkbox = gimp_prop_check_button_new (config, "fade-reverse",
_("Reverse"));
checkbox = gimp_prop_check_button_new (config, "fade-reverse", NULL);
gtk_box_pack_start (GTK_BOX (inner_vbox), checkbox, FALSE, FALSE, 0);
gtk_widget_show (checkbox);
@ -386,12 +379,10 @@ jitter_options_gui (GimpPaintOptions *paint_options,
GtkWidget *frame;
GtkWidget *scale;
scale = gimp_prop_spin_scale_new (config, "jitter-amount",
_("Amount"),
scale = gimp_prop_spin_scale_new (config, "jitter-amount", NULL,
0.01, 1.0, 2);
frame = gimp_prop_expanding_frame_new (config, "use-jitter",
_("Apply Jitter"),
frame = gimp_prop_expanding_frame_new (config, "use-jitter", NULL,
scale, NULL);
return frame;
@ -408,18 +399,15 @@ smoothing_options_gui (GimpPaintOptions *paint_options,
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
frame = gimp_prop_expanding_frame_new (config, "use-smoothing",
_("Smooth stroke"),
frame = gimp_prop_expanding_frame_new (config, "use-smoothing", NULL,
vbox, NULL);
scale = gimp_prop_spin_scale_new (config, "smoothing-quality",
_("Quality"),
scale = gimp_prop_spin_scale_new (config, "smoothing-quality", NULL,
1, 10, 1);
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
gtk_widget_show (scale);
scale = gimp_prop_spin_scale_new (config, "smoothing-factor",
_("Weight"),
scale = gimp_prop_spin_scale_new (config, "smoothing-factor", NULL,
1, 10, 1);
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
gtk_widget_show (scale);
@ -516,7 +504,6 @@ gimp_paint_options_gui_reset_force (GtkWidget *button,
static GtkWidget *
gimp_paint_options_gui_scale_with_buttons (GObject *config,
gchar *prop_name,
gchar *prop_descr,
gchar *link_prop_name,
gchar *reset_tooltip,
gdouble step_increment,
@ -535,8 +522,7 @@ gimp_paint_options_gui_scale_with_buttons (GObject *config,
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
scale = gimp_prop_spin_scale_new (config, prop_name,
prop_descr,
scale = gimp_prop_spin_scale_new (config, prop_name, NULL,
step_increment, page_increment, digits);
gimp_prop_widget_set_factor (scale, factor,
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 *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);
gtk_box_pack_start (GTK_BOX (vbox), mode, FALSE, FALSE, 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_param_spec_boolean ("shrink-merged",
NULL,
N_("Use all visible layers when shrinking "
"the selection"),
_("Shrink merged"),
_("Use all visible layers when shrinking "
"the selection"),
FALSE,
GIMP_CONFIG_PARAM_FLAGS |
GIMP_PARAM_STATIC_STRINGS));
@ -314,8 +314,8 @@ gimp_rectangle_options_iface_base_init (GimpRectangleOptionsInterface *iface)
g_object_interface_install_property (iface,
g_param_spec_boolean ("fixed-center",
NULL,
N_("Expand selection from center outwards"),
_("Expand from center"),
_("Expand selection from center outwards"),
FALSE,
GIMP_CONFIG_PARAM_FLAGS |
GIMP_PARAM_STATIC_STRINGS));
@ -836,8 +836,7 @@ gimp_rectangle_options_gui (GimpToolOptions *tool_options)
private = GIMP_RECTANGLE_OPTIONS_GET_PRIVATE (tool_options);
/* Fixed Center */
button = gimp_prop_check_button_new (config, "fixed-center",
_("Expand from center"));
button = gimp_prop_check_button_new (config, "fixed-center", NULL);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
@ -860,6 +859,7 @@ gimp_rectangle_options_gui (GimpToolOptions *tool_options)
gtk_widget_show (hbox);
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_widget_show (button);
@ -1026,8 +1026,7 @@ gimp_rectangle_options_gui (GimpToolOptions *tool_options)
gtk_widget_show (frame);
/* Highlight */
button = gimp_prop_check_button_new (config, "highlight",
_("Highlight"));
button = gimp_prop_check_button_new (config, "highlight", NULL);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
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),
(gpointer) &private->auto_shrink_button);
button = gimp_prop_check_button_new (config, "shrink-merged",
_("Shrink merged"));
button = gimp_prop_check_button_new (config, "shrink-merged", NULL);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
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
* default values for the Crop and the Rectangle Select tools.
*/
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class,
GIMP_RECTANGLE_OPTIONS_PROP_HIGHLIGHT,
"highlight",
_("Dim everything outside selection"),
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class,
GIMP_RECTANGLE_OPTIONS_PROP_HIGHLIGHT,
"highlight",
_("Highlight"),
_("Dim everything outside selection"),
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_ROUND_CORNERS,
"round-corners",
_("Round corners of selection"),
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_ROUND_CORNERS,
"round-corners",
_("Rounded corners"),
_("Round corners of selection"),
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_CORNER_RADIUS,
"corner-radius",
_("Radius of rounding in pixels"),
0.0, 100.0, 5.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_CORNER_RADIUS,
"corner-radius",
_("Radius"),
_("Radius of rounding in pixels"),
0.0, 100.0, 5.0,
GIMP_PARAM_STATIC_STRINGS);
gimp_rectangle_options_install_properties (object_class);
}
@ -160,12 +163,10 @@ gimp_rectangle_select_options_gui (GimpToolOptions *tool_options)
GtkWidget *scale;
GtkWidget *toggle;
scale = gimp_prop_spin_scale_new (config, "corner-radius",
_("Radius"),
scale = gimp_prop_spin_scale_new (config, "corner-radius", NULL,
1.0, 10.0, 1);
frame = gimp_prop_expanding_frame_new (config, "round-corners",
_("Rounded corners"),
frame = gimp_prop_expanding_frame_new (config, "round-corners", NULL,
scale, NULL);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
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->get_property = gimp_region_select_options_get_property;
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_SELECT_TRANSPARENT,
"select-transparent",
_("Allow completely transparent regions "
"to be selected"),
TRUE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_SELECT_TRANSPARENT,
"select-transparent",
_("Select transparent areas"),
_("Allow completely transparent regions "
"to be selected"),
TRUE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_SAMPLE_MERGED,
"sample-merged",
_("Base selection on all visible layers"),
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_SAMPLE_MERGED,
"sample-merged",
_("Sample merged"),
_("Base selection on all visible layers"),
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_DIAGONAL_NEIGHBORS,
"diagonal-neighbors",
_("Treat diagonally neighboring pixels as "
"connected"),
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_DIAGONAL_NEIGHBORS,
"diagonal-neighbors",
_("Diagonal neighbors"),
_("Treat diagonally neighboring pixels as "
"connected"),
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_THRESHOLD,
"threshold",
_("Maximum color difference"),
0.0, 255.0, 15.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_THRESHOLD,
"threshold",
_("Threshold"),
_("Maximum color difference"),
0.0, 255.0, 15.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_SELECT_CRITERION,
"select-criterion",
_("Selection criterion"),
GIMP_TYPE_SELECT_CRITERION,
GIMP_SELECT_CRITERION_COMPOSITE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_SELECT_CRITERION,
"select-criterion",
_("Select by"),
_("Selection criterion"),
GIMP_TYPE_SELECT_CRITERION,
GIMP_SELECT_CRITERION_COMPOSITE,
GIMP_PARAM_STATIC_STRINGS);
g_object_class_install_property (object_class, PROP_DRAW_MASK,
g_param_spec_boolean ("draw-mask",
"Draw mask",
_("Draw mask"),
_("Draw the selected region's mask"),
FALSE,
G_PARAM_READWRITE |
@ -248,29 +253,25 @@ gimp_region_select_options_gui (GimpToolOptions *tool_options)
tool_type = tool_options->tool_info->tool_type;
/* the select transparent areas toggle */
button = gimp_prop_check_button_new (config, "select-transparent",
_("Select transparent areas"));
button = gimp_prop_check_button_new (config, "select-transparent", NULL);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
/* the sample merged toggle */
button = gimp_prop_check_button_new (config, "sample-merged",
_("Sample merged"));
button = gimp_prop_check_button_new (config, "sample-merged", NULL);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
/* the diagonal neighbors toggle */
if (tool_type == GIMP_TYPE_FUZZY_SELECT_TOOL)
{
button = gimp_prop_check_button_new (config, "diagonal-neighbors",
_("Diagonal neighbors"));
button = gimp_prop_check_button_new (config, "diagonal-neighbors", NULL);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
}
/* the threshold scale */
scale = gimp_prop_spin_scale_new (config, "threshold",
_("Threshold"),
scale = gimp_prop_spin_scale_new (config, "threshold", NULL,
1.0, 16.0, 1);
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
gtk_widget_show (scale);
@ -282,8 +283,7 @@ gimp_region_select_options_gui (GimpToolOptions *tool_options)
gtk_widget_show (combo);
/* the show mask toggle */
button = gimp_prop_check_button_new (config, "draw-mask",
_("Draw Mask"));
button = gimp_prop_check_button_new (config, "draw-mask", NULL);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
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->get_property = gimp_seamless_clone_options_get_property;
GIMP_CONFIG_INSTALL_PROP_INT (object_class, PROP_MAX_REFINE_SCALE,
"max-refine-scale",
_("Maximal scale of refinement points to be used for the interpolation mesh"),
0, 50, 5,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_INT (object_class, PROP_MAX_REFINE_SCALE,
"max-refine-scale",
_("Refinement scale"),
_("Maximal scale of refinement points to be "
"used for the interpolation mesh"),
0, 50, 5,
GIMP_PARAM_STATIC_STRINGS);
}
static void
@ -126,8 +128,7 @@ gimp_seamless_clone_options_gui (GimpToolOptions *tool_options)
GtkWidget *vbox = gimp_tool_options_gui (tool_options);
GtkWidget *scale;
scale = gimp_prop_spin_scale_new (config, "max-refine-scale",
_("Refinement scale"),
scale = gimp_prop_spin_scale_new (config, "max-refine-scale", NULL,
1.0, 10.0, 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);

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

3
app/tools/gimpsmudgetool.c
View File

@ -88,8 +88,7 @@ gimp_smudge_options_gui (GimpToolOptions *tool_options)
GtkWidget *scale;
/* the rate scale */
scale = gimp_prop_spin_scale_new (config, "rate",
C_("smudge-tool", "Rate"),
scale = gimp_prop_spin_scale_new (config, "rate", NULL,
1.0, 10.0, 1);
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
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
* default values for the Crop, Text and the Rectangle Select tools.
*/
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class,
GIMP_RECTANGLE_OPTIONS_PROP_HIGHLIGHT,
"highlight", NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class,
GIMP_RECTANGLE_OPTIONS_PROP_HIGHLIGHT,
"highlight",
_("Highlight"),
NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_UNIT (object_class, PROP_UNIT,
"font-size-unit",
_("Font size unit"),
TRUE, FALSE, GIMP_UNIT_PIXEL,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_FONT_SIZE,
"font-size",
_("Font size"),
0.0, 8192.0, 18.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_ANTIALIAS,
"antialias", NULL,
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_PROP_UNIT (object_class, PROP_UNIT,
"font-size-unit",
_("Unit"),
_("Font size unit"),
TRUE, FALSE, GIMP_UNIT_PIXEL,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_FONT_SIZE,
"font-size",
_("Font size"),
_("Font size"),
0.0, 8192.0, 18.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_USE_EDITOR,
"use-editor",
_("Use an external editor window for text "
"entry"),
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_ANTIALIAS,
"antialias",
_("Antialiasing"),
NULL,
TRUE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_FONT_VIEW_TYPE,
"font-view-type", NULL,
GIMP_TYPE_VIEW_TYPE,
GIMP_VIEW_TYPE_LIST,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_INT (object_class, PROP_FONT_VIEW_SIZE,
"font-view-size", NULL,
GIMP_VIEW_SIZE_TINY,
GIMP_VIEWABLE_MAX_BUTTON_SIZE,
GIMP_VIEW_SIZE_SMALL,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_HINT_STYLE,
"hint-style",
_("Hinting"),
_("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_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);
}
@ -544,11 +569,11 @@ gimp_text_options_gui (GimpToolOptions *tool_options)
gtk_box_pack_start (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0);
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_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_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->get_property = gimp_transform_options_get_property;
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_TYPE,
"type", NULL,
GIMP_TYPE_TRANSFORM_TYPE,
GIMP_TRANSFORM_TYPE_LAYER,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_DIRECTION,
"direction",
_("Direction of transformation"),
GIMP_TYPE_TRANSFORM_DIRECTION,
GIMP_TRANSFORM_FORWARD,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_INTERPOLATION,
"interpolation",
_("Interpolation method"),
GIMP_TYPE_INTERPOLATION_TYPE,
GIMP_INTERPOLATION_LINEAR,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_CLIP,
"clip",
_("How to clip"),
GIMP_TYPE_TRANSFORM_RESIZE,
GIMP_TRANSFORM_RESIZE_ADJUST,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_SHOW_PREVIEW,
"show-preview",
_("Show a preview of the transformed image"),
TRUE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_PREVIEW_OPACITY,
"preview-opacity",
_("Opacity of the preview image"),
0.0, 1.0, 1.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_GRID_TYPE,
"grid-type",
_("Composition guides such as rule of thirds"),
GIMP_TYPE_GUIDES_TYPE,
GIMP_GUIDES_N_LINES,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_INT (object_class, PROP_GRID_SIZE,
"grid-size",
_("Size of a grid cell for variable number "
"of composition guides"),
1, 128, 15,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_CONSTRAIN_MOVE,
"constrain-move",
NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_CONSTRAIN_SCALE,
"constrain-scale",
NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_CONSTRAIN_ROTATE,
"constrain-rotate",
NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_CONSTRAIN_SHEAR,
"constrain-shear",
NULL,
TRUE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_CONSTRAIN_PERSPECTIVE,
"constrain-perspective",
NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_FROMPIVOT_SCALE,
"frompivot-scale",
NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_FROMPIVOT_SHEAR,
"frompivot-shear",
NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_FROMPIVOT_PERSPECTIVE,
"frompivot-perspective",
NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_CORNERSNAP,
"cornersnap",
NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_FIXEDPIVOT,
"fixedpivot",
NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_TYPE,
"type",
NULL, NULL,
GIMP_TYPE_TRANSFORM_TYPE,
GIMP_TRANSFORM_TYPE_LAYER,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_DIRECTION,
"direction",
_("Direction"),
_("Direction of transformation"),
GIMP_TYPE_TRANSFORM_DIRECTION,
GIMP_TRANSFORM_FORWARD,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_INTERPOLATION,
"interpolation",
_("Interpolation"),
_("Interpolation method"),
GIMP_TYPE_INTERPOLATION_TYPE,
GIMP_INTERPOLATION_LINEAR,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_CLIP,
"clip",
_("Clipping"),
_("How to clip"),
GIMP_TYPE_TRANSFORM_RESIZE,
GIMP_TRANSFORM_RESIZE_ADJUST,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_SHOW_PREVIEW,
"show-preview",
_("Show image preview"),
_("Show a preview of the transformed image"),
TRUE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_PREVIEW_OPACITY,
"preview-opacity",
_("Image opacity"),
_("Opacity of the preview image"),
0.0, 1.0, 1.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_GRID_TYPE,
"grid-type",
_("Guides"),
_("Composition guides such as rule of thirds"),
GIMP_TYPE_GUIDES_TYPE,
GIMP_GUIDES_N_LINES,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_INT (object_class, PROP_GRID_SIZE,
"grid-size",
NULL,
_("Size of a grid cell for variable number "
"of composition guides"),
1, 128, 15,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_CONSTRAIN_MOVE,
"constrain-move",
NULL, NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_CONSTRAIN_SCALE,
"constrain-scale",
NULL, NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_CONSTRAIN_ROTATE,
"constrain-rotate",
NULL, NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_CONSTRAIN_SHEAR,
"constrain-shear",
NULL, NULL,
TRUE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_CONSTRAIN_PERSPECTIVE,
"constrain-perspective",
NULL, NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_FROMPIVOT_SCALE,
"frompivot-scale",
NULL, NULL,
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
@ -406,8 +431,8 @@ gimp_transform_options_gui (GimpToolOptions *tool_options)
gtk_box_pack_start (GTK_BOX (hbox), box, FALSE, FALSE, 0);
gtk_widget_show (box);
frame = gimp_prop_enum_radio_frame_new (config, "direction",
_("Direction"), 0, 0);
frame = gimp_prop_enum_radio_frame_new (config, "direction", NULL,
0, 0);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
@ -426,12 +451,10 @@ gimp_transform_options_gui (GimpToolOptions *tool_options)
gtk_widget_show (combo);
/* the preview frame */
scale = gimp_prop_spin_scale_new (config, "preview-opacity",
_("Image opacity"),
scale = gimp_prop_spin_scale_new (config, "preview-opacity", NULL,
0.01, 0.1, 0);
gimp_prop_widget_set_factor (scale, 100.0, 0.0, 0.0, 1);
frame = gimp_prop_expanding_frame_new (config, "show-preview",
_("Show image preview"),
frame = gimp_prop_expanding_frame_new (config, "show-preview", NULL,
scale, NULL);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
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->get_property = gimp_vector_options_get_property;
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_VECTORS_EDIT_MODE,
"vectors-edit-mode", NULL,
GIMP_TYPE_VECTOR_MODE,
GIMP_VECTOR_MODE_DESIGN,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_VECTORS_EDIT_MODE,
"vectors-edit-mode",
_("Edit Mode"),
NULL,
GIMP_TYPE_VECTOR_MODE,
GIMP_VECTOR_MODE_DESIGN,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_VECTORS_POLYGONAL,
"vectors-polygonal",
N_("Restrict editing to polygons"),
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_VECTORS_POLYGONAL,
"vectors-polygonal",
_("Polygonal"),
_("Restrict editing to polygons"),
FALSE,
GIMP_PARAM_STATIC_STRINGS);
}
static void
@ -152,8 +155,8 @@ gimp_vector_options_gui (GimpToolOptions *tool_options)
gchar *str;
/* tool toggle */
frame = gimp_prop_enum_radio_frame_new (config, "vectors-edit-mode",
_("Edit Mode"), 0, 0);
frame = gimp_prop_enum_radio_frame_new (config, "vectors-edit-mode", NULL,
0, 0);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
@ -171,8 +174,7 @@ gimp_vector_options_gui (GimpToolOptions *tool_options)
gimp_get_toggle_behavior_mask ());
}
button = gimp_prop_check_button_new (config, "vectors-polygonal",
_("Polygonal"));
button = gimp_prop_check_button_new (config, "vectors-polygonal", NULL);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
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->get_property = gimp_warp_options_get_property;
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_BEHAVIOR,
"behavior",
_("Behavior"),
GIMP_TYPE_WARP_BEHAVIOR,
GIMP_WARP_BEHAVIOR_MOVE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_BEHAVIOR,
"behavior",
_("Behavior"),
_("Behavior"),
GIMP_TYPE_WARP_BEHAVIOR,
GIMP_WARP_BEHAVIOR_MOVE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_EFFECT_STRENGTH,
"effect-strength",
_("Effect Strength"),
1.0, 100.0, 50.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_EFFECT_STRENGTH,
"effect-strength",
_("Strength"),
_("Effect Strength"),
1.0, 100.0, 50.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_EFFECT_SIZE,
"effect-size",
_("Effect Size"),
1.0, 10000.0, 40.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_EFFECT_SIZE,
"effect-size",
_("Size"),
_("Effect Size"),
1.0, 10000.0, 40.0,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_EFFECT_HARDNESS,
"effect-hardness",
_("Effect Hardness"),
0.0, 1.0, 0.5,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_EFFECT_HARDNESS,
"effect-hardness",
_("Hardness"),
_("Effect Hardness"),
0.0, 1.0, 0.5,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_INT (object_class, PROP_N_ANIMATION_FRAMES,
"n-animation-frames",
_("Number of animation frames"),
3, 1000, 10,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_INT (object_class, PROP_N_ANIMATION_FRAMES,
"n-animation-frames",
_("Frames"),
_("Number of animation frames"),
3, 1000, 10,
GIMP_PARAM_STATIC_STRINGS);
}
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_widget_show (combo);
scale = gimp_prop_spin_scale_new (config, "effect-strength",
_("Strength"),
scale = gimp_prop_spin_scale_new (config, "effect-strength", NULL,
1, 10, 1);
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_widget_show (scale);
scale = gimp_prop_spin_scale_new (config, "effect-size",
_("Size"),
scale = gimp_prop_spin_scale_new (config, "effect-size", NULL,
0.01, 1.0, 2);
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_widget_show (scale);
scale = gimp_prop_spin_scale_new (config, "effect-hardness",
_("Hardness"),
scale = gimp_prop_spin_scale_new (config, "effect-hardness", NULL,
0.01, 1.0, 2);
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);
@ -218,8 +220,7 @@ gimp_warp_options_gui (GimpToolOptions *tool_options)
gtk_container_add (GTK_CONTAINER (frame), anim_vbox);
gtk_widget_show (anim_vbox);
scale = gimp_prop_spin_scale_new (config, "n-animation-frames",
_("Frames"),
scale = gimp_prop_spin_scale_new (config, "n-animation-frames", NULL,
1.0, 10.0, 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);

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;
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_ENABLED,
"enabled", NULL,
TRUE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_DEBUG_EVENTS,
"debug-events", NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_CONTROLLER,
"controller", NULL,
GIMP_TYPE_CONTROLLER,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOXED (object_class, PROP_MAPPING,
"mapping", NULL,
G_TYPE_HASH_TABLE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_ENABLED,
"enabled",
_("Enabled"),
NULL,
TRUE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_DEBUG_EVENTS,
"debug-events",
_("Debug events"),
NULL,
FALSE,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_OBJECT (object_class, PROP_CONTROLLER,
"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] =
g_signal_new ("event-mapped",

23
app/widgets/gimpdeviceinfo.c
View File

@ -41,6 +41,8 @@
#include "gimpdeviceinfo.h"
#include "gimp-intl.h"
#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_CONSTRUCT));
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_MODE, "mode", NULL,
GDK_TYPE_INPUT_MODE,
GDK_MODE_DISABLED,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_ENUM (object_class, PROP_MODE,
"mode",
_("Mode"),
NULL,
GDK_TYPE_INPUT_MODE,
GDK_MODE_DISABLED,
GIMP_PARAM_STATIC_STRINGS);
param_spec = g_param_spec_enum ("axis",
NULL, NULL,
@ -153,10 +158,12 @@ gimp_device_info_class_init (GimpDeviceInfoClass *klass)
GIMP_PARAM_STATIC_STRINGS |
GIMP_CONFIG_PARAM_FLAGS));
GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_PRESSURE_CURVE,
"pressure-curve", NULL,
GIMP_TYPE_CURVE,
GIMP_CONFIG_PARAM_AGGREGATE);
GIMP_CONFIG_PROP_OBJECT (object_class, PROP_PRESSURE_CURVE,
"pressure-curve",
_("Pressure curve"),
NULL,
GIMP_TYPE_CURVE,
GIMP_CONFIG_PARAM_AGGREGATE);
}
static void

1
app/widgets/gimpdynamicseditor.c
View File

@ -352,6 +352,7 @@ dynamics_check_button_new (GObject *config,
GtkWidget *button;
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_SHRINK, GTK_SHRINK, 0, 0);
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);
button = editor->priv->fg_bg_toggle =
gimp_prop_check_button_new (G_OBJECT (preset), "use-fg-bg",
_("Apply stored FG/BG"));
gimp_prop_check_button_new (G_OBJECT (preset), "use-fg-bg", NULL);
gtk_box_pack_start (GTK_BOX (data_editor), button, FALSE, FALSE, 0);
gtk_widget_show (button);
button = editor->priv->brush_toggle =
gimp_prop_check_button_new (G_OBJECT (preset), "use-brush",
_("Apply stored brush"));
gimp_prop_check_button_new (G_OBJECT (preset), "use-brush", NULL);
gtk_box_pack_start (GTK_BOX (data_editor), button, FALSE, FALSE, 0);
gtk_widget_show (button);
button = editor->priv->dynamics_toggle =
gimp_prop_check_button_new (G_OBJECT (preset), "use-dynamics",
_("Apply stored dynamics"));
gimp_prop_check_button_new (G_OBJECT (preset), "use-dynamics", NULL);
gtk_box_pack_start (GTK_BOX (data_editor), button, FALSE, FALSE, 0);
gtk_widget_show (button);
button = editor->priv->mybrush_toggle =
gimp_prop_check_button_new (G_OBJECT (preset), "use-mypaint-brush",
_("Apply stored MyPaint brush"));
gimp_prop_check_button_new (G_OBJECT (preset), "use-mypaint-brush", NULL);
gtk_box_pack_start (GTK_BOX (data_editor), button, FALSE, FALSE, 0);
gtk_widget_show (button);
button = editor->priv->gradient_toggle =
gimp_prop_check_button_new (G_OBJECT (preset), "use-gradient",
_("Apply stored gradient"));
gimp_prop_check_button_new (G_OBJECT (preset), "use-gradient", NULL);
gtk_box_pack_start (GTK_BOX (data_editor), button, FALSE, FALSE, 0);
gtk_widget_show (button);
button = editor->priv->pattern_toggle =
gimp_prop_check_button_new (G_OBJECT (preset), "use-pattern",
_("Apply stored pattern"));
gimp_prop_check_button_new (G_OBJECT (preset), "use-pattern", NULL);
gtk_box_pack_start (GTK_BOX (data_editor), button, FALSE, FALSE, 0);
gtk_widget_show (button);
button = editor->priv->palette_toggle =
gimp_prop_check_button_new (G_OBJECT (preset), "use-palette",
_("Apply stored palette"));
gimp_prop_check_button_new (G_OBJECT (preset), "use-palette", NULL);
gtk_box_pack_start (GTK_BOX (data_editor), button, FALSE, FALSE, 0);
gtk_widget_show (button);
button = editor->priv->font_toggle =
gimp_prop_check_button_new (G_OBJECT (preset), "use-font",
_("Apply stored font"));
gimp_prop_check_button_new (G_OBJECT (preset), "use-font", NULL);
gtk_box_pack_start (GTK_BOX (data_editor), button, FALSE, FALSE, 0);
gtk_widget_show (button);