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,
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_blend_tool_button_press (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonPressType press_type,
GimpDisplay *display)
{
GimpBlendTool *blend_tool = GIMP_BLEND_TOOL (tool);
if (tool->display && display != tool->display)
{
gimp_tool_pop_status (tool, tool->display);
gimp_blend_tool_halt (blend_tool);
}
blend_tool->grabbed_point = gimp_blend_tool_get_point_under_cursor (blend_tool);
if (blend_tool->grabbed_point == POINT_NONE &&
! gimp_draw_tool_is_active (GIMP_DRAW_TOOL (tool)))
{
blend_tool->start_x = coords->x;
blend_tool->start_y = coords->y;
if (gimp_blend_tool_is_shapeburst (blend_tool))
{
blend_tool->grabbed_point = POINT_FILL_MODE;
}
else
{
blend_tool->grabbed_point = POINT_INIT_MODE;
}
}
else if ((state & GDK_MOD1_MASK) &&
gimp_draw_tool_is_active (GIMP_DRAW_TOOL (tool)))
{
blend_tool->grabbed_point = POINT_BOTH;
}
gimp_blend_tool_point_motion (blend_tool,
state & gimp_get_constrain_behavior_mask ());
tool->display = display;
gimp_blend_tool_update_items (blend_tool);
if (blend_tool->grabbed_point != POINT_FILL_MODE &&
blend_tool->grabbed_point != POINT_INIT_MODE)
{
gimp_blend_tool_update_graph (blend_tool);
gimp_drawable_filter_apply (blend_tool->filter, NULL);
}
gimp_tool_control_activate (tool->control);
gimp_blend_tool_push_status (blend_tool, state, display);
}
static GimpBlendToolPoint
gimp_blend_tool_get_point_under_cursor (GimpBlendTool *blend_tool)
{
GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (blend_tool);
gdouble dist;
if (! gimp_draw_tool_is_active (draw_tool))
return POINT_NONE;
/* Check the points in the reverse order of drawing */
/* Check end point */
dist = gimp_draw_tool_calc_distance_square (draw_tool,
draw_tool->display,
blend_tool->mouse_x,
blend_tool->mouse_y,
blend_tool->end_x,
blend_tool->end_y);
if (dist < POINT_GRAB_THRESHOLD_SQ)
return POINT_END;
/* Check start point */
dist = gimp_draw_tool_calc_distance_square (draw_tool,
draw_tool->display,
blend_tool->mouse_x,
blend_tool->mouse_y,
blend_tool->start_x,
blend_tool->start_y);
if (dist < POINT_GRAB_THRESHOLD_SQ)
return POINT_START;
/* No point found */
return POINT_NONE;
}
void
gimp_color_tool_start_sample_point (GimpTool *tool,
GimpDisplay *display)
{
GimpColorTool *color_tool;
g_return_if_fail (GIMP_IS_COLOR_TOOL (tool));
g_return_if_fail (GIMP_IS_DISPLAY (display));
color_tool = GIMP_COLOR_TOOL (tool);
gimp_display_shell_selection_pause (gimp_display_get_shell (display));
tool->display = display;
gimp_tool_control_activate (tool->control);
gimp_tool_control_set_scroll_lock (tool->control, TRUE);
if (gimp_draw_tool_is_active (GIMP_DRAW_TOOL (tool)))
gimp_draw_tool_stop (GIMP_DRAW_TOOL (tool));
color_tool->sample_point = NULL;
color_tool->moving_sample_point = TRUE;
color_tool->sample_point_x = SAMPLE_POINT_POSITION_INVALID;
color_tool->sample_point_y = SAMPLE_POINT_POSITION_INVALID;
gimp_tool_set_cursor (tool, display,
GIMP_CURSOR_MOUSE,
GIMP_TOOL_CURSOR_COLOR_PICKER,
GIMP_CURSOR_MODIFIER_MOVE);
gimp_draw_tool_start (GIMP_DRAW_TOOL (tool), display);
}
static void
gimp_blend_tool_halt_preview (GimpBlendTool *blend_tool)
{
GimpTool *tool = GIMP_TOOL (blend_tool);
if (blend_tool->graph)
{
g_object_unref (blend_tool->graph);
blend_tool->graph = NULL;
blend_tool->render_node = NULL;
}
if (blend_tool->image_map)
{
gimp_image_map_abort (blend_tool->image_map);
g_object_unref (blend_tool->image_map);
blend_tool->image_map = NULL;
gimp_image_flush (gimp_display_get_image (tool->display));
}
tool->display = NULL;
tool->drawable = NULL;
if (gimp_draw_tool_is_active (GIMP_DRAW_TOOL (blend_tool)))
gimp_draw_tool_stop (GIMP_DRAW_TOOL (blend_tool));
}
void
gimp_draw_tool_resume (GimpDrawTool *draw_tool)
{
g_return_if_fail (GIMP_IS_DRAW_TOOL (draw_tool));
g_return_if_fail (draw_tool->paused_count > 0);
draw_tool->paused_count--;
if (draw_tool->paused_count == 0)
{
#ifdef USE_TIMEOUT
/* Don't install the timeout if the draw tool isn't active, so
* suspend()/resume() can always be called, and have no side
* effect on an inactive tool. See bug #687851.
*/
if (gimp_draw_tool_is_active (draw_tool) && ! draw_tool->draw_timeout)
{
draw_tool->draw_timeout =
gdk_threads_add_timeout_full (G_PRIORITY_HIGH_IDLE,
DRAW_TIMEOUT,
(GSourceFunc) gimp_draw_tool_draw_timeout,
draw_tool, NULL);
}
#endif
/* call draw() anyway, it will do nothing if the timeout is
* running, but will additionally check the drawing times to
* ensure the minimum framerate
*/
gimp_draw_tool_draw (draw_tool);
}
}
static void
gimp_blend_tool_start_preview (GimpBlendTool *blend_tool,
GimpDisplay *display)
{
GimpTool *tool = GIMP_TOOL (blend_tool);
GimpImage *image = gimp_display_get_image (display);
GimpDrawable *drawable = gimp_image_get_active_drawable (image);
GimpBlendOptions *options = GIMP_BLEND_TOOL_GET_OPTIONS (blend_tool);
GimpContext *context = GIMP_CONTEXT (options);
tool->display = display;
tool->drawable = drawable;
if (blend_tool->grabbed_point != POINT_FILL_MODE)
{
gimp_blend_tool_create_image_map (blend_tool, drawable);
/* Initially sync all of the properties */
gimp_gegl_config_proxy_sync (GIMP_OBJECT (options), blend_tool->render_node);
/* Connect signal handlers for the gradient */
gimp_blend_tool_set_gradient (blend_tool, context->gradient);
}
if (! gimp_draw_tool_is_active (GIMP_DRAW_TOOL (blend_tool)))
gimp_draw_tool_start (GIMP_DRAW_TOOL (blend_tool), display);
}
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_blend_tool_update_items (GimpBlendTool *blend_tool)
{
if (gimp_draw_tool_is_active (GIMP_DRAW_TOOL (blend_tool)) &&
blend_tool->grabbed_point != POINT_FILL_MODE &&
blend_tool->grabbed_point != POINT_INIT_MODE)
{
gimp_canvas_line_set (blend_tool->line,
blend_tool->start_x,
blend_tool->start_y,
blend_tool->end_x,
blend_tool->end_y);
gimp_canvas_handle_set_position (blend_tool->start_handle_circle,
blend_tool->start_x,
blend_tool->start_y);
gimp_canvas_handle_set_position (blend_tool->start_handle_cross,
blend_tool->start_x,
blend_tool->start_y);
gimp_canvas_handle_set_position (blend_tool->end_handle_circle,
blend_tool->end_x,
blend_tool->end_y);
gimp_canvas_handle_set_position (blend_tool->end_handle_cross,
blend_tool->end_x,
blend_tool->end_y);
gimp_blend_tool_update_item_hilight (blend_tool);
}
}
static void
gimp_move_tool_start_guide (GimpMoveTool *move,
GimpDisplay *display,
GimpOrientationType orientation)
{
GimpTool *tool = GIMP_TOOL (move);
gimp_display_shell_selection_pause (gimp_display_get_shell (display));
tool->display = display;
gimp_tool_control_activate (tool->control);
gimp_tool_control_set_scroll_lock (tool->control, TRUE);
if (gimp_draw_tool_is_active (GIMP_DRAW_TOOL (tool)))
gimp_draw_tool_stop (GIMP_DRAW_TOOL (tool));
move->guide = NULL;
move->moving_guide = TRUE;
move->guide_position = GUIDE_POSITION_INVALID;
move->guide_orientation = orientation;
gimp_tool_set_cursor (tool, display,
GIMP_CURSOR_MOUSE,
GIMP_TOOL_CURSOR_HAND,
GIMP_CURSOR_MODIFIER_MOVE);
gimp_draw_tool_start (GIMP_DRAW_TOOL (move), display);
}
static void
gimp_warp_tool_start (GimpWarpTool *wt,
GimpDisplay *display)
{
GimpTool *tool = GIMP_TOOL (wt);
GimpImage *image = gimp_display_get_image (display);
GimpDrawable *drawable = gimp_image_get_active_drawable (image);
const Babl *format;
GeglRectangle bbox;
tool->display = display;
tool->drawable = drawable;
/* Create the coords buffer, with the size of the selection */
format = babl_format_n (babl_type ("float"), 2);
gimp_item_mask_intersect (GIMP_ITEM (drawable), &bbox.x, &bbox.y,
&bbox.width, &bbox.height);
#ifdef WARP_DEBUG
g_printerr ("Initialize coordinate buffer (%d,%d) at %d,%d\n",
bbox.width, bbox.height, bbox.x, bbox.y);
#endif
wt->coords_buffer = gegl_buffer_new (&bbox, format);
gimp_warp_tool_create_image_map (wt, drawable);
if (! gimp_draw_tool_is_active (GIMP_DRAW_TOOL (wt)))
gimp_draw_tool_start (GIMP_DRAW_TOOL (wt), display);
}
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);
}
static void
gimp_blend_tool_update_item_hilight (GimpBlendTool *blend_tool)
{
GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (blend_tool);
if (gimp_draw_tool_is_active (draw_tool))
{
GimpBlendToolPoint hilight_point;
gboolean start_visible, end_visible;
/* Calculate handle visibility */
if (blend_tool->grabbed_point)
{
start_visible = FALSE;
end_visible = FALSE;
}
else
{
gdouble dist;
dist = gimp_draw_tool_calc_distance_square (draw_tool,
draw_tool->display,
blend_tool->mouse_x,
blend_tool->mouse_y,
blend_tool->start_x,
blend_tool->start_y);
start_visible = dist < FULL_HANDLE_THRESHOLD_SQ;
dist = gimp_draw_tool_calc_distance_square (draw_tool,
draw_tool->display,
blend_tool->mouse_x,
blend_tool->mouse_y,
blend_tool->end_x,
blend_tool->end_y);
end_visible = dist < FULL_HANDLE_THRESHOLD_SQ;
}
gimp_canvas_item_set_visible (blend_tool->start_handle_circle,
start_visible);
gimp_canvas_item_set_visible (blend_tool->end_handle_circle,
end_visible);
/* Update hilights */
if (blend_tool->grabbed_point)
hilight_point = blend_tool->grabbed_point;
else
hilight_point = gimp_blend_tool_get_point_under_cursor (blend_tool);
gimp_canvas_item_set_highlight (blend_tool->start_handle_circle,
hilight_point == POINT_START);
gimp_canvas_item_set_highlight (blend_tool->start_handle_cross,
hilight_point == POINT_START);
gimp_canvas_item_set_highlight (blend_tool->end_handle_circle,
hilight_point == POINT_END);
gimp_canvas_item_set_highlight (blend_tool->end_handle_cross,
hilight_point == POINT_END);
}
}
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_move_tool_oper_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
gboolean proximity,
GimpDisplay *display)
{
GimpMoveTool *move = GIMP_MOVE_TOOL (tool);
GimpMoveOptions *options = GIMP_MOVE_TOOL_GET_OPTIONS (tool);
GimpDisplayShell *shell = gimp_display_get_shell (display);
GimpImage *image = gimp_display_get_image (display);
GimpGuide *guide = NULL;
if (options->move_type == GIMP_TRANSFORM_TYPE_LAYER &&
! options->move_current &&
gimp_display_shell_get_show_guides (shell) &&
proximity)
{
const gint snap_distance = display->config->snap_distance;
guide = gimp_image_find_guide (image, coords->x, coords->y,
FUNSCALEX (shell, snap_distance),
FUNSCALEY (shell, snap_distance));
}
if (move->guide != guide)
{
GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (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);
move->guide = guide;
if (! gimp_draw_tool_is_active (draw_tool))
gimp_draw_tool_start (draw_tool, display);
gimp_draw_tool_resume (draw_tool);
}
}
static void
gimp_color_tool_oper_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
gboolean proximity,
GimpDisplay *display)
{
GimpColorTool *color_tool = GIMP_COLOR_TOOL (tool);
GimpDisplayShell *shell = gimp_display_get_shell (display);
GimpImage *image = gimp_display_get_image (display);
GimpSamplePoint *sample_point = NULL;
if (color_tool->enabled &&
gimp_display_shell_get_show_sample_points (shell) &&
proximity)
{
gint snap_distance = display->config->snap_distance;
sample_point =
gimp_image_find_sample_point (image,
coords->x, coords->y,
FUNSCALEX (shell, snap_distance),
FUNSCALEY (shell, snap_distance));
}
if (color_tool->sample_point != sample_point)
{
GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (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);
color_tool->sample_point = sample_point;
if (! gimp_draw_tool_is_active (draw_tool))
gimp_draw_tool_start (draw_tool, display);
gimp_draw_tool_resume (draw_tool);
}
}
static void
gimp_foreground_select_tool_button_press (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonPressType press_type,
GimpDisplay *display)
{
GimpForegroundSelectTool *fg_select = GIMP_FOREGROUND_SELECT_TOOL (tool);
GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (tool);
if ((fg_select->state == MATTING_STATE_PAINT_TRIMAP) ||
(fg_select->state == MATTING_STATE_PREVIEW_MASK))
{
GimpVector2 point = gimp_vector2_new (coords->x, coords->y);
gimp_draw_tool_pause (draw_tool);
if (gimp_draw_tool_is_active (draw_tool) && draw_tool->display != display)
gimp_draw_tool_stop (draw_tool);
gimp_tool_control_activate (tool->control);
fg_select->last_coords = *coords;
g_return_if_fail (fg_select->stroke == NULL);
fg_select->stroke = g_array_new (FALSE, FALSE, sizeof (GimpVector2));
g_array_append_val (fg_select->stroke, point);
if (!gimp_draw_tool_is_active (draw_tool))
gimp_draw_tool_start (draw_tool, display);
gimp_draw_tool_resume (draw_tool);
}
else if (fg_select->state == MATTING_STATE_FREE_SELECT)
{
GIMP_TOOL_CLASS (parent_class)->button_press (tool, coords, time, state,
press_type, display);
}
}
void
gimp_draw_tool_start (GimpDrawTool *draw_tool,
GimpDisplay *display)
{
g_return_if_fail (GIMP_IS_DRAW_TOOL (draw_tool));
g_return_if_fail (GIMP_IS_DISPLAY (display));
g_return_if_fail (gimp_draw_tool_is_active (draw_tool) == FALSE);
draw_tool->display = display;
gimp_draw_tool_draw (draw_tool);
}
static void
gimp_n_point_deformation_tool_halt (GimpNPointDeformationTool *npd_tool)
{
GimpTool *tool = GIMP_TOOL (npd_tool);
GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (npd_tool);
GimpNPointDeformationOptions *npd_options;
npd_options = GIMP_N_POINT_DEFORMATION_TOOL_GET_OPTIONS (npd_tool);
if (npd_tool->active)
{
gimp_n_point_deformation_tool_halt_threads (npd_tool);
/* show original/deformed image */
gimp_item_set_visible (GIMP_ITEM (tool->drawable), TRUE, FALSE);
gimp_image_flush (gimp_display_get_image (tool->display));
/* disable some options */
gimp_n_point_deformation_options_set_sensitivity (npd_options, FALSE);
npd_tool->active = FALSE;
}
if (gimp_draw_tool_is_active (draw_tool))
gimp_draw_tool_stop (draw_tool);
gimp_n_point_deformation_tool_clear_selected_points_list (npd_tool);
if (npd_tool->graph)
{
g_object_unref (npd_tool->graph);
npd_tool->graph = NULL;
npd_tool->source = NULL;
npd_tool->npd_node = NULL;
npd_tool->sink = NULL;
}
if (npd_tool->preview_buffer)
{
g_object_unref (npd_tool->preview_buffer);
npd_tool->preview_buffer = NULL;
}
if (npd_tool->lattice_points)
{
g_free (npd_tool->lattice_points);
npd_tool->lattice_points = NULL;
}
tool->display = NULL;
tool->drawable = NULL;
}
static void
gimp_color_tool_button_press (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonPressType press_type,
GimpDisplay *display)
{
GimpColorTool *color_tool = GIMP_COLOR_TOOL (tool);
GimpDisplayShell *shell = gimp_display_get_shell (display);
/* Chain up to activate the tool */
GIMP_TOOL_CLASS (parent_class)->button_press (tool, coords, time, state,
press_type, display);
if (! color_tool->enabled)
return;
if (color_tool->sample_point)
{
color_tool->moving_sample_point = TRUE;
gimp_sample_point_get_position (color_tool->sample_point,
&color_tool->sample_point_x,
&color_tool->sample_point_y);
gimp_tool_control_set_scroll_lock (tool->control, TRUE);
gimp_display_shell_selection_pause (shell);
if (! gimp_draw_tool_is_active (GIMP_DRAW_TOOL (tool)))
gimp_draw_tool_start (GIMP_DRAW_TOOL (tool), display);
gimp_tool_push_status_coords (tool, display,
gimp_tool_control_get_precision (tool->control),
_("Move Sample Point: "),
color_tool->sample_point_x,
", ",
color_tool->sample_point_y,
NULL);
}
else
{
color_tool->center_x = coords->x;
color_tool->center_y = coords->y;
gimp_draw_tool_start (GIMP_DRAW_TOOL (tool), display);
gimp_color_tool_pick (color_tool, GIMP_COLOR_PICK_STATE_START,
coords->x, coords->y);
}
}
static void
clear_all_selected_objects (GimpAlignTool *align_tool)
{
GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (align_tool);
if (gimp_draw_tool_is_active (draw_tool))
gimp_draw_tool_pause (draw_tool);
while (align_tool->selected_objects)
{
GObject *object = G_OBJECT (g_list_first (align_tool->selected_objects)->data);
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);
}
if (gimp_draw_tool_is_active (draw_tool))
gimp_draw_tool_resume (draw_tool);
}
static void
gimp_warp_tool_halt (GimpWarpTool *wt)
{
GimpTool *tool = GIMP_TOOL (wt);
GimpWarpOptions *options = GIMP_WARP_TOOL_GET_OPTIONS (wt);
if (wt->coords_buffer)
{
g_object_unref (wt->coords_buffer);
wt->coords_buffer = NULL;
}
if (wt->graph)
{
g_object_unref (wt->graph);
wt->graph = NULL;
wt->render_node = NULL;
}
if (wt->image_map)
{
gimp_image_map_abort (wt->image_map);
g_object_unref (wt->image_map);
wt->image_map = NULL;
gimp_image_flush (gimp_display_get_image (tool->display));
}
if (wt->redo_stack)
{
g_list_free_full (wt->redo_stack, (GDestroyNotify) g_object_unref);
wt->redo_stack = NULL;
}
tool->display = NULL;
tool->drawable = NULL;
if (gimp_draw_tool_is_active (GIMP_DRAW_TOOL (wt)))
gimp_draw_tool_stop (GIMP_DRAW_TOOL (wt));
if (options->animate_button)
{
gtk_widget_set_sensitive (options->animate_button, FALSE);
g_signal_handlers_disconnect_by_func (options->animate_button,
gimp_warp_tool_animate,
wt);
}
}
static void
gimp_blend_tool_update_items (GimpBlendTool *blend_tool)
{
if (gimp_draw_tool_is_active (GIMP_DRAW_TOOL (blend_tool)))
{
gimp_canvas_line_set (blend_tool->line,
blend_tool->start_x,
blend_tool->start_y,
blend_tool->end_x,
blend_tool->end_y);
gimp_canvas_handle_set_position (blend_tool->end_handle,
blend_tool->end_x,
blend_tool->end_y);
}
}
void
gimp_draw_tool_stop (GimpDrawTool *draw_tool)
{
g_return_if_fail (GIMP_IS_DRAW_TOOL (draw_tool));
g_return_if_fail (gimp_draw_tool_is_active (draw_tool) == TRUE);
gimp_draw_tool_undraw (draw_tool);
if (draw_tool->draw_timeout)
{
g_source_remove (draw_tool->draw_timeout);
draw_tool->draw_timeout = 0;
}
draw_tool->display = NULL;
}
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);
gimp_tool_pop_status (tool, display);
/* XXX: Push a useful status message */
gimp_tool_control_halt (tool->control);
switch (release_type)
{
case GIMP_BUTTON_RELEASE_NORMAL:
break;
case GIMP_BUTTON_RELEASE_CANCEL:
/* XXX: handle cancel properly */
break;
case GIMP_BUTTON_RELEASE_CLICK:
case GIMP_BUTTON_RELEASE_NO_MOTION:
if (blend_tool->grabbed_point == POINT_NONE)
{
if (gimp_draw_tool_is_active (GIMP_DRAW_TOOL (blend_tool)))
{
gimp_tool_control (tool, GIMP_TOOL_ACTION_COMMIT, display);
gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, display);
}
}
else if (blend_tool->grabbed_point == POINT_FILL_MODE)
{
/* XXX: Temporary, until the handles are working properly
* for shapebursts
*/
gimp_tool_control (tool, GIMP_TOOL_ACTION_COMMIT, display);
gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, display);
}
break;
}
blend_tool->grabbed_point = POINT_NONE;
}
void
gimp_draw_tool_start (GimpDrawTool *draw_tool,
GimpDisplay *display)
{
g_return_if_fail (GIMP_IS_DRAW_TOOL (draw_tool));
g_return_if_fail (GIMP_IS_DISPLAY (display));
#ifdef STRICT_TOOL_CHECKS
g_return_if_fail (gimp_draw_tool_is_active (draw_tool) == FALSE);
#else
gimp_draw_tool_stop (draw_tool);
#endif
draw_tool->display = display;
gimp_draw_tool_draw (draw_tool);
}
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_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_align_tool_finalize (GObject *object)
{
GimpTool *tool = GIMP_TOOL (object);
GimpAlignTool *align_tool = GIMP_ALIGN_TOOL (object);
if (gimp_draw_tool_is_active (GIMP_DRAW_TOOL (object)))
gimp_draw_tool_stop (GIMP_DRAW_TOOL (object));
if (gimp_tool_control_is_active (tool->control))
gimp_tool_control_halt (tool->control);
if (align_tool->controls)
{
gtk_widget_destroy (align_tool->controls);
align_tool->controls = NULL;
}
G_OBJECT_CLASS (parent_class)->finalize (object);
}