static void
tool_manager_disconnect_options (GimpToolManager *tool_manager,
GimpContext *user_context,
GimpToolInfo *tool_info)
{
if (tool_info->context_props)
{
if (GIMP_IS_PAINT_OPTIONS (tool_info->tool_options))
{
/* Storing is unconditional, because the user may turn on
* brush sharing mid use
*/
gimp_paint_options_copy_brush_props (GIMP_PAINT_OPTIONS (tool_info->tool_options),
tool_manager->shared_paint_options);
gimp_paint_options_copy_dynamics_props (GIMP_PAINT_OPTIONS (tool_info->tool_options),
tool_manager->shared_paint_options);
gimp_paint_options_copy_gradient_props (GIMP_PAINT_OPTIONS (tool_info->tool_options),
tool_manager->shared_paint_options);
}
gimp_context_set_parent (GIMP_CONTEXT (tool_info->tool_options), NULL);
}
}
static void
tool_manager_preset_changed (GimpContext *user_context,
GimpToolPreset *preset,
GimpToolManager *tool_manager)
{
GimpToolInfo *preset_tool;
gchar *options_name;
gboolean tool_change = FALSE;
if (! preset || user_context->gimp->busy)
return;
preset_tool = gimp_context_get_tool (GIMP_CONTEXT (preset->tool_options));
if (preset_tool != gimp_context_get_tool (user_context))
tool_change = TRUE;
/* save the name, we don't want to overwrite it */
options_name = g_strdup (gimp_object_get_name (preset_tool->tool_options));
gimp_config_copy (GIMP_CONFIG (preset->tool_options),
GIMP_CONFIG (preset_tool->tool_options), 0);
/* restore the saved name */
gimp_object_take_name (GIMP_OBJECT (preset_tool->tool_options), options_name);
if (tool_change)
gimp_context_set_tool (user_context, preset_tool);
gimp_context_copy_properties (GIMP_CONTEXT (preset->tool_options),
user_context,
gimp_tool_preset_get_prop_mask (preset));
if (GIMP_IS_PAINT_OPTIONS (preset->tool_options))
{
GimpToolOptions *src;
GimpToolOptions *dest;
GimpContextPropMask prop_mask = 0;
src = preset->tool_options;
dest = tool_manager->active_tool->tool_info->tool_options;
/* copy various data objects' additional tool options again
* manually, they might have been overwritten by e.g. the "link
* brush stuff to brush defaults" logic in gimptooloptions.c
*/
if (preset->use_brush)
prop_mask |= GIMP_CONTEXT_PROP_MASK_BRUSH;
if (preset->use_dynamics)
prop_mask |= GIMP_CONTEXT_PROP_MASK_DYNAMICS;
if (preset->use_gradient)
prop_mask |= GIMP_CONTEXT_PROP_MASK_GRADIENT;
gimp_paint_options_copy_props (GIMP_PAINT_OPTIONS (src),
GIMP_PAINT_OPTIONS (dest),
prop_mask);
}
}
static void
tool_manager_connect_options (GimpToolManager *tool_manager,
GimpContext *user_context,
GimpToolInfo *tool_info)
{
if (tool_info->context_props)
{
GimpCoreConfig *config = user_context->gimp->config;
GimpContextPropMask global_props = 0;
/* FG and BG are always shared between all tools */
global_props |= GIMP_CONTEXT_PROP_MASK_FOREGROUND;
global_props |= GIMP_CONTEXT_PROP_MASK_BACKGROUND;
if (config->global_brush)
global_props |= GIMP_CONTEXT_PROP_MASK_BRUSH;
if (config->global_dynamics)
global_props |= GIMP_CONTEXT_PROP_MASK_DYNAMICS;
if (config->global_pattern)
global_props |= GIMP_CONTEXT_PROP_MASK_PATTERN;
if (config->global_palette)
global_props |= GIMP_CONTEXT_PROP_MASK_PALETTE;
if (config->global_gradient)
global_props |= GIMP_CONTEXT_PROP_MASK_GRADIENT;
if (config->global_font)
global_props |= GIMP_CONTEXT_PROP_MASK_FONT;
gimp_context_copy_properties (GIMP_CONTEXT (tool_info->tool_options),
user_context,
tool_info->context_props & ~global_props);
gimp_context_set_parent (GIMP_CONTEXT (tool_info->tool_options),
user_context);
if (GIMP_IS_PAINT_OPTIONS (tool_info->tool_options))
{
if (config->global_brush)
gimp_paint_options_copy_brush_props (tool_manager->shared_paint_options,
GIMP_PAINT_OPTIONS (tool_info->tool_options));
if (config->global_dynamics)
gimp_paint_options_copy_dynamics_props (tool_manager->shared_paint_options,
GIMP_PAINT_OPTIONS (tool_info->tool_options));
if (config->global_gradient)
gimp_paint_options_copy_gradient_props (tool_manager->shared_paint_options,
GIMP_PAINT_OPTIONS (tool_info->tool_options));
}
}
}
static void
gimp_paint_options_finalize (GObject *object)
{
GimpPaintOptions *options = GIMP_PAINT_OPTIONS (object);
g_slice_free (GimpJitterOptions, options->jitter_options);
g_slice_free (GimpFadeOptions, options->fade_options);
g_slice_free (GimpGradientOptions, options->gradient_options);
g_slice_free (GimpSmoothingOptions, options->smoothing_options);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gimp_paint_options_dispose (GObject *object)
{
GimpPaintOptions *options = GIMP_PAINT_OPTIONS (object);
if (options->paint_info)
{
g_object_unref (options->paint_info);
options->paint_info = NULL;
}
G_OBJECT_CLASS (parent_class)->dispose (object);
}
static void
gimp_paint_options_finalize (GObject *object)
{
GimpPaintOptions *options = GIMP_PAINT_OPTIONS (object);
if (options->paint_info)
g_object_unref (options->paint_info);
g_slice_free (GimpDynamicOptions, options->pressure_options);
g_slice_free (GimpDynamicOptions, options->velocity_options);
g_slice_free (GimpDynamicOptions, options->random_options);
g_slice_free (GimpFadeOptions, options->fade_options);
g_slice_free (GimpJitterOptions, options->jitter_options);
g_slice_free (GimpGradientOptions, options->gradient_options);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gimp_pencil_options_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
GimpPaintOptions *options = GIMP_PAINT_OPTIONS (object);
switch (property_id)
{
case PROP_HARD:
g_value_set_boolean (value, options->hard);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
gimp_blend_tool_commit (GimpBlendTool *blend_tool)
{
GimpTool *tool = GIMP_TOOL (blend_tool);
GimpBlendOptions *options = GIMP_BLEND_TOOL_GET_OPTIONS (tool);
GimpPaintOptions *paint_options = GIMP_PAINT_OPTIONS (options);
GimpContext *context = GIMP_CONTEXT (options);
GimpImage *image = gimp_display_get_image (tool->display);
GimpDrawable *drawable = gimp_image_get_active_drawable (image);
GimpProgress *progress;
gint off_x;
gint off_y;
progress = gimp_progress_start (GIMP_PROGRESS (tool), FALSE,
_("Blending"));
gimp_item_get_offset (GIMP_ITEM (drawable), &off_x, &off_y);
gimp_drawable_blend (drawable,
context,
gimp_context_get_gradient (context),
gimp_context_get_paint_mode (context),
options->gradient_type,
gimp_context_get_opacity (context),
options->offset,
paint_options->gradient_options->gradient_repeat,
paint_options->gradient_options->gradient_reverse,
options->supersample,
options->supersample_depth,
options->supersample_threshold,
options->dither,
blend_tool->start_x - off_x,
blend_tool->start_y - off_y,
blend_tool->end_x - off_x,
blend_tool->end_y - off_y,
progress);
if (progress)
gimp_progress_end (progress);
gimp_image_flush (image);
}
static void
gimp_blend_options_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
GimpBlendOptions *options = GIMP_BLEND_OPTIONS (object);
switch (property_id)
{
case PROP_OFFSET:
g_value_set_double (value, options->offset);
break;
case PROP_GRADIENT_TYPE:
g_value_set_enum (value, options->gradient_type);
break;
case PROP_GRADIENT_REPEAT:
g_value_set_enum (value,
GIMP_PAINT_OPTIONS (options)->gradient_options->gradient_repeat);
break;
case PROP_SUPERSAMPLE:
g_value_set_boolean (value, options->supersample);
break;
case PROP_SUPERSAMPLE_DEPTH:
g_value_set_int (value, options->supersample_depth);
break;
case PROP_SUPERSAMPLE_THRESHOLD:
g_value_set_double (value, options->supersample_threshold);
break;
case PROP_DITHER:
g_value_set_boolean (value, options->dither);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
gimp_paint_options_notify (GObject *object,
GParamSpec *pspec)
{
GimpPaintOptions *options = GIMP_PAINT_OPTIONS (object);
if (pspec->param_id == PROP_USE_GRADIENT)
{
if (options->gradient_options->use_gradient)
{
options->application_mode_save = options->application_mode;
options->application_mode = GIMP_PAINT_INCREMENTAL;
}
else
{
options->application_mode = options->application_mode_save;
}
g_object_notify (object, "application-mode");
}
if (G_OBJECT_CLASS (parent_class)->notify)
G_OBJECT_CLASS (parent_class)->notify (object, pspec);
}
static void
gimp_paint_options_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
GimpPaintOptions *options = GIMP_PAINT_OPTIONS (object);
GimpFadeOptions *fade_options = options->fade_options;
GimpJitterOptions *jitter_options = options->jitter_options;
GimpGradientOptions *gradient_options = options->gradient_options;
GimpSmoothingOptions *smoothing_options = options->smoothing_options;
switch (property_id)
{
case PROP_PAINT_INFO:
g_value_set_object (value, options->paint_info);
break;
case PROP_USE_APPLICATOR:
g_value_set_boolean (value, options->use_applicator);
break;
case PROP_BRUSH_SIZE:
g_value_set_double (value, options->brush_size);
break;
case PROP_BRUSH_ZOOM:
g_value_set_boolean (value, options->brush_zoom);
break;
case PROP_BRUSH_ASPECT_RATIO:
g_value_set_double (value, options->brush_aspect_ratio);
break;
case PROP_BRUSH_ANGLE:
g_value_set_double (value, - 1.0 * options->brush_angle * 360.0); /* mathematically correct -> intuitively correct */
break;
case PROP_BRUSH_SPACING:
g_value_set_double (value, options->brush_spacing);
break;
case PROP_BRUSH_HARDNESS:
g_value_set_double (value, options->brush_hardness);
break;
case PROP_BRUSH_FORCE:
g_value_set_double (value, options->brush_force);
break;
case PROP_BRUSH_LINK_SIZE:
g_value_set_boolean (value, options->brush_link_size);
break;
case PROP_BRUSH_LINK_ASPECT_RATIO:
g_value_set_boolean (value, options->brush_link_aspect_ratio);
break;
case PROP_BRUSH_LINK_ANGLE:
g_value_set_boolean (value, options->brush_link_angle);
break;
case PROP_BRUSH_LINK_SPACING:
g_value_set_boolean (value, options->brush_link_spacing);
break;
case PROP_BRUSH_LINK_HARDNESS:
g_value_set_boolean (value, options->brush_link_hardness);
break;
case PROP_APPLICATION_MODE:
g_value_set_enum (value, options->application_mode);
break;
case PROP_HARD:
g_value_set_boolean (value, options->hard);
break;
case PROP_USE_JITTER:
g_value_set_boolean (value, jitter_options->use_jitter);
break;
case PROP_JITTER_AMOUNT:
g_value_set_double (value, jitter_options->jitter_amount);
break;
case PROP_DYNAMICS_EXPANDED:
g_value_set_boolean (value, options->dynamics_expanded);
break;
case PROP_FADE_LENGTH:
g_value_set_double (value, fade_options->fade_length);
break;
case PROP_FADE_REVERSE:
g_value_set_boolean (value, fade_options->fade_reverse);
break;
case PROP_FADE_REPEAT:
g_value_set_enum (value, fade_options->fade_repeat);
break;
case PROP_FADE_UNIT:
g_value_set_int (value, fade_options->fade_unit);
break;
case PROP_GRADIENT_REVERSE:
g_value_set_boolean (value, gradient_options->gradient_reverse);
break;
case PROP_BRUSH_VIEW_TYPE:
g_value_set_enum (value, options->brush_view_type);
break;
case PROP_BRUSH_VIEW_SIZE:
g_value_set_int (value, options->brush_view_size);
break;
case PROP_DYNAMICS_VIEW_TYPE:
g_value_set_enum (value, options->dynamics_view_type);
break;
case PROP_DYNAMICS_VIEW_SIZE:
g_value_set_int (value, options->dynamics_view_size);
break;
case PROP_PATTERN_VIEW_TYPE:
g_value_set_enum (value, options->pattern_view_type);
break;
case PROP_PATTERN_VIEW_SIZE:
g_value_set_int (value, options->pattern_view_size);
break;
case PROP_GRADIENT_VIEW_TYPE:
g_value_set_enum (value, options->gradient_view_type);
break;
case PROP_GRADIENT_VIEW_SIZE:
g_value_set_int (value, options->gradient_view_size);
break;
case PROP_USE_SMOOTHING:
g_value_set_boolean (value, smoothing_options->use_smoothing);
break;
case PROP_SMOOTHING_QUALITY:
g_value_set_int (value, smoothing_options->smoothing_quality);
break;
case PROP_SMOOTHING_FACTOR:
g_value_set_double (value, smoothing_options->smoothing_factor);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
GtkWidget *
gimp_paint_options_gui (GimpToolOptions *tool_options)
{
GObject *config = G_OBJECT (tool_options);
GimpPaintOptions *options = GIMP_PAINT_OPTIONS (tool_options);
GtkWidget *vbox = gimp_tool_options_gui (tool_options);
GtkWidget *hbox;
GtkWidget *menu;
GtkWidget *label;
GtkWidget *scale;
GType tool_type;
tool_type = tool_options->tool_info->tool_type;
/* the paint mode menu */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
label = gtk_label_new (_("Mode:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
menu = gimp_prop_paint_mode_menu_new (config, "paint-mode", TRUE, FALSE);
gtk_box_pack_start (GTK_BOX (hbox), menu, TRUE, TRUE, 0);
gtk_widget_show (menu);
if (tool_type == GIMP_TYPE_ERASER_TOOL ||
tool_type == GIMP_TYPE_CONVOLVE_TOOL ||
tool_type == GIMP_TYPE_DODGE_BURN_TOOL ||
tool_type == GIMP_TYPE_SMUDGE_TOOL)
{
gtk_widget_set_sensitive (menu, FALSE);
gtk_widget_set_sensitive (label, FALSE);
}
/* the opacity scale */
scale = gimp_prop_opacity_spin_scale_new (config, "opacity",
_("Opacity"));
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
gtk_widget_show (scale);
/* the brush */
if (g_type_is_a (tool_type, GIMP_TYPE_BRUSH_TOOL))
{
GtkWidget *button;
GtkWidget *hbox;
GtkWidget *frame;
button = gimp_prop_brush_box_new (NULL, GIMP_CONTEXT (tool_options),
_("Brush"), 2,
"brush-view-type", "brush-view-size",
"gimp-brush-editor");
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
scale = gimp_prop_spin_scale_new (config, "brush-size",
_("Size"),
0.01, 1.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);
gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0);
gtk_widget_show (scale);
button = gimp_stock_button_new (GIMP_STOCK_RESET, NULL);
gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE);
gtk_image_set_from_stock (GTK_IMAGE (gtk_bin_get_child (GTK_BIN (button))),
GIMP_STOCK_RESET, GTK_ICON_SIZE_MENU);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
g_signal_connect (button, "clicked",
G_CALLBACK (gimp_paint_options_gui_reset_size),
options);
gimp_help_set_help_data (button,
_("Reset size to brush's native size"), NULL);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
scale = gimp_prop_spin_scale_new (config, "brush-aspect-ratio",
_("Aspect Ratio"),
0.01, 0.1, 2);
gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0);
gtk_widget_show (scale);
button = gimp_stock_button_new (GIMP_STOCK_RESET, NULL);
gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE);
gtk_image_set_from_stock (GTK_IMAGE (gtk_bin_get_child (GTK_BIN (button))),
GIMP_STOCK_RESET, GTK_ICON_SIZE_MENU);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
g_signal_connect (button, "clicked",
G_CALLBACK (gimp_paint_options_gui_reset_aspect_ratio),
options);
gimp_help_set_help_data (button,
_("Reset aspect ratio to brush's native"), NULL);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
scale = gimp_prop_spin_scale_new (config, "brush-angle",
_("Angle"),
1.0, 5.0, 2);
gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0);
gtk_widget_show (scale);
button = gimp_stock_button_new (GIMP_STOCK_RESET, NULL);
gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE);
gtk_image_set_from_stock (GTK_IMAGE (gtk_bin_get_child (GTK_BIN (button))),
GIMP_STOCK_RESET, GTK_ICON_SIZE_MENU);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
g_signal_connect (button, "clicked",
G_CALLBACK (gimp_paint_options_gui_reset_angle),
options);
gimp_help_set_help_data (button,
_("Reset angle to zero"), NULL);
button = gimp_prop_dynamics_box_new (NULL, GIMP_CONTEXT (tool_options),
_("Dynamics"), 2,
"dynamics-view-type",
"dynamics-view-size",
"gimp-dynamics-editor");
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
frame = dynamics_options_gui (options, tool_type);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
frame = jitter_options_gui (options, tool_type);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
}
/* the "smooth stroke" options */
if (g_type_is_a (tool_type, GIMP_TYPE_PAINT_TOOL))
{
GtkWidget *frame;
frame = smoothing_options_gui (options, tool_type);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
}
/* the "incremental" toggle */
if (tool_type == GIMP_TYPE_PENCIL_TOOL ||
tool_type == GIMP_TYPE_PAINTBRUSH_TOOL ||
tool_type == GIMP_TYPE_ERASER_TOOL)
{
GtkWidget *button;
button = gimp_prop_enum_check_button_new (config,
"application-mode",
_("Incremental"),
GIMP_PAINT_CONSTANT,
GIMP_PAINT_INCREMENTAL);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
}
/* the "hard edge" toggle */
if (tool_type == GIMP_TYPE_ERASER_TOOL ||
tool_type == GIMP_TYPE_CLONE_TOOL ||
tool_type == GIMP_TYPE_HEAL_TOOL ||
tool_type == GIMP_TYPE_PERSPECTIVE_CLONE_TOOL ||
tool_type == GIMP_TYPE_CONVOLVE_TOOL ||
tool_type == GIMP_TYPE_DODGE_BURN_TOOL ||
tool_type == GIMP_TYPE_SMUDGE_TOOL)
{
GtkWidget *button;
button = gimp_prop_check_button_new (config, "hard", _("Hard edge"));
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
}
return vbox;
}
static void
gimp_paint_options_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
GimpPaintOptions *options = GIMP_PAINT_OPTIONS (object);
GimpDynamicOptions *pressure_options = options->pressure_options;
GimpDynamicOptions *velocity_options = options->velocity_options;
GimpDynamicOptions *random_options = options->random_options;
GimpFadeOptions *fade_options = options->fade_options;
GimpJitterOptions *jitter_options = options->jitter_options;
GimpGradientOptions *gradient_options = options->gradient_options;
switch (property_id)
{
case PROP_PAINT_INFO:
g_value_set_object (value, options->paint_info);
break;
case PROP_BRUSH_SCALE:
g_value_set_double (value, options->brush_scale);
break;
case PROP_APPLICATION_MODE:
g_value_set_enum (value, options->application_mode);
break;
case PROP_HARD:
g_value_set_boolean (value, options->hard);
break;
case PROP_DYNAMICS_EXPANDED:
g_value_set_boolean (value, options->dynamics_expanded);
break;
case PROP_PRESSURE_OPACITY:
g_value_set_boolean (value, pressure_options->opacity);
break;
case PROP_PRESSURE_HARDNESS:
g_value_set_boolean (value, pressure_options->hardness);
break;
case PROP_PRESSURE_RATE:
g_value_set_boolean (value, pressure_options->rate);
break;
case PROP_PRESSURE_SIZE:
g_value_set_boolean (value, pressure_options->size);
break;
case PROP_PRESSURE_INVERSE_SIZE:
g_value_set_boolean (value, pressure_options->inverse_size);
break;
case PROP_PRESSURE_COLOR:
g_value_set_boolean (value, pressure_options->color);
break;
case PROP_PRESSURE_PRESCALE:
g_value_set_double (value, pressure_options->prescale);
break;
case PROP_VELOCITY_OPACITY:
g_value_set_boolean (value, velocity_options->opacity);
break;
case PROP_VELOCITY_HARDNESS:
g_value_set_boolean (value, velocity_options->hardness);
break;
case PROP_VELOCITY_RATE:
g_value_set_boolean (value, velocity_options->rate);
break;
case PROP_VELOCITY_SIZE:
g_value_set_boolean (value, velocity_options->size);
break;
case PROP_VELOCITY_INVERSE_SIZE:
g_value_set_boolean (value, velocity_options->inverse_size);
break;
case PROP_VELOCITY_COLOR:
g_value_set_boolean (value, velocity_options->color);
break;
case PROP_VELOCITY_PRESCALE:
g_value_set_double (value, velocity_options->prescale);
break;
case PROP_RANDOM_OPACITY:
g_value_set_boolean (value, random_options->opacity);
break;
case PROP_RANDOM_HARDNESS:
g_value_set_boolean (value, random_options->hardness);
break;
case PROP_RANDOM_RATE:
g_value_set_boolean (value, random_options->rate);
break;
case PROP_RANDOM_SIZE:
g_value_set_boolean (value, random_options->size);
break;
case PROP_RANDOM_INVERSE_SIZE:
g_value_set_boolean (value, random_options->inverse_size);
break;
case PROP_RANDOM_COLOR:
g_value_set_boolean (value, random_options->color);
break;
case PROP_RANDOM_PRESCALE:
g_value_set_double (value, random_options->prescale);
break;
case PROP_USE_FADE:
g_value_set_boolean (value, fade_options->use_fade);
break;
case PROP_FADE_LENGTH:
g_value_set_double (value, fade_options->fade_length);
break;
case PROP_FADE_UNIT:
g_value_set_int (value, fade_options->fade_unit);
break;
case PROP_USE_JITTER:
g_value_set_boolean (value, jitter_options->use_jitter);
break;
case PROP_JITTER_AMOUNT:
g_value_set_double (value, jitter_options->jitter_amount);
break;
case PROP_USE_GRADIENT:
g_value_set_boolean (value, gradient_options->use_gradient);
break;
case PROP_GRADIENT_REVERSE:
g_value_set_boolean (value, gradient_options->gradient_reverse);
break;
case PROP_GRADIENT_REPEAT:
g_value_set_enum (value, gradient_options->gradient_repeat);
break;
case PROP_GRADIENT_LENGTH:
g_value_set_double (value, gradient_options->gradient_length);
break;
case PROP_GRADIENT_UNIT:
g_value_set_int (value, gradient_options->gradient_unit);
break;
case PROP_BRUSH_VIEW_TYPE:
g_value_set_enum (value, options->brush_view_type);
break;
case PROP_BRUSH_VIEW_SIZE:
g_value_set_int (value, options->brush_view_size);
break;
case PROP_PATTERN_VIEW_TYPE:
g_value_set_enum (value, options->pattern_view_type);
break;
case PROP_PATTERN_VIEW_SIZE:
g_value_set_int (value, options->pattern_view_size);
break;
case PROP_GRADIENT_VIEW_TYPE:
g_value_set_enum (value, options->gradient_view_type);
break;
case PROP_GRADIENT_VIEW_SIZE:
g_value_set_int (value, options->gradient_view_size);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
tool_manager_preset_changed (GimpContext *user_context,
GimpToolPreset *preset,
GimpToolManager *tool_manager)
{
GimpToolInfo *preset_tool;
gchar *options_name;
gboolean tool_change = FALSE;
if (! preset || user_context->gimp->busy)
return;
preset_tool = gimp_context_get_tool (GIMP_CONTEXT (preset->tool_options));
if (preset_tool != gimp_context_get_tool (user_context))
tool_change = TRUE;
if (! tool_change)
tool_manager_disconnect_options (tool_manager, user_context, preset_tool);
/* save the name, we don't want to overwrite it */
options_name = g_strdup (gimp_object_get_name (preset_tool->tool_options));
gimp_config_copy (GIMP_CONFIG (preset->tool_options),
GIMP_CONFIG (preset_tool->tool_options), 0);
/* restore the saved name */
gimp_object_take_name (GIMP_OBJECT (preset_tool->tool_options), options_name);
if (tool_change)
gimp_context_set_tool (user_context, preset_tool);
else
tool_manager_connect_options (tool_manager, user_context, preset_tool);
gimp_context_copy_properties (GIMP_CONTEXT (preset->tool_options),
user_context,
gimp_tool_preset_get_prop_mask (preset));
if (GIMP_IS_PAINT_OPTIONS (preset->tool_options))
{
GimpCoreConfig *config = user_context->gimp->config;
GimpToolOptions *src = preset->tool_options;
GimpToolOptions *dest = tool_manager->active_tool->tool_info->tool_options;
/* if connect_options() did overwrite the brush options and the
* preset contains a brush, use the brush options from the
* preset
*/
if (config->global_brush && preset->use_brush)
gimp_paint_options_copy_brush_props (GIMP_PAINT_OPTIONS (src),
GIMP_PAINT_OPTIONS (dest));
if (config->global_dynamics && preset->use_dynamics)
gimp_paint_options_copy_dynamics_props (GIMP_PAINT_OPTIONS (src),
GIMP_PAINT_OPTIONS (dest));
if (config->global_gradient && preset->use_gradient)
gimp_paint_options_copy_gradient_props (GIMP_PAINT_OPTIONS (src),
GIMP_PAINT_OPTIONS (dest));
}
}
static void
gimp_paint_options_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
GimpPaintOptions *options = GIMP_PAINT_OPTIONS (object);
GimpFadeOptions *fade_options = options->fade_options;
GimpJitterOptions *jitter_options = options->jitter_options;
GimpGradientOptions *gradient_options = options->gradient_options;
GimpSmoothingOptions *smoothing_options = options->smoothing_options;
switch (property_id)
{
case PROP_PAINT_INFO:
options->paint_info = g_value_dup_object (value);
break;
case PROP_USE_APPLICATOR:
options->use_applicator = g_value_get_boolean (value);
break;
case PROP_BRUSH_SIZE:
options->brush_size = g_value_get_double (value);
break;
case PROP_BRUSH_ASPECT_RATIO:
options->brush_aspect_ratio = g_value_get_double (value);
break;
case PROP_BRUSH_ANGLE:
options->brush_angle = - 1.0 * g_value_get_double (value) / 360.0; /* let's make the angle mathematically correct */
break;
case PROP_APPLICATION_MODE:
options->application_mode = g_value_get_enum (value);
break;
case PROP_HARD:
options->hard = g_value_get_boolean (value);
break;
case PROP_USE_JITTER:
jitter_options->use_jitter = g_value_get_boolean (value);
break;
case PROP_JITTER_AMOUNT:
jitter_options->jitter_amount = g_value_get_double (value);
break;
case PROP_DYNAMICS_EXPANDED:
options->dynamics_expanded = g_value_get_boolean (value);
break;
case PROP_FADE_LENGTH:
fade_options->fade_length = g_value_get_double (value);
break;
case PROP_FADE_REVERSE:
fade_options->fade_reverse = g_value_get_boolean (value);
break;
case PROP_FADE_REPEAT:
fade_options->fade_repeat = g_value_get_enum (value);
break;
case PROP_FADE_UNIT:
fade_options->fade_unit = g_value_get_int (value);
break;
case PROP_GRADIENT_REVERSE:
gradient_options->gradient_reverse = g_value_get_boolean (value);
break;
case PROP_BRUSH_VIEW_TYPE:
options->brush_view_type = g_value_get_enum (value);
break;
case PROP_BRUSH_VIEW_SIZE:
options->brush_view_size = g_value_get_int (value);
break;
case PROP_DYNAMICS_VIEW_TYPE:
options->dynamics_view_type = g_value_get_enum (value);
break;
case PROP_DYNAMICS_VIEW_SIZE:
options->dynamics_view_size = g_value_get_int (value);
break;
case PROP_PATTERN_VIEW_TYPE:
options->pattern_view_type = g_value_get_enum (value);
break;
case PROP_PATTERN_VIEW_SIZE:
options->pattern_view_size = g_value_get_int (value);
break;
case PROP_GRADIENT_VIEW_TYPE:
options->gradient_view_type = g_value_get_enum (value);
break;
case PROP_GRADIENT_VIEW_SIZE:
options->gradient_view_size = g_value_get_int (value);
break;
case PROP_USE_SMOOTHING:
smoothing_options->use_smoothing = g_value_get_boolean (value);
break;
case PROP_SMOOTHING_QUALITY:
smoothing_options->smoothing_quality = g_value_get_int (value);
break;
case PROP_SMOOTHING_FACTOR:
smoothing_options->smoothing_factor = g_value_get_double (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
gimp_blend_tool_button_release (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonReleaseType release_type,
GimpDisplay *display)
{
GimpBlendTool *blend_tool = GIMP_BLEND_TOOL (tool);
GimpBlendOptions *options = GIMP_BLEND_TOOL_GET_OPTIONS (tool);
GimpPaintOptions *paint_options = GIMP_PAINT_OPTIONS (options);
GimpContext *context = GIMP_CONTEXT (options);
GimpImage *image = gimp_display_get_image (display);
gimp_tool_pop_status (tool, display);
gimp_draw_tool_stop (GIMP_DRAW_TOOL (tool));
gimp_tool_control_halt (tool->control);
if ((release_type != GIMP_BUTTON_RELEASE_CANCEL) &&
((blend_tool->start_x != blend_tool->end_x) ||
(blend_tool->start_y != blend_tool->end_y)))
{
GimpDrawable *drawable = gimp_image_get_active_drawable (image);
GimpProgress *progress;
gint off_x;
gint off_y;
progress = gimp_progress_start (GIMP_PROGRESS (tool),
_("Blending"), FALSE);
gimp_item_get_offset (GIMP_ITEM (drawable), &off_x, &off_y);
gimp_drawable_blend (drawable,
context,
GIMP_CUSTOM_MODE,
gimp_context_get_paint_mode (context),
options->gradient_type,
gimp_context_get_opacity (context),
options->offset,
paint_options->gradient_options->gradient_repeat,
paint_options->gradient_options->gradient_reverse,
options->supersample,
options->supersample_depth,
options->supersample_threshold,
options->dither,
blend_tool->start_x - off_x,
blend_tool->start_y - off_y,
blend_tool->end_x - off_x,
blend_tool->end_y - off_y,
progress);
if (progress)
gimp_progress_end (progress);
gimp_image_flush (image);
}
tool->display = NULL;
tool->drawable = NULL;
}
