static void gimp_source_tool_cursor_update (GimpTool *tool, const GimpCoords *coords, GdkModifierType state, GimpDisplay *display) { GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool); GimpSourceOptions *options = GIMP_SOURCE_TOOL_GET_OPTIONS (tool); GimpCursorType cursor = GIMP_CURSOR_MOUSE; GimpCursorModifier modifier = GIMP_CURSOR_MODIFIER_NONE; if (gimp_source_core_use_source (GIMP_SOURCE_CORE (paint_tool->core), options)) { GdkModifierType toggle_mask = gimp_get_toggle_behavior_mask (); if ((state & (toggle_mask | GDK_SHIFT_MASK)) == toggle_mask) { cursor = GIMP_CURSOR_CROSSHAIR_SMALL; } else if (! GIMP_SOURCE_CORE (GIMP_PAINT_TOOL (tool)->core)->src_drawable) { modifier = GIMP_CURSOR_MODIFIER_BAD; } } gimp_tool_control_set_cursor (tool->control, cursor); gimp_tool_control_set_cursor_modifier (tool->control, modifier); GIMP_TOOL_CLASS (parent_class)->cursor_update (tool, coords, state, display); }
static void gimp_source_tool_cursor_update (GimpTool *tool, GimpCoords *coords, GdkModifierType state, GimpDisplay *display) { GimpSourceOptions *options = GIMP_SOURCE_TOOL_GET_OPTIONS (tool); GimpCursorType cursor = GIMP_CURSOR_MOUSE; GimpCursorModifier modifier = GIMP_CURSOR_MODIFIER_NONE; if (options->use_source) { if ((state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK)) == GDK_CONTROL_MASK) { cursor = GIMP_CURSOR_CROSSHAIR_SMALL; } else if (! GIMP_SOURCE_CORE (GIMP_PAINT_TOOL (tool)->core)->src_drawable) { modifier = GIMP_CURSOR_MODIFIER_BAD; } } gimp_tool_control_set_cursor (tool->control, cursor); gimp_tool_control_set_cursor_modifier (tool->control, modifier); GIMP_TOOL_CLASS (parent_class)->cursor_update (tool, coords, state, display); }
static void gimp_source_tool_button_press (GimpTool *tool, GimpCoords *coords, guint32 time, GdkModifierType state, GimpDisplay *display) { GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool); GimpSourceTool *source_tool = GIMP_SOURCE_TOOL (tool); GimpSourceCore *source = GIMP_SOURCE_CORE (paint_tool->core); gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool)); if ((state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK)) == GDK_CONTROL_MASK) { source->set_source = TRUE; source_tool->src_display = display; } else { source->set_source = FALSE; } GIMP_TOOL_CLASS (parent_class)->button_press (tool, coords, time, state, display); source_tool->src_x = source->src_x; source_tool->src_y = source->src_y; gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool)); }
static void gimp_source_core_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { GimpSourceCore *source_core = GIMP_SOURCE_CORE (object); switch (property_id) { case PROP_SRC_DRAWABLE: gimp_source_core_set_src_drawable (source_core, g_value_get_object (value)); break; case PROP_SRC_X: source_core->src_x = g_value_get_double (value); break; case PROP_SRC_Y: source_core->src_y = g_value_get_double (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
static gboolean gimp_perspective_clone_start (GimpPaintCore *paint_core, GimpDrawable *drawable, GimpPaintOptions *paint_options, GimpCoords *coords, GError **error) { GimpSourceCore *source_core = GIMP_SOURCE_CORE (paint_core); if (! GIMP_PAINT_CORE_CLASS (parent_class)->start (paint_core, drawable, paint_options, coords, error)) { return FALSE; } if (! source_core->set_source && gimp_drawable_is_indexed (drawable)) { g_set_error (error, 0, 0, _("Perspective Clone does not operate on indexed layers.")); return FALSE; } return TRUE; }
static void gimp_source_tool_button_press (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpButtonPressType press_type, GimpDisplay *display) { GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool); GimpSourceTool *source_tool = GIMP_SOURCE_TOOL (tool); GimpSourceCore *source = GIMP_SOURCE_CORE (paint_tool->core); GdkModifierType toggle_mask = gimp_get_toggle_behavior_mask (); gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool)); if ((state & (toggle_mask | GDK_SHIFT_MASK)) == toggle_mask) { source->set_source = TRUE; gimp_source_tool_set_src_display (source_tool, display); } else { source->set_source = FALSE; } GIMP_TOOL_CLASS (parent_class)->button_press (tool, coords, time, state, press_type, display); source_tool->src_x = source->src_x; source_tool->src_y = source->src_y; gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool)); }
static void gimp_source_tool_motion (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpDisplay *display) { GimpSourceTool *source_tool = GIMP_SOURCE_TOOL (tool); GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool); GimpSourceCore *source = GIMP_SOURCE_CORE (paint_tool->core); gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool)); GIMP_TOOL_CLASS (parent_class)->motion (tool, coords, time, state, display); source_tool->src_x = source->src_x; source_tool->src_y = source->src_y; gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool)); }
static gboolean gimp_source_core_start (GimpPaintCore *paint_core, GimpDrawable *drawable, GimpPaintOptions *paint_options, const GimpCoords *coords, GError **error) { GimpSourceCore *source_core = GIMP_SOURCE_CORE (paint_core); GimpSourceOptions *options = GIMP_SOURCE_OPTIONS (paint_options); if (! GIMP_PAINT_CORE_CLASS (parent_class)->start (paint_core, drawable, paint_options, coords, error)) { return FALSE; } paint_core->use_saved_proj = FALSE; if (! source_core->set_source && gimp_source_core_use_source (source_core, options)) { if (! source_core->src_drawable) { g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED, _("Set a source image first.")); return FALSE; } if (options->sample_merged && gimp_item_get_image (GIMP_ITEM (source_core->src_drawable)) == gimp_item_get_image (GIMP_ITEM (drawable))) { paint_core->use_saved_proj = TRUE; } } return TRUE; }
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_source_tool_modifier_key (GimpTool *tool, GdkModifierType key, gboolean press, GdkModifierType state, GimpDisplay *display) { GimpSourceTool *source_tool = GIMP_SOURCE_TOOL (tool); GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool); GimpSourceOptions *options = GIMP_SOURCE_TOOL_GET_OPTIONS (tool); if (gimp_source_core_use_source (GIMP_SOURCE_CORE (paint_tool->core), options) && key == gimp_get_toggle_behavior_mask ()) { gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool)); if (press) { paint_tool->status = source_tool->status_set_source; source_tool->show_source_outline = FALSE; } else { paint_tool->status = source_tool->status_paint; source_tool->show_source_outline = TRUE; } gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool)); } GIMP_TOOL_CLASS (parent_class)->modifier_key (tool, key, press, state, display); }
static void gimp_perspective_clone_tool_cursor_update (GimpTool *tool, const GimpCoords *coords, GdkModifierType state, GimpDisplay *display) { GimpPerspectiveCloneTool *clone_tool = GIMP_PERSPECTIVE_CLONE_TOOL (tool); GimpPerspectiveCloneOptions *options; GimpImage *image; GimpToolClass *tool_class; GimpCursorType cursor = GIMP_CURSOR_MOUSE; GimpCursorModifier modifier = GIMP_CURSOR_MODIFIER_NONE; options = GIMP_PERSPECTIVE_CLONE_TOOL_GET_OPTIONS (tool); image = gimp_display_get_image (display); if (gimp_image_coords_in_active_pickable (image, coords, FALSE, TRUE)) { cursor = GIMP_CURSOR_MOUSE; } if (options->clone_mode == GIMP_PERSPECTIVE_CLONE_MODE_ADJUST) { /* perspective cursors */ cursor = gimp_tool_control_get_cursor (tool->control); switch (clone_tool->function) { case TRANSFORM_HANDLE_NW: cursor = GIMP_CURSOR_CORNER_TOP_LEFT; break; case TRANSFORM_HANDLE_NE: cursor = GIMP_CURSOR_CORNER_TOP_RIGHT; break; case TRANSFORM_HANDLE_SW: cursor = GIMP_CURSOR_CORNER_BOTTOM_LEFT; break; case TRANSFORM_HANDLE_SE: cursor = GIMP_CURSOR_CORNER_BOTTOM_RIGHT; break; default: cursor = GIMP_CURSOR_CROSSHAIR_SMALL; break; } } else { GdkModifierType extend_mask = gimp_get_extend_selection_mask (); GdkModifierType toggle_mask = gimp_get_toggle_behavior_mask (); if ((state & (toggle_mask | extend_mask)) == toggle_mask) { cursor = GIMP_CURSOR_CROSSHAIR_SMALL; } else if (! GIMP_SOURCE_CORE (GIMP_PAINT_TOOL (tool)->core)->src_drawable) { modifier = GIMP_CURSOR_MODIFIER_BAD; } } gimp_tool_control_set_cursor (tool->control, cursor); gimp_tool_control_set_cursor_modifier (tool->control, modifier); /* If we are in adjust mode, skip the GimpBrushClass when chaining up. * This ensures that the cursor will be set regardless of * GimpBrushTool::show_cursor (see bug #354933). */ if (options->clone_mode == GIMP_PERSPECTIVE_CLONE_MODE_ADJUST) tool_class = GIMP_TOOL_CLASS (g_type_class_peek_parent (parent_class)); else tool_class = GIMP_TOOL_CLASS (parent_class); tool_class->cursor_update (tool, coords, state, display); }
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_source_tool_oper_update (GimpTool *tool, const GimpCoords *coords, GdkModifierType state, gboolean proximity, GimpDisplay *display) { GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool); GimpSourceTool *source_tool = GIMP_SOURCE_TOOL (tool); GimpSourceOptions *options = GIMP_SOURCE_TOOL_GET_OPTIONS (tool); GimpSourceCore *source; source = GIMP_SOURCE_CORE (GIMP_PAINT_TOOL (tool)->core); if (proximity) { if (gimp_source_core_use_source (source, options)) paint_tool->status_ctrl = source_tool->status_set_source_ctrl; else paint_tool->status_ctrl = NULL; } GIMP_TOOL_CLASS (parent_class)->oper_update (tool, coords, state, proximity, display); if (gimp_source_core_use_source (source, options)) { if (source->src_drawable == NULL) { GdkModifierType toggle_mask = gimp_get_toggle_behavior_mask (); if (state & toggle_mask) { gimp_tool_replace_status (tool, display, "%s", source_tool->status_set_source); } else { gimp_tool_replace_status (tool, display, "%s-%s", gimp_get_mod_string (toggle_mask), source_tool->status_set_source); } } else { gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool)); source_tool->src_x = source->src_x; source_tool->src_y = source->src_y; if (! source->first_stroke) { switch (options->align_mode) { case GIMP_SOURCE_ALIGN_YES: source_tool->src_x = coords->x + source->offset_x; source_tool->src_y = coords->y + source->offset_y; break; case GIMP_SOURCE_ALIGN_REGISTERED: source_tool->src_x = coords->x; source_tool->src_y = coords->y; break; default: break; } } gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool)); } } }
static void gimp_source_tool_oper_update (GimpTool *tool, GimpCoords *coords, GdkModifierType state, gboolean proximity, GimpDisplay *display) { GimpSourceTool *source_tool = GIMP_SOURCE_TOOL (tool); GimpSourceOptions *options = GIMP_SOURCE_TOOL_GET_OPTIONS (tool); if (proximity) { GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool); if (options->use_source) paint_tool->status_ctrl = source_tool->status_set_source_ctrl; else paint_tool->status_ctrl = NULL; } GIMP_TOOL_CLASS (parent_class)->oper_update (tool, coords, state, proximity, display); if (options->use_source) { GimpSourceCore *source = GIMP_SOURCE_CORE (GIMP_PAINT_TOOL (tool)->core); if (source->src_drawable == NULL) { if (state & GDK_CONTROL_MASK) gimp_tool_replace_status (tool, display, "%s", source_tool->status_set_source); else { gchar *status; status = g_strconcat (gimp_get_mod_name_control (), gimp_get_mod_separator (), source_tool->status_set_source, NULL); gimp_tool_replace_status (tool, display, "%s", status); g_free (status); } } else { gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool)); source_tool->src_x = source->src_x; source_tool->src_y = source->src_y; if (! source->first_stroke) { switch (options->align_mode) { case GIMP_SOURCE_ALIGN_YES: source_tool->src_x = coords->x + source->offset_x; source_tool->src_y = coords->y + source->offset_y; break; case GIMP_SOURCE_ALIGN_REGISTERED: source_tool->src_x = coords->x; source_tool->src_y = coords->y; break; default: break; } } gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool)); } } }
static void gimp_perspective_clone_paint (GimpPaintCore *paint_core, GimpDrawable *drawable, GimpPaintOptions *paint_options, const GimpCoords *coords, GimpPaintState paint_state, guint32 time) { GimpSourceCore *source_core = GIMP_SOURCE_CORE (paint_core); GimpPerspectiveClone *clone = GIMP_PERSPECTIVE_CLONE (paint_core); GimpContext *context = GIMP_CONTEXT (paint_options); GimpCloneOptions *clone_options = GIMP_CLONE_OPTIONS (paint_options); GimpSourceOptions *options = GIMP_SOURCE_OPTIONS (paint_options); switch (paint_state) { case GIMP_PAINT_STATE_INIT: if (source_core->set_source) { g_object_set (source_core, "src-drawable", drawable, NULL); source_core->src_x = coords->x; source_core->src_y = coords->y; /* get source coordinates in front view perspective */ gimp_matrix3_transform_point (&clone->transform_inv, source_core->src_x, source_core->src_y, &clone->src_x_fv, &clone->src_y_fv); source_core->first_stroke = TRUE; } else { GeglBuffer *orig_buffer = NULL; GeglNode *tile = NULL; GeglNode *src_node; if (options->align_mode == GIMP_SOURCE_ALIGN_NO) { source_core->orig_src_x = source_core->src_x; source_core->orig_src_y = source_core->src_y; source_core->first_stroke = TRUE; } clone->node = gegl_node_new (); g_object_set (clone->node, "dont-cache", TRUE, NULL); switch (clone_options->clone_type) { case GIMP_IMAGE_CLONE: { GimpPickable *src_pickable; GimpImage *src_image; GimpImage *dest_image; /* If the source image is different from the * destination, then we should copy straight from the * source image to the canvas. * Otherwise, we need a call to get_orig_image to make sure * we get a copy of the unblemished (offset) image */ src_pickable = GIMP_PICKABLE (source_core->src_drawable); src_image = gimp_pickable_get_image (src_pickable); if (options->sample_merged) src_pickable = GIMP_PICKABLE (gimp_image_get_projection (src_image)); dest_image = gimp_item_get_image (GIMP_ITEM (drawable)); if ((options->sample_merged && (src_image != dest_image)) || (! options->sample_merged && (source_core->src_drawable != drawable))) { orig_buffer = gimp_pickable_get_buffer (src_pickable); } else { if (options->sample_merged) orig_buffer = gimp_paint_core_get_orig_proj (paint_core); else orig_buffer = gimp_paint_core_get_orig_image (paint_core); } } break; case GIMP_PATTERN_CLONE: { GimpPattern *pattern = gimp_context_get_pattern (context); orig_buffer = gimp_pattern_create_buffer (pattern); tile = gegl_node_new_child (clone->node, "operation", "gegl:tile", NULL); clone->crop = gegl_node_new_child (clone->node, "operation", "gegl:crop", NULL); } break; } src_node = gegl_node_new_child (clone->node, "operation", "gegl:buffer-source", "buffer", orig_buffer, NULL); clone->transform_node = gegl_node_new_child (clone->node, "operation", "gegl:transform", "sampler", GIMP_INTERPOLATION_LINEAR, NULL); clone->dest_node = gegl_node_new_child (clone->node, "operation", "gegl:write-buffer", NULL); if (tile) { gegl_node_link_many (src_node, tile, clone->crop, clone->transform_node, clone->dest_node, NULL); g_object_unref (orig_buffer); } else { gegl_node_link_many (src_node, clone->transform_node, clone->dest_node, NULL); } } break; case GIMP_PAINT_STATE_MOTION: if (source_core->set_source) { /* If the control key is down, move the src target and return */ source_core->src_x = coords->x; source_core->src_y = coords->y; /* get source coordinates in front view perspective */ gimp_matrix3_transform_point (&clone->transform_inv, source_core->src_x, source_core->src_y, &clone->src_x_fv, &clone->src_y_fv); source_core->first_stroke = TRUE; } else { /* otherwise, update the target */ gint dest_x; gint dest_y; dest_x = coords->x; dest_y = coords->y; if (options->align_mode == GIMP_SOURCE_ALIGN_REGISTERED) { source_core->offset_x = 0; source_core->offset_y = 0; } else if (options->align_mode == GIMP_SOURCE_ALIGN_FIXED) { source_core->offset_x = source_core->src_x - dest_x; source_core->offset_y = source_core->src_y - dest_y; } else if (source_core->first_stroke) { source_core->offset_x = source_core->src_x - dest_x; source_core->offset_y = source_core->src_y - dest_y; /* get destination coordinates in front view perspective */ gimp_matrix3_transform_point (&clone->transform_inv, dest_x, dest_y, &clone->dest_x_fv, &clone->dest_y_fv); source_core->first_stroke = FALSE; } gimp_source_core_motion (source_core, drawable, paint_options, coords); } break; case GIMP_PAINT_STATE_FINISH: if (clone->node) { g_object_unref (clone->node); clone->node = NULL; clone->crop = NULL; clone->transform_node = NULL; clone->dest_node = NULL; } break; default: break; } g_object_notify (G_OBJECT (clone), "src-x"); g_object_notify (G_OBJECT (clone), "src-y"); }
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_paint (GimpPaintCore *paint_core, GimpDrawable *drawable, GimpPaintOptions *paint_options, GimpPaintState paint_state, guint32 time) { GimpSourceCore *source_core = GIMP_SOURCE_CORE (paint_core); GimpPerspectiveClone *clone = GIMP_PERSPECTIVE_CLONE (paint_core); GimpSourceOptions *options = GIMP_SOURCE_OPTIONS (paint_options); switch (paint_state) { case GIMP_PAINT_STATE_INIT: if (source_core->set_source) { g_object_set (source_core, "src-drawable", drawable, NULL); source_core->src_x = paint_core->cur_coords.x; source_core->src_y = paint_core->cur_coords.y; /* get source coordinates in front view perspective */ gimp_matrix3_transform_point (&clone->transform_inv, source_core->src_x, source_core->src_y, &clone->src_x_fv, &clone->src_y_fv); source_core->first_stroke = TRUE; } else if (options->align_mode == GIMP_SOURCE_ALIGN_NO) { source_core->orig_src_x = source_core->src_x; source_core->orig_src_y = source_core->src_y; source_core->first_stroke = TRUE; } break; case GIMP_PAINT_STATE_MOTION: if (source_core->set_source) { /* If the control key is down, move the src target and return */ source_core->src_x = paint_core->cur_coords.x; source_core->src_y = paint_core->cur_coords.y; /* get source coordinates in front view perspective */ gimp_matrix3_transform_point (&clone->transform_inv, source_core->src_x, source_core->src_y, &clone->src_x_fv, &clone->src_y_fv); source_core->first_stroke = TRUE; } else { /* otherwise, update the target */ gint dest_x; gint dest_y; dest_x = paint_core->cur_coords.x; dest_y = paint_core->cur_coords.y; if (options->align_mode == GIMP_SOURCE_ALIGN_REGISTERED) { source_core->offset_x = 0; source_core->offset_y = 0; } else if (options->align_mode == GIMP_SOURCE_ALIGN_FIXED) { source_core->offset_x = source_core->src_x - dest_x; source_core->offset_y = source_core->src_y - dest_y; } else if (source_core->first_stroke) { source_core->offset_x = source_core->src_x - dest_x; source_core->offset_y = source_core->src_y - dest_y; /* get destination coordinates in front view perspective */ gimp_matrix3_transform_point (&clone->transform_inv, dest_x, dest_y, &clone->dest_x_fv, &clone->dest_y_fv); source_core->first_stroke = FALSE; } gimp_source_core_motion (source_core, drawable, paint_options); } break; case GIMP_PAINT_STATE_FINISH: break; default: break; } g_object_notify (G_OBJECT (clone), "src-x"); g_object_notify (G_OBJECT (clone), "src-y"); }
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_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_perspective_clone_tool_oper_update (GimpTool *tool, const GimpCoords *coords, GdkModifierType state, gboolean proximity, GimpDisplay *display) { GimpPerspectiveCloneTool *clone_tool = GIMP_PERSPECTIVE_CLONE_TOOL (tool); GimpPerspectiveCloneOptions *options; options = GIMP_PERSPECTIVE_CLONE_TOOL_GET_OPTIONS (tool); if (options->clone_mode == GIMP_PERSPECTIVE_CLONE_MODE_ADJUST) { if (clone_tool->widget) { if (display == tool->display) { gimp_tool_widget_hover (clone_tool->widget, coords, state, proximity); } } } else { GIMP_TOOL_CLASS (parent_class)->oper_update (tool, coords, state, proximity, display); if (proximity) { GimpPaintCore *core = GIMP_PAINT_TOOL (tool)->core; GimpPerspectiveClone *clone = GIMP_PERSPECTIVE_CLONE (core); GimpSourceCore *source_core = GIMP_SOURCE_CORE (core); if (source_core->src_drawable == NULL) { gimp_tool_replace_status (tool, display, _("Ctrl-Click to set a clone source")); } else { gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool)); clone_tool->src_x = source_core->src_x; clone_tool->src_y = source_core->src_y; if (! source_core->first_stroke) { if (GIMP_SOURCE_OPTIONS (options)->align_mode == GIMP_SOURCE_ALIGN_YES) { gdouble nnx, nny; /* 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)); } } } }
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)); } }
static void gimp_source_core_paint (GimpPaintCore *paint_core, GimpDrawable *drawable, GimpPaintOptions *paint_options, GimpSymmetry *sym, GimpPaintState paint_state, guint32 time) { GimpSourceCore *source_core = GIMP_SOURCE_CORE (paint_core); GimpSourceOptions *options = GIMP_SOURCE_OPTIONS (paint_options); const GimpCoords *coords; /* The source is based on the original stroke */ coords = gimp_symmetry_get_origin (sym); switch (paint_state) { case GIMP_PAINT_STATE_INIT: if (source_core->set_source) { gimp_source_core_set_src_drawable (source_core, drawable); source_core->src_x = coords->x; source_core->src_y = coords->y; source_core->first_stroke = TRUE; } else if (options->align_mode == GIMP_SOURCE_ALIGN_NO) { source_core->orig_src_x = source_core->src_x; source_core->orig_src_y = source_core->src_y; source_core->first_stroke = TRUE; } break; case GIMP_PAINT_STATE_MOTION: if (source_core->set_source) { /* If the control key is down, move the src target and return */ source_core->src_x = coords->x; source_core->src_y = coords->y; source_core->first_stroke = TRUE; } else { /* otherwise, update the target */ gint dest_x; gint dest_y; dest_x = coords->x; dest_y = coords->y; if (options->align_mode == GIMP_SOURCE_ALIGN_REGISTERED) { source_core->offset_x = 0; source_core->offset_y = 0; } else if (options->align_mode == GIMP_SOURCE_ALIGN_FIXED) { source_core->offset_x = source_core->src_x - dest_x; source_core->offset_y = source_core->src_y - dest_y; } else if (source_core->first_stroke) { source_core->offset_x = source_core->src_x - dest_x; source_core->offset_y = source_core->src_y - dest_y; source_core->first_stroke = FALSE; } source_core->src_x = dest_x + source_core->offset_x; source_core->src_y = dest_y + source_core->offset_y; gimp_source_core_motion (source_core, drawable, paint_options, sym); } break; case GIMP_PAINT_STATE_FINISH: if (options->align_mode == GIMP_SOURCE_ALIGN_NO && ! source_core->first_stroke) { source_core->src_x = source_core->orig_src_x; source_core->src_y = source_core->orig_src_y; } break; default: break; } g_object_notify (G_OBJECT (source_core), "src-x"); g_object_notify (G_OBJECT (source_core), "src-y"); }
static void gimp_perspective_clone_tool_oper_update (GimpTool *tool, const GimpCoords *coords, GdkModifierType state, gboolean proximity, GimpDisplay *display) { GimpPerspectiveCloneTool *clone_tool = GIMP_PERSPECTIVE_CLONE_TOOL (tool); GimpPerspectiveCloneOptions *options; options = GIMP_PERSPECTIVE_CLONE_TOOL_GET_OPTIONS (tool); if (options->clone_mode == GIMP_PERSPECTIVE_CLONE_MODE_ADJUST) { GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (tool); gdouble closest_dist; gdouble dist; clone_tool->function = TRANSFORM_HANDLE_NONE; if (display != tool->display) return; dist = gimp_draw_tool_calc_distance_square (draw_tool, display, coords->x, coords->y, clone_tool->tx1, clone_tool->ty1); closest_dist = dist; clone_tool->function = TRANSFORM_HANDLE_NW; dist = gimp_draw_tool_calc_distance_square (draw_tool, display, coords->x, coords->y, clone_tool->tx2, clone_tool->ty2); if (dist < closest_dist) { closest_dist = dist; clone_tool->function = TRANSFORM_HANDLE_NE; } dist = gimp_draw_tool_calc_distance_square (draw_tool, display, coords->x, coords->y, clone_tool->tx3, clone_tool->ty3); if (dist < closest_dist) { closest_dist = dist; clone_tool->function = TRANSFORM_HANDLE_SW; } dist = gimp_draw_tool_calc_distance_square (draw_tool, display, coords->x, coords->y, clone_tool->tx4, clone_tool->ty4); if (dist < closest_dist) { closest_dist = dist; clone_tool->function = TRANSFORM_HANDLE_SE; } } else { GIMP_TOOL_CLASS (parent_class)->oper_update (tool, coords, state, proximity, display); if (proximity) { GimpPaintCore *core = GIMP_PAINT_TOOL (tool)->core; GimpPerspectiveClone *clone = GIMP_PERSPECTIVE_CLONE (core); GimpSourceCore *source_core = GIMP_SOURCE_CORE (core); if (source_core->src_drawable == NULL) { gimp_tool_replace_status (tool, display, _("Ctrl-Click to set a clone source")); } else { gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool)); clone_tool->src_x = source_core->src_x; clone_tool->src_y = source_core->src_y; if (! source_core->first_stroke) { if (GIMP_SOURCE_OPTIONS (options)->align_mode == GIMP_SOURCE_ALIGN_YES) { gdouble nnx, nny; /* 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)); } } } }