static void
gimp_color_tool_motion (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpDisplay *display)
{
GimpColorTool *color_tool = GIMP_COLOR_TOOL (tool);
if (! color_tool->enabled)
return;
if (! color_tool->sample_point)
{
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
color_tool->center_x = coords->x;
color_tool->center_y = coords->y;
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
gimp_color_tool_pick (color_tool, GIMP_COLOR_PICK_STATE_UPDATE,
coords->x, coords->y);
}
}
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_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_blend_tool_active_modifier_key (GimpTool *tool,
GdkModifierType key,
gboolean press,
GdkModifierType state,
GimpDisplay *display)
{
GimpBlendTool *blend_tool = GIMP_BLEND_TOOL (tool);
GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (tool);
if (key == gimp_get_constrain_behavior_mask ())
{
gimp_draw_tool_pause (draw_tool);
gimp_blend_tool_point_motion (blend_tool, press);
gimp_draw_tool_resume (draw_tool);
gimp_tool_pop_status (tool, display);
gimp_blend_tool_push_status (blend_tool, state, display);
gimp_blend_tool_update_preview_coords (blend_tool);
gimp_image_map_apply (blend_tool->image_map, NULL);
}
else if (key == GDK_MOD1_MASK)
{
gimp_tool_pop_status (tool, display);
gimp_blend_tool_push_status (blend_tool, state, display);
}
}
static void
gimp_cage_tool_motion (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpDisplay *display)
{
GimpCageTool *ct = GIMP_CAGE_TOOL (tool);
GimpCageOptions *options = GIMP_CAGE_TOOL_GET_OPTIONS (ct);
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
ct->cursor_x = coords->x;
ct->cursor_y = coords->y;
switch (ct->tool_state)
{
case CAGE_STATE_MOVE_HANDLE:
case CAGE_STATE_CLOSING:
case DEFORM_STATE_MOVE_HANDLE:
gimp_cage_config_add_displacement (ct->config,
options->cage_mode,
ct->cursor_x - ct->movement_start_x,
ct->cursor_y - ct->movement_start_y);
break;
}
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
}
static void
gimp_align_tool_button_press (GimpTool *tool,
GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpDisplay *display)
{
GimpAlignTool *align_tool = GIMP_ALIGN_TOOL (tool);
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
/* If the tool was being used in another image... reset it */
if (display != tool->display)
{
if (gimp_draw_tool_is_active (GIMP_DRAW_TOOL (tool)))
gimp_draw_tool_stop (GIMP_DRAW_TOOL (tool));
gimp_tool_pop_status (tool, display);
clear_all_selected_objects (align_tool);
}
if (! gimp_tool_control_is_active (tool->control))
gimp_tool_control_activate (tool->control);
tool->display = display;
align_tool->x1 = align_tool->x0 = coords->x;
align_tool->y1 = align_tool->y0 = coords->y;
if (! gimp_draw_tool_is_active (GIMP_DRAW_TOOL (tool)))
gimp_draw_tool_start (GIMP_DRAW_TOOL (tool), display);
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
}
static void
gimp_foreground_select_tool_motion (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpDisplay *display)
{
GimpForegroundSelectTool *fg_select = GIMP_FOREGROUND_SELECT_TOOL (tool);
if (fg_select->mask)
{
GimpVector2 *last = &g_array_index (fg_select->stroke,
GimpVector2,
fg_select->stroke->len - 1);
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
fg_select->last_coords = *coords;
if (last->x != (gint) coords->x || last->y != (gint) coords->y)
{
GimpVector2 point = gimp_vector2_new (coords->x, coords->y);
g_array_append_val (fg_select->stroke, point);
}
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
}
else
{
GIMP_TOOL_CLASS (parent_class)->motion (tool,
coords, time, state, display);
}
}
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_cage_tool_oper_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
gboolean proximity,
GimpDisplay *display)
{
GimpCageTool *ct = GIMP_CAGE_TOOL (tool);
GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (tool);
if (ct->config)
{
ct->hovering_handle = gimp_cage_tool_is_on_handle (ct,
draw_tool,
display,
coords->x,
coords->y,
GIMP_TOOL_HANDLE_SIZE_CIRCLE);
ct->hovering_edge = gimp_cage_tool_is_on_edge (ct,
coords->x,
coords->y,
GIMP_TOOL_HANDLE_SIZE_CIRCLE);
}
gimp_draw_tool_pause (draw_tool);
ct->cursor_x = coords->x;
ct->cursor_y = coords->y;
gimp_draw_tool_resume (draw_tool);
}
static void
gimp_warp_tool_oper_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
gboolean proximity,
GimpDisplay *display)
{
GimpWarpTool *wt = GIMP_WARP_TOOL (tool);
GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (tool);
if (proximity)
{
gimp_draw_tool_pause (draw_tool);
if (! tool->display || display == tool->display)
{
wt->cursor_x = coords->x;
wt->cursor_y = coords->y;
}
if (! gimp_draw_tool_is_active (draw_tool))
gimp_draw_tool_start (draw_tool, display);
gimp_draw_tool_resume (draw_tool);
}
else if (gimp_draw_tool_is_active (draw_tool))
{
gimp_draw_tool_stop (draw_tool);
}
}
static void
gimp_align_tool_button_press (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonPressType press_type,
GimpDisplay *display)
{
GimpAlignTool *align_tool = GIMP_ALIGN_TOOL (tool);
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
/* If the tool was being used in another image... reset it */
if (display != tool->display)
gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, display);
tool->display = display;
gimp_tool_control_activate (tool->control);
align_tool->x2 = align_tool->x1 = coords->x;
align_tool->y2 = align_tool->y1 = coords->y;
if (! gimp_draw_tool_is_active (GIMP_DRAW_TOOL (tool)))
gimp_draw_tool_start (GIMP_DRAW_TOOL (tool), display);
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
}
static void
gimp_n_point_deformation_tool_oper_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
gboolean proximity,
GimpDisplay *display)
{
GimpNPointDeformationTool *npd_tool = GIMP_N_POINT_DEFORMATION_TOOL (tool);
GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (tool);
gimp_draw_tool_pause (draw_tool);
if (npd_tool->active)
{
NPDModel *model = npd_tool->model;
GimpDisplayShell *shell = gimp_display_get_shell (display);
NPDPoint p;
npd_tool->cp_scaled_radius = model->control_point_radius / shell->scale_x;
p.x = coords->x - npd_tool->offset_x;
p.y = coords->y - npd_tool->offset_y;
npd_tool->hovering_cp =
npd_get_control_point_with_radius_at (model,
&p,
npd_tool->cp_scaled_radius);
}
npd_tool->cursor_x = coords->x;
npd_tool->cursor_y = coords->y;
gimp_draw_tool_resume (draw_tool);
}
static void
gimp_text_tool_select_all (GimpTextTool *text_tool,
gboolean select)
{
GtkTextBuffer *buffer = GTK_TEXT_BUFFER (text_tool->buffer);
gimp_draw_tool_pause (GIMP_DRAW_TOOL (text_tool));
if (select)
{
GtkTextIter start, end;
gtk_text_buffer_get_bounds (buffer, &start, &end);
gtk_text_buffer_select_range (buffer, &start, &end);
}
else
{
GtkTextIter cursor;
gtk_text_buffer_get_iter_at_mark (buffer, &cursor,
gtk_text_buffer_get_insert (buffer));
gtk_text_buffer_move_mark_by_name (buffer, "selection_bound", &cursor);
}
gimp_draw_tool_resume (GIMP_DRAW_TOOL (text_tool));
}
static void
gimp_foreground_select_tool_button_release (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonReleaseType release_type,
GimpDisplay *display)
{
GimpForegroundSelectTool *fg_select = GIMP_FOREGROUND_SELECT_TOOL (tool);
if (fg_select->mask)
{
GimpForegroundSelectOptions *options;
options = GIMP_FOREGROUND_SELECT_TOOL_GET_OPTIONS (tool);
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
gimp_tool_control_halt (tool->control);
gimp_foreground_select_tool_push_stroke (fg_select, display, options);
gimp_free_select_tool_select (GIMP_FREE_SELECT_TOOL (tool), display);
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
}
else
{
GIMP_TOOL_CLASS (parent_class)->button_release (tool,
coords, time, state,
release_type,
display);
}
}
static void
gimp_text_tool_toggle_overwrite (GimpTextTool *text_tool)
{
gimp_draw_tool_pause (GIMP_DRAW_TOOL (text_tool));
text_tool->overwrite_mode = ! text_tool->overwrite_mode;
gimp_draw_tool_resume (GIMP_DRAW_TOOL (text_tool));
}
static void
gimp_cage_tool_remove_last_handle (GimpCageTool *ct)
{
GimpCageConfig *config = ct->config;
gimp_draw_tool_pause (GIMP_DRAW_TOOL (ct));
gimp_cage_config_remove_last_cage_point (config);
gimp_draw_tool_resume (GIMP_DRAW_TOOL (ct));
}
static void
gimp_align_tool_clear_selected (GimpAlignTool *align_tool)
{
gimp_draw_tool_pause (GIMP_DRAW_TOOL (align_tool));
while (align_tool->selected_objects)
gimp_align_tool_object_removed (align_tool->selected_objects->data,
align_tool);
gimp_draw_tool_resume (GIMP_DRAW_TOOL (align_tool));
}
void
gimp_warp_tool_button_release (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonReleaseType release_type,
GimpDisplay *display)
{
GimpWarpTool *wt = GIMP_WARP_TOOL (tool);
gimp_draw_tool_pause (GIMP_DRAW_TOOL (wt));
gimp_tool_control_halt (tool->control);
g_source_remove (wt->stroke_timer);
wt->stroke_timer = 0;
g_signal_handlers_disconnect_by_func (wt->current_stroke,
gimp_warp_tool_stroke_changed,
wt);
#ifdef WARP_DEBUG
g_printerr ("%s\n", gegl_path_to_string (wt->current_stroke));
#endif
g_object_unref (wt->current_stroke);
wt->current_stroke = NULL;
if (release_type == GIMP_BUTTON_RELEASE_CANCEL)
{
gimp_warp_tool_undo (tool, display);
/* the just undone stroke has no business on the redo stack */
g_object_unref (wt->redo_stack->data);
wt->redo_stack = g_list_remove_link (wt->redo_stack, wt->redo_stack);
}
else
{
if (wt->redo_stack)
{
/* the redo stack becomes invalid by actually doing a stroke */
g_list_free_full (wt->redo_stack, (GDestroyNotify) g_object_unref);
wt->redo_stack = NULL;
}
gimp_tool_push_status (tool, tool->display,
_("Press ENTER to commit the transform"));
}
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
/* update the undo actions / menu items */
gimp_image_flush (gimp_display_get_image (GIMP_TOOL (wt)->display));
}
static void
gimp_paint_tool_cursor_notify (GimpDisplayConfig *config,
GParamSpec *pspec,
GimpPaintTool *paint_tool)
{
gimp_draw_tool_pause (GIMP_DRAW_TOOL (paint_tool));
paint_tool->show_cursor = config->show_paint_tool_cursor;
paint_tool->draw_brush = config->show_brush_outline;
gimp_draw_tool_resume (GIMP_DRAW_TOOL (paint_tool));
}
static void
gimp_blend_tool_motion (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpDisplay *display)
{
GimpBlendTool *blend_tool = GIMP_BLEND_TOOL (tool);
/* Save the mouse coordinates from last call */
gdouble last_x = blend_tool->mouse_x;
gdouble last_y = blend_tool->mouse_y;
blend_tool->mouse_x = coords->x;
blend_tool->mouse_y = coords->y;
if (blend_tool->grabbed_point == POINT_INIT_MODE)
{
GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (blend_tool);
gimp_draw_tool_pause (draw_tool);
blend_tool->grabbed_point = POINT_END;
gimp_draw_tool_resume (draw_tool);
}
/* Move the whole line if alt is pressed */
if (state & GDK_MOD1_MASK)
{
gdouble dx = last_x - coords->x;
gdouble dy = last_y - coords->y;
blend_tool->start_x -= dx;
blend_tool->start_y -= dy;
blend_tool->end_x -= dx;
blend_tool->end_y -= dy;
}
else
{
gimp_blend_tool_point_motion (blend_tool,
state & gimp_get_constrain_behavior_mask ());
}
gimp_tool_pop_status (tool, display);
gimp_blend_tool_push_status (blend_tool, state, display);
if (GIMP_IS_CANVAS_LINE (blend_tool->line))
gimp_blend_tool_update_items (blend_tool);
gimp_blend_tool_update_preview_coords (blend_tool);
gimp_image_map_apply (blend_tool->image_map, NULL);
}
static void
gimp_mybrush_tool_options_notify (GimpTool *tool,
GimpToolOptions *options,
const GParamSpec *pspec)
{
GIMP_TOOL_CLASS (parent_class)->options_notify (tool, options, pspec);
if (! strcmp (pspec->name, "radius"))
{
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
}
}
static void
gimp_seamless_clone_tool_oper_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
gboolean proximity,
GimpDisplay *display)
{
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
/* TODO: Modify data here */
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
}
static void
gimp_seamless_clone_tool_button_press (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonPressType press_type,
GimpDisplay *display)
{
GimpSeamlessCloneTool *sc = GIMP_SEAMLESS_CLONE_TOOL (tool);
if (display != tool->display)
{
gimp_seamless_clone_tool_start (sc, display);
/* Center the paste on the mouse */
sc->xoff = (gint) coords->x - sc->width / 2;
sc->yoff = (gint) coords->y - sc->height / 2;
}
if (sc->tool_state == SC_STATE_RENDER_WAIT &&
gimp_seamless_clone_tool_is_in_paste_c (sc, coords))
{
gimp_draw_tool_pause (GIMP_DRAW_TOOL (sc));
/* Record previous location, in case the user cancels the
* movement
*/
sc->xoff_p = sc->xoff;
sc->yoff_p = sc->yoff;
/* Record the mouse location, so that the dragging offset can be
* calculated
*/
sc->xclick = coords->x;
sc->yclick = coords->y;
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
if (gimp_seamless_clone_tool_render_node_update (sc))
{
gimp_seamless_clone_tool_filter_update (sc);
}
sc->tool_state = SC_STATE_RENDER_MOTION;
/* In order to receive motion events from the current click, we must
* activate the tool control
*/
gimp_tool_control_activate (tool->control);
}
}
static gboolean
gimp_n_point_deformation_tool_canvas_update_timeout (GimpNPointDeformationTool *npd_tool)
{
if (! GIMP_TOOL (npd_tool)->drawable)
return FALSE;
gimp_npd_debug (("canvas update thread\n"));
gimp_draw_tool_pause (GIMP_DRAW_TOOL(npd_tool));
gimp_draw_tool_resume (GIMP_DRAW_TOOL(npd_tool));
gimp_npd_debug (("canvas update thread stop\n"));
return TRUE;
}
static void
gimp_blend_tool_oper_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
gboolean proximity,
GimpDisplay *display)
{
GimpBlendTool *blend_tool = GIMP_BLEND_TOOL (tool);
GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (tool);
gimp_draw_tool_pause (draw_tool);
blend_tool->mouse_x = coords->x;
blend_tool->mouse_y = coords->y;
gimp_draw_tool_resume (draw_tool);
}
static void
clear_selected_object (GObject *object,
GimpAlignTool *align_tool)
{
gimp_draw_tool_pause (GIMP_DRAW_TOOL (align_tool));
if (align_tool->selected_objects)
g_signal_handlers_disconnect_by_func (object,
G_CALLBACK (clear_selected_object),
(gpointer) align_tool);
align_tool->selected_objects = g_list_remove (align_tool->selected_objects,
object);
gimp_draw_tool_resume (GIMP_DRAW_TOOL (align_tool));
}
static void
gimp_warp_tool_motion (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpDisplay *display)
{
GimpWarpTool *wt = GIMP_WARP_TOOL (tool);
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
wt->cursor_x = coords->x;
wt->cursor_y = coords->y;
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
}
static void
gimp_align_tool_object_removed (GObject *object,
GimpAlignTool *align_tool)
{
gimp_draw_tool_pause (GIMP_DRAW_TOOL (align_tool));
if (align_tool->selected_objects)
g_signal_handlers_disconnect_by_func (object,
gimp_align_tool_object_removed,
align_tool);
align_tool->selected_objects = g_list_remove (align_tool->selected_objects,
object);
gimp_draw_tool_resume (GIMP_DRAW_TOOL (align_tool));
}
static void
gimp_align_tool_motion (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpDisplay *display)
{
GimpAlignTool *align_tool = GIMP_ALIGN_TOOL (tool);
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
align_tool->x2 = coords->x;
align_tool->y2 = coords->y;
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
}
static void
gimp_flip_tool_oper_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
gboolean proximity,
GimpDisplay *display)
{
GimpFlipTool *flip = GIMP_FLIP_TOOL (tool);
GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (tool);
GimpFlipOptions *options = GIMP_FLIP_TOOL_GET_OPTIONS (tool);
GimpDisplayShell *shell = gimp_display_get_shell (display);
GimpImage *image = gimp_display_get_image (display);
GimpGuide *guide = NULL;
if (gimp_display_shell_get_show_guides (shell) &&
proximity)
{
gint snap_distance = display->config->snap_distance;
guide = gimp_image_pick_guide (image, coords->x, coords->y,
FUNSCALEX (shell, snap_distance),
FUNSCALEY (shell, snap_distance));
}
if (flip->guide != guide ||
(guide && ! gimp_draw_tool_is_active (draw_tool)))
{
gimp_draw_tool_pause (draw_tool);
if (gimp_draw_tool_is_active (draw_tool) &&
draw_tool->display != display)
gimp_draw_tool_stop (draw_tool);
flip->guide = guide;
if (! gimp_draw_tool_is_active (draw_tool))
gimp_draw_tool_start (draw_tool, display);
gimp_draw_tool_resume (draw_tool);
}
gtk_widget_set_sensitive (options->direction_frame, guide == NULL);
GIMP_TOOL_CLASS (parent_class)->oper_update (tool,
coords, state, proximity,
display);
}
