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_curves_tool_oper_update (GimpTool *tool,
GimpCoords *coords,
GdkModifierType state,
gboolean proximity,
GimpDisplay *display)
{
GimpColorPickMode mode = GIMP_COLOR_PICK_MODE_NONE;
const gchar *status = NULL;
GIMP_TOOL_CLASS (parent_class)->oper_update (tool, coords, state, proximity,
display);
gimp_tool_pop_status (tool, display);
if (state & GDK_SHIFT_MASK)
{
mode = GIMP_COLOR_PICK_MODE_PALETTE;
status = _("Click to add a control point");
}
else if (state & GDK_CONTROL_MASK)
{
mode = GIMP_COLOR_PICK_MODE_PALETTE;
status = _("Click to add control points to all channels");
}
GIMP_COLOR_TOOL (tool)->pick_mode = mode;
if (status && proximity)
gimp_tool_push_status (tool, display, "%s", status);
}
static void
gimp_region_select_tool_button_press (GimpTool *tool,
GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpDisplay *display)
{
GimpRegionSelectTool *region_sel = GIMP_REGION_SELECT_TOOL (tool);
GimpRegionSelectOptions *options = GIMP_REGION_SELECT_TOOL_GET_OPTIONS (tool);
region_sel->x = coords->x;
region_sel->y = coords->y;
region_sel->saved_threshold = options->threshold;
gimp_tool_control_activate (tool->control);
tool->display = display;
if (gimp_selection_tool_start_edit (GIMP_SELECTION_TOOL (region_sel), coords))
return;
gimp_tool_push_status (tool, display,
_("Move the mouse to change threshold"));
/* calculate the region boundary */
region_sel->segs = gimp_region_select_tool_calculate (region_sel, display,
®ion_sel->num_segs);
gimp_draw_tool_start (GIMP_DRAW_TOOL (tool), display);
}
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_curves_tool_oper_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
gboolean proximity,
GimpDisplay *display)
{
if (gimp_image_map_tool_on_guide (GIMP_IMAGE_MAP_TOOL (tool),
coords, display))
{
GIMP_TOOL_CLASS (parent_class)->oper_update (tool, coords, state, proximity,
display);
}
else
{
GimpColorPickMode mode;
gchar *status = NULL;
GdkModifierType extend_mask = gimp_get_extend_selection_mask ();
GdkModifierType toggle_mask = gimp_get_toggle_behavior_mask ();
gimp_tool_pop_status (tool, display);
if (state & extend_mask)
{
mode = GIMP_COLOR_PICK_MODE_PALETTE;
status = g_strdup (_("Click to add a control point"));
}
else if (state & toggle_mask)
{
mode = GIMP_COLOR_PICK_MODE_PALETTE;
status = g_strdup (_("Click to add control points to all channels"));
}
else
{
mode = GIMP_COLOR_PICK_MODE_NONE;
status = gimp_suggest_modifiers (_("Click to locate on curve"),
(extend_mask | toggle_mask) & ~state,
_("%s: add control point"),
_("%s: add control points to all channels"),
NULL);
}
GIMP_COLOR_TOOL (tool)->pick_mode = mode;
if (proximity)
gimp_tool_push_status (tool, display, "%s", status);
g_free (status);
}
}
static void
gimp_image_map_tool_oper_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
gboolean proximity,
GimpDisplay *display)
{
GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (tool);
gimp_tool_pop_status (tool, display);
if (! gimp_image_map_tool_on_guide (im_tool, coords, display))
{
GIMP_TOOL_CLASS (parent_class)->oper_update (tool, coords, state,
proximity, display);
}
else
{
GdkModifierType extend_mask = gimp_get_extend_selection_mask ();
GdkModifierType toggle_mask = gimp_get_toggle_behavior_mask ();
gchar *status = NULL;
if (state & extend_mask)
{
status = g_strdup (_("Click to switch the original and filtered sides"));
}
else if (state & toggle_mask)
{
status = g_strdup (_("Click to switch between vertical and horizontal"));
}
else
{
status = gimp_suggest_modifiers (_("Click to move the split guide"),
(extend_mask | toggle_mask) & ~state,
_("%s: switch original and filtered"),
_("%s: switch horizontal and vertical"),
NULL);
}
if (proximity)
gimp_tool_push_status (tool, display, "%s", status);
g_free (status);
}
}
static void
gimp_crop_tool_button_release (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonReleaseType release_type,
GimpDisplay *display)
{
gimp_tool_push_status (tool, display, _("Click or press Enter to crop"));
gimp_rectangle_tool_button_release (tool,
coords,
time,
state,
release_type,
display);
gimp_tool_control_halt (tool->control);
}
/**
* gimp_seamless_clone_tool_start:
* @sc: The GimpSeamlessCloneTool to initialize for usage on the given
* display
* @display: The display to initialize the tool for
*
* A utility function to initialize a tool for working on a given
* display. At the beginning of each function, we can check if the event's
* display is the same as the tool's one, and if not call this. This is
* not required by the gimptool interface or anything like that, but
* this is a convenient way to do all the initialization work in one
* place, and this is how the base class (GimpDrawTool) does that
*/
static void
gimp_seamless_clone_tool_start (GimpSeamlessCloneTool *sc,
GimpDisplay *display)
{
GimpTool *tool = GIMP_TOOL (sc);
GimpImage *image = gimp_display_get_image (display);
GimpDrawable *drawable = gimp_image_get_active_drawable (image);
/* First handle the paste - we need to make sure we have one in order
* to do anything else.
*/
if (sc->paste == NULL)
{
GimpBuffer *buffer = gimp_clipboard_get_buffer (tool->tool_info->gimp);
if (! buffer)
{
gimp_tool_push_status (tool, display,
"%s",
_("There is no image data in the clipboard to paste."));
return;
}
sc->paste = gegl_buffer_dup (gimp_buffer_get_buffer (buffer));
g_object_unref (buffer);
sc->width = gegl_buffer_get_width (sc->paste);
sc->height = gegl_buffer_get_height (sc->paste);
}
/* Free resources which are relevant only for the previous display */
gimp_seamless_clone_tool_stop (sc, TRUE);
tool->display = display;
gimp_seamless_clone_tool_create_filter (sc, drawable);
gimp_draw_tool_start (GIMP_DRAW_TOOL (sc), display);
sc->tool_state = SC_STATE_RENDER_WAIT;
}
static void
gimp_align_tool_status_update (GimpTool *tool,
GimpDisplay *display,
GdkModifierType state,
gboolean proximity)
{
GimpAlignTool *align_tool = GIMP_ALIGN_TOOL (tool);
GdkModifierType extend_mask;
extend_mask = gimp_get_extend_selection_mask ();
gimp_tool_pop_status (tool, display);
if (proximity)
{
gchar *status = NULL;
if (! align_tool->selected_objects)
{
/* no need to suggest Shift if nothing is selected */
state |= extend_mask;
}
switch (align_tool->function)
{
case ALIGN_TOOL_IDLE:
status = gimp_suggest_modifiers (_("Click on a layer, path or guide, "
"or Click-Drag to pick several "
"layers"),
extend_mask & ~state,
NULL, NULL, NULL);
break;
case ALIGN_TOOL_PICK_LAYER:
status = gimp_suggest_modifiers (_("Click to pick this layer as "
"first item"),
extend_mask & ~state,
NULL, NULL, NULL);
break;
case ALIGN_TOOL_ADD_LAYER:
status = g_strdup (_("Click to add this layer to the list"));
break;
case ALIGN_TOOL_PICK_GUIDE:
status = gimp_suggest_modifiers (_("Click to pick this guide as "
"first item"),
extend_mask & ~state,
NULL, NULL, NULL);
break;
case ALIGN_TOOL_ADD_GUIDE:
status = g_strdup (_("Click to add this guide to the list"));
break;
case ALIGN_TOOL_PICK_PATH:
status = gimp_suggest_modifiers (_("Click to pick this path as "
"first item"),
extend_mask & ~state,
NULL, NULL, NULL);
break;
case ALIGN_TOOL_ADD_PATH:
status = g_strdup (_("Click to add this path to the list"));
break;
case ALIGN_TOOL_DRAG_BOX:
break;
}
if (status)
{
gimp_tool_push_status (tool, display, "%s", status);
g_free (status);
}
}
}
static void
gimp_selection_tool_oper_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
gboolean proximity,
GimpDisplay *display)
{
GimpSelectionTool *selection_tool = GIMP_SELECTION_TOOL (tool);
GimpSelectionOptions *options = GIMP_SELECTION_TOOL_GET_OPTIONS (tool);
GimpImage *image;
GimpChannel *selection;
GimpDrawable *drawable;
GimpLayer *layer;
GimpLayer *floating_sel;
GdkModifierType extend_mask;
GdkModifierType modify_mask;
gboolean move_layer = FALSE;
gboolean move_floating_sel = FALSE;
gboolean selection_empty;
image = gimp_display_get_image (display);
selection = gimp_image_get_mask (image);
drawable = gimp_image_get_active_drawable (image);
layer = gimp_image_pick_layer (image, coords->x, coords->y);
floating_sel = gimp_image_get_floating_selection (image);
extend_mask = gimp_get_extend_selection_mask ();
modify_mask = gimp_get_modify_selection_mask ();
if (drawable)
{
if (floating_sel)
{
if (layer == floating_sel)
move_floating_sel = TRUE;
}
else if (gimp_item_mask_intersect (GIMP_ITEM (drawable),
NULL, NULL, NULL, NULL))
{
move_layer = TRUE;
}
}
selection_empty = gimp_channel_is_empty (selection);
selection_tool->function = SELECTION_SELECT;
if (selection_tool->allow_move &&
(state & GDK_MOD1_MASK) && (state & modify_mask) && move_layer)
{
/* move the selection */
selection_tool->function = SELECTION_MOVE;
}
else if (selection_tool->allow_move &&
(state & GDK_MOD1_MASK) && (state & extend_mask) && move_layer)
{
/* move a copy of the selection */
selection_tool->function = SELECTION_MOVE_COPY;
}
else if (selection_tool->allow_move &&
(state & GDK_MOD1_MASK) && ! selection_empty)
{
/* move the selection mask */
selection_tool->function = SELECTION_MOVE_MASK;
}
else if (selection_tool->allow_move &&
! (state & (extend_mask | modify_mask)) &&
move_floating_sel)
{
/* move the selection */
selection_tool->function = SELECTION_MOVE;
}
else if ((state & modify_mask) || (state & extend_mask))
{
/* select */
selection_tool->function = SELECTION_SELECT;
}
else if (floating_sel)
{
/* anchor the selection */
selection_tool->function = SELECTION_ANCHOR;
}
gimp_tool_pop_status (tool, display);
if (proximity)
{
const gchar *status = NULL;
gboolean free_status = FALSE;
GdkModifierType modifiers = (extend_mask | modify_mask);
if (! selection_empty)
modifiers |= GDK_MOD1_MASK;
switch (selection_tool->function)
{
case SELECTION_SELECT:
switch (options->operation)
{
case GIMP_CHANNEL_OP_REPLACE:
if (! selection_empty)
{
status = gimp_suggest_modifiers (_("Click-Drag to replace the "
"current selection"),
modifiers & ~state,
NULL, NULL, NULL);
free_status = TRUE;
}
else
{
status = _("Click-Drag to create a new selection");
}
break;
case GIMP_CHANNEL_OP_ADD:
status = gimp_suggest_modifiers (_("Click-Drag to add to the "
"current selection"),
modifiers
& ~(state | extend_mask),
NULL, NULL, NULL);
free_status = TRUE;
break;
case GIMP_CHANNEL_OP_SUBTRACT:
status = gimp_suggest_modifiers (_("Click-Drag to subtract from the "
"current selection"),
modifiers
& ~(state | modify_mask),
NULL, NULL, NULL);
free_status = TRUE;
break;
case GIMP_CHANNEL_OP_INTERSECT:
status = gimp_suggest_modifiers (_("Click-Drag to intersect with "
"the current selection"),
modifiers & ~state,
NULL, NULL, NULL);
free_status = TRUE;
break;
}
break;
case SELECTION_MOVE_MASK:
status = gimp_suggest_modifiers (_("Click-Drag to move the "
"selection mask"),
modifiers & ~state,
NULL, NULL, NULL);
free_status = TRUE;
break;
case SELECTION_MOVE:
status = _("Click-Drag to move the selected pixels");
break;
case SELECTION_MOVE_COPY:
status = _("Click-Drag to move a copy of the selected pixels");
break;
case SELECTION_ANCHOR:
status = _("Click to anchor the floating selection");
break;
default:
g_return_if_reached ();
}
if (status)
gimp_tool_push_status (tool, display, "%s", status);
if (free_status)
g_free ((gchar *) status);
}
}
static void
gimp_cage_tool_options_notify (GimpTool *tool,
GimpToolOptions *options,
const GParamSpec *pspec)
{
GimpCageTool *ct = GIMP_CAGE_TOOL (tool);
GIMP_TOOL_CLASS (parent_class)->options_notify (tool, options, pspec);
if (! tool->display)
return;
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
if (strcmp (pspec->name, "cage-mode") == 0)
{
GimpCageMode mode;
g_object_get (options,
"cage-mode", &mode,
NULL);
if (mode == GIMP_CAGE_MODE_DEFORM)
{
/* switch to deform mode */
gimp_cage_config_reset_displacement (ct->config);
gimp_cage_config_reverse_cage_if_needed (ct->config);
gimp_tool_push_status (tool, tool->display,
_("Press ENTER to commit the transform"));
ct->tool_state = DEFORM_STATE_WAIT;
if (! ct->render_node)
{
gimp_cage_tool_create_render_node (ct);
}
if (ct->dirty_coef)
{
gimp_cage_tool_compute_coef (ct);
gimp_cage_tool_render_node_update (ct);
}
if (! ct->image_map)
{
GimpImage *image = gimp_display_get_image (tool->display);
GimpDrawable *drawable = gimp_image_get_active_drawable (image);
gimp_cage_tool_create_image_map (ct, drawable);
}
gimp_cage_tool_image_map_update (ct);
}
else
{
/* switch to edit mode */
gimp_image_map_abort (ct->image_map);
gimp_tool_pop_status (tool, tool->display);
ct->tool_state = CAGE_STATE_WAIT;
}
}
else if (strcmp (pspec->name, "fill-plain-color") == 0)
{
gimp_cage_tool_render_node_update (ct);
gimp_cage_tool_image_map_update (ct);
}
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
}
static void
gimp_guide_tool_motion (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpDisplay *display)
{
GimpGuideTool *guide_tool = GIMP_GUIDE_TOOL (tool);
GimpDisplayShell *shell = gimp_display_get_shell (display);
GimpImage *image = gimp_display_get_image (display);
gboolean delete_guide = FALSE;
gint max_position;
gint tx, ty;
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
gimp_display_shell_transform_xy (shell,
coords->x, coords->y,
&tx, &ty);
if (guide_tool->guide_orientation == GIMP_ORIENTATION_HORIZONTAL)
max_position = gimp_image_get_height (image);
else
max_position = gimp_image_get_width (image);
if (tx < 0 || tx >= shell->disp_width ||
ty < 0 || ty >= shell->disp_height)
{
guide_tool->guide_position = GIMP_GUIDE_POSITION_UNDEFINED;
delete_guide = TRUE;
}
else
{
if (guide_tool->guide_orientation == GIMP_ORIENTATION_HORIZONTAL)
guide_tool->guide_position = RINT (coords->y);
else
guide_tool->guide_position = RINT (coords->x);
if (guide_tool->guide_position < 0 ||
guide_tool->guide_position > max_position)
{
delete_guide = TRUE;
}
}
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
gimp_tool_pop_status (tool, display);
/* custom guides are moved live */
if (guide_tool->guide_custom &&
guide_tool->guide_position != GIMP_GUIDE_POSITION_UNDEFINED)
{
gimp_image_move_guide (image, guide_tool->guide,
CLAMP (guide_tool->guide_position,
0, max_position), TRUE);
}
if (delete_guide)
{
gimp_tool_push_status (tool, display,
guide_tool->guide ?
_("Remove Guide") : _("Cancel Guide"));
}
else 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_color_picker_tool_oper_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
gboolean proximity,
GimpDisplay *display)
{
GimpColorPickerTool *picker_tool = GIMP_COLOR_PICKER_TOOL (tool);
GimpColorPickerOptions *options = GIMP_COLOR_PICKER_TOOL_GET_OPTIONS (tool);
GdkModifierType toggle_mask;
toggle_mask = gimp_get_toggle_behavior_mask ();
GIMP_COLOR_TOOL (tool)->pick_mode = options->pick_mode;
gimp_tool_pop_status (tool, display);
if (proximity)
{
gchar *status_help = NULL;
GdkModifierType shift_mod = 0;
if (! picker_tool->gui)
shift_mod = GDK_SHIFT_MASK;
switch (options->pick_mode)
{
case GIMP_COLOR_PICK_MODE_NONE:
status_help = gimp_suggest_modifiers (_("Click in any image to view"
" its color"),
shift_mod & ~state,
NULL, NULL, NULL);
break;
case GIMP_COLOR_PICK_MODE_FOREGROUND:
status_help = gimp_suggest_modifiers (_("Click in any image to pick"
" the foreground color"),
(shift_mod | toggle_mask) &
~state,
NULL, NULL, NULL);
break;
case GIMP_COLOR_PICK_MODE_BACKGROUND:
status_help = gimp_suggest_modifiers (_("Click in any image to pick"
" the background color"),
(shift_mod | toggle_mask) &
~state,
NULL, NULL, NULL);
break;
case GIMP_COLOR_PICK_MODE_PALETTE:
status_help = gimp_suggest_modifiers (_("Click in any image to add"
" the color to the palette"),
shift_mod & ~state,
NULL, NULL, NULL);
break;
}
if (status_help != NULL)
{
gimp_tool_push_status (tool, display, "%s", status_help);
g_free (status_help);
}
}
GIMP_TOOL_CLASS (parent_class)->oper_update (tool, coords, state, proximity,
display);
}
static void
gimp_color_tool_motion (GimpTool *tool,
GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpDisplay *display)
{
GimpColorTool *color_tool = GIMP_COLOR_TOOL (tool);
GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (display->shell);
if (! color_tool->enabled)
return;
if (color_tool->moving_sample_point)
{
gint tx, ty;
gboolean delete_point = FALSE;
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
gimp_display_shell_transform_xy (shell,
coords->x, coords->y,
&tx, &ty,
FALSE);
if (tx < 0 || tx > shell->disp_width ||
ty < 0 || ty > shell->disp_height)
{
color_tool->sample_point_x = -1;
color_tool->sample_point_y = -1;
delete_point = TRUE;
}
else
{
gint x, y, width, height;
color_tool->sample_point_x = floor (coords->x);
color_tool->sample_point_y = floor (coords->y);
gimp_display_shell_untransform_viewport (shell, &x, &y,
&width, &height);
if ((color_tool->sample_point_x < x ||
color_tool->sample_point_x > (x + width - 1) ||
color_tool->sample_point_y < y ||
color_tool->sample_point_y > (y + height - 1)))
{
delete_point = TRUE;
}
}
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
gimp_tool_pop_status (tool, display);
if (delete_point)
{
gimp_tool_push_status (tool, display,
color_tool->sample_point ?
_("Remove Sample Point") :
_("Cancel Sample Point"));
}
else
{
gimp_tool_push_status_coords (tool, display,
color_tool->sample_point ?
_("Move Sample Point: ") :
_("Add Sample Point: "),
color_tool->sample_point_x,
", ",
color_tool->sample_point_y,
NULL);
}
}
else
{
gint off_x, off_y;
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
gimp_item_offsets (GIMP_ITEM (tool->drawable), &off_x, &off_y);
color_tool->center_x = coords->x - off_x;
color_tool->center_y = coords->y - off_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_sample_point_tool_motion (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpDisplay *display)
{
GimpSamplePointTool *sp_tool = GIMP_SAMPLE_POINT_TOOL (tool);
GimpDisplayShell *shell = gimp_display_get_shell (display);
gboolean delete_point = FALSE;
gint tx, ty;
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
gimp_display_shell_transform_xy (shell,
coords->x, coords->y,
&tx, &ty);
if (tx < 0 || tx >= shell->disp_width ||
ty < 0 || ty >= shell->disp_height)
{
sp_tool->sample_point_x = GIMP_SAMPLE_POINT_POSITION_UNDEFINED;
sp_tool->sample_point_y = GIMP_SAMPLE_POINT_POSITION_UNDEFINED;
delete_point = TRUE;
}
else
{
GimpImage *image = gimp_display_get_image (display);
gint width = gimp_image_get_width (image);
gint height = gimp_image_get_height (image);
sp_tool->sample_point_x = floor (coords->x);
sp_tool->sample_point_y = floor (coords->y);
if (sp_tool->sample_point_x < 0 ||
sp_tool->sample_point_x >= height ||
sp_tool->sample_point_y < 0 ||
sp_tool->sample_point_y >= width)
{
delete_point = TRUE;
}
}
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
gimp_tool_pop_status (tool, display);
if (delete_point)
{
gimp_tool_push_status (tool, display,
sp_tool->sample_point ?
_("Remove Sample Point") :
_("Cancel Sample Point"));
}
else 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);
}
}
static void
gimp_move_tool_motion (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpDisplay *display)
{
GimpMoveTool *move = GIMP_MOVE_TOOL (tool);
GimpDisplayShell *shell = gimp_display_get_shell (display);
if (move->moving_guide)
{
gint tx, ty;
gboolean delete_guide = FALSE;
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
gimp_display_shell_transform_xy (shell,
coords->x, coords->y,
&tx, &ty);
if (tx < 0 || tx >= shell->disp_width ||
ty < 0 || ty >= shell->disp_height)
{
move->guide_position = GUIDE_POSITION_INVALID;
delete_guide = TRUE;
}
else
{
gint x, y, width, height;
if (move->guide_orientation == GIMP_ORIENTATION_HORIZONTAL)
move->guide_position = RINT (coords->y);
else
move->guide_position = RINT (coords->x);
gimp_display_shell_untransform_viewport (shell, &x, &y,
&width, &height);
switch (move->guide_orientation)
{
case GIMP_ORIENTATION_HORIZONTAL:
if ((move->guide_position < y) ||
(move->guide_position > (y + height)))
delete_guide = TRUE;
break;
case GIMP_ORIENTATION_VERTICAL:
if ((move->guide_position < x) ||
(move->guide_position > (x + width)))
delete_guide = TRUE;
break;
default:
break;
}
}
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
gimp_tool_pop_status (tool, display);
if (delete_guide)
{
gimp_tool_push_status (tool, display,
move->guide ?
_("Remove Guide") : _("Cancel Guide"));
}
else
{
gimp_tool_push_status_length (tool, display,
move->guide ?
_("Move Guide: ") : _("Add Guide: "),
SWAP_ORIENT (move->guide_orientation),
move->guide_position,
NULL);
}
}
}
static void
gimp_color_tool_motion (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpDisplay *display)
{
GimpColorTool *color_tool = GIMP_COLOR_TOOL (tool);
GimpDisplayShell *shell = gimp_display_get_shell (display);
if (! color_tool->enabled)
return;
if (color_tool->moving_sample_point)
{
gint tx, ty;
gboolean delete_point = FALSE;
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
gimp_display_shell_transform_xy (shell,
coords->x, coords->y,
&tx, &ty);
if (tx < 0 || tx > shell->disp_width ||
ty < 0 || ty > shell->disp_height)
{
color_tool->sample_point_x = SAMPLE_POINT_POSITION_INVALID;
color_tool->sample_point_y = SAMPLE_POINT_POSITION_INVALID;
delete_point = TRUE;
}
else
{
GimpImage *image = gimp_display_get_image (display);
gint width = gimp_image_get_width (image);
gint height = gimp_image_get_height (image);
color_tool->sample_point_x = floor (coords->x);
color_tool->sample_point_y = floor (coords->y);
if (color_tool->sample_point_x < 0 ||
color_tool->sample_point_x >= width ||
color_tool->sample_point_y < 0 ||
color_tool->sample_point_y >= height)
{
delete_point = TRUE;
}
}
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
gimp_tool_pop_status (tool, display);
if (delete_point)
{
gimp_tool_push_status (tool, display,
color_tool->sample_point ?
_("Remove Sample Point") :
_("Cancel Sample Point"));
}
else
{
gimp_tool_push_status_coords (tool, display,
gimp_tool_control_get_precision (tool->control),
color_tool->sample_point ?
_("Move Sample Point: ") :
_("Add Sample Point: "),
color_tool->sample_point_x,
", ",
color_tool->sample_point_y,
NULL);
}
}
else
{
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_paint_tool_oper_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
gboolean proximity,
GimpDisplay *display)
{
GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool);
GimpDrawTool *draw_tool = GIMP_DRAW_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)->oper_update (tool, coords, state,
proximity, display);
return;
}
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_pop_status (tool, display);
if (tool->display &&
tool->display != display &&
gimp_display_get_image (tool->display) == image)
{
/* if this is a different display, but the same image, HACK around
* in tool internals AFTER stopping the current draw_tool, so
* straight line drawing works across different views of the
* same image.
*/
tool->display = display;
}
if (drawable && proximity)
{
gboolean constrain_mask = gimp_get_constrain_behavior_mask ();
gint off_x, off_y;
core->cur_coords = *coords;
gimp_item_get_offset (GIMP_ITEM (drawable), &off_x, &off_y);
core->cur_coords.x -= off_x;
core->cur_coords.y -= off_y;
if (display == tool->display && (state & GIMP_PAINT_TOOL_LINE_MASK))
{
/* If shift is down and this is not the first paint stroke,
* draw a line.
*/
gchar *status_help;
gdouble dx, dy, dist;
gimp_paint_core_round_line (core, paint_options,
(state & constrain_mask) != 0);
dx = core->cur_coords.x - core->last_coords.x;
dy = core->cur_coords.y - core->last_coords.y;
status_help = gimp_suggest_modifiers (paint_tool->status_line,
constrain_mask & ~state,
NULL,
_("%s for constrained angles"),
NULL);
/* show distance in statusbar */
if (shell->unit == GIMP_UNIT_PIXEL)
{
dist = sqrt (SQR (dx) + SQR (dy));
gimp_tool_push_status (tool, display, "%.1f %s. %s",
dist, _("pixels"), status_help);
}
else
{
gdouble xres;
gdouble yres;
gchar format_str[64];
gimp_image_get_resolution (image, &xres, &yres);
g_snprintf (format_str, sizeof (format_str), "%%.%df %s. %%s",
gimp_unit_get_digits (shell->unit),
gimp_unit_get_symbol (shell->unit));
dist = (gimp_unit_get_factor (shell->unit) *
sqrt (SQR (dx / xres) +
SQR (dy / yres)));
gimp_tool_push_status (tool, display, format_str,
dist, status_help);
}
g_free (status_help);
paint_tool->draw_line = TRUE;
}
else
{
gchar *status;
GdkModifierType modifiers = 0;
/* HACK: A paint tool may set status_ctrl to NULL to indicate that
* it ignores the Ctrl modifier (temporarily or permanently), so
* it should not be suggested. This is different from how
* gimp_suggest_modifiers() would interpret this parameter.
*/
if (paint_tool->status_ctrl != NULL)
modifiers |= constrain_mask;
/* suggest drawing lines only after the first point is set
*/
if (display == tool->display)
modifiers |= GIMP_PAINT_TOOL_LINE_MASK;
status = gimp_suggest_modifiers (paint_tool->status,
modifiers & ~state,
_("%s for a straight line"),
paint_tool->status_ctrl,
NULL);
gimp_tool_push_status (tool, display, "%s", status);
g_free (status);
paint_tool->draw_line = FALSE;
}
if (! gimp_draw_tool_is_active (draw_tool))
gimp_draw_tool_start (draw_tool, display);
}
else if (gimp_draw_tool_is_active (draw_tool))
{
gimp_draw_tool_stop (draw_tool);
}
GIMP_TOOL_CLASS (parent_class)->oper_update (tool, coords, state, proximity,
display);
gimp_draw_tool_resume (draw_tool);
}