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 (options->use_source && key == GDK_CONTROL_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_color_tool_motion (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpDisplay *display) { GimpColorTool *color_tool = GIMP_COLOR_TOOL (tool); if (! color_tool->enabled) return; if (! color_tool->sample_point) { gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool)); color_tool->center_x = coords->x; color_tool->center_y = coords->y; gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool)); gimp_color_tool_pick (color_tool, GIMP_COLOR_PICK_STATE_UPDATE, coords->x, coords->y); } }
static void gimp_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)); }
static void gimp_foreground_select_tool_motion (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpDisplay *display) { GimpForegroundSelectTool *fg_select = GIMP_FOREGROUND_SELECT_TOOL (tool); if (fg_select->mask) { GimpVector2 *last = &g_array_index (fg_select->stroke, GimpVector2, fg_select->stroke->len - 1); gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool)); fg_select->last_coords = *coords; if (last->x != (gint) coords->x || last->y != (gint) coords->y) { GimpVector2 point = gimp_vector2_new (coords->x, coords->y); g_array_append_val (fg_select->stroke, point); } gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool)); } else { GIMP_TOOL_CLASS (parent_class)->motion (tool, coords, time, state, 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_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_text_tool_select_all (GimpTextTool *text_tool, gboolean select) { GtkTextBuffer *buffer = GTK_TEXT_BUFFER (text_tool->buffer); gimp_draw_tool_pause (GIMP_DRAW_TOOL (text_tool)); if (select) { GtkTextIter start, end; gtk_text_buffer_get_bounds (buffer, &start, &end); gtk_text_buffer_select_range (buffer, &start, &end); } else { GtkTextIter cursor; gtk_text_buffer_get_iter_at_mark (buffer, &cursor, gtk_text_buffer_get_insert (buffer)); gtk_text_buffer_move_mark_by_name (buffer, "selection_bound", &cursor); } gimp_draw_tool_resume (GIMP_DRAW_TOOL (text_tool)); }
static void gimp_cage_tool_motion (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpDisplay *display) { GimpCageTool *ct = GIMP_CAGE_TOOL (tool); GimpCageOptions *options = GIMP_CAGE_TOOL_GET_OPTIONS (ct); gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool)); ct->cursor_x = coords->x; ct->cursor_y = coords->y; switch (ct->tool_state) { case CAGE_STATE_MOVE_HANDLE: case CAGE_STATE_CLOSING: case DEFORM_STATE_MOVE_HANDLE: gimp_cage_config_add_displacement (ct->config, options->cage_mode, ct->cursor_x - ct->movement_start_x, ct->cursor_y - ct->movement_start_y); break; } gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool)); }
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_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_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_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_foreground_select_tool_button_release (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpButtonReleaseType release_type, GimpDisplay *display) { GimpForegroundSelectTool *fg_select = GIMP_FOREGROUND_SELECT_TOOL (tool); if (fg_select->mask) { GimpForegroundSelectOptions *options; options = GIMP_FOREGROUND_SELECT_TOOL_GET_OPTIONS (tool); gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool)); gimp_tool_control_halt (tool->control); gimp_foreground_select_tool_push_stroke (fg_select, display, options); gimp_free_select_tool_select (GIMP_FREE_SELECT_TOOL (tool), display); gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool)); } else { GIMP_TOOL_CLASS (parent_class)->button_release (tool, coords, time, state, release_type, display); } }
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_text_tool_toggle_overwrite (GimpTextTool *text_tool) { gimp_draw_tool_pause (GIMP_DRAW_TOOL (text_tool)); text_tool->overwrite_mode = ! text_tool->overwrite_mode; gimp_draw_tool_resume (GIMP_DRAW_TOOL (text_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 void gimp_cage_tool_remove_last_handle (GimpCageTool *ct) { GimpCageConfig *config = ct->config; gimp_draw_tool_pause (GIMP_DRAW_TOOL (ct)); gimp_cage_config_remove_last_cage_point (config); gimp_draw_tool_resume (GIMP_DRAW_TOOL (ct)); }
void gimp_warp_tool_button_release (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpButtonReleaseType release_type, GimpDisplay *display) { GimpWarpTool *wt = GIMP_WARP_TOOL (tool); gimp_draw_tool_pause (GIMP_DRAW_TOOL (wt)); gimp_tool_control_halt (tool->control); g_source_remove (wt->stroke_timer); wt->stroke_timer = 0; g_signal_handlers_disconnect_by_func (wt->current_stroke, gimp_warp_tool_stroke_changed, wt); #ifdef WARP_DEBUG g_printerr ("%s\n", gegl_path_to_string (wt->current_stroke)); #endif g_object_unref (wt->current_stroke); wt->current_stroke = NULL; if (release_type == GIMP_BUTTON_RELEASE_CANCEL) { gimp_warp_tool_undo (tool, display); /* the just undone stroke has no business on the redo stack */ g_object_unref (wt->redo_stack->data); wt->redo_stack = g_list_remove_link (wt->redo_stack, wt->redo_stack); } else { if (wt->redo_stack) { /* the redo stack becomes invalid by actually doing a stroke */ g_list_free_full (wt->redo_stack, (GDestroyNotify) g_object_unref); wt->redo_stack = NULL; } gimp_tool_push_status (tool, tool->display, _("Press ENTER to commit the transform")); } gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool)); /* update the undo actions / menu items */ gimp_image_flush (gimp_display_get_image (GIMP_TOOL (wt)->display)); }
static void gimp_align_tool_clear_selected (GimpAlignTool *align_tool) { gimp_draw_tool_pause (GIMP_DRAW_TOOL (align_tool)); while (align_tool->selected_objects) gimp_align_tool_object_removed (align_tool->selected_objects->data, align_tool); gimp_draw_tool_resume (GIMP_DRAW_TOOL (align_tool)); }
static void gimp_paint_tool_cursor_notify (GimpDisplayConfig *config, GParamSpec *pspec, GimpPaintTool *paint_tool) { gimp_draw_tool_pause (GIMP_DRAW_TOOL (paint_tool)); paint_tool->show_cursor = config->show_paint_tool_cursor; paint_tool->draw_brush = config->show_brush_outline; gimp_draw_tool_resume (GIMP_DRAW_TOOL (paint_tool)); }
static void gimp_mybrush_tool_options_notify (GimpTool *tool, GimpToolOptions *options, const GParamSpec *pspec) { GIMP_TOOL_CLASS (parent_class)->options_notify (tool, options, pspec); if (! strcmp (pspec->name, "radius")) { gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool)); gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool)); } }
static void gimp_seamless_clone_tool_oper_update (GimpTool *tool, const GimpCoords *coords, GdkModifierType state, gboolean proximity, GimpDisplay *display) { gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool)); /* TODO: Modify data here */ gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool)); }
static void gimp_seamless_clone_tool_button_press (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpButtonPressType press_type, GimpDisplay *display) { GimpSeamlessCloneTool *sc = GIMP_SEAMLESS_CLONE_TOOL (tool); if (display != tool->display) { gimp_seamless_clone_tool_start (sc, display); /* Center the paste on the mouse */ sc->xoff = (gint) coords->x - sc->width / 2; sc->yoff = (gint) coords->y - sc->height / 2; } if (sc->tool_state == SC_STATE_RENDER_WAIT && gimp_seamless_clone_tool_is_in_paste_c (sc, coords)) { gimp_draw_tool_pause (GIMP_DRAW_TOOL (sc)); /* Record previous location, in case the user cancels the * movement */ sc->xoff_p = sc->xoff; sc->yoff_p = sc->yoff; /* Record the mouse location, so that the dragging offset can be * calculated */ sc->xclick = coords->x; sc->yclick = coords->y; gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool)); if (gimp_seamless_clone_tool_render_node_update (sc)) { gimp_seamless_clone_tool_filter_update (sc); } sc->tool_state = SC_STATE_RENDER_MOTION; /* In order to receive motion events from the current click, we must * activate the tool control */ gimp_tool_control_activate (tool->control); } }
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 gimp_color_tool_button_press (GimpTool *tool, GimpCoords *coords, guint32 time, GdkModifierType state, GimpDisplay *display) { GimpColorTool *color_tool = GIMP_COLOR_TOOL (tool); GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (display->shell); /* Chain up to activate the tool */ GIMP_TOOL_CLASS (parent_class)->button_press (tool, coords, time, state, display); if (! color_tool->enabled) return; if (color_tool->sample_point) { color_tool->moving_sample_point = TRUE; color_tool->sample_point_x = color_tool->sample_point->x; color_tool->sample_point_y = color_tool->sample_point->y; gimp_display_shell_selection_control (shell, GIMP_SELECTION_PAUSE); gimp_draw_tool_start (GIMP_DRAW_TOOL (tool), display); gimp_tool_push_status_coords (tool, display, _("Move Sample Point: "), color_tool->sample_point_x, ", ", color_tool->sample_point_y, NULL); } else { gint off_x, off_y; /* Keep the coordinates of the target */ gimp_item_offsets (GIMP_ITEM (tool->drawable), &off_x, &off_y); color_tool->center_x = coords->x - off_x; color_tool->center_y = coords->y - off_y; gimp_draw_tool_start (GIMP_DRAW_TOOL (tool), display); gimp_color_tool_pick (color_tool, GIMP_COLOR_PICK_STATE_NEW, coords->x, coords->y); } }
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 gboolean gimp_n_point_deformation_tool_canvas_update_timeout (GimpNPointDeformationTool *npd_tool) { if (! GIMP_TOOL (npd_tool)->drawable) return FALSE; gimp_npd_debug (("canvas update thread\n")); gimp_draw_tool_pause (GIMP_DRAW_TOOL(npd_tool)); gimp_draw_tool_resume (GIMP_DRAW_TOOL(npd_tool)); gimp_npd_debug (("canvas update thread stop\n")); return TRUE; }
static void gimp_n_point_deformation_tool_oper_update (GimpTool *tool, const GimpCoords *coords, GdkModifierType state, gboolean proximity, GimpDisplay *display) { GimpNPointDeformationTool *npd_tool = GIMP_N_POINT_DEFORMATION_TOOL (tool); GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (tool); gimp_draw_tool_pause (draw_tool); if (npd_tool->active) { NPDModel *model = npd_tool->model; GimpDisplayShell *shell = gimp_display_get_shell (display); NPDPoint p; npd_tool->cp_scaled_radius = model->control_point_radius / shell->scale_x; p.x = coords->x - npd_tool->offset_x; p.y = coords->y - npd_tool->offset_y; npd_tool->hovering_cp = npd_get_control_point_with_radius_at (model, &p, npd_tool->cp_scaled_radius); } npd_tool->cursor_x = coords->x; npd_tool->cursor_y = coords->y; gimp_draw_tool_resume (draw_tool); }
static void gimp_align_tool_object_removed (GObject *object, GimpAlignTool *align_tool) { gimp_draw_tool_pause (GIMP_DRAW_TOOL (align_tool)); if (align_tool->selected_objects) g_signal_handlers_disconnect_by_func (object, gimp_align_tool_object_removed, align_tool); align_tool->selected_objects = g_list_remove (align_tool->selected_objects, object); gimp_draw_tool_resume (GIMP_DRAW_TOOL (align_tool)); }
static void gimp_align_tool_motion (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpDisplay *display) { GimpAlignTool *align_tool = GIMP_ALIGN_TOOL (tool); gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool)); align_tool->x2 = coords->x; align_tool->y2 = coords->y; gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool)); }