static void
gimp_source_tool_cursor_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
GimpDisplay *display)
{
GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool);
GimpSourceOptions *options = GIMP_SOURCE_TOOL_GET_OPTIONS (tool);
GimpCursorType cursor = GIMP_CURSOR_MOUSE;
GimpCursorModifier modifier = GIMP_CURSOR_MODIFIER_NONE;
if (gimp_source_core_use_source (GIMP_SOURCE_CORE (paint_tool->core),
options))
{
GdkModifierType toggle_mask = gimp_get_toggle_behavior_mask ();
if ((state & (toggle_mask | GDK_SHIFT_MASK)) == toggle_mask)
{
cursor = GIMP_CURSOR_CROSSHAIR_SMALL;
}
else if (! GIMP_SOURCE_CORE (GIMP_PAINT_TOOL (tool)->core)->src_drawable)
{
modifier = GIMP_CURSOR_MODIFIER_BAD;
}
}
gimp_tool_control_set_cursor (tool->control, cursor);
gimp_tool_control_set_cursor_modifier (tool->control, modifier);
GIMP_TOOL_CLASS (parent_class)->cursor_update (tool, coords, state, display);
}
static void
gimp_source_tool_control (GimpTool *tool,
GimpToolAction action,
GimpDisplay *display)
{
GimpSourceTool *source_tool = GIMP_SOURCE_TOOL (tool);
/* chain up early so the draw tool can undraw the source marker
* while we still know about source drawable and display
*/
GIMP_TOOL_CLASS (parent_class)->control (tool, action, display);
switch (action)
{
case GIMP_TOOL_ACTION_PAUSE:
case GIMP_TOOL_ACTION_RESUME:
break;
case GIMP_TOOL_ACTION_HALT:
source_tool->src_display = NULL;
g_object_set (GIMP_PAINT_TOOL (tool)->core,
"src-drawable", NULL,
NULL);
break;
}
}
static void
gimp_source_tool_modifier_key (GimpTool *tool,
GdkModifierType key,
gboolean press,
GdkModifierType state,
GimpDisplay *display)
{
GimpSourceTool *source_tool = GIMP_SOURCE_TOOL (tool);
GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool);
GimpSourceOptions *options = GIMP_SOURCE_TOOL_GET_OPTIONS (tool);
if (options->use_source && key == GDK_CONTROL_MASK)
{
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
if (press)
{
paint_tool->status = source_tool->status_set_source;
source_tool->show_source_outline = FALSE;
}
else
{
paint_tool->status = source_tool->status_paint;
source_tool->show_source_outline = TRUE;
}
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
}
GIMP_TOOL_CLASS (parent_class)->modifier_key (tool, key, press, state,
display);
}
static void
gimp_source_tool_control (GimpTool *tool,
GimpToolAction action,
GimpDisplay *display)
{
GimpSourceTool *source_tool = GIMP_SOURCE_TOOL (tool);
switch (action)
{
case GIMP_TOOL_ACTION_PAUSE:
case GIMP_TOOL_ACTION_RESUME:
break;
case GIMP_TOOL_ACTION_HALT:
gimp_source_tool_set_src_display (source_tool, NULL);
g_object_set (GIMP_PAINT_TOOL (tool)->core,
"src-drawable", NULL,
NULL);
break;
case GIMP_TOOL_ACTION_COMMIT:
break;
}
GIMP_TOOL_CLASS (parent_class)->control (tool, action, display);
}
static void
gimp_source_tool_button_press (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonPressType press_type,
GimpDisplay *display)
{
GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool);
GimpSourceTool *source_tool = GIMP_SOURCE_TOOL (tool);
GimpSourceCore *source = GIMP_SOURCE_CORE (paint_tool->core);
GdkModifierType toggle_mask = gimp_get_toggle_behavior_mask ();
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
if ((state & (toggle_mask | GDK_SHIFT_MASK)) == toggle_mask)
{
source->set_source = TRUE;
gimp_source_tool_set_src_display (source_tool, display);
}
else
{
source->set_source = FALSE;
}
GIMP_TOOL_CLASS (parent_class)->button_press (tool, coords, time, state,
press_type, display);
source_tool->src_x = source->src_x;
source_tool->src_y = source->src_y;
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
}
static void
gimp_source_tool_cursor_update (GimpTool *tool,
GimpCoords *coords,
GdkModifierType state,
GimpDisplay *display)
{
GimpSourceOptions *options = GIMP_SOURCE_TOOL_GET_OPTIONS (tool);
GimpCursorType cursor = GIMP_CURSOR_MOUSE;
GimpCursorModifier modifier = GIMP_CURSOR_MODIFIER_NONE;
if (options->use_source)
{
if ((state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK)) == GDK_CONTROL_MASK)
{
cursor = GIMP_CURSOR_CROSSHAIR_SMALL;
}
else if (! GIMP_SOURCE_CORE (GIMP_PAINT_TOOL (tool)->core)->src_drawable)
{
modifier = GIMP_CURSOR_MODIFIER_BAD;
}
}
gimp_tool_control_set_cursor (tool->control, cursor);
gimp_tool_control_set_cursor_modifier (tool->control, modifier);
GIMP_TOOL_CLASS (parent_class)->cursor_update (tool, coords, state, display);
}
static void
gimp_source_tool_button_press (GimpTool *tool,
GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpDisplay *display)
{
GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool);
GimpSourceTool *source_tool = GIMP_SOURCE_TOOL (tool);
GimpSourceCore *source = GIMP_SOURCE_CORE (paint_tool->core);
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
if ((state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK)) == GDK_CONTROL_MASK)
{
source->set_source = TRUE;
source_tool->src_display = display;
}
else
{
source->set_source = FALSE;
}
GIMP_TOOL_CLASS (parent_class)->button_press (tool, coords, time, state,
display);
source_tool->src_x = source->src_x;
source_tool->src_y = source->src_y;
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
}
static void
gimp_airbrush_tool_stamp (GimpAirbrushTool *airbrush_tool,
gpointer data)
{
GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (airbrush_tool);
gimp_airbrush_stamp (GIMP_AIRBRUSH (paint_tool->core));
}
static void
gimp_paint_tool_cursor_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
GimpDisplay *display)
{
GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool);
GimpCursorModifier modifier;
GimpCursorModifier toggle_modifier;
GimpCursorModifier old_modifier;
GimpCursorModifier old_toggle_modifier;
modifier = tool->control->cursor_modifier;
toggle_modifier = tool->control->toggle_cursor_modifier;
old_modifier = modifier;
old_toggle_modifier = toggle_modifier;
if (! gimp_color_tool_is_enabled (GIMP_COLOR_TOOL (tool)))
{
GimpImage *image = gimp_display_get_image (display);
GimpDrawable *drawable = gimp_image_get_active_drawable (image);
if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable)) ||
gimp_item_is_content_locked (GIMP_ITEM (drawable)) ||
! gimp_item_is_visible (GIMP_ITEM (drawable)))
{
modifier = GIMP_CURSOR_MODIFIER_BAD;
toggle_modifier = GIMP_CURSOR_MODIFIER_BAD;
}
if (! paint_tool->show_cursor &&
modifier != GIMP_CURSOR_MODIFIER_BAD)
{
gimp_tool_set_cursor (tool, display,
GIMP_CURSOR_NONE,
GIMP_TOOL_CURSOR_NONE,
GIMP_CURSOR_MODIFIER_NONE);
return;
}
gimp_tool_control_set_cursor_modifier (tool->control,
modifier);
gimp_tool_control_set_toggle_cursor_modifier (tool->control,
toggle_modifier);
}
GIMP_TOOL_CLASS (parent_class)->cursor_update (tool, coords, state,
display);
/* reset old stuff here so we are not interferring with the modifiers
* set by our subclasses
*/
gimp_tool_control_set_cursor_modifier (tool->control,
old_modifier);
gimp_tool_control_set_toggle_cursor_modifier (tool->control,
old_toggle_modifier);
}
static void
gimp_paint_tool_modifier_key (GimpTool *tool,
GdkModifierType key,
gboolean press,
GdkModifierType state,
GimpDisplay *display)
{
GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool);
GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (tool);
if (paint_tool->pick_colors && ! paint_tool->draw_line)
{
if ((state & gimp_get_all_modifiers_mask ()) ==
gimp_get_constrain_behavior_mask ())
{
if (! gimp_color_tool_is_enabled (GIMP_COLOR_TOOL (tool)))
{
GimpToolInfo *info = gimp_get_tool_info (display->gimp,
"gimp-color-picker-tool");
if (GIMP_IS_TOOL_INFO (info))
{
if (gimp_draw_tool_is_active (draw_tool))
gimp_draw_tool_stop (draw_tool);
gimp_color_tool_enable (GIMP_COLOR_TOOL (tool),
GIMP_COLOR_OPTIONS (info->tool_options));
switch (GIMP_COLOR_TOOL (tool)->pick_mode)
{
case GIMP_COLOR_PICK_MODE_FOREGROUND:
gimp_tool_push_status (tool, display,
_("Click in any image to pick the "
"foreground color"));
break;
case GIMP_COLOR_PICK_MODE_BACKGROUND:
gimp_tool_push_status (tool, display,
_("Click in any image to pick the "
"background color"));
break;
default:
break;
}
}
}
}
else
{
if (gimp_color_tool_is_enabled (GIMP_COLOR_TOOL (tool)))
{
gimp_tool_pop_status (tool, display);
gimp_color_tool_disable (GIMP_COLOR_TOOL (tool));
}
}
}
}
static void
gimp_perspective_clone_tool_options_notify (GimpTool *tool,
GimpToolOptions *options,
const GParamSpec *pspec)
{
GimpPerspectiveCloneTool *clone_tool = GIMP_PERSPECTIVE_CLONE_TOOL (tool);
GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool);
GimpPerspectiveCloneOptions *clone_options;
clone_options = GIMP_PERSPECTIVE_CLONE_OPTIONS (options);
GIMP_TOOL_CLASS (parent_class)->options_notify (tool, options, pspec);
if (! strcmp (pspec->name, "clone-mode"))
{
GimpPerspectiveClone *clone;
clone = GIMP_PERSPECTIVE_CLONE (GIMP_PAINT_TOOL (tool)->core);
gimp_draw_tool_pause (GIMP_DRAW_TOOL (clone_tool));
if (clone_options->clone_mode == GIMP_PERSPECTIVE_CLONE_MODE_PAINT)
{
gimp_perspective_clone_set_transform (clone, &clone_tool->transform);
gimp_paint_tool_set_active (paint_tool, TRUE);
}
else
{
gimp_paint_tool_set_active (paint_tool, FALSE);
gimp_tool_control_set_precision (tool->control,
GIMP_CURSOR_PRECISION_SUBPIXEL);
/* start drawing the bounding box and handles... */
if (tool->display &&
! gimp_draw_tool_is_active (GIMP_DRAW_TOOL (clone_tool)))
{
gimp_draw_tool_start (GIMP_DRAW_TOOL (clone_tool), tool->display);
}
}
gimp_draw_tool_resume (GIMP_DRAW_TOOL (clone_tool));
}
}
static void
gimp_airbrush_tool_init (GimpAirbrushTool *airbrush)
{
GimpTool *tool = GIMP_TOOL (airbrush);
gimp_tool_control_set_tool_cursor (tool->control, GIMP_TOOL_CURSOR_AIRBRUSH);
gimp_paint_tool_enable_color_picker (GIMP_PAINT_TOOL (airbrush),
GIMP_COLOR_PICK_MODE_FOREGROUND);
}
static void
gimp_airbrush_tool_airbrush_stamp (GimpAirbrush *airbrush,
GimpAirbrushTool *airbrush_tool)
{
GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (airbrush_tool);
gimp_paint_tool_paint_push (
paint_tool,
(GimpPaintToolPaintFunc) gimp_airbrush_tool_stamp,
NULL);
}
static void
gimp_brush_tool_brush_changed (GimpContext *context,
GimpBrush *brush,
GimpBrushTool *brush_tool)
{
GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (brush_tool);
GimpBrushCore *brush_core = GIMP_BRUSH_CORE (paint_tool->core);
gimp_brush_core_set_brush (brush_core, brush);
}
static void
gimp_airbrush_tool_constructed (GObject *object)
{
GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (object);
G_OBJECT_CLASS (parent_class)->constructed (object);
g_signal_connect_object (paint_tool->core, "stamp",
G_CALLBACK (gimp_airbrush_tool_airbrush_stamp),
object, 0);
}
static void
gimp_perspective_clone_tool_constructed (GObject *object)
{
GimpPerspectiveCloneOptions *options;
options = GIMP_PERSPECTIVE_CLONE_TOOL_GET_OPTIONS (object);
G_OBJECT_CLASS (parent_class)->constructed (object);
if (options->clone_mode == GIMP_PERSPECTIVE_CLONE_MODE_ADJUST)
gimp_paint_tool_set_active (GIMP_PAINT_TOOL (object), FALSE);
}
static void
gimp_mybrush_tool_init (GimpMybrushTool *mybrush_tool)
{
GimpTool *tool = GIMP_TOOL (mybrush_tool);
gimp_tool_control_set_tool_cursor (tool->control, GIMP_TOOL_CURSOR_INK);
gimp_tool_control_set_action_size (tool->control,
"tools/tools-mybrush-radius-set");
gimp_paint_tool_enable_color_picker (GIMP_PAINT_TOOL (mybrush_tool),
GIMP_COLOR_PICK_MODE_FOREGROUND);
}
static void
gimp_smudge_tool_init (GimpSmudgeTool *smudge)
{
GimpTool *tool = GIMP_TOOL (smudge);
GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (smudge);
gimp_tool_control_set_tool_cursor (tool->control, GIMP_TOOL_CURSOR_SMUDGE);
paint_tool->status = _("Click to smudge");
paint_tool->status_line = _("Click to smudge the line");
paint_tool->status_ctrl = NULL;
}
static void
gimp_paint_tool_finalize (GObject *object)
{
GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (object);
if (paint_tool->core)
{
g_object_unref (paint_tool->core);
paint_tool->core = NULL;
}
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gimp_ink_tool_init (GimpInkTool *ink_tool)
{
GimpTool *tool = GIMP_TOOL (ink_tool);
gimp_tool_control_set_tool_cursor (tool->control, GIMP_TOOL_CURSOR_INK);
gimp_tool_control_set_action_value_2 (tool->control,
"tools/tools-ink-blob-size-set");
gimp_tool_control_set_action_value_3 (tool->control,
"tools/tools-ink-blob-aspect-set");
gimp_tool_control_set_action_value_4 (tool->control,
"tools/tools-ink-blob-angle-set");
gimp_paint_tool_enable_color_picker (GIMP_PAINT_TOOL (ink_tool),
GIMP_COLOR_PICK_MODE_FOREGROUND);
}
static void
gimp_heal_tool_init (GimpHealTool *heal)
{
GimpTool *tool = GIMP_TOOL (heal);
GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool);
GimpSourceTool *source_tool = GIMP_SOURCE_TOOL (tool);
gimp_tool_control_set_tool_cursor (tool->control, GIMP_TOOL_CURSOR_HEAL);
paint_tool->status = _("Click to heal");
paint_tool->status_ctrl = _("%s to set a new heal source");
source_tool->status_paint = _("Click to heal");
source_tool->status_set_source = _("Click to set a new heal source");
source_tool->status_set_source_ctrl = _("%s to set a new heal source");
}
static void
gimp_perspective_clone_tool_halt (GimpPerspectiveCloneTool *clone_tool)
{
GimpTool *tool = GIMP_TOOL (clone_tool);
clone_tool->src_display = NULL;
g_object_set (GIMP_PAINT_TOOL (tool)->core,
"src-drawable", NULL,
NULL);
if (gimp_draw_tool_is_active (GIMP_DRAW_TOOL (tool)))
gimp_draw_tool_stop (GIMP_DRAW_TOOL (tool));
tool->display = NULL;
tool->drawable = NULL;
}
static void
gimp_paint_tool_motion (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpDisplay *display)
{
GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool);
GimpPaintOptions *paint_options = GIMP_PAINT_TOOL_GET_OPTIONS (tool);
GimpPaintCore *core = paint_tool->core;
GimpImage *image = gimp_display_get_image (display);
GimpDrawable *drawable = gimp_image_get_active_drawable (image);
GimpCoords curr_coords;
gint off_x, off_y;
GIMP_TOOL_CLASS (parent_class)->motion (tool, coords, time, state, display);
if (gimp_color_tool_is_enabled (GIMP_COLOR_TOOL (tool)))
return;
curr_coords = *coords;
gimp_paint_core_smooth_coords (core, paint_options, &curr_coords);
gimp_item_get_offset (GIMP_ITEM (drawable), &off_x, &off_y);
curr_coords.x -= off_x;
curr_coords.y -= off_y;
/* don't paint while the Shift key is pressed for line drawing */
if (paint_tool->draw_line)
{
gimp_paint_core_set_current_coords (core, &curr_coords);
return;
}
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
gimp_paint_core_interpolate (core, drawable, paint_options,
&curr_coords, time);
gimp_projection_flush_now (gimp_image_get_projection (image));
gimp_display_flush_now (display);
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
}
static void
gimp_paint_tool_button_release (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonReleaseType release_type,
GimpDisplay *display)
{
GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool);
GimpPaintOptions *paint_options = GIMP_PAINT_TOOL_GET_OPTIONS (tool);
GimpPaintCore *core = paint_tool->core;
GimpDisplayShell *shell = gimp_display_get_shell (display);
GimpImage *image = gimp_display_get_image (display);
GimpDrawable *drawable = gimp_image_get_active_drawable (image);
if (gimp_color_tool_is_enabled (GIMP_COLOR_TOOL (tool)))
{
GIMP_TOOL_CLASS (parent_class)->button_release (tool, coords, time,
state, release_type,
display);
return;
}
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
/* Let the specific painting function finish up */
gimp_paint_core_paint (core, drawable, paint_options,
GIMP_PAINT_STATE_FINISH, time);
/* resume the current selection */
gimp_display_shell_selection_resume (shell);
/* chain up to halt the tool */
GIMP_TOOL_CLASS (parent_class)->button_release (tool, coords, time, state,
release_type, display);
if (release_type == GIMP_BUTTON_RELEASE_CANCEL)
gimp_paint_core_cancel (core, drawable);
else
gimp_paint_core_finish (core, drawable, TRUE);
gimp_image_flush (image);
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
}
static void
gimp_brush_tool_constructed (GObject *object)
{
GimpTool *tool = GIMP_TOOL (object);
GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (object);
G_OBJECT_CLASS (parent_class)->constructed (object);
g_assert (GIMP_IS_BRUSH_CORE (paint_tool->core));
g_signal_connect_object (gimp_tool_get_options (tool), "brush-changed",
G_CALLBACK (gimp_brush_tool_brush_changed),
paint_tool, 0);
g_signal_connect_object (paint_tool->core, "set-brush",
G_CALLBACK (gimp_brush_tool_set_brush),
paint_tool, 0);
}
static void
gimp_brush_tool_options_notify (GimpTool *tool,
GimpToolOptions *options,
const GParamSpec *pspec)
{
GIMP_TOOL_CLASS (parent_class)->options_notify (tool, options, pspec);
if (! strcmp (pspec->name, "brush-size") ||
! strcmp (pspec->name, "brush-angle") ||
! strcmp (pspec->name, "brush-aspect-ratio"))
{
GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool);
GimpBrushCore *brush_core = GIMP_BRUSH_CORE (paint_tool->core);
g_signal_emit_by_name (brush_core, "set-brush",
brush_core->main_brush);
}
}
static void
gimp_eraser_tool_init (GimpEraserTool *eraser)
{
GimpTool *tool = GIMP_TOOL (eraser);
GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (eraser);
gimp_tool_control_set_tool_cursor (tool->control,
GIMP_TOOL_CURSOR_ERASER);
gimp_tool_control_set_toggle_cursor_modifier (tool->control,
GIMP_CURSOR_MODIFIER_MINUS);
gimp_paint_tool_enable_color_picker (paint_tool,
GIMP_COLOR_PICK_MODE_BACKGROUND);
paint_tool->status = _("Click to erase");
paint_tool->status_line = _("Click to erase the line");
paint_tool->status_ctrl = _("%s to pick a background color");
}
static void
gimp_clone_tool_init (GimpCloneTool *clone)
{
GimpTool *tool = GIMP_TOOL (clone);
GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool);
GimpSourceTool *source_tool = GIMP_SOURCE_TOOL (tool);
gimp_tool_control_set_tool_cursor (tool->control,
GIMP_TOOL_CURSOR_CLONE);
gimp_tool_control_set_action_object_2 (tool->control,
"context/context-pattern-select-set");
paint_tool->status = _("Click to clone");
paint_tool->status_ctrl = _("%s to set a new clone source");
source_tool->status_paint = _("Click to clone");
source_tool->status_set_source = _("Click to set a new clone source");
source_tool->status_set_source_ctrl = _("%s to set a new clone source");
}
static void
gimp_source_tool_motion (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpDisplay *display)
{
GimpSourceTool *source_tool = GIMP_SOURCE_TOOL (tool);
GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool);
GimpSourceCore *source = GIMP_SOURCE_CORE (paint_tool->core);
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
GIMP_TOOL_CLASS (parent_class)->motion (tool, coords, time, state, display);
source_tool->src_x = source->src_x;
source_tool->src_y = source->src_y;
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
}
static void
gimp_brush_tool_oper_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
gboolean proximity,
GimpDisplay *display)
{
GimpPaintOptions *paint_options = GIMP_PAINT_TOOL_GET_OPTIONS (tool);
GimpDrawable *drawable;
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
GIMP_TOOL_CLASS (parent_class)->oper_update (tool, coords, state,
proximity, display);
drawable = gimp_image_get_active_drawable (gimp_display_get_image (display));
if (! gimp_color_tool_is_enabled (GIMP_COLOR_TOOL (tool)) &&
drawable && proximity)
{
GimpContext *context = GIMP_CONTEXT (paint_options);
GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool);
GimpBrushCore *brush_core = GIMP_BRUSH_CORE (paint_tool->core);
gimp_brush_core_set_brush (brush_core,
gimp_context_get_brush (context));
gimp_brush_core_set_dynamics (brush_core,
gimp_context_get_dynamics (context));
if (GIMP_BRUSH_CORE_GET_CLASS (brush_core)->handles_transforming_brush)
{
gimp_brush_core_eval_transform_dynamics (brush_core,
drawable,
paint_options,
coords);
}
}
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
}