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); /* XXX: handle cancel properly */ /* if (release_type == GIMP_BUTTON_RELEASE_CANCEL) */ if (blend_tool->grabbed_point == POINT_INIT_MODE) { gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, display); } 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); } blend_tool->grabbed_point = POINT_NONE; }
static gboolean gimp_blend_tool_key_press (GimpTool *tool, GdkEventKey *kevent, GimpDisplay *display) { switch (kevent->keyval) { case GDK_KEY_BackSpace: return TRUE; case GDK_KEY_Return: case GDK_KEY_KP_Enter: case GDK_KEY_ISO_Enter: gimp_tool_control (tool, GIMP_TOOL_ACTION_COMMIT, display); /* fall thru */ case GDK_KEY_Escape: gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, display); return TRUE; default: break; } return FALSE; }
static gboolean gimp_cage_tool_key_press (GimpTool *tool, GdkEventKey *kevent, GimpDisplay *display) { GimpCageTool *ct = GIMP_CAGE_TOOL (tool); switch (kevent->keyval) { case GDK_KEY_BackSpace: if (! ct->cage_complete && ct->tool_state == CAGE_STATE_WAIT) { gimp_cage_tool_remove_last_handle (ct); } else if (ct->cage_complete && ct->tool_state == CAGE_STATE_WAIT) { gimp_cage_config_remove_selected_points(ct->config); /* if the cage have less than 3 handles, we reopen it */ if (gimp_cage_config_get_n_points(ct->config) <= 2) ct->cage_complete = FALSE; } return TRUE; case GDK_KEY_Return: case GDK_KEY_KP_Enter: case GDK_KEY_ISO_Enter: if (ct->cage_complete == FALSE && gimp_cage_config_get_n_points (ct->config) > 2) { g_object_set (gimp_tool_get_options (tool), "cage-mode", GIMP_CAGE_MODE_DEFORM, NULL); } else if (ct->tool_state == DEFORM_STATE_WAIT) { gimp_tool_control_push_preserve (tool->control, TRUE); gimp_image_map_commit (ct->image_map); g_object_unref (ct->image_map); ct->image_map = NULL; gimp_tool_control_pop_preserve (tool->control); gimp_image_flush (gimp_display_get_image (display)); gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, display); } break; case GDK_KEY_Escape: gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, display); return TRUE; default: break; } return FALSE; }
static gboolean gimp_cage_tool_key_press (GimpTool *tool, GdkEventKey *kevent, GimpDisplay *display) { GimpCageTool *ct = GIMP_CAGE_TOOL (tool); switch (kevent->keyval) { case GDK_KEY_BackSpace: if (ct->tool_state == CAGE_STATE_WAIT) { gimp_cage_tool_remove_last_handle (ct); } else if (ct->tool_state == DEFORM_STATE_WAIT) { gimp_cage_config_remove_selected_points(ct->config); /* if the cage have less than 3 handles, we reopen it */ if (gimp_cage_config_get_n_points(ct->config) <= 2) { ct->tool_state = CAGE_STATE_WAIT; } gimp_cage_tool_compute_coef (ct); gimp_cage_tool_render_node_update (ct); } return TRUE; case GDK_KEY_Return: case GDK_KEY_KP_Enter: case GDK_KEY_ISO_Enter: if (! gimp_cage_tool_is_complete (ct) && gimp_cage_config_get_n_points (ct->config) > 2) { g_object_set (gimp_tool_get_options (tool), "cage-mode", GIMP_CAGE_MODE_DEFORM, NULL); } else if (ct->tool_state == DEFORM_STATE_WAIT) { gimp_tool_control (tool, GIMP_TOOL_ACTION_COMMIT, display); gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, display); } return TRUE; case GDK_KEY_Escape: gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, display); return TRUE; default: break; } return FALSE; }
static gboolean gimp_n_point_deformation_tool_key_press (GimpTool *tool, GdkEventKey *kevent, GimpDisplay *display) { GimpNPointDeformationTool *npd_tool = GIMP_N_POINT_DEFORMATION_TOOL (tool); switch (kevent->keyval) { case GDK_KEY_BackSpace: /* if there is at least one control point, remove last added * control point */ if (npd_tool->model && npd_tool->model->control_points && npd_tool->model->control_points->len > 0) { GArray *cps = npd_tool->model->control_points; NPDControlPoint *cp = &g_array_index (cps, NPDControlPoint, cps->len - 1); gimp_npd_debug (("removing last cp %p\n", cp)); gimp_n_point_deformation_tool_remove_cp_from_selection (npd_tool, cp); npd_remove_control_point (npd_tool->model, cp); } break; case GDK_KEY_Delete: if (npd_tool->model && npd_tool->selected_cps) { /* if there is at least one selected control point, remove it */ npd_remove_control_points (npd_tool->model, npd_tool->selected_cps); gimp_n_point_deformation_tool_clear_selected_points_list (npd_tool); } break; case GDK_KEY_Return: case GDK_KEY_KP_Enter: case GDK_KEY_ISO_Enter: gimp_tool_control (tool, GIMP_TOOL_ACTION_COMMIT, display); gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, display); break; case GDK_KEY_Escape: gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, display); break; default: return FALSE; } return TRUE; }
void gimp_image_map_tool_edit_as (GimpImageMapTool *im_tool, const gchar *new_tool_id, GimpConfig *config) { GimpDisplay *display; GimpContext *user_context; GimpToolInfo *tool_info; GimpTool *new_tool; g_return_if_fail (GIMP_IS_IMAGE_MAP_TOOL (im_tool)); g_return_if_fail (new_tool_id != NULL); g_return_if_fail (GIMP_IS_CONFIG (config)); display = GIMP_TOOL (im_tool)->display; user_context = gimp_get_user_context (display->gimp); tool_info = (GimpToolInfo *) gimp_container_get_child_by_name (display->gimp->tool_info_list, new_tool_id); gimp_tool_control (GIMP_TOOL (im_tool), GIMP_TOOL_ACTION_HALT, display); gimp_context_set_tool (user_context, tool_info); tool_manager_initialize_active (display->gimp, display); new_tool = tool_manager_get_active (display->gimp); GIMP_IMAGE_MAP_TOOL (new_tool)->default_config = g_object_ref (config); gimp_image_map_tool_reset (GIMP_IMAGE_MAP_TOOL (new_tool)); }
static gboolean gimp_foreground_select_tool_key_press (GimpTool *tool, GdkEventKey *kevent, GimpDisplay *display) { GimpForegroundSelectTool *fg_select = GIMP_FOREGROUND_SELECT_TOOL (tool); if (display != tool->display) return FALSE; if (fg_select->state) { switch (kevent->keyval) { case GDK_KEY_Return: case GDK_KEY_KP_Enter: case GDK_KEY_ISO_Enter: gimp_foreground_select_tool_apply (fg_select, display); return TRUE; case GDK_KEY_Escape: gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, display); return TRUE; default: return FALSE; } } else { return GIMP_TOOL_CLASS (parent_class)->key_press (tool, kevent, display); } }
void tool_manager_control_active (Gimp *gimp, GimpToolAction action, GimpDisplay *display) { GimpToolManager *tool_manager; g_return_if_fail (GIMP_IS_GIMP (gimp)); tool_manager = tool_manager_get (gimp); if (tool_manager->active_tool) { GimpTool *tool = tool_manager->active_tool; if (display && gimp_tool_has_display (tool, display)) { gimp_tool_control (tool, action, display); } else if (action == GIMP_TOOL_ACTION_HALT) { if (gimp_tool_control_is_active (tool->control)) gimp_tool_control_halt (tool->control); } } }
static void gimp_align_tool_button_press (GimpTool *tool, 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_foreground_select_tool_response (GimpToolGui *gui, gint response_id, GimpForegroundSelectTool *fg_select) { GimpTool *tool = GIMP_TOOL (fg_select); GimpDisplay *display = tool->display; if (response_id == RESPONSE_PREVIEW) { if (fg_select->state == MATTING_STATE_PREVIEW_MASK) gimp_foreground_select_tool_set_trimap (fg_select, display); else gimp_foreground_select_tool_preview (fg_select, display); } else if (response_id == RESPONSE_APPLY) { if (fg_select->state != MATTING_STATE_PREVIEW_MASK) gimp_foreground_select_tool_preview (fg_select, display); gimp_foreground_select_tool_apply (fg_select, display); } else if (response_id == RESPONSE_RESET) { gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, display); } gimp_foreground_select_tool_update_gui (fg_select); }
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; }
static void gimp_cage_tool_start (GimpCageTool *ct, GimpDisplay *display) { GimpTool *tool = GIMP_TOOL (ct); GimpImage *image = gimp_display_get_image (display); GimpDrawable *drawable = gimp_image_get_active_drawable (image); gint off_x; gint off_y; gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, display); tool->display = display; if (ct->config) { g_object_unref (ct->config); ct->config = NULL; } if (ct->coef) { g_object_unref (ct->coef); ct->dirty_coef = TRUE; ct->coef = NULL; } if (ct->image_map) { gimp_image_map_abort (ct->image_map); g_object_unref (ct->image_map); ct->image_map = NULL; } if (ct->render_node) { g_object_unref (ct->render_node); ct->render_node = NULL; ct->coef_node = NULL; ct->cage_node = NULL; } ct->config = g_object_new (GIMP_TYPE_CAGE_CONFIG, NULL); ct->hovering_handle = -1; ct->hovering_edge = -1; ct->cage_complete = FALSE; ct->tool_state = CAGE_STATE_INIT; /* Setting up cage offset to convert the cage point coords to * drawable coords */ gimp_item_get_offset (GIMP_ITEM (drawable), &off_x, &off_y); ct->offset_x = off_x; ct->offset_y = off_y; gimp_draw_tool_start (GIMP_DRAW_TOOL (ct), display); }
static void gimp_color_picker_tool_info_response (GimpToolGui *gui, gint response_id, GimpColorPickerTool *picker_tool) { GimpTool *tool = GIMP_TOOL (picker_tool); gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, tool->display); }
static void gimp_tool_dispose (GObject *object) { GimpTool *tool = GIMP_TOOL (object); gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, tool->display); G_OBJECT_CLASS (parent_class)->dispose (object); }
static void gimp_image_map_tool_response (GimpToolGui *gui, gint response_id, GimpImageMapTool *im_tool) { GimpTool *tool = GIMP_TOOL (im_tool); switch (response_id) { case RESPONSE_RESET: gimp_image_map_tool_reset (im_tool); gimp_image_map_tool_preview (im_tool); break; case GTK_RESPONSE_OK: gimp_tool_control (tool, GIMP_TOOL_ACTION_COMMIT, tool->display); break; default: gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, tool->display); break; } }
static void gimp_crop_tool_button_press (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpButtonPressType press_type, GimpDisplay *display) { if (tool->display && display != tool->display) gimp_tool_control (tool, GIMP_TOOL_ACTION_COMMIT, tool->display); gimp_tool_control_activate (tool->control); gimp_rectangle_tool_button_press (tool, coords, time, state, display); }
static gboolean gimp_align_tool_key_press (GimpTool *tool, GdkEventKey *kevent, GimpDisplay *display) { if (display == tool->display) { switch (kevent->keyval) { case GDK_KEY_Escape: gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, display); return TRUE; default: break; } } return FALSE; }
static void gimp_foreground_select_tool_apply (GimpForegroundSelectTool *fg_select, GimpDisplay *display) { GimpTool *tool = GIMP_TOOL (fg_select); GimpSelectionOptions *options = GIMP_SELECTION_TOOL_GET_OPTIONS (tool); GimpImage *image = gimp_display_get_image (display); g_return_if_fail (fg_select->mask != NULL); gimp_channel_select_channel (gimp_image_get_mask (image), C_("command", "Foreground Select"), fg_select->mask, 0, 0, options->operation, options->feather, options->feather_radius, options->feather_radius); gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, display); gimp_image_flush (image); }
static gboolean gimp_warp_tool_key_press (GimpTool *tool, GdkEventKey *kevent, GimpDisplay *display) { GimpWarpTool *wt = GIMP_WARP_TOOL (tool); switch (kevent->keyval) { case GDK_KEY_BackSpace: return TRUE; case GDK_KEY_Return: case GDK_KEY_KP_Enter: case GDK_KEY_ISO_Enter: if (wt->image_map) { gimp_tool_control_push_preserve (tool->control, TRUE); gimp_image_map_commit (wt->image_map, GIMP_PROGRESS (tool)); g_object_unref (wt->image_map); wt->image_map = NULL; gimp_tool_control_pop_preserve (tool->control); gimp_image_flush (gimp_display_get_image (display)); } /* fall thru */ case GDK_KEY_Escape: gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, display); return TRUE; default: break; } return FALSE; }
static void gimp_n_point_deformation_tool_start (GimpNPointDeformationTool *npd_tool, GimpDisplay *display) { GimpTool *tool = GIMP_TOOL (npd_tool); GimpNPointDeformationOptions *npd_options; GimpImage *image; GeglBuffer *source_buffer; GeglBuffer *preview_buffer; NPDModel *model; npd_options = GIMP_N_POINT_DEFORMATION_TOOL_GET_OPTIONS (npd_tool); gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, display); image = gimp_display_get_image (display); tool->display = display; tool->drawable = gimp_image_get_active_drawable (image); npd_tool->active = TRUE; /* create GEGL graph */ source_buffer = gimp_drawable_get_buffer (tool->drawable); preview_buffer = gegl_buffer_new (gegl_buffer_get_extent (source_buffer), babl_format ("cairo-ARGB32")); npd_tool->graph = gegl_node_new (); npd_tool->source = gegl_node_new_child (npd_tool->graph, "operation", "gegl:buffer-source", "buffer", source_buffer, NULL); npd_tool->npd_node = gegl_node_new_child (npd_tool->graph, "operation", "gegl:npd", NULL); npd_tool->sink = gegl_node_new_child (npd_tool->graph, "operation", "gegl:write-buffer", "buffer", preview_buffer, NULL); gegl_node_link_many (npd_tool->source, npd_tool->npd_node, npd_tool->sink, NULL); /* initialize some options */ g_object_set (G_OBJECT (npd_options), "mesh-visible", TRUE, NULL); gimp_n_point_deformation_options_set_sensitivity (npd_options, TRUE); /* compute and get model */ gegl_node_process (npd_tool->npd_node); gegl_node_get (npd_tool->npd_node, "model", &model, NULL); npd_tool->model = model; npd_tool->preview_buffer = preview_buffer; npd_tool->selected_cp = NULL; npd_tool->hovering_cp = NULL; npd_tool->selected_cps = NULL; npd_tool->rubber_band = FALSE; npd_tool->lattice_points = g_new (GimpVector2, 5 * model->hidden_model->num_of_bones); gimp_item_get_offset (GIMP_ITEM (tool->drawable), &npd_tool->offset_x, &npd_tool->offset_y); gimp_npd_debug (("offset: %f %f\n", npd_tool->offset_x, npd_tool->offset_y)); gimp_draw_tool_start (GIMP_DRAW_TOOL (npd_tool), display); gimp_n_point_deformation_tool_perform_deformation (npd_tool); /* hide original image */ gimp_item_set_visible (GIMP_ITEM (tool->drawable), FALSE, FALSE); gimp_image_flush (image); /* create and start a deformation thread */ npd_tool->deform_thread = g_thread_new ("deform thread", (GThreadFunc) gimp_n_point_deformation_tool_deform_thread_func, npd_tool); /* create and start canvas update timeout */ npd_tool->draw_timeout_id = gdk_threads_add_timeout_full (G_PRIORITY_DEFAULT_IDLE, GIMP_NPD_DRAW_INTERVAL, (GSourceFunc) gimp_n_point_deformation_tool_canvas_update_timeout, npd_tool, NULL); }
static void gimp_rectangle_select_tool_button_press (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpButtonPressType press_type, GimpDisplay *display) { GimpRectangleTool *rectangle; GimpRectangleSelectTool *rect_sel_tool; GimpDisplayShell *shell; GimpRectangleSelectToolPrivate *priv; GimpRectangleFunction function; rectangle = GIMP_RECTANGLE_TOOL (tool); rect_sel_tool = GIMP_RECTANGLE_SELECT_TOOL (tool); shell = gimp_display_get_shell (display); priv = GIMP_RECTANGLE_SELECT_TOOL_GET_PRIVATE (rect_sel_tool); if (tool->display && display != tool->display) gimp_tool_control (tool, GIMP_TOOL_ACTION_COMMIT, tool->display); if (gimp_selection_tool_start_edit (GIMP_SELECTION_TOOL (tool), display, coords)) { /* In some cases we want to finish the rectangle select tool * and hand over responsibility to the selection tool */ gimp_rectangle_tool_control (tool, GIMP_TOOL_ACTION_COMMIT, display); gimp_rectangle_select_tool_update_option_defaults (rect_sel_tool, TRUE); return; } gimp_tool_control_activate (tool->control); priv->saved_show_selection = gimp_display_shell_get_show_selection (shell); /* if the shift or ctrl keys are down, we don't want to adjust, we * want to create a new rectangle, regardless of pointer loc */ if (state & (gimp_get_extend_selection_mask () | gimp_get_modify_selection_mask ())) { gimp_rectangle_tool_set_function (rectangle, GIMP_RECTANGLE_TOOL_CREATING); } gimp_rectangle_tool_button_press (tool, coords, time, state, display); priv->press_x = coords->x; priv->press_y = coords->y; /* if we have an existing rectangle in the current display, then * we have already "executed", and need to undo at this point, * unless the user has done something in the meantime */ function = gimp_rectangle_tool_get_function (rectangle); if (function == GIMP_RECTANGLE_TOOL_CREATING) { priv->use_saved_op = FALSE; } else { GimpImage *image = gimp_display_get_image (tool->display); GimpUndoStack *undo_stack = gimp_image_get_undo_stack (image); GimpUndoStack *redo_stack = gimp_image_get_redo_stack (image); GimpUndo *undo; GimpChannelOps operation; undo = gimp_undo_stack_peek (undo_stack); if (undo && priv->undo == undo) { /* prevent this change from halting the tool */ gimp_tool_control_push_preserve (tool->control, TRUE); gimp_image_undo (image); gimp_tool_control_pop_preserve (tool->control); /* we will need to redo if the user cancels or executes */ priv->redo = gimp_undo_stack_peek (redo_stack); } /* if the operation is "Replace", turn off the marching ants, because they are confusing */ operation = gimp_rectangle_select_tool_get_operation (rect_sel_tool); if (operation == GIMP_CHANNEL_OP_REPLACE) gimp_display_shell_set_show_selection (shell, FALSE); } priv->undo = NULL; }
gboolean gimp_text_tool_editor_key_press (GimpTextTool *text_tool, GdkEventKey *kevent) { GtkTextBuffer *buffer = GTK_TEXT_BUFFER (text_tool->buffer); GtkTextIter cursor; GtkTextIter selection; gint x_pos = -1; gboolean retval = TRUE; if (gtk_im_context_filter_keypress (text_tool->im_context, kevent)) { text_tool->needs_im_reset = TRUE; text_tool->x_pos = -1; return TRUE; } gimp_text_tool_ensure_proxy (text_tool); if (gtk_bindings_activate_event (GTK_OBJECT (text_tool->proxy_text_view), kevent)) { GIMP_LOG (TEXT_EDITING, "binding handled event"); return TRUE; } gtk_text_buffer_get_iter_at_mark (buffer, &cursor, gtk_text_buffer_get_insert (buffer)); gtk_text_buffer_get_iter_at_mark (buffer, &selection, gtk_text_buffer_get_selection_bound (buffer)); switch (kevent->keyval) { case GDK_KEY_Return: case GDK_KEY_KP_Enter: case GDK_KEY_ISO_Enter: gimp_text_tool_reset_im_context (text_tool); gimp_text_tool_enter_text (text_tool, "\n"); break; case GDK_KEY_Tab: case GDK_KEY_KP_Tab: case GDK_KEY_ISO_Left_Tab: gimp_text_tool_reset_im_context (text_tool); gimp_text_tool_enter_text (text_tool, "\t"); break; case GDK_KEY_Escape: gimp_rectangle_tool_cancel (GIMP_RECTANGLE_TOOL (text_tool)); gimp_tool_control (GIMP_TOOL (text_tool), GIMP_TOOL_ACTION_HALT, GIMP_TOOL (text_tool)->display); break; default: retval = FALSE; } text_tool->x_pos = x_pos; return retval; }
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); GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (tool); blend_tool->mouse_x = coords->x; blend_tool->mouse_y = coords->y; if (tool->display && display != tool->display) { gimp_tool_pop_status (tool, tool->display); gimp_blend_tool_halt_preview (blend_tool); } gimp_draw_tool_pause (draw_tool); blend_tool->grabbed_point = gimp_blend_tool_get_point_under_cursor (blend_tool); if (blend_tool->grabbed_point == POINT_NONE) { if (gimp_draw_tool_is_active (draw_tool)) { gimp_tool_control (tool, GIMP_TOOL_ACTION_COMMIT, display); gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, display); } if (gimp_blend_tool_is_shapeburst (blend_tool)) { blend_tool->grabbed_point = POINT_FILL_MODE; } else { blend_tool->grabbed_point = POINT_INIT_MODE; blend_tool->start_x = coords->x; blend_tool->start_y = coords->y; } } gimp_blend_tool_point_motion (blend_tool, state & gimp_get_constrain_behavior_mask ()); tool->display = display; gimp_draw_tool_resume (draw_tool); if (blend_tool->grabbed_point != POINT_FILL_MODE && blend_tool->grabbed_point != POINT_INIT_MODE) { gimp_blend_tool_update_preview_coords (blend_tool); gimp_image_map_apply (blend_tool->image_map, NULL); } gimp_tool_control_activate (tool->control); gimp_blend_tool_push_status (blend_tool, state, display); }