static void
gimp_color_tool_class_init (GimpColorToolClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GimpToolClass *tool_class = GIMP_TOOL_CLASS (klass);
GimpDrawToolClass *draw_class = GIMP_DRAW_TOOL_CLASS (klass);
gimp_color_tool_signals[PICKED] =
g_signal_new ("picked",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpColorToolClass, picked),
NULL, NULL,
gimp_marshal_VOID__ENUM_DOUBLE_DOUBLE_POINTER_BOXED_INT,
G_TYPE_NONE, 6,
GIMP_TYPE_COLOR_PICK_STATE,
G_TYPE_DOUBLE,
G_TYPE_DOUBLE,
G_TYPE_POINTER,
GIMP_TYPE_RGB | G_SIGNAL_TYPE_STATIC_SCOPE,
G_TYPE_INT);
object_class->finalize = gimp_color_tool_finalize;
tool_class->button_press = gimp_color_tool_button_press;
tool_class->button_release = gimp_color_tool_button_release;
tool_class->motion = gimp_color_tool_motion;
tool_class->oper_update = gimp_color_tool_oper_update;
tool_class->cursor_update = gimp_color_tool_cursor_update;
draw_class->draw = gimp_color_tool_draw;
klass->pick = gimp_color_tool_real_pick;
klass->picked = gimp_color_tool_real_picked;
}
static void
gimp_foreground_select_tool_class_init (GimpForegroundSelectToolClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GimpToolClass *tool_class = GIMP_TOOL_CLASS (klass);
GimpDrawToolClass *draw_tool_class = GIMP_DRAW_TOOL_CLASS (klass);
GimpFreeSelectToolClass *free_select_tool_class;
free_select_tool_class = GIMP_FREE_SELECT_TOOL_CLASS (klass);
object_class->constructed = gimp_foreground_select_tool_constructed;
object_class->finalize = gimp_foreground_select_tool_finalize;
tool_class->control = gimp_foreground_select_tool_control;
tool_class->oper_update = gimp_foreground_select_tool_oper_update;
tool_class->modifier_key = gimp_foreground_select_tool_modifier_key;
tool_class->cursor_update = gimp_foreground_select_tool_cursor_update;
tool_class->key_press = gimp_foreground_select_tool_key_press;
tool_class->button_press = gimp_foreground_select_tool_button_press;
tool_class->button_release = gimp_foreground_select_tool_button_release;
tool_class->motion = gimp_foreground_select_tool_motion;
draw_tool_class->draw = gimp_foreground_select_tool_draw;
free_select_tool_class->select = gimp_foreground_select_tool_select;
}
static void
gimp_rectangle_select_tool_class_init (GimpRectangleSelectToolClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GimpToolClass *tool_class = GIMP_TOOL_CLASS (klass);
GimpDrawToolClass *draw_tool_class = GIMP_DRAW_TOOL_CLASS (klass);
g_type_class_add_private (klass, sizeof (GimpRectangleSelectToolPrivate));
object_class->constructed = gimp_rectangle_select_tool_constructed;
object_class->set_property = gimp_rectangle_tool_set_property;
object_class->get_property = gimp_rectangle_tool_get_property;
tool_class->control = gimp_rectangle_select_tool_control;
tool_class->button_press = gimp_rectangle_select_tool_button_press;
tool_class->button_release = gimp_rectangle_select_tool_button_release;
tool_class->motion = gimp_rectangle_tool_motion;
tool_class->key_press = gimp_rectangle_select_tool_key_press;
tool_class->active_modifier_key = gimp_rectangle_select_tool_active_modifier_key;
tool_class->oper_update = gimp_rectangle_select_tool_oper_update;
tool_class->cursor_update = gimp_rectangle_select_tool_cursor_update;
draw_tool_class->draw = gimp_rectangle_select_tool_draw;
klass->select = gimp_rectangle_select_tool_real_select;
gimp_rectangle_tool_install_properties (object_class);
}
static void
gimp_foreground_select_tool_draw (GimpDrawTool *draw_tool)
{
GimpForegroundSelectTool *fg_select = GIMP_FOREGROUND_SELECT_TOOL (draw_tool);
GimpTool *tool = GIMP_TOOL (draw_tool);
GimpForegroundSelectOptions *options;
options = GIMP_FOREGROUND_SELECT_TOOL_GET_OPTIONS (tool);
if (fg_select->stroke)
{
gimp_draw_tool_add_pen (draw_tool,
(const GimpVector2 *) fg_select->stroke->data,
fg_select->stroke->len,
GIMP_CONTEXT (options),
(options->background ?
GIMP_ACTIVE_COLOR_BACKGROUND :
GIMP_ACTIVE_COLOR_FOREGROUND),
options->stroke_width);
}
if (fg_select->mask)
{
GimpDisplayShell *shell = gimp_display_get_shell (draw_tool->display);
gint x = fg_select->last_coords.x;
gint y = fg_select->last_coords.y;
gdouble radius;
radius = (options->stroke_width / shell->scale_y) / 2;
/* warn if the user is drawing outside of the working area */
if (FALSE)
{
gint x1, y1;
gint x2, y2;
gimp_foreground_select_tool_get_area (fg_select->mask,
&x1, &y1, &x2, &y2);
if (x < x1 + radius || x > x2 - radius ||
y < y1 + radius || y > y2 - radius)
{
gimp_draw_tool_add_rectangle (draw_tool, FALSE,
x1, y1,
x2 - x1, y2 - y1);
}
}
gimp_draw_tool_add_arc (draw_tool, FALSE,
x - radius, y - radius,
2 * radius, 2 * radius,
0.0, 2.0 * G_PI);
}
else
{
GIMP_DRAW_TOOL_CLASS (parent_class)->draw (draw_tool);
}
}
static void
gimp_ellipse_select_tool_class_init (GimpEllipseSelectToolClass *klass)
{
GimpDrawToolClass *draw_tool_class = GIMP_DRAW_TOOL_CLASS (klass);
GimpRectangleSelectToolClass *rect_tool_class = GIMP_RECTANGLE_SELECT_TOOL_CLASS (klass);
draw_tool_class->draw = gimp_ellipse_select_tool_draw;
rect_tool_class->select = gimp_ellipse_select_tool_select;
}
static void
gimp_sample_point_tool_class_init (GimpSamplePointToolClass *klass)
{
GimpToolClass *tool_class = GIMP_TOOL_CLASS (klass);
GimpDrawToolClass *draw_tool_class = GIMP_DRAW_TOOL_CLASS (klass);
tool_class->button_release = gimp_sample_point_tool_button_release;
tool_class->motion = gimp_sample_point_tool_motion;
draw_tool_class->draw = gimp_sample_point_tool_draw;
}
static void
gimp_guide_tool_class_init (GimpGuideToolClass *klass)
{
GimpToolClass *tool_class = GIMP_TOOL_CLASS (klass);
GimpDrawToolClass *draw_tool_class = GIMP_DRAW_TOOL_CLASS (klass);
tool_class->button_release = gimp_guide_tool_button_release;
tool_class->motion = gimp_guide_tool_motion;
draw_tool_class->draw = gimp_guide_tool_draw;
}
static void
gimp_blend_tool_class_init (GimpBlendToolClass *klass)
{
GimpToolClass *tool_class = GIMP_TOOL_CLASS (klass);
GimpDrawToolClass *draw_tool_class = GIMP_DRAW_TOOL_CLASS (klass);
tool_class->initialize = gimp_blend_tool_initialize;
tool_class->button_press = gimp_blend_tool_button_press;
tool_class->button_release = gimp_blend_tool_button_release;
tool_class->motion = gimp_blend_tool_motion;
tool_class->active_modifier_key = gimp_blend_tool_active_modifier_key;
tool_class->cursor_update = gimp_blend_tool_cursor_update;
draw_tool_class->draw = gimp_blend_tool_draw;
}
static void
gimp_move_tool_class_init (GimpMoveToolClass *klass)
{
GimpToolClass *tool_class = GIMP_TOOL_CLASS (klass);
GimpDrawToolClass *draw_tool_class = GIMP_DRAW_TOOL_CLASS (klass);
tool_class->button_press = gimp_move_tool_button_press;
tool_class->button_release = gimp_move_tool_button_release;
tool_class->motion = gimp_move_tool_motion;
tool_class->key_press = gimp_move_tool_key_press;
tool_class->modifier_key = gimp_move_tool_modifier_key;
tool_class->oper_update = gimp_move_tool_oper_update;
tool_class->cursor_update = gimp_move_tool_cursor_update;
draw_tool_class->draw = gimp_move_tool_draw;
}
static void
gimp_region_select_tool_class_init (GimpRegionSelectToolClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GimpToolClass *tool_class = GIMP_TOOL_CLASS (klass);
GimpDrawToolClass *draw_tool_class = GIMP_DRAW_TOOL_CLASS (klass);
object_class->finalize = gimp_region_select_tool_finalize;
tool_class->button_press = gimp_region_select_tool_button_press;
tool_class->button_release = gimp_region_select_tool_button_release;
tool_class->motion = gimp_region_select_tool_motion;
tool_class->cursor_update = gimp_region_select_tool_cursor_update;
draw_tool_class->draw = gimp_region_select_tool_draw;
}
static void
gimp_cage_tool_class_init (GimpCageToolClass *klass)
{
GimpToolClass *tool_class = GIMP_TOOL_CLASS (klass);
GimpDrawToolClass *draw_tool_class = GIMP_DRAW_TOOL_CLASS (klass);
tool_class->options_notify = gimp_cage_tool_options_notify;
tool_class->button_press = gimp_cage_tool_button_press;
tool_class->button_release = gimp_cage_tool_button_release;
tool_class->key_press = gimp_cage_tool_key_press;
tool_class->motion = gimp_cage_tool_motion;
tool_class->control = gimp_cage_tool_control;
tool_class->cursor_update = gimp_cage_tool_cursor_update;
tool_class->oper_update = gimp_cage_tool_oper_update;
draw_tool_class->draw = gimp_cage_tool_draw;
}
static void
gimp_source_tool_class_init (GimpSourceToolClass *klass)
{
GimpToolClass *tool_class = GIMP_TOOL_CLASS (klass);
GimpDrawToolClass *draw_tool_class = GIMP_DRAW_TOOL_CLASS (klass);
tool_class->has_display = gimp_source_tool_has_display;
tool_class->has_image = gimp_source_tool_has_image;
tool_class->control = gimp_source_tool_control;
tool_class->button_press = gimp_source_tool_button_press;
tool_class->motion = gimp_source_tool_motion;
tool_class->modifier_key = gimp_source_tool_modifier_key;
tool_class->oper_update = gimp_source_tool_oper_update;
tool_class->cursor_update = gimp_source_tool_cursor_update;
draw_tool_class->draw = gimp_source_tool_draw;
}
static void
gimp_color_tool_draw (GimpDrawTool *draw_tool)
{
GimpColorTool *color_tool = GIMP_COLOR_TOOL (draw_tool);
if (color_tool->enabled)
{
if (color_tool->moving_sample_point)
{
if (color_tool->sample_point_x != -1 &&
color_tool->sample_point_y != -1)
{
gimp_draw_tool_draw_line (draw_tool,
0, color_tool->sample_point_y + 0.5,
draw_tool->display->image->width,
color_tool->sample_point_y + 0.5,
FALSE);
gimp_draw_tool_draw_line (draw_tool,
color_tool->sample_point_x + 0.5, 0,
color_tool->sample_point_x + 0.5,
draw_tool->display->image->height,
FALSE);
}
}
else
{
if (color_tool->options->sample_average)
{
gdouble radius = color_tool->options->average_radius;
gimp_draw_tool_draw_rectangle (draw_tool,
FALSE,
color_tool->center_x - radius,
color_tool->center_y - radius,
2 * radius + 1,
2 * radius + 1,
TRUE);
}
}
}
GIMP_DRAW_TOOL_CLASS (parent_class)->draw (draw_tool);
}
static void
gimp_align_tool_class_init (GimpAlignToolClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GimpToolClass *tool_class = GIMP_TOOL_CLASS (klass);
GimpDrawToolClass *draw_tool_class = GIMP_DRAW_TOOL_CLASS (klass);
object_class->constructed = gimp_align_tool_constructed;
tool_class->control = gimp_align_tool_control;
tool_class->button_press = gimp_align_tool_button_press;
tool_class->button_release = gimp_align_tool_button_release;
tool_class->motion = gimp_align_tool_motion;
tool_class->key_press = gimp_align_tool_key_press;
tool_class->oper_update = gimp_align_tool_oper_update;
tool_class->cursor_update = gimp_align_tool_cursor_update;
draw_tool_class->draw = gimp_align_tool_draw;
}
static void
gimp_flip_tool_class_init (GimpFlipToolClass *klass)
{
GimpToolClass *tool_class = GIMP_TOOL_CLASS (klass);
GimpDrawToolClass *draw_tool_class = GIMP_DRAW_TOOL_CLASS (klass);
GimpTransformToolClass *tr_class = GIMP_TRANSFORM_TOOL_CLASS (klass);
tool_class->button_press = gimp_flip_tool_button_press;
tool_class->modifier_key = gimp_flip_tool_modifier_key;
tool_class->oper_update = gimp_flip_tool_oper_update;
tool_class->cursor_update = gimp_flip_tool_cursor_update;
draw_tool_class->draw = gimp_flip_tool_draw;
tr_class->get_undo_desc = gimp_flip_tool_get_undo_desc;
tr_class->transform = gimp_flip_tool_transform;
tr_class->undo_desc = C_("undo-type", "Flip");
tr_class->progress_text = _("Flipping");
}
static void
gimp_warp_tool_class_init (GimpWarpToolClass *klass)
{
GimpToolClass *tool_class = GIMP_TOOL_CLASS (klass);
GimpDrawToolClass *draw_tool_class = GIMP_DRAW_TOOL_CLASS (klass);
tool_class->control = gimp_warp_tool_control;
tool_class->button_press = gimp_warp_tool_button_press;
tool_class->button_release = gimp_warp_tool_button_release;
tool_class->motion = gimp_warp_tool_motion;
tool_class->key_press = gimp_warp_tool_key_press;
tool_class->oper_update = gimp_warp_tool_oper_update;
tool_class->cursor_update = gimp_warp_tool_cursor_update;
tool_class->get_undo_desc = gimp_warp_tool_get_undo_desc;
tool_class->get_redo_desc = gimp_warp_tool_get_redo_desc;
tool_class->undo = gimp_warp_tool_undo;
tool_class->redo = gimp_warp_tool_redo;
draw_tool_class->draw = gimp_warp_tool_draw;
}
static void
gimp_ellipse_select_tool_draw (GimpDrawTool *draw_tool)
{
gint x1, y1, x2, y2;
GIMP_DRAW_TOOL_CLASS (parent_class)->draw (draw_tool);
g_object_get (draw_tool,
"x1", &x1,
"y1", &y1,
"x2", &x2,
"y2", &y2,
NULL);
gimp_draw_tool_draw_arc (draw_tool,
FALSE,
x1, y1,
x2 - x1, y2 - y1,
0, 360 * 64,
FALSE);
}
static void
gimp_perspective_clone_tool_class_init (GimpPerspectiveCloneToolClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GimpToolClass *tool_class = GIMP_TOOL_CLASS (klass);
GimpDrawToolClass *draw_tool_class = GIMP_DRAW_TOOL_CLASS (klass);
object_class->constructed = gimp_perspective_clone_tool_constructed;
tool_class->initialize = gimp_perspective_clone_tool_initialize;
tool_class->has_display = gimp_perspective_clone_tool_has_display;
tool_class->has_image = gimp_perspective_clone_tool_has_image;
tool_class->control = gimp_perspective_clone_tool_control;
tool_class->button_press = gimp_perspective_clone_tool_button_press;
tool_class->button_release = gimp_perspective_clone_tool_button_release;
tool_class->motion = gimp_perspective_clone_tool_motion;
tool_class->cursor_update = gimp_perspective_clone_tool_cursor_update;
tool_class->oper_update = gimp_perspective_clone_tool_oper_update;
draw_tool_class->draw = gimp_perspective_clone_tool_draw;
}
static void
gimp_blend_tool_class_init (GimpBlendToolClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GimpToolClass *tool_class = GIMP_TOOL_CLASS (klass);
GimpDrawToolClass *draw_tool_class = GIMP_DRAW_TOOL_CLASS (klass);
object_class->dispose = gimp_blend_tool_dispose;
tool_class->initialize = gimp_blend_tool_initialize;
tool_class->control = gimp_blend_tool_control;
tool_class->oper_update = gimp_blend_tool_oper_update;
tool_class->button_press = gimp_blend_tool_button_press;
tool_class->button_release = gimp_blend_tool_button_release;
tool_class->motion = gimp_blend_tool_motion;
tool_class->key_press = gimp_blend_tool_key_press;
tool_class->active_modifier_key = gimp_blend_tool_active_modifier_key;
tool_class->cursor_update = gimp_blend_tool_cursor_update;
tool_class->options_notify = gimp_blend_tool_options_notify;
draw_tool_class->draw = gimp_blend_tool_draw;
}
static void
gimp_source_tool_draw (GimpDrawTool *draw_tool)
{
GimpSourceTool *source_tool = GIMP_SOURCE_TOOL (draw_tool);
GimpSourceOptions *options = GIMP_SOURCE_TOOL_GET_OPTIONS (draw_tool);
GimpSourceCore *source;
source = GIMP_SOURCE_CORE (GIMP_PAINT_TOOL (draw_tool)->core);
if (options->use_source && source->src_drawable && source_tool->src_display)
{
GimpDisplay *tmp_display = draw_tool->display;
gint off_x;
gint off_y;
draw_tool->display = source_tool->src_display;
gimp_item_get_offset (GIMP_ITEM (source->src_drawable), &off_x, &off_y);
if (source_tool->show_source_outline)
gimp_brush_tool_draw_brush (GIMP_BRUSH_TOOL (source_tool),
source_tool->src_x + off_x,
source_tool->src_y + off_y,
FALSE);
gimp_draw_tool_add_handle (draw_tool,
GIMP_HANDLE_CROSS,
source_tool->src_x + off_x,
source_tool->src_y + off_y,
GIMP_TOOL_HANDLE_SIZE_CROSS,
GIMP_TOOL_HANDLE_SIZE_CROSS,
GIMP_HANDLE_ANCHOR_CENTER);
draw_tool->display = tmp_display;
}
GIMP_DRAW_TOOL_CLASS (parent_class)->draw (draw_tool);
}
static void
gimp_perspective_clone_tool_draw (GimpDrawTool *draw_tool)
{
GimpTool *tool = GIMP_TOOL (draw_tool);
GimpPerspectiveCloneTool *clone_tool = GIMP_PERSPECTIVE_CLONE_TOOL (draw_tool);
GimpPerspectiveClone *clone = GIMP_PERSPECTIVE_CLONE (GIMP_PAINT_TOOL (tool)->core);
GimpSourceCore *source_core = GIMP_SOURCE_CORE (clone);
GimpPerspectiveCloneOptions *options;
GimpCanvasGroup *stroke_group;
options = GIMP_PERSPECTIVE_CLONE_TOOL_GET_OPTIONS (tool);
stroke_group = gimp_draw_tool_add_stroke_group (draw_tool);
/* draw the bounding box */
gimp_draw_tool_push_group (draw_tool, stroke_group);
gimp_draw_tool_add_line (draw_tool,
clone_tool->tx1, clone_tool->ty1,
clone_tool->tx2, clone_tool->ty2);
gimp_draw_tool_add_line (draw_tool,
clone_tool->tx2, clone_tool->ty2,
clone_tool->tx4, clone_tool->ty4);
gimp_draw_tool_add_line (draw_tool,
clone_tool->tx3, clone_tool->ty3,
clone_tool->tx4, clone_tool->ty4);
gimp_draw_tool_add_line (draw_tool,
clone_tool->tx3, clone_tool->ty3,
clone_tool->tx1, clone_tool->ty1);
gimp_draw_tool_pop_group (draw_tool);
/* draw the tool handles only when they can be used */
if (options->clone_mode == GIMP_PERSPECTIVE_CLONE_MODE_ADJUST)
{
gimp_draw_tool_add_handle (draw_tool,
GIMP_HANDLE_SQUARE,
clone_tool->tx1, clone_tool->ty1,
GIMP_TOOL_HANDLE_SIZE_LARGE,
GIMP_TOOL_HANDLE_SIZE_LARGE,
GIMP_HANDLE_ANCHOR_CENTER);
gimp_draw_tool_add_handle (draw_tool,
GIMP_HANDLE_SQUARE,
clone_tool->tx2, clone_tool->ty2,
GIMP_TOOL_HANDLE_SIZE_LARGE,
GIMP_TOOL_HANDLE_SIZE_LARGE,
GIMP_HANDLE_ANCHOR_CENTER);
gimp_draw_tool_add_handle (draw_tool,
GIMP_HANDLE_SQUARE,
clone_tool->tx3, clone_tool->ty3,
GIMP_TOOL_HANDLE_SIZE_LARGE,
GIMP_TOOL_HANDLE_SIZE_LARGE,
GIMP_HANDLE_ANCHOR_CENTER);
gimp_draw_tool_add_handle (draw_tool,
GIMP_HANDLE_SQUARE,
clone_tool->tx4, clone_tool->ty4,
GIMP_TOOL_HANDLE_SIZE_LARGE,
GIMP_TOOL_HANDLE_SIZE_LARGE,
GIMP_HANDLE_ANCHOR_CENTER);
}
if (source_core->src_drawable && clone_tool->src_display)
{
GimpDisplay *tmp_display;
tmp_display = draw_tool->display;
draw_tool->display = clone_tool->src_display;
gimp_draw_tool_add_handle (draw_tool,
GIMP_HANDLE_CROSS,
clone_tool->src_x,
clone_tool->src_y,
GIMP_TOOL_HANDLE_SIZE_CROSS,
GIMP_TOOL_HANDLE_SIZE_CROSS,
GIMP_HANDLE_ANCHOR_CENTER);
draw_tool->display = tmp_display;
}
GIMP_DRAW_TOOL_CLASS (parent_class)->draw (draw_tool);
}
static void
gimp_perspective_clone_tool_draw (GimpDrawTool *draw_tool)
{
GimpTool *tool = GIMP_TOOL (draw_tool);
GimpPerspectiveCloneTool *clone_tool = GIMP_PERSPECTIVE_CLONE_TOOL (draw_tool);
GimpPerspectiveClone *clone = GIMP_PERSPECTIVE_CLONE (GIMP_PAINT_TOOL (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)
{
GimpCanvasItem *item = gimp_tool_widget_get_item (clone_tool->widget);
gimp_draw_tool_add_item (draw_tool, item);
}
}
else
{
GimpCanvasGroup *stroke_group;
stroke_group = gimp_draw_tool_add_stroke_group (draw_tool);
/* draw the bounding box */
gimp_draw_tool_push_group (draw_tool, stroke_group);
gimp_draw_tool_add_line (draw_tool,
clone_tool->trans_info[X0],
clone_tool->trans_info[Y0],
clone_tool->trans_info[X1],
clone_tool->trans_info[Y1]);
gimp_draw_tool_add_line (draw_tool,
clone_tool->trans_info[X1],
clone_tool->trans_info[Y1],
clone_tool->trans_info[X3],
clone_tool->trans_info[Y3]);
gimp_draw_tool_add_line (draw_tool,
clone_tool->trans_info[X2],
clone_tool->trans_info[Y2],
clone_tool->trans_info[X3],
clone_tool->trans_info[Y3]);
gimp_draw_tool_add_line (draw_tool,
clone_tool->trans_info[X2],
clone_tool->trans_info[Y2],
clone_tool->trans_info[X0],
clone_tool->trans_info[Y0]);
gimp_draw_tool_pop_group (draw_tool);
}
if (source_core->src_drawable && clone_tool->src_display)
{
GimpDisplay *tmp_display;
tmp_display = draw_tool->display;
draw_tool->display = clone_tool->src_display;
gimp_draw_tool_add_handle (draw_tool,
GIMP_HANDLE_CROSS,
clone_tool->src_x + 0.5,
clone_tool->src_y + 0.5,
GIMP_TOOL_HANDLE_SIZE_CROSS,
GIMP_TOOL_HANDLE_SIZE_CROSS,
GIMP_HANDLE_ANCHOR_CENTER);
draw_tool->display = tmp_display;
}
GIMP_DRAW_TOOL_CLASS (parent_class)->draw (draw_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);
}
static void
gimp_source_tool_draw (GimpDrawTool *draw_tool)
{
GimpSourceTool *source_tool = GIMP_SOURCE_TOOL (draw_tool);
GimpSourceOptions *options = GIMP_SOURCE_TOOL_GET_OPTIONS (draw_tool);
GimpSourceCore *source;
source = GIMP_SOURCE_CORE (GIMP_PAINT_TOOL (draw_tool)->core);
GIMP_DRAW_TOOL_CLASS (parent_class)->draw (draw_tool);
if (gimp_source_core_use_source (source, options) &&
source->src_drawable && source_tool->src_display)
{
GimpDisplayShell *src_shell;
gint off_x;
gint off_y;
src_shell = gimp_display_get_shell (source_tool->src_display);
gimp_item_get_offset (GIMP_ITEM (source->src_drawable), &off_x, &off_y);
if (source_tool->src_outline)
{
gimp_display_shell_remove_tool_item (src_shell,
source_tool->src_outline);
source_tool->src_outline = NULL;
}
if (source_tool->show_source_outline)
{
source_tool->src_outline =
gimp_brush_tool_create_outline (GIMP_BRUSH_TOOL (source_tool),
source_tool->src_display,
source_tool->src_x + off_x,
source_tool->src_y + off_y);
if (source_tool->src_outline)
{
gimp_display_shell_add_tool_item (src_shell,
source_tool->src_outline);
g_object_unref (source_tool->src_outline);
}
}
if (source_tool->src_outline)
{
if (source_tool->src_handle)
{
gimp_display_shell_remove_tool_item (src_shell,
source_tool->src_handle);
source_tool->src_handle = NULL;
}
}
else
{
if (! source_tool->src_handle)
{
source_tool->src_handle =
gimp_canvas_handle_new (src_shell,
GIMP_HANDLE_CROSS,
GIMP_HANDLE_ANCHOR_CENTER,
source_tool->src_x + off_x,
source_tool->src_y + off_y,
GIMP_TOOL_HANDLE_SIZE_CROSS,
GIMP_TOOL_HANDLE_SIZE_CROSS);
gimp_display_shell_add_tool_item (src_shell,
source_tool->src_handle);
g_object_unref (source_tool->src_handle);
}
else
{
gimp_canvas_handle_set_position (source_tool->src_handle,
source_tool->src_x + off_x,
source_tool->src_y + off_y);
}
}
}
}
static void
gimp_n_point_deformation_tool_draw (GimpDrawTool *draw_tool)
{
GimpNPointDeformationTool *npd_tool;
GimpNPointDeformationOptions *npd_options;
NPDModel *model;
gint x0, y0, x1, y1;
gint i;
npd_tool = GIMP_N_POINT_DEFORMATION_TOOL (draw_tool);
npd_options = GIMP_N_POINT_DEFORMATION_TOOL_GET_OPTIONS (npd_tool);
model = npd_tool->model;
g_return_if_fail (model != NULL);
/* draw lattice */
if (npd_options->mesh_visible)
gimp_n_point_deformation_tool_draw_lattice (npd_tool);
x0 = MIN (npd_tool->start_x, npd_tool->cursor_x);
y0 = MIN (npd_tool->start_y, npd_tool->cursor_y);
x1 = MAX (npd_tool->start_x, npd_tool->cursor_x);
y1 = MAX (npd_tool->start_y, npd_tool->cursor_y);
for (i = 0; i < model->control_points->len; i++)
{
NPDControlPoint *cp = &g_array_index (model->control_points,
NPDControlPoint, i);
NPDPoint p = cp->point;
GimpHandleType handle_type;
p.x += npd_tool->offset_x;
p.y += npd_tool->offset_y;
handle_type = GIMP_HANDLE_CIRCLE;
/* check if cursor is hovering over a control point or if a
* control point is situated in an area defined by rubber band
*/
if (cp == npd_tool->hovering_cp ||
(npd_tool->rubber_band &&
gimp_n_point_deformation_tool_is_cp_in_area (cp,
x0, y0,
x1, y1,
npd_tool->offset_x,
npd_tool->offset_y,
npd_tool->cp_scaled_radius)))
{
handle_type = GIMP_HANDLE_FILLED_CIRCLE;
}
gimp_draw_tool_add_handle (draw_tool,
handle_type,
p.x, p.y,
GIMP_TOOL_HANDLE_SIZE_CIRCLE,
GIMP_TOOL_HANDLE_SIZE_CIRCLE,
GIMP_HANDLE_ANCHOR_CENTER);
if (g_list_find (npd_tool->selected_cps, cp))
{
gimp_draw_tool_add_handle (draw_tool,
GIMP_HANDLE_SQUARE,
p.x, p.y,
GIMP_TOOL_HANDLE_SIZE_CIRCLE,
GIMP_TOOL_HANDLE_SIZE_CIRCLE,
GIMP_HANDLE_ANCHOR_CENTER);
}
}
if (npd_tool->rubber_band)
{
/* draw a rubber band */
gimp_draw_tool_add_rectangle (draw_tool, FALSE,
x0, y0, x1 - x0, y1 - y0);
}
if (npd_tool->preview_buffer)
{
GimpCanvasItem *item;
item = gimp_canvas_buffer_preview_new (gimp_display_get_shell (draw_tool->display),
npd_tool->preview_buffer);
gimp_draw_tool_add_preview (draw_tool, item);
g_object_unref (item);
}
GIMP_DRAW_TOOL_CLASS (parent_class)->draw (draw_tool);
}
