static void
gimp_crop_tool_button_press (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonPressType press_type,
GimpDisplay *display)
{
if (tool->display && display != tool->display)
gimp_tool_control (tool, GIMP_TOOL_ACTION_COMMIT, tool->display);
gimp_tool_control_activate (tool->control);
gimp_rectangle_tool_button_press (tool, coords, time, state, display);
}
static void
gimp_warp_tool_button_press (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonPressType press_type,
GimpDisplay *display)
{
GimpWarpTool *wt = GIMP_WARP_TOOL (tool);
GimpWarpOptions *options = GIMP_WARP_TOOL_GET_OPTIONS (wt);
GeglNode *new_op;
gint off_x, off_y;
if (tool->display && display != tool->display)
gimp_warp_tool_halt (wt);
if (! tool->display)
gimp_warp_tool_start (wt, display);
wt->current_stroke = gegl_path_new ();
new_op = gegl_node_new_child (NULL,
"operation", "gegl:warp",
"behavior", options->behavior,
"strength", options->effect_strength,
"size", options->effect_size,
"hardness", options->effect_hardness,
"stroke", wt->current_stroke,
NULL);
gimp_warp_tool_add_op (wt, new_op);
g_object_unref (new_op);
g_signal_connect (wt->current_stroke, "changed",
G_CALLBACK (gimp_warp_tool_stroke_changed),
wt);
gimp_item_get_offset (GIMP_ITEM (tool->drawable), &off_x, &off_y);
gegl_path_append (wt->current_stroke,
'M', coords->x - off_x, coords->y - off_y);
wt->stroke_timer = g_timeout_add (STROKE_PERIOD,
(GSourceFunc) gimp_warp_tool_stroke_timer,
wt);
gimp_tool_control_activate (tool->control);
}
static void
gimp_brightness_contrast_tool_button_press (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonPressType press_type,
GimpDisplay *display)
{
GimpBrightnessContrastTool *bc_tool = GIMP_BRIGHTNESS_CONTRAST_TOOL (tool);
bc_tool->x = coords->x - bc_tool->config->contrast * 127.0;
bc_tool->y = coords->y + bc_tool->config->brightness * 127.0;
bc_tool->dx = bc_tool->config->contrast * 127.0;
bc_tool->dy = - bc_tool->config->brightness * 127.0;
gimp_tool_control_activate (tool->control);
tool->display = display;
}
static void
gimp_tool_real_button_press (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonPressType press_type,
GimpDisplay *display)
{
if (press_type == GIMP_BUTTON_PRESS_NORMAL)
{
GimpImage *image = gimp_display_get_image (display);
tool->display = display;
tool->drawable = gimp_image_get_active_drawable (image);
gimp_tool_control_activate (tool->control);
}
}
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);
}
}
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);
blend_tool->start_x = blend_tool->end_x = coords->x;
blend_tool->start_y = blend_tool->end_y = coords->y;
blend_tool->last_x = blend_tool->mouse_x = coords->x;
blend_tool->last_y = blend_tool->mouse_y = coords->y;
tool->display = display;
gimp_tool_control_activate (tool->control);
gimp_blend_tool_push_status (blend_tool, state, display);
gimp_draw_tool_start (GIMP_DRAW_TOOL (tool), display);
}
static void
gimp_rectangle_select_tool_button_press (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonPressType press_type,
GimpDisplay *display)
{
GimpRectangleTool *rectangle;
GimpRectangleSelectTool *rect_sel_tool;
GimpDisplayShell *shell;
GimpRectangleSelectToolPrivate *priv;
GimpRectangleFunction function;
rectangle = GIMP_RECTANGLE_TOOL (tool);
rect_sel_tool = GIMP_RECTANGLE_SELECT_TOOL (tool);
shell = gimp_display_get_shell (display);
priv = GIMP_RECTANGLE_SELECT_TOOL_GET_PRIVATE (rect_sel_tool);
if (tool->display && display != tool->display)
{
gimp_rectangle_tool_cancel (GIMP_RECTANGLE_TOOL (tool));
}
if (gimp_selection_tool_start_edit (GIMP_SELECTION_TOOL (tool),
display, coords))
{
/* In some cases we want to finish the rectangle select tool
* and hand over responsability to the selection tool
*/
gimp_rectangle_tool_execute (rectangle);
gimp_rectangle_tool_control (tool, GIMP_TOOL_ACTION_HALT, display);
gimp_rectangle_select_tool_update_option_defaults (rect_sel_tool,
TRUE);
return;
}
gimp_tool_control_activate (tool->control);
priv->saved_show_selection = gimp_display_shell_get_show_selection (shell);
/* if the shift or ctrl keys are down, we don't want to adjust, we
* want to create a new rectangle, regardless of pointer loc */
if (state & (gimp_get_extend_selection_mask () |
gimp_get_modify_selection_mask ()))
{
gimp_rectangle_tool_set_function (rectangle,
GIMP_RECTANGLE_TOOL_CREATING);
}
gimp_rectangle_tool_button_press (tool, coords, time, state, display);
priv->press_x = coords->x;
priv->press_y = coords->y;
/* if we have an existing rectangle in the current display, then
* we have already "executed", and need to undo at this point,
* unless the user has done something in the meantime
*/
function = gimp_rectangle_tool_get_function (rectangle);
if (function == GIMP_RECTANGLE_TOOL_CREATING)
{
priv->use_saved_op = FALSE;
}
else
{
GimpImage *image = gimp_display_get_image (tool->display);
GimpUndoStack *undo_stack = gimp_image_get_undo_stack (image);
GimpUndoStack *redo_stack = gimp_image_get_redo_stack (image);
GimpUndo *undo;
GimpChannelOps operation;
undo = gimp_undo_stack_peek (undo_stack);
if (undo && priv->undo == undo)
{
/* prevent this change from halting the tool */
gimp_tool_control_push_preserve (tool->control, TRUE);
gimp_image_undo (image);
gimp_tool_control_pop_preserve (tool->control);
/* we will need to redo if the user cancels or executes */
priv->redo = gimp_undo_stack_peek (redo_stack);
}
/* if the operation is "Replace", turn off the marching ants,
because they are confusing */
operation = gimp_rectangle_select_tool_get_operation (rect_sel_tool);
if (operation == GIMP_CHANNEL_OP_REPLACE)
gimp_display_shell_set_show_selection (shell, FALSE);
}
priv->undo = NULL;
}
static void
gimp_n_point_deformation_tool_button_press (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonPressType press_type,
GimpDisplay *display)
{
GimpNPointDeformationTool *npd_tool = GIMP_N_POINT_DEFORMATION_TOOL (tool);
if (display != tool->display)
{
/* this is the first click on the drawable - just start the tool */
gimp_n_point_deformation_tool_start (npd_tool, display);
}
npd_tool->selected_cp = NULL;
if (press_type == GIMP_BUTTON_PRESS_NORMAL)
{
NPDControlPoint *cp = npd_tool->hovering_cp;
if (cp)
{
/* there is a control point at cursor's position */
npd_tool->selected_cp = cp;
if (! g_list_find (npd_tool->selected_cps, cp))
{
/* control point isn't selected, so we can add it to the
* list of selected control points
*/
if (! (state & gimp_get_extend_selection_mask ()))
{
/* <SHIFT> isn't pressed, so this isn't a
* multiselection - clear the list of selected
* control points
*/
gimp_n_point_deformation_tool_clear_selected_points_list (npd_tool);
}
gimp_n_point_deformation_tool_add_cp_to_selection (npd_tool, cp);
}
else if (state & gimp_get_extend_selection_mask ())
{
/* control point is selected and <SHIFT> is pressed -
* remove control point from selected points
*/
gimp_n_point_deformation_tool_remove_cp_from_selection (npd_tool,
cp);
}
}
npd_tool->start_x = coords->x;
npd_tool->start_y = coords->y;
npd_tool->last_x = coords->x;
npd_tool->last_y = coords->y;
}
gimp_tool_control_activate (tool->control);
}
static void
gimp_move_tool_button_press (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonPressType press_type,
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);
tool->display = display;
move->floating_layer = NULL;
move->guide = NULL;
move->moving_guide = FALSE;
move->old_active_layer = NULL;
move->old_active_vectors = NULL;
if (! options->move_current)
{
if (options->move_type == GIMP_TRANSFORM_TYPE_PATH)
{
GimpVectors *vectors;
if (gimp_draw_tool_on_vectors (GIMP_DRAW_TOOL (tool), display,
coords, 7, 7,
NULL, NULL, NULL, NULL, NULL,
&vectors))
{
move->old_active_vectors =
gimp_image_get_active_vectors (image);
gimp_image_set_active_vectors (image, vectors);
}
else
{
/* no path picked */
return;
}
}
else if (options->move_type == GIMP_TRANSFORM_TYPE_LAYER)
{
GimpGuide *guide;
GimpLayer *layer;
const gint snap_distance = display->config->snap_distance;
if (gimp_display_shell_get_show_guides (shell) &&
(guide = gimp_image_find_guide (image,
coords->x, coords->y,
FUNSCALEX (shell, snap_distance),
FUNSCALEY (shell, snap_distance))))
{
move->guide = guide;
move->moving_guide = TRUE;
move->guide_position = gimp_guide_get_position (guide);
move->guide_orientation = gimp_guide_get_orientation (guide);
gimp_tool_control_set_scroll_lock (tool->control, TRUE);
gimp_tool_control_set_precision (tool->control,
GIMP_CURSOR_PRECISION_PIXEL_BORDER);
gimp_tool_control_activate (tool->control);
gimp_display_shell_selection_pause (shell);
gimp_draw_tool_start (GIMP_DRAW_TOOL (tool), display);
gimp_tool_push_status_length (tool, display,
_("Move Guide: "),
SWAP_ORIENT (move->guide_orientation),
move->guide_position,
NULL);
return;
}
else if ((layer = gimp_image_pick_layer (image,
coords->x,
coords->y)))
{
if (gimp_image_get_floating_selection (image) &&
! gimp_layer_is_floating_sel (layer))
{
/* If there is a floating selection, and this aint it,
* use the move tool to anchor it.
*/
move->floating_layer =
gimp_image_get_floating_selection (image);
gimp_tool_control_activate (tool->control);
return;
}
else
{
move->old_active_layer = gimp_image_get_active_layer (image);
gimp_image_set_active_layer (image, layer);
}
}
else
{
/* no guide and no layer picked */
return;
}
}
}
switch (options->move_type)
{
case GIMP_TRANSFORM_TYPE_PATH:
if (gimp_image_get_active_vectors (image))
gimp_edit_selection_tool_start (tool, display, coords,
GIMP_TRANSLATE_MODE_VECTORS, TRUE);
break;
case GIMP_TRANSFORM_TYPE_SELECTION:
if (! gimp_channel_is_empty (gimp_image_get_mask (image)))
gimp_edit_selection_tool_start (tool, display, coords,
GIMP_TRANSLATE_MODE_MASK, TRUE);
break;
case GIMP_TRANSFORM_TYPE_LAYER:
{
GimpDrawable *drawable = gimp_image_get_active_drawable (image);
if (GIMP_IS_LAYER_MASK (drawable))
gimp_edit_selection_tool_start (tool, display, coords,
GIMP_TRANSLATE_MODE_LAYER_MASK, TRUE);
else if (GIMP_IS_CHANNEL (drawable))
gimp_edit_selection_tool_start (tool, display, coords,
GIMP_TRANSLATE_MODE_CHANNEL, TRUE);
else if (GIMP_IS_LAYER (drawable))
gimp_edit_selection_tool_start (tool, display, coords,
GIMP_TRANSLATE_MODE_LAYER, TRUE);
}
break;
}
}
static void
gimp_cage_tool_button_press (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonPressType press_type,
GimpDisplay *display)
{
GimpCageTool *ct = GIMP_CAGE_TOOL (tool);
GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (tool);
gint handle = -1;
gint edge = -1;
if (display != tool->display)
gimp_cage_tool_start (ct, display);
gimp_tool_control_activate (tool->control);
if (ct->config)
{
handle = gimp_cage_tool_is_on_handle (ct,
draw_tool,
display,
coords->x,
coords->y,
GIMP_TOOL_HANDLE_SIZE_CIRCLE);
edge = gimp_cage_tool_is_on_edge (ct,
coords->x,
coords->y,
GIMP_TOOL_HANDLE_SIZE_CIRCLE);
}
ct->movement_start_x = coords->x;
ct->movement_start_y = coords->y;
switch (ct->tool_state)
{
case CAGE_STATE_INIT:
/* No handle yet, we add the first one and swith the tool to
* moving handle state.
*/
gimp_cage_config_add_cage_point (ct->config,
coords->x - ct->offset_x,
coords->y - ct->offset_y);
gimp_cage_config_select_point (ct->config, 0);
ct->tool_state = CAGE_STATE_MOVE_HANDLE;
break;
case CAGE_STATE_WAIT:
if (handle == -1 && edge <= 0)
{
/* User clicked on the background, we add a new handle
* and move it
*/
gimp_cage_config_add_cage_point (ct->config,
coords->x - ct->offset_x,
coords->y - ct->offset_y);
gimp_cage_config_select_point (ct->config,
gimp_cage_config_get_n_points (ct->config) - 1);
ct->tool_state = CAGE_STATE_MOVE_HANDLE;
}
else if (handle == 0 && gimp_cage_config_get_n_points (ct->config) > 2)
{
/* User clicked on the first handle, we wait for
* release for closing the cage and switching to
* deform if possible
*/
gimp_cage_config_select_point (ct->config, 0);
ct->tool_state = CAGE_STATE_CLOSING;
}
else if (handle >= 0)
{
/* User clicked on a handle, so we move it */
if (state & GDK_SHIFT_MASK)
{
/* Multiple selection */
gimp_cage_config_toggle_point_selection (ct->config, handle);
}
else
{
/* New selection */
if (! gimp_cage_config_point_is_selected (ct->config, handle))
{
gimp_cage_config_select_point (ct->config, handle);
}
}
ct->tool_state = CAGE_STATE_MOVE_HANDLE;
}
else if (edge > 0)
{
/* User clicked on an edge, we add a new handle here and select it */
gimp_cage_config_insert_cage_point (ct->config, edge, coords->x, coords->y);
gimp_cage_config_select_point (ct->config, edge);
ct->tool_state = CAGE_STATE_MOVE_HANDLE;
}
break;
case DEFORM_STATE_WAIT:
if (handle == -1)
{
/* User clicked on the background, we start a rubber band
* selection
*/
ct->selection_start_x = coords->x;
ct->selection_start_y = coords->y;
ct->tool_state = DEFORM_STATE_SELECTING;
}
if (handle >= 0)
{
/* User clicked on a handle, so we move it */
if (state & GDK_SHIFT_MASK)
{
/* Multiple selection */
gimp_cage_config_toggle_point_selection (ct->config, handle);
}
else
{
/* New selection */
if (! gimp_cage_config_point_is_selected (ct->config, handle))
{
gimp_cage_config_select_point (ct->config, handle);
}
}
ct->tool_state = DEFORM_STATE_MOVE_HANDLE;
}
break;
}
}
static void
gimp_guide_tool_start (GimpTool *parent_tool,
GimpDisplay *display,
GimpGuide *guide,
GimpOrientationType orientation)
{
GimpGuideTool *guide_tool;
GimpTool *tool;
guide_tool = g_object_new (GIMP_TYPE_GUIDE_TOOL,
"tool-info", parent_tool->tool_info,
NULL);
tool = GIMP_TOOL (guide_tool);
gimp_display_shell_selection_pause (gimp_display_get_shell (display));
if (guide)
{
guide_tool->guide = guide;
guide_tool->guide_old_position = gimp_guide_get_position (guide);
guide_tool->guide_position = gimp_guide_get_position (guide);
guide_tool->guide_orientation = gimp_guide_get_orientation (guide);
guide_tool->guide_custom = gimp_guide_is_custom (guide);
}
else
{
guide_tool->guide = NULL;
guide_tool->guide_old_position = 0;
guide_tool->guide_position = GIMP_GUIDE_POSITION_UNDEFINED;
guide_tool->guide_orientation = orientation;
guide_tool->guide_custom = FALSE;
}
gimp_tool_set_cursor (tool, display,
GIMP_CURSOR_MOUSE,
GIMP_TOOL_CURSOR_HAND,
GIMP_CURSOR_MODIFIER_MOVE);
tool_manager_push_tool (display->gimp, tool);
tool->display = display;
gimp_tool_control_activate (tool->control);
gimp_draw_tool_start (GIMP_DRAW_TOOL (guide_tool), display);
if (guide_tool->guide)
{
gimp_tool_push_status_length (tool, display,
_("Move Guide: "),
SWAP_ORIENT (guide_tool->guide_orientation),
guide_tool->guide_position -
guide_tool->guide_old_position,
NULL);
}
else
{
gimp_tool_push_status_length (tool, display,
_("Add Guide: "),
SWAP_ORIENT (guide_tool->guide_orientation),
guide_tool->guide_position,
NULL);
}
}
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);
GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (tool);
blend_tool->mouse_x = coords->x;
blend_tool->mouse_y = coords->y;
if (tool->display && display != tool->display)
{
gimp_tool_pop_status (tool, tool->display);
gimp_blend_tool_halt_preview (blend_tool);
}
gimp_draw_tool_pause (draw_tool);
blend_tool->grabbed_point = gimp_blend_tool_get_point_under_cursor (blend_tool);
if (blend_tool->grabbed_point == POINT_NONE)
{
if (gimp_draw_tool_is_active (draw_tool))
{
gimp_tool_control (tool, GIMP_TOOL_ACTION_COMMIT, display);
gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, display);
}
if (gimp_blend_tool_is_shapeburst (blend_tool))
{
blend_tool->grabbed_point = POINT_FILL_MODE;
}
else
{
blend_tool->grabbed_point = POINT_INIT_MODE;
blend_tool->start_x = coords->x;
blend_tool->start_y = coords->y;
}
}
gimp_blend_tool_point_motion (blend_tool,
state & gimp_get_constrain_behavior_mask ());
tool->display = display;
gimp_draw_tool_resume (draw_tool);
if (blend_tool->grabbed_point != POINT_FILL_MODE &&
blend_tool->grabbed_point != POINT_INIT_MODE)
{
gimp_blend_tool_update_preview_coords (blend_tool);
gimp_image_map_apply (blend_tool->image_map, NULL);
}
gimp_tool_control_activate (tool->control);
gimp_blend_tool_push_status (blend_tool, state, display);
}
static void
gimp_perspective_clone_tool_button_press (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonPressType press_type,
GimpDisplay *display)
{
GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool);
GimpPerspectiveCloneTool *clone_tool = GIMP_PERSPECTIVE_CLONE_TOOL (tool);
GimpPerspectiveClone *clone = GIMP_PERSPECTIVE_CLONE (paint_tool->core);
GimpSourceCore *source_core = GIMP_SOURCE_CORE (clone);
GimpPerspectiveCloneOptions *options;
options = GIMP_PERSPECTIVE_CLONE_TOOL_GET_OPTIONS (tool);
switch (options->clone_mode)
{
case GIMP_PERSPECTIVE_CLONE_MODE_ADJUST:
if (clone_tool->function == TRANSFORM_CREATING)
gimp_perspective_clone_tool_oper_update (tool,
coords, state, TRUE, display);
clone_tool->lastx = coords->x;
clone_tool->lasty = coords->y;
gimp_tool_control_activate (tool->control);
break;
case GIMP_PERSPECTIVE_CLONE_MODE_PAINT:
{
GdkModifierType extend_mask = gimp_get_extend_selection_mask ();
GdkModifierType toggle_mask = gimp_get_toggle_behavior_mask ();
gdouble nnx, nny;
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
if ((state & (toggle_mask | extend_mask)) == toggle_mask)
{
source_core->set_source = TRUE;
clone_tool->src_display = display;
}
else
{
source_core->set_source = FALSE;
}
GIMP_TOOL_CLASS (parent_class)->button_press (tool, coords, time, state,
press_type, display);
/* Set the coordinates for the reference cross */
gimp_perspective_clone_get_source_point (clone,
coords->x, coords->y,
&nnx, &nny);
clone_tool->src_x = nnx;
clone_tool->src_y = nny;
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
}
break;
}
}
static void
gimp_perspective_clone_tool_button_press (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonPressType press_type,
GimpDisplay *display)
{
GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool);
GimpPerspectiveCloneTool *clone_tool = GIMP_PERSPECTIVE_CLONE_TOOL (tool);
GimpPerspectiveClone *clone = GIMP_PERSPECTIVE_CLONE (paint_tool->core);
GimpSourceCore *source_core = GIMP_SOURCE_CORE (clone);
GimpPerspectiveCloneOptions *options;
options = GIMP_PERSPECTIVE_CLONE_TOOL_GET_OPTIONS (tool);
if (options->clone_mode == GIMP_PERSPECTIVE_CLONE_MODE_ADJUST)
{
if (clone_tool->widget)
{
gimp_tool_widget_hover (clone_tool->widget, coords, state, TRUE);
if (gimp_tool_widget_button_press (clone_tool->widget, coords,
time, state, press_type))
{
clone_tool->grab_widget = clone_tool->widget;
}
}
gimp_tool_control_activate (tool->control);
}
else
{
GdkModifierType extend_mask = gimp_get_extend_selection_mask ();
GdkModifierType toggle_mask = gimp_get_toggle_behavior_mask ();
gdouble nnx, nny;
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
if ((state & (toggle_mask | extend_mask)) == toggle_mask)
{
source_core->set_source = TRUE;
clone_tool->src_display = display;
}
else
{
source_core->set_source = FALSE;
}
GIMP_TOOL_CLASS (parent_class)->button_press (tool, coords, time, state,
press_type, display);
/* Set the coordinates for the reference cross */
gimp_perspective_clone_get_source_point (clone,
coords->x, coords->y,
&nnx, &nny);
clone_tool->src_x = floor (nnx);
clone_tool->src_y = floor (nny);
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
}
}
void
gimp_tool_button_release (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpDisplay *display)
{
GimpButtonReleaseType release_type = GIMP_BUTTON_RELEASE_NORMAL;
GimpCoords my_coords;
g_return_if_fail (GIMP_IS_TOOL (tool));
g_return_if_fail (coords != NULL);
g_return_if_fail (GIMP_IS_DISPLAY (display));
g_return_if_fail (gimp_tool_control_is_active (tool->control) == TRUE);
g_object_ref (tool);
my_coords = *coords;
if (state & GDK_BUTTON3_MASK)
{
release_type = GIMP_BUTTON_RELEASE_CANCEL;
}
else if (gimp_tool_control_get_wants_click (tool->control))
{
if (gimp_tool_check_click_distance (tool, coords, time, display))
{
release_type = GIMP_BUTTON_RELEASE_CLICK;
my_coords = tool->button_press_coords;
/* synthesize a motion event back to the recorded press
* coordinates
*/
GIMP_TOOL_GET_CLASS (tool)->motion (tool, &my_coords, time,
state & GDK_BUTTON1_MASK,
display);
}
else if (! tool->got_motion_event)
{
release_type = GIMP_BUTTON_RELEASE_NO_MOTION;
}
}
GIMP_TOOL_GET_CLASS (tool)->button_release (tool, &my_coords, time, state,
release_type, display);
g_warn_if_fail (gimp_tool_control_is_active (tool->control) == FALSE);
if (tool->active_modifier_state != 0)
{
gimp_tool_control_activate (tool->control);
gimp_tool_set_active_modifier_state (tool, 0, display);
gimp_tool_control_halt (tool->control);
}
tool->button_press_state = 0;
g_object_unref (tool);
}
static void
gimp_sample_point_tool_start (GimpTool *parent_tool,
GimpDisplay *display,
GimpSamplePoint *sample_point)
{
GimpSamplePointTool *sp_tool;
GimpTool *tool;
sp_tool = g_object_new (GIMP_TYPE_SAMPLE_POINT_TOOL,
"tool-info", parent_tool->tool_info,
NULL);
tool = GIMP_TOOL (sp_tool);
gimp_display_shell_selection_pause (gimp_display_get_shell (display));
if (sample_point)
{
sp_tool->sample_point = sample_point;
gimp_sample_point_get_position (sample_point,
&sp_tool->sample_point_old_x,
&sp_tool->sample_point_old_y);
sp_tool->sample_point_x = sp_tool->sample_point_old_x;
sp_tool->sample_point_y = sp_tool->sample_point_old_y;
}
else
{
sp_tool->sample_point = NULL;
sp_tool->sample_point_old_x = 0;
sp_tool->sample_point_old_y = 0;
sp_tool->sample_point_x = GIMP_SAMPLE_POINT_POSITION_UNDEFINED;
sp_tool->sample_point_y = GIMP_SAMPLE_POINT_POSITION_UNDEFINED;
}
gimp_tool_set_cursor (tool, display,
GIMP_CURSOR_MOUSE,
GIMP_TOOL_CURSOR_COLOR_PICKER,
GIMP_CURSOR_MODIFIER_MOVE);
tool_manager_push_tool (display->gimp, tool);
tool->display = display;
gimp_tool_control_activate (tool->control);
gimp_draw_tool_start (GIMP_DRAW_TOOL (sp_tool), display);
if (sp_tool->sample_point)
{
gimp_tool_push_status_coords (tool, display,
gimp_tool_control_get_precision (tool->control),
_("Move Sample Point: "),
sp_tool->sample_point_x -
sp_tool->sample_point_old_x,
", ",
sp_tool->sample_point_y -
sp_tool->sample_point_old_y,
NULL);
}
else
{
gimp_tool_push_status_coords (tool, display,
gimp_tool_control_get_precision (tool->control),
_("Add Sample Point: "),
sp_tool->sample_point_x,
", ",
sp_tool->sample_point_y,
NULL);
}
}
