static void gimp_warp_tool_oper_update (GimpTool *tool, const GimpCoords *coords, GdkModifierType state, gboolean proximity, GimpDisplay *display) { GimpWarpTool *wt = GIMP_WARP_TOOL (tool); GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (tool); if (proximity) { gimp_draw_tool_pause (draw_tool); if (! tool->display || display == tool->display) { wt->cursor_x = coords->x; wt->cursor_y = coords->y; } if (! gimp_draw_tool_is_active (draw_tool)) gimp_draw_tool_start (draw_tool, display); gimp_draw_tool_resume (draw_tool); } else if (gimp_draw_tool_is_active (draw_tool)) { gimp_draw_tool_stop (draw_tool); } }
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)); }
static void gimp_blend_tool_button_press (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpButtonPressType press_type, GimpDisplay *display) { GimpBlendTool *blend_tool = GIMP_BLEND_TOOL (tool); if (tool->display && display != tool->display) { gimp_tool_pop_status (tool, tool->display); gimp_blend_tool_halt (blend_tool); } blend_tool->grabbed_point = gimp_blend_tool_get_point_under_cursor (blend_tool); if (blend_tool->grabbed_point == POINT_NONE && ! gimp_draw_tool_is_active (GIMP_DRAW_TOOL (tool))) { blend_tool->start_x = coords->x; blend_tool->start_y = coords->y; if (gimp_blend_tool_is_shapeburst (blend_tool)) { blend_tool->grabbed_point = POINT_FILL_MODE; } else { blend_tool->grabbed_point = POINT_INIT_MODE; } } else if ((state & GDK_MOD1_MASK) && gimp_draw_tool_is_active (GIMP_DRAW_TOOL (tool))) { blend_tool->grabbed_point = POINT_BOTH; } gimp_blend_tool_point_motion (blend_tool, state & gimp_get_constrain_behavior_mask ()); tool->display = display; gimp_blend_tool_update_items (blend_tool); if (blend_tool->grabbed_point != POINT_FILL_MODE && blend_tool->grabbed_point != POINT_INIT_MODE) { gimp_blend_tool_update_graph (blend_tool); gimp_drawable_filter_apply (blend_tool->filter, NULL); } gimp_tool_control_activate (tool->control); gimp_blend_tool_push_status (blend_tool, state, display); }
static GimpBlendToolPoint gimp_blend_tool_get_point_under_cursor (GimpBlendTool *blend_tool) { GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (blend_tool); gdouble dist; if (! gimp_draw_tool_is_active (draw_tool)) return POINT_NONE; /* Check the points in the reverse order of drawing */ /* Check end point */ dist = gimp_draw_tool_calc_distance_square (draw_tool, draw_tool->display, blend_tool->mouse_x, blend_tool->mouse_y, blend_tool->end_x, blend_tool->end_y); if (dist < POINT_GRAB_THRESHOLD_SQ) return POINT_END; /* Check start point */ dist = gimp_draw_tool_calc_distance_square (draw_tool, draw_tool->display, blend_tool->mouse_x, blend_tool->mouse_y, blend_tool->start_x, blend_tool->start_y); if (dist < POINT_GRAB_THRESHOLD_SQ) return POINT_START; /* No point found */ return POINT_NONE; }
void gimp_color_tool_start_sample_point (GimpTool *tool, GimpDisplay *display) { GimpColorTool *color_tool; g_return_if_fail (GIMP_IS_COLOR_TOOL (tool)); g_return_if_fail (GIMP_IS_DISPLAY (display)); color_tool = GIMP_COLOR_TOOL (tool); gimp_display_shell_selection_pause (gimp_display_get_shell (display)); tool->display = display; gimp_tool_control_activate (tool->control); gimp_tool_control_set_scroll_lock (tool->control, TRUE); if (gimp_draw_tool_is_active (GIMP_DRAW_TOOL (tool))) gimp_draw_tool_stop (GIMP_DRAW_TOOL (tool)); color_tool->sample_point = NULL; color_tool->moving_sample_point = TRUE; color_tool->sample_point_x = SAMPLE_POINT_POSITION_INVALID; color_tool->sample_point_y = SAMPLE_POINT_POSITION_INVALID; gimp_tool_set_cursor (tool, display, GIMP_CURSOR_MOUSE, GIMP_TOOL_CURSOR_COLOR_PICKER, GIMP_CURSOR_MODIFIER_MOVE); gimp_draw_tool_start (GIMP_DRAW_TOOL (tool), display); }
static void gimp_blend_tool_halt_preview (GimpBlendTool *blend_tool) { GimpTool *tool = GIMP_TOOL (blend_tool); if (blend_tool->graph) { g_object_unref (blend_tool->graph); blend_tool->graph = NULL; blend_tool->render_node = NULL; } if (blend_tool->image_map) { gimp_image_map_abort (blend_tool->image_map); g_object_unref (blend_tool->image_map); blend_tool->image_map = NULL; gimp_image_flush (gimp_display_get_image (tool->display)); } tool->display = NULL; tool->drawable = NULL; if (gimp_draw_tool_is_active (GIMP_DRAW_TOOL (blend_tool))) gimp_draw_tool_stop (GIMP_DRAW_TOOL (blend_tool)); }
void gimp_draw_tool_resume (GimpDrawTool *draw_tool) { g_return_if_fail (GIMP_IS_DRAW_TOOL (draw_tool)); g_return_if_fail (draw_tool->paused_count > 0); draw_tool->paused_count--; if (draw_tool->paused_count == 0) { #ifdef USE_TIMEOUT /* Don't install the timeout if the draw tool isn't active, so * suspend()/resume() can always be called, and have no side * effect on an inactive tool. See bug #687851. */ if (gimp_draw_tool_is_active (draw_tool) && ! draw_tool->draw_timeout) { draw_tool->draw_timeout = gdk_threads_add_timeout_full (G_PRIORITY_HIGH_IDLE, DRAW_TIMEOUT, (GSourceFunc) gimp_draw_tool_draw_timeout, draw_tool, NULL); } #endif /* call draw() anyway, it will do nothing if the timeout is * running, but will additionally check the drawing times to * ensure the minimum framerate */ gimp_draw_tool_draw (draw_tool); } }
static void gimp_blend_tool_start_preview (GimpBlendTool *blend_tool, GimpDisplay *display) { GimpTool *tool = GIMP_TOOL (blend_tool); GimpImage *image = gimp_display_get_image (display); GimpDrawable *drawable = gimp_image_get_active_drawable (image); GimpBlendOptions *options = GIMP_BLEND_TOOL_GET_OPTIONS (blend_tool); GimpContext *context = GIMP_CONTEXT (options); tool->display = display; tool->drawable = drawable; if (blend_tool->grabbed_point != POINT_FILL_MODE) { gimp_blend_tool_create_image_map (blend_tool, drawable); /* Initially sync all of the properties */ gimp_gegl_config_proxy_sync (GIMP_OBJECT (options), blend_tool->render_node); /* Connect signal handlers for the gradient */ gimp_blend_tool_set_gradient (blend_tool, context->gradient); } if (! gimp_draw_tool_is_active (GIMP_DRAW_TOOL (blend_tool))) gimp_draw_tool_start (GIMP_DRAW_TOOL (blend_tool), display); }
static void gimp_align_tool_button_press (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpButtonPressType press_type, 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) gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, display); tool->display = display; gimp_tool_control_activate (tool->control); align_tool->x2 = align_tool->x1 = coords->x; align_tool->y2 = align_tool->y1 = 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)); }
static void gimp_blend_tool_update_items (GimpBlendTool *blend_tool) { if (gimp_draw_tool_is_active (GIMP_DRAW_TOOL (blend_tool)) && blend_tool->grabbed_point != POINT_FILL_MODE && blend_tool->grabbed_point != POINT_INIT_MODE) { gimp_canvas_line_set (blend_tool->line, blend_tool->start_x, blend_tool->start_y, blend_tool->end_x, blend_tool->end_y); gimp_canvas_handle_set_position (blend_tool->start_handle_circle, blend_tool->start_x, blend_tool->start_y); gimp_canvas_handle_set_position (blend_tool->start_handle_cross, blend_tool->start_x, blend_tool->start_y); gimp_canvas_handle_set_position (blend_tool->end_handle_circle, blend_tool->end_x, blend_tool->end_y); gimp_canvas_handle_set_position (blend_tool->end_handle_cross, blend_tool->end_x, blend_tool->end_y); gimp_blend_tool_update_item_hilight (blend_tool); } }
static void gimp_move_tool_start_guide (GimpMoveTool *move, GimpDisplay *display, GimpOrientationType orientation) { GimpTool *tool = GIMP_TOOL (move); gimp_display_shell_selection_pause (gimp_display_get_shell (display)); tool->display = display; gimp_tool_control_activate (tool->control); gimp_tool_control_set_scroll_lock (tool->control, TRUE); if (gimp_draw_tool_is_active (GIMP_DRAW_TOOL (tool))) gimp_draw_tool_stop (GIMP_DRAW_TOOL (tool)); move->guide = NULL; move->moving_guide = TRUE; move->guide_position = GUIDE_POSITION_INVALID; move->guide_orientation = orientation; gimp_tool_set_cursor (tool, display, GIMP_CURSOR_MOUSE, GIMP_TOOL_CURSOR_HAND, GIMP_CURSOR_MODIFIER_MOVE); gimp_draw_tool_start (GIMP_DRAW_TOOL (move), display); }
static void gimp_warp_tool_start (GimpWarpTool *wt, GimpDisplay *display) { GimpTool *tool = GIMP_TOOL (wt); GimpImage *image = gimp_display_get_image (display); GimpDrawable *drawable = gimp_image_get_active_drawable (image); const Babl *format; GeglRectangle bbox; tool->display = display; tool->drawable = drawable; /* Create the coords buffer, with the size of the selection */ format = babl_format_n (babl_type ("float"), 2); gimp_item_mask_intersect (GIMP_ITEM (drawable), &bbox.x, &bbox.y, &bbox.width, &bbox.height); #ifdef WARP_DEBUG g_printerr ("Initialize coordinate buffer (%d,%d) at %d,%d\n", bbox.width, bbox.height, bbox.x, bbox.y); #endif wt->coords_buffer = gegl_buffer_new (&bbox, format); gimp_warp_tool_create_image_map (wt, drawable); if (! gimp_draw_tool_is_active (GIMP_DRAW_TOOL (wt))) gimp_draw_tool_start (GIMP_DRAW_TOOL (wt), display); }
static void gimp_flip_tool_oper_update (GimpTool *tool, const GimpCoords *coords, GdkModifierType state, gboolean proximity, GimpDisplay *display) { GimpFlipTool *flip = GIMP_FLIP_TOOL (tool); GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (tool); GimpFlipOptions *options = GIMP_FLIP_TOOL_GET_OPTIONS (tool); GimpDisplayShell *shell = gimp_display_get_shell (display); GimpImage *image = gimp_display_get_image (display); GimpGuide *guide = NULL; if (gimp_display_shell_get_show_guides (shell) && proximity) { gint snap_distance = display->config->snap_distance; guide = gimp_image_pick_guide (image, coords->x, coords->y, FUNSCALEX (shell, snap_distance), FUNSCALEY (shell, snap_distance)); } if (flip->guide != guide || (guide && ! gimp_draw_tool_is_active (draw_tool))) { gimp_draw_tool_pause (draw_tool); if (gimp_draw_tool_is_active (draw_tool) && draw_tool->display != display) gimp_draw_tool_stop (draw_tool); flip->guide = guide; if (! gimp_draw_tool_is_active (draw_tool)) gimp_draw_tool_start (draw_tool, display); gimp_draw_tool_resume (draw_tool); } gtk_widget_set_sensitive (options->direction_frame, guide == NULL); GIMP_TOOL_CLASS (parent_class)->oper_update (tool, coords, state, proximity, display); }
static void gimp_blend_tool_update_item_hilight (GimpBlendTool *blend_tool) { GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (blend_tool); if (gimp_draw_tool_is_active (draw_tool)) { GimpBlendToolPoint hilight_point; gboolean start_visible, end_visible; /* Calculate handle visibility */ if (blend_tool->grabbed_point) { start_visible = FALSE; end_visible = FALSE; } else { gdouble dist; dist = gimp_draw_tool_calc_distance_square (draw_tool, draw_tool->display, blend_tool->mouse_x, blend_tool->mouse_y, blend_tool->start_x, blend_tool->start_y); start_visible = dist < FULL_HANDLE_THRESHOLD_SQ; dist = gimp_draw_tool_calc_distance_square (draw_tool, draw_tool->display, blend_tool->mouse_x, blend_tool->mouse_y, blend_tool->end_x, blend_tool->end_y); end_visible = dist < FULL_HANDLE_THRESHOLD_SQ; } gimp_canvas_item_set_visible (blend_tool->start_handle_circle, start_visible); gimp_canvas_item_set_visible (blend_tool->end_handle_circle, end_visible); /* Update hilights */ if (blend_tool->grabbed_point) hilight_point = blend_tool->grabbed_point; else hilight_point = gimp_blend_tool_get_point_under_cursor (blend_tool); gimp_canvas_item_set_highlight (blend_tool->start_handle_circle, hilight_point == POINT_START); gimp_canvas_item_set_highlight (blend_tool->start_handle_cross, hilight_point == POINT_START); gimp_canvas_item_set_highlight (blend_tool->end_handle_circle, hilight_point == POINT_END); gimp_canvas_item_set_highlight (blend_tool->end_handle_cross, hilight_point == POINT_END); } }
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_move_tool_oper_update (GimpTool *tool, const GimpCoords *coords, GdkModifierType state, gboolean proximity, GimpDisplay *display) { GimpMoveTool *move = GIMP_MOVE_TOOL (tool); GimpMoveOptions *options = GIMP_MOVE_TOOL_GET_OPTIONS (tool); GimpDisplayShell *shell = gimp_display_get_shell (display); GimpImage *image = gimp_display_get_image (display); GimpGuide *guide = NULL; if (options->move_type == GIMP_TRANSFORM_TYPE_LAYER && ! options->move_current && gimp_display_shell_get_show_guides (shell) && proximity) { const gint snap_distance = display->config->snap_distance; guide = gimp_image_find_guide (image, coords->x, coords->y, FUNSCALEX (shell, snap_distance), FUNSCALEY (shell, snap_distance)); } if (move->guide != guide) { GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (tool); gimp_draw_tool_pause (draw_tool); if (gimp_draw_tool_is_active (draw_tool) && draw_tool->display != display) gimp_draw_tool_stop (draw_tool); move->guide = guide; if (! gimp_draw_tool_is_active (draw_tool)) gimp_draw_tool_start (draw_tool, display); gimp_draw_tool_resume (draw_tool); } }
static void gimp_color_tool_oper_update (GimpTool *tool, const GimpCoords *coords, GdkModifierType state, gboolean proximity, GimpDisplay *display) { GimpColorTool *color_tool = GIMP_COLOR_TOOL (tool); GimpDisplayShell *shell = gimp_display_get_shell (display); GimpImage *image = gimp_display_get_image (display); GimpSamplePoint *sample_point = NULL; if (color_tool->enabled && gimp_display_shell_get_show_sample_points (shell) && proximity) { gint snap_distance = display->config->snap_distance; sample_point = gimp_image_find_sample_point (image, coords->x, coords->y, FUNSCALEX (shell, snap_distance), FUNSCALEY (shell, snap_distance)); } if (color_tool->sample_point != sample_point) { GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (tool); gimp_draw_tool_pause (draw_tool); if (gimp_draw_tool_is_active (draw_tool) && draw_tool->display != display) gimp_draw_tool_stop (draw_tool); color_tool->sample_point = sample_point; if (! gimp_draw_tool_is_active (draw_tool)) gimp_draw_tool_start (draw_tool, display); gimp_draw_tool_resume (draw_tool); } }
static void gimp_foreground_select_tool_button_press (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpButtonPressType press_type, GimpDisplay *display) { GimpForegroundSelectTool *fg_select = GIMP_FOREGROUND_SELECT_TOOL (tool); GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (tool); if ((fg_select->state == MATTING_STATE_PAINT_TRIMAP) || (fg_select->state == MATTING_STATE_PREVIEW_MASK)) { GimpVector2 point = gimp_vector2_new (coords->x, coords->y); gimp_draw_tool_pause (draw_tool); if (gimp_draw_tool_is_active (draw_tool) && draw_tool->display != display) gimp_draw_tool_stop (draw_tool); gimp_tool_control_activate (tool->control); fg_select->last_coords = *coords; g_return_if_fail (fg_select->stroke == NULL); fg_select->stroke = g_array_new (FALSE, FALSE, sizeof (GimpVector2)); g_array_append_val (fg_select->stroke, point); if (!gimp_draw_tool_is_active (draw_tool)) gimp_draw_tool_start (draw_tool, display); gimp_draw_tool_resume (draw_tool); } else if (fg_select->state == MATTING_STATE_FREE_SELECT) { GIMP_TOOL_CLASS (parent_class)->button_press (tool, coords, time, state, press_type, display); } }
void gimp_draw_tool_start (GimpDrawTool *draw_tool, GimpDisplay *display) { g_return_if_fail (GIMP_IS_DRAW_TOOL (draw_tool)); g_return_if_fail (GIMP_IS_DISPLAY (display)); g_return_if_fail (gimp_draw_tool_is_active (draw_tool) == FALSE); draw_tool->display = display; gimp_draw_tool_draw (draw_tool); }
static void gimp_n_point_deformation_tool_halt (GimpNPointDeformationTool *npd_tool) { GimpTool *tool = GIMP_TOOL (npd_tool); GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (npd_tool); GimpNPointDeformationOptions *npd_options; npd_options = GIMP_N_POINT_DEFORMATION_TOOL_GET_OPTIONS (npd_tool); if (npd_tool->active) { gimp_n_point_deformation_tool_halt_threads (npd_tool); /* show original/deformed image */ gimp_item_set_visible (GIMP_ITEM (tool->drawable), TRUE, FALSE); gimp_image_flush (gimp_display_get_image (tool->display)); /* disable some options */ gimp_n_point_deformation_options_set_sensitivity (npd_options, FALSE); npd_tool->active = FALSE; } if (gimp_draw_tool_is_active (draw_tool)) gimp_draw_tool_stop (draw_tool); gimp_n_point_deformation_tool_clear_selected_points_list (npd_tool); if (npd_tool->graph) { g_object_unref (npd_tool->graph); npd_tool->graph = NULL; npd_tool->source = NULL; npd_tool->npd_node = NULL; npd_tool->sink = NULL; } if (npd_tool->preview_buffer) { g_object_unref (npd_tool->preview_buffer); npd_tool->preview_buffer = NULL; } if (npd_tool->lattice_points) { g_free (npd_tool->lattice_points); npd_tool->lattice_points = NULL; } tool->display = NULL; tool->drawable = NULL; }
static void gimp_color_tool_button_press (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpButtonPressType press_type, GimpDisplay *display) { GimpColorTool *color_tool = GIMP_COLOR_TOOL (tool); GimpDisplayShell *shell = gimp_display_get_shell (display); /* Chain up to activate the tool */ GIMP_TOOL_CLASS (parent_class)->button_press (tool, coords, time, state, press_type, display); if (! color_tool->enabled) return; if (color_tool->sample_point) { color_tool->moving_sample_point = TRUE; gimp_sample_point_get_position (color_tool->sample_point, &color_tool->sample_point_x, &color_tool->sample_point_y); gimp_tool_control_set_scroll_lock (tool->control, TRUE); gimp_display_shell_selection_pause (shell); if (! gimp_draw_tool_is_active (GIMP_DRAW_TOOL (tool))) gimp_draw_tool_start (GIMP_DRAW_TOOL (tool), display); gimp_tool_push_status_coords (tool, display, gimp_tool_control_get_precision (tool->control), _("Move Sample Point: "), color_tool->sample_point_x, ", ", color_tool->sample_point_y, NULL); } else { color_tool->center_x = coords->x; color_tool->center_y = coords->y; gimp_draw_tool_start (GIMP_DRAW_TOOL (tool), display); gimp_color_tool_pick (color_tool, GIMP_COLOR_PICK_STATE_START, coords->x, coords->y); } }
static void clear_all_selected_objects (GimpAlignTool *align_tool) { GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (align_tool); if (gimp_draw_tool_is_active (draw_tool)) gimp_draw_tool_pause (draw_tool); while (align_tool->selected_objects) { GObject *object = G_OBJECT (g_list_first (align_tool->selected_objects)->data); g_signal_handlers_disconnect_by_func (object, G_CALLBACK (clear_selected_object), (gpointer) align_tool); align_tool->selected_objects = g_list_remove (align_tool->selected_objects, object); } if (gimp_draw_tool_is_active (draw_tool)) gimp_draw_tool_resume (draw_tool); }
static void gimp_warp_tool_halt (GimpWarpTool *wt) { GimpTool *tool = GIMP_TOOL (wt); GimpWarpOptions *options = GIMP_WARP_TOOL_GET_OPTIONS (wt); if (wt->coords_buffer) { g_object_unref (wt->coords_buffer); wt->coords_buffer = NULL; } if (wt->graph) { g_object_unref (wt->graph); wt->graph = NULL; wt->render_node = NULL; } if (wt->image_map) { gimp_image_map_abort (wt->image_map); g_object_unref (wt->image_map); wt->image_map = NULL; gimp_image_flush (gimp_display_get_image (tool->display)); } if (wt->redo_stack) { g_list_free_full (wt->redo_stack, (GDestroyNotify) g_object_unref); wt->redo_stack = NULL; } tool->display = NULL; tool->drawable = NULL; if (gimp_draw_tool_is_active (GIMP_DRAW_TOOL (wt))) gimp_draw_tool_stop (GIMP_DRAW_TOOL (wt)); if (options->animate_button) { gtk_widget_set_sensitive (options->animate_button, FALSE); g_signal_handlers_disconnect_by_func (options->animate_button, gimp_warp_tool_animate, wt); } }
static void gimp_blend_tool_update_items (GimpBlendTool *blend_tool) { if (gimp_draw_tool_is_active (GIMP_DRAW_TOOL (blend_tool))) { gimp_canvas_line_set (blend_tool->line, blend_tool->start_x, blend_tool->start_y, blend_tool->end_x, blend_tool->end_y); gimp_canvas_handle_set_position (blend_tool->end_handle, blend_tool->end_x, blend_tool->end_y); } }
void gimp_draw_tool_stop (GimpDrawTool *draw_tool) { g_return_if_fail (GIMP_IS_DRAW_TOOL (draw_tool)); g_return_if_fail (gimp_draw_tool_is_active (draw_tool) == TRUE); gimp_draw_tool_undraw (draw_tool); if (draw_tool->draw_timeout) { g_source_remove (draw_tool->draw_timeout); draw_tool->draw_timeout = 0; } draw_tool->display = NULL; }
static void gimp_blend_tool_button_release (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpButtonReleaseType release_type, GimpDisplay *display) { GimpBlendTool *blend_tool = GIMP_BLEND_TOOL (tool); gimp_tool_pop_status (tool, display); /* XXX: Push a useful status message */ gimp_tool_control_halt (tool->control); switch (release_type) { case GIMP_BUTTON_RELEASE_NORMAL: break; case GIMP_BUTTON_RELEASE_CANCEL: /* XXX: handle cancel properly */ break; case GIMP_BUTTON_RELEASE_CLICK: case GIMP_BUTTON_RELEASE_NO_MOTION: if (blend_tool->grabbed_point == POINT_NONE) { if (gimp_draw_tool_is_active (GIMP_DRAW_TOOL (blend_tool))) { gimp_tool_control (tool, GIMP_TOOL_ACTION_COMMIT, display); gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, display); } } else if (blend_tool->grabbed_point == POINT_FILL_MODE) { /* XXX: Temporary, until the handles are working properly * for shapebursts */ gimp_tool_control (tool, GIMP_TOOL_ACTION_COMMIT, display); gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, display); } break; } blend_tool->grabbed_point = POINT_NONE; }
void gimp_draw_tool_start (GimpDrawTool *draw_tool, GimpDisplay *display) { g_return_if_fail (GIMP_IS_DRAW_TOOL (draw_tool)); g_return_if_fail (GIMP_IS_DISPLAY (display)); #ifdef STRICT_TOOL_CHECKS g_return_if_fail (gimp_draw_tool_is_active (draw_tool) == FALSE); #else gimp_draw_tool_stop (draw_tool); #endif draw_tool->display = display; gimp_draw_tool_draw (draw_tool); }
static void gimp_perspective_clone_tool_halt (GimpPerspectiveCloneTool *clone_tool) { GimpTool *tool = GIMP_TOOL (clone_tool); clone_tool->src_display = NULL; g_object_set (GIMP_PAINT_TOOL (tool)->core, "src-drawable", NULL, NULL); if (gimp_draw_tool_is_active (GIMP_DRAW_TOOL (tool))) gimp_draw_tool_stop (GIMP_DRAW_TOOL (tool)); tool->display = NULL; tool->drawable = NULL; }
static void gimp_perspective_clone_tool_options_notify (GimpTool *tool, GimpToolOptions *options, const GParamSpec *pspec) { GimpPerspectiveCloneTool *clone_tool = GIMP_PERSPECTIVE_CLONE_TOOL (tool); GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool); GimpPerspectiveCloneOptions *clone_options; clone_options = GIMP_PERSPECTIVE_CLONE_OPTIONS (options); GIMP_TOOL_CLASS (parent_class)->options_notify (tool, options, pspec); if (! strcmp (pspec->name, "clone-mode")) { GimpPerspectiveClone *clone; clone = GIMP_PERSPECTIVE_CLONE (GIMP_PAINT_TOOL (tool)->core); gimp_draw_tool_pause (GIMP_DRAW_TOOL (clone_tool)); if (clone_options->clone_mode == GIMP_PERSPECTIVE_CLONE_MODE_PAINT) { gimp_perspective_clone_set_transform (clone, &clone_tool->transform); gimp_paint_tool_set_active (paint_tool, TRUE); } else { gimp_paint_tool_set_active (paint_tool, FALSE); gimp_tool_control_set_precision (tool->control, GIMP_CURSOR_PRECISION_SUBPIXEL); /* start drawing the bounding box and handles... */ if (tool->display && ! gimp_draw_tool_is_active (GIMP_DRAW_TOOL (clone_tool))) { gimp_draw_tool_start (GIMP_DRAW_TOOL (clone_tool), tool->display); } } gimp_draw_tool_resume (GIMP_DRAW_TOOL (clone_tool)); } }
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); }