void
gimp_tool_set_focus_display (GimpTool *tool,
GimpDisplay *display)
{
g_return_if_fail (GIMP_IS_TOOL (tool));
g_return_if_fail (display == NULL || GIMP_IS_DISPLAY (display));
g_return_if_fail (gimp_tool_control_is_active (tool->control) == FALSE);
GIMP_LOG (TOOL_FOCUS, "tool: %p focus_display: %p tool->focus_display: %p",
tool, display, tool->focus_display);
if (display != tool->focus_display)
{
if (tool->focus_display)
{
if (tool->active_modifier_state != 0)
{
gimp_tool_control_activate (tool->control);
gimp_tool_set_active_modifier_state (tool, 0, tool->focus_display);
gimp_tool_control_halt (tool->control);
}
if (tool->modifier_state != 0)
gimp_tool_set_modifier_state (tool, 0, tool->focus_display);
}
tool->focus_display = display;
}
}
void
gimp_tool_button_press (GimpTool *tool,
GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpDisplay *display)
{
g_return_if_fail (GIMP_IS_TOOL (tool));
g_return_if_fail (coords != NULL);
g_return_if_fail (GIMP_IS_DISPLAY (display));
GIMP_TOOL_GET_CLASS (tool)->button_press (tool, coords, time, state,
display);
if (gimp_tool_control_is_active (tool->control))
{
tool->button_press_state = state;
tool->active_modifier_state = state;
if (gimp_tool_control_get_wants_click (tool->control))
{
tool->in_click_distance = TRUE;
tool->got_motion_event = FALSE;
tool->button_press_coords = *coords;
tool->button_press_time = time;
}
else
{
tool->in_click_distance = FALSE;
}
}
}
void
tool_manager_control_active (Gimp *gimp,
GimpToolAction action,
GimpDisplay *display)
{
GimpToolManager *tool_manager;
g_return_if_fail (GIMP_IS_GIMP (gimp));
tool_manager = tool_manager_get (gimp);
if (tool_manager->active_tool)
{
GimpTool *tool = tool_manager->active_tool;
if (display && gimp_tool_has_display (tool, display))
{
gimp_tool_control (tool, action, display);
}
else if (action == GIMP_TOOL_ACTION_HALT)
{
if (gimp_tool_control_is_active (tool->control))
gimp_tool_control_halt (tool->control);
}
}
}
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));
}
gboolean
gimp_tool_key_release (GimpTool *tool,
GdkEventKey *kevent,
GimpDisplay *display)
{
g_return_val_if_fail (GIMP_IS_TOOL (tool), FALSE);
g_return_val_if_fail (GIMP_IS_DISPLAY (display), FALSE);
g_return_val_if_fail (display == tool->focus_display, FALSE);
g_return_val_if_fail (gimp_tool_control_is_active (tool->control) == FALSE,
FALSE);
return GIMP_TOOL_GET_CLASS (tool)->key_release (tool, kevent, display);
}
void
gimp_tool_cursor_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
GimpDisplay *display)
{
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) == FALSE);
GIMP_TOOL_GET_CLASS (tool)->cursor_update (tool, coords, state, display);
}
static void
gimp_color_tool_draw (GimpDrawTool *draw_tool)
{
GimpColorTool *color_tool = GIMP_COLOR_TOOL (draw_tool);
if (color_tool->enabled)
{
if (color_tool->sample_point)
{
GimpImage *image = gimp_display_get_image (draw_tool->display);
GimpCanvasItem *item;
gint index;
gint x;
gint y;
gimp_sample_point_get_position (color_tool->sample_point, &x, &y);
index = g_list_index (gimp_image_get_sample_points (image),
color_tool->sample_point) + 1;
item = gimp_draw_tool_add_sample_point (draw_tool, x, y, index);
gimp_canvas_item_set_highlight (item, TRUE);
}
if (color_tool->moving_sample_point)
{
if (color_tool->sample_point_x != SAMPLE_POINT_POSITION_INVALID &&
color_tool->sample_point_y != SAMPLE_POINT_POSITION_INVALID)
{
gimp_draw_tool_add_crosshair (draw_tool,
color_tool->sample_point_x,
color_tool->sample_point_y);
}
}
else if (color_tool->options->sample_average &&
gimp_tool_control_is_active (GIMP_TOOL (draw_tool)->control))
{
gdouble radius = color_tool->options->average_radius;
gimp_draw_tool_add_rectangle (draw_tool,
FALSE,
color_tool->center_x - radius,
color_tool->center_y - radius,
2 * radius + 1,
2 * radius + 1);
}
}
}
void
gimp_tool_motion (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpDisplay *display)
{
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);
tool->got_motion_event = TRUE;
GIMP_TOOL_GET_CLASS (tool)->motion (tool, coords, time, state, display);
}
void
gimp_tool_set_modifier_state (GimpTool *tool,
GdkModifierType state,
GimpDisplay *display)
{
gboolean press;
g_return_if_fail (GIMP_IS_TOOL (tool));
g_return_if_fail (GIMP_IS_DISPLAY (display));
g_return_if_fail (gimp_tool_control_is_active (tool->control) == FALSE);
GIMP_LOG (TOOL_FOCUS, "tool: %p display: %p tool->focus_display: %p",
tool, display, tool->focus_display);
g_return_if_fail (display == tool->focus_display);
if (state_changed (tool->modifier_state, state, GDK_SHIFT_MASK, &press))
{
gimp_tool_modifier_key (tool, GDK_SHIFT_MASK,
press, state,
display);
}
if (state_changed (tool->modifier_state, state, GDK_CONTROL_MASK, &press))
{
gimp_tool_modifier_key (tool, GDK_CONTROL_MASK,
press, state,
display);
}
if (state_changed (tool->modifier_state, state, GDK_MOD1_MASK, &press))
{
gimp_tool_modifier_key (tool, GDK_MOD1_MASK,
press, state,
display);
}
if (state_changed (tool->modifier_state, state, GDK_MOD2_MASK, &press))
{
gimp_tool_modifier_key (tool, GDK_MOD2_MASK,
press, state,
display);
}
tool->modifier_state = state;
}
void
tool_manager_focus_display_active (Gimp *gimp,
GimpDisplay *display)
{
GimpToolManager *tool_manager;
g_return_if_fail (GIMP_IS_GIMP (gimp));
tool_manager = tool_manager_get (gimp);
if (tool_manager->active_tool &&
! gimp_tool_control_is_active (tool_manager->active_tool->control))
{
gimp_tool_set_focus_display (tool_manager->active_tool,
display);
}
}
void
tool_manager_modifier_state_active (Gimp *gimp,
GdkModifierType state,
GimpDisplay *display)
{
GimpToolManager *tool_manager;
g_return_if_fail (GIMP_IS_GIMP (gimp));
tool_manager = tool_manager_get (gimp);
if (tool_manager->active_tool &&
! gimp_tool_control_is_active (tool_manager->active_tool->control))
{
gimp_tool_set_modifier_state (tool_manager->active_tool,
state,
display);
}
}
void
tool_manager_cursor_update_active (Gimp *gimp,
const GimpCoords *coords,
GdkModifierType state,
GimpDisplay *display)
{
GimpToolManager *tool_manager;
g_return_if_fail (GIMP_IS_GIMP (gimp));
tool_manager = tool_manager_get (gimp);
if (tool_manager->active_tool &&
! gimp_tool_control_is_active (tool_manager->active_tool->control))
{
gimp_tool_cursor_update (tool_manager->active_tool,
coords, state,
display);
}
}
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);
}
void
gimp_tool_control (GimpTool *tool,
GimpToolAction action,
GimpDisplay *display)
{
g_return_if_fail (GIMP_IS_TOOL (tool));
switch (action)
{
case GIMP_TOOL_ACTION_PAUSE:
if (! gimp_tool_control_is_paused (tool->control))
GIMP_TOOL_GET_CLASS (tool)->control (tool, action, display);
gimp_tool_control_pause (tool->control);
break;
case GIMP_TOOL_ACTION_RESUME:
if (gimp_tool_control_is_paused (tool->control))
{
gimp_tool_control_resume (tool->control);
if (! gimp_tool_control_is_paused (tool->control))
GIMP_TOOL_GET_CLASS (tool)->control (tool, action, display);
}
else
{
g_warning ("gimp_tool_control: unable to RESUME tool with "
"tool->control->paused_count == 0");
}
break;
case GIMP_TOOL_ACTION_HALT:
GIMP_TOOL_GET_CLASS (tool)->control (tool, action, display);
if (gimp_tool_control_is_active (tool->control))
gimp_tool_control_halt (tool->control);
gimp_tool_clear_status (tool);
break;
}
}
gboolean
gimp_selection_tool_start_edit (GimpSelectionTool *sel_tool,
GimpDisplay *display,
const GimpCoords *coords)
{
GimpTool *tool;
g_return_val_if_fail (GIMP_IS_SELECTION_TOOL (sel_tool), FALSE);
g_return_val_if_fail (GIMP_IS_DISPLAY (display), FALSE);
g_return_val_if_fail (coords != NULL, FALSE);
tool = GIMP_TOOL (sel_tool);
g_return_val_if_fail (gimp_tool_control_is_active (tool->control) == FALSE,
FALSE);
switch (sel_tool->function)
{
case SELECTION_MOVE_MASK:
gimp_edit_selection_tool_start (tool, display, coords,
GIMP_TRANSLATE_MODE_MASK, FALSE);
return TRUE;
case SELECTION_MOVE:
gimp_edit_selection_tool_start (tool, display, coords,
GIMP_TRANSLATE_MODE_MASK_TO_LAYER, FALSE);
return TRUE;
case SELECTION_MOVE_COPY:
gimp_edit_selection_tool_start (tool, display, coords,
GIMP_TRANSLATE_MODE_MASK_COPY_TO_LAYER,
FALSE);
return TRUE;
default:
break;
}
return FALSE;
}
void
gimp_color_tool_disable (GimpColorTool *color_tool)
{
GimpTool *tool;
g_return_if_fail (GIMP_IS_COLOR_TOOL (color_tool));
tool = GIMP_TOOL (color_tool);
if (gimp_tool_control_is_active (tool->control))
{
g_warning ("Trying to disable GimpColorTool while it is active.");
return;
}
if (color_tool->options)
{
g_object_unref (color_tool->options);
color_tool->options = NULL;
}
color_tool->enabled = FALSE;
}
void
gimp_color_tool_enable (GimpColorTool *color_tool,
GimpColorOptions *options)
{
GimpTool *tool;
g_return_if_fail (GIMP_IS_COLOR_TOOL (color_tool));
g_return_if_fail (GIMP_IS_COLOR_OPTIONS (options));
tool = GIMP_TOOL (color_tool);
if (gimp_tool_control_is_active (tool->control))
{
g_warning ("Trying to enable GimpColorTool while it is active.");
return;
}
if (color_tool->options)
g_object_unref (color_tool->options);
color_tool->options = g_object_ref (options);
color_tool->enabled = TRUE;
}
void
gimp_tool_oper_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
gboolean proximity,
GimpDisplay *display)
{
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) == FALSE);
GIMP_TOOL_GET_CLASS (tool)->oper_update (tool, coords, state, proximity,
display);
if (G_UNLIKELY (gimp_image_is_empty (gimp_display_get_image (display)) &&
! gimp_tool_control_get_handle_empty_image (tool->control)))
{
gimp_tool_replace_status (tool, display,
"%s",
_("Can't work on an empty image, "
"add a layer first"));
}
}
static gboolean
gimp_rectangle_select_tool_rectangle_change_complete (GimpRectangleTool *rectangle)
{
GimpTool *tool;
GimpRectangleSelectTool *rect_sel_tool;
GimpRectangleSelectToolPrivate *priv;
tool = GIMP_TOOL (rectangle);
rect_sel_tool = GIMP_RECTANGLE_SELECT_TOOL (tool);
priv = GIMP_RECTANGLE_SELECT_TOOL_GET_PRIVATE (rect_sel_tool);
/* prevent change in selection from halting the tool */
gimp_tool_control_push_preserve (tool->control, TRUE);
if (tool->display && ! gimp_tool_control_is_active (tool->control))
{
GimpImage *image = gimp_display_get_image (tool->display);
GimpUndoStack *undo_stack = gimp_image_get_undo_stack (image);
GimpUndo *undo = gimp_undo_stack_peek (undo_stack);
gint x1, y1, x2, y2;
/* if we got here via button release, we have already undone the
* previous operation. But if we got here by some other means,
* we need to undo it now.
*/
if (undo && priv->undo == undo)
{
gimp_image_undo (image);
priv->undo = NULL;
}
g_object_get (rectangle,
"x1", &x1,
"y1", &y1,
"x2", &x2,
"y2", &y2,
NULL);
if (gimp_rectangle_select_tool_select (rectangle, x1, y1, x2 - x1, y2 - y1))
{
/* save the undo that we got when executing, but only if
* we actually selected something
*/
priv->undo = gimp_undo_stack_peek (undo_stack);
priv->redo = NULL;
}
if (! priv->use_saved_op)
{
GimpSelectionOptions *options;
options = GIMP_SELECTION_TOOL_GET_OPTIONS (tool);
/* remember the operation now in case we modify the rectangle */
priv->operation = options->operation;
priv->use_saved_op = TRUE;
}
gimp_image_flush (image);
}
gimp_tool_control_pop_preserve (tool->control);
gimp_rectangle_select_tool_update_option_defaults (rect_sel_tool, FALSE);
return TRUE;
}
static void
gimp_move_tool_button_release (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonReleaseType release_type,
GimpDisplay *display)
{
GimpMoveTool *move = GIMP_MOVE_TOOL (tool);
GimpGuiConfig *config = GIMP_GUI_CONFIG (display->gimp->config);
GimpDisplayShell *shell = gimp_display_get_shell (display);
GimpImage *image = gimp_display_get_image (display);
if (gimp_tool_control_is_active (tool->control))
gimp_tool_control_halt (tool->control);
if (move->moving_guide)
{
gboolean delete_guide = FALSE;
gint x, y, width, height;
gimp_tool_pop_status (tool, display);
gimp_tool_control_set_scroll_lock (tool->control, FALSE);
gimp_tool_control_set_precision (tool->control,
GIMP_CURSOR_PRECISION_PIXEL_CENTER);
gimp_draw_tool_stop (GIMP_DRAW_TOOL (tool));
if (release_type == GIMP_BUTTON_RELEASE_CANCEL)
{
move->moving_guide = FALSE;
move->guide_position = GUIDE_POSITION_INVALID;
move->guide_orientation = GIMP_ORIENTATION_UNKNOWN;
gimp_display_shell_selection_resume (shell);
return;
}
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;
}
if (delete_guide)
{
if (move->guide)
{
gimp_image_remove_guide (image, move->guide, TRUE);
move->guide = NULL;
}
}
else
{
if (move->guide)
{
gimp_image_move_guide (image, move->guide,
move->guide_position, TRUE);
}
else
{
switch (move->guide_orientation)
{
case GIMP_ORIENTATION_HORIZONTAL:
move->guide = gimp_image_add_hguide (image,
move->guide_position,
TRUE);
break;
case GIMP_ORIENTATION_VERTICAL:
move->guide = gimp_image_add_vguide (image,
move->guide_position,
TRUE);
break;
default:
g_assert_not_reached ();
}
}
}
gimp_display_shell_selection_resume (shell);
gimp_image_flush (image);
move->moving_guide = FALSE;
move->guide_position = GUIDE_POSITION_INVALID;
move->guide_orientation = GIMP_ORIENTATION_UNKNOWN;
if (move->guide)
gimp_draw_tool_start (GIMP_DRAW_TOOL (tool), display);
}
else
{
gboolean flush = FALSE;
if (! config->move_tool_changes_active ||
(release_type == GIMP_BUTTON_RELEASE_CANCEL))
{
if (move->old_active_layer)
{
gimp_image_set_active_layer (image, move->old_active_layer);
move->old_active_layer = NULL;
flush = TRUE;
}
if (move->old_active_vectors)
{
gimp_image_set_active_vectors (image, move->old_active_vectors);
move->old_active_vectors = NULL;
flush = TRUE;
}
}
if (release_type != GIMP_BUTTON_RELEASE_CANCEL)
{
if (move->floating_layer)
{
floating_sel_anchor (move->floating_layer);
flush = TRUE;
}
}
if (flush)
gimp_image_flush (image);
}
}
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_paint_tool_draw (GimpDrawTool *draw_tool)
{
if (! gimp_color_tool_is_enabled (GIMP_COLOR_TOOL (draw_tool)))
{
GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (draw_tool);
GimpPaintCore *core = paint_tool->core;
GimpImage *image = gimp_display_get_image (draw_tool->display);
GimpDrawable *drawable = gimp_image_get_active_drawable (image);
GimpCanvasItem *outline = NULL;
gboolean line_drawn = FALSE;
gdouble last_x, last_y;
gdouble cur_x, cur_y;
gint off_x, off_y;
gimp_item_get_offset (GIMP_ITEM (drawable), &off_x, &off_y);
last_x = core->last_coords.x + off_x;
last_y = core->last_coords.y + off_y;
cur_x = core->cur_coords.x + off_x;
cur_y = core->cur_coords.y + off_y;
if (paint_tool->draw_line &&
! gimp_tool_control_is_active (GIMP_TOOL (draw_tool)->control))
{
GimpCanvasGroup *group;
group = gimp_draw_tool_add_stroke_group (draw_tool);
gimp_draw_tool_push_group (draw_tool, group);
gimp_draw_tool_add_handle (draw_tool,
GIMP_HANDLE_CIRCLE,
last_x, last_y,
GIMP_TOOL_HANDLE_SIZE_CIRCLE,
GIMP_TOOL_HANDLE_SIZE_CIRCLE,
GIMP_HANDLE_ANCHOR_CENTER);
gimp_draw_tool_add_line (draw_tool,
last_x, last_y,
cur_x, cur_y);
gimp_draw_tool_add_handle (draw_tool,
GIMP_HANDLE_CIRCLE,
cur_x, cur_y,
GIMP_TOOL_HANDLE_SIZE_CIRCLE,
GIMP_TOOL_HANDLE_SIZE_CIRCLE,
GIMP_HANDLE_ANCHOR_CENTER);
gimp_draw_tool_pop_group (draw_tool);
line_drawn = TRUE;
}
gimp_paint_tool_set_draw_fallback (paint_tool, FALSE, 0.0);
if (paint_tool->draw_brush)
outline = gimp_paint_tool_get_outline (paint_tool,
draw_tool->display,
cur_x, cur_y);
if (outline)
{
gimp_draw_tool_add_item (draw_tool, outline);
g_object_unref (outline);
}
else if (paint_tool->draw_fallback)
{
/* Lets make a sensible fallback cursor
*
* Sensible cursor is
* * crossed to indicate draw point
* * reactive to options alterations
* * not a full circle that would be in the way
*/
gint size = (gint) paint_tool->fallback_size;
#define TICKMARK_ANGLE 48
#define ROTATION_ANGLE G_PI / 4
/* marks for indicating full size */
gimp_draw_tool_add_arc (draw_tool,
FALSE,
cur_x - (size / 2.0),
cur_y - (size / 2.0),
size, size,
ROTATION_ANGLE - (2.0 * G_PI) / (TICKMARK_ANGLE * 2),
(2.0 * G_PI) / TICKMARK_ANGLE);
gimp_draw_tool_add_arc (draw_tool,
FALSE,
cur_x - (size / 2.0),
cur_y - (size / 2.0),
size, size,
ROTATION_ANGLE + G_PI / 2 - (2.0 * G_PI) / (TICKMARK_ANGLE * 2),
(2.0 * G_PI) / TICKMARK_ANGLE);
gimp_draw_tool_add_arc (draw_tool,
FALSE,
cur_x - (size / 2.0),
cur_y - (size / 2.0),
size, size,
ROTATION_ANGLE + G_PI - (2.0 * G_PI) / (TICKMARK_ANGLE * 2),
(2.0 * G_PI) / TICKMARK_ANGLE);
gimp_draw_tool_add_arc (draw_tool,
FALSE,
cur_x - (size / 2.0),
cur_y - (size / 2.0),
size, size,
ROTATION_ANGLE + 3 * G_PI / 2 - (2.0 * G_PI) / (TICKMARK_ANGLE * 2),
(2.0 * G_PI) / TICKMARK_ANGLE);
}
else if (paint_tool->draw_circle)
{
gint size = (gint) paint_tool->circle_size;
/* draw an indicatory circle */
gimp_draw_tool_add_arc (draw_tool,
FALSE,
cur_x - (size / 2.0),
cur_y - (size / 2.0),
size, size,
0.0, (2.0 * G_PI));
}
if (! outline &&
! line_drawn &&
! paint_tool->show_cursor &&
! paint_tool->draw_circle)
{
/* don't leave the user without any indication and draw
* a fallback crosshair
*/
gimp_draw_tool_add_handle (draw_tool,
GIMP_HANDLE_CROSSHAIR,
cur_x, cur_y,
GIMP_TOOL_HANDLE_SIZE_CROSSHAIR,
GIMP_TOOL_HANDLE_SIZE_CROSSHAIR,
GIMP_HANDLE_ANCHOR_CENTER);
}
}
GIMP_DRAW_TOOL_CLASS (parent_class)->draw (draw_tool);
}
void
gimp_tool_set_active_modifier_state (GimpTool *tool,
GdkModifierType state,
GimpDisplay *display)
{
gboolean press;
g_return_if_fail (GIMP_IS_TOOL (tool));
g_return_if_fail (GIMP_IS_DISPLAY (display));
g_return_if_fail (gimp_tool_control_is_active (tool->control) == TRUE);
GIMP_LOG (TOOL_FOCUS, "tool: %p display: %p tool->focus_display: %p",
tool, display, tool->focus_display);
g_return_if_fail (display == tool->focus_display);
if (state_changed (tool->active_modifier_state, state, GDK_SHIFT_MASK,
&press))
{
#ifdef DEBUG_ACTIVE_STATE
g_printerr ("%s: SHIFT %s\n", G_STRFUNC,
press ? "pressed" : "released");
#endif
if (! press && (tool->button_press_state & GDK_SHIFT_MASK))
{
tool->button_press_state &= ~GDK_SHIFT_MASK;
}
else
{
gimp_tool_active_modifier_key (tool, GDK_SHIFT_MASK,
press, state,
display);
}
}
if (state_changed (tool->active_modifier_state, state, GDK_CONTROL_MASK,
&press))
{
#ifdef DEBUG_ACTIVE_STATE
g_printerr ("%s: CONTROL %s\n", G_STRFUNC,
press ? "pressed" : "released");
#endif
if (! press && (tool->button_press_state & GDK_CONTROL_MASK))
{
tool->button_press_state &= ~GDK_CONTROL_MASK;
}
else
{
gimp_tool_active_modifier_key (tool, GDK_CONTROL_MASK,
press, state,
display);
}
}
if (state_changed (tool->active_modifier_state, state, GDK_MOD1_MASK,
&press))
{
#ifdef DEBUG_ACTIVE_STATE
g_printerr ("%s: ALT %s\n", G_STRFUNC,
press ? "pressed" : "released");
#endif
if (! press && (tool->button_press_state & GDK_MOD1_MASK))
{
tool->button_press_state &= ~GDK_MOD1_MASK;
}
else
{
gimp_tool_active_modifier_key (tool, GDK_MOD1_MASK,
press, state,
display);
}
}
if (state_changed (tool->active_modifier_state, state, GDK_MOD2_MASK,
&press))
{
#ifdef DEBUG_ACTIVE_STATE
g_printerr ("%s: MOD2 %s\n", G_STRFUNC,
press ? "pressed" : "released");
#endif
if (! press && (tool->button_press_state & GDK_MOD2_MASK))
{
tool->button_press_state &= ~GDK_MOD2_MASK;
}
else
{
gimp_tool_active_modifier_key (tool, GDK_MOD2_MASK,
press, state,
display);
}
}
tool->active_modifier_state = state;
}