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_curves_tool_oper_update (GimpTool *tool, GimpCoords *coords, GdkModifierType state, gboolean proximity, GimpDisplay *display) { GimpColorPickMode mode = GIMP_COLOR_PICK_MODE_NONE; const gchar *status = NULL; GIMP_TOOL_CLASS (parent_class)->oper_update (tool, coords, state, proximity, display); gimp_tool_pop_status (tool, display); if (state & GDK_SHIFT_MASK) { mode = GIMP_COLOR_PICK_MODE_PALETTE; status = _("Click to add a control point"); } else if (state & GDK_CONTROL_MASK) { mode = GIMP_COLOR_PICK_MODE_PALETTE; status = _("Click to add control points to all channels"); } GIMP_COLOR_TOOL (tool)->pick_mode = mode; if (status && proximity) gimp_tool_push_status (tool, display, "%s", status); }
static void gimp_region_select_tool_button_press (GimpTool *tool, GimpCoords *coords, guint32 time, GdkModifierType state, GimpDisplay *display) { GimpRegionSelectTool *region_sel = GIMP_REGION_SELECT_TOOL (tool); GimpRegionSelectOptions *options = GIMP_REGION_SELECT_TOOL_GET_OPTIONS (tool); region_sel->x = coords->x; region_sel->y = coords->y; region_sel->saved_threshold = options->threshold; gimp_tool_control_activate (tool->control); tool->display = display; if (gimp_selection_tool_start_edit (GIMP_SELECTION_TOOL (region_sel), coords)) return; gimp_tool_push_status (tool, display, _("Move the mouse to change threshold")); /* calculate the region boundary */ region_sel->segs = gimp_region_select_tool_calculate (region_sel, display, ®ion_sel->num_segs); gimp_draw_tool_start (GIMP_DRAW_TOOL (tool), display); }
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_curves_tool_oper_update (GimpTool *tool, const GimpCoords *coords, GdkModifierType state, gboolean proximity, GimpDisplay *display) { if (gimp_image_map_tool_on_guide (GIMP_IMAGE_MAP_TOOL (tool), coords, display)) { GIMP_TOOL_CLASS (parent_class)->oper_update (tool, coords, state, proximity, display); } else { GimpColorPickMode mode; gchar *status = NULL; GdkModifierType extend_mask = gimp_get_extend_selection_mask (); GdkModifierType toggle_mask = gimp_get_toggle_behavior_mask (); gimp_tool_pop_status (tool, display); if (state & extend_mask) { mode = GIMP_COLOR_PICK_MODE_PALETTE; status = g_strdup (_("Click to add a control point")); } else if (state & toggle_mask) { mode = GIMP_COLOR_PICK_MODE_PALETTE; status = g_strdup (_("Click to add control points to all channels")); } else { mode = GIMP_COLOR_PICK_MODE_NONE; status = gimp_suggest_modifiers (_("Click to locate on curve"), (extend_mask | toggle_mask) & ~state, _("%s: add control point"), _("%s: add control points to all channels"), NULL); } GIMP_COLOR_TOOL (tool)->pick_mode = mode; if (proximity) gimp_tool_push_status (tool, display, "%s", status); g_free (status); } }
static void gimp_image_map_tool_oper_update (GimpTool *tool, const GimpCoords *coords, GdkModifierType state, gboolean proximity, GimpDisplay *display) { GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (tool); gimp_tool_pop_status (tool, display); if (! gimp_image_map_tool_on_guide (im_tool, coords, display)) { GIMP_TOOL_CLASS (parent_class)->oper_update (tool, coords, state, proximity, display); } else { GdkModifierType extend_mask = gimp_get_extend_selection_mask (); GdkModifierType toggle_mask = gimp_get_toggle_behavior_mask (); gchar *status = NULL; if (state & extend_mask) { status = g_strdup (_("Click to switch the original and filtered sides")); } else if (state & toggle_mask) { status = g_strdup (_("Click to switch between vertical and horizontal")); } else { status = gimp_suggest_modifiers (_("Click to move the split guide"), (extend_mask | toggle_mask) & ~state, _("%s: switch original and filtered"), _("%s: switch horizontal and vertical"), NULL); } if (proximity) gimp_tool_push_status (tool, display, "%s", status); g_free (status); } }
static void gimp_crop_tool_button_release (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpButtonReleaseType release_type, GimpDisplay *display) { gimp_tool_push_status (tool, display, _("Click or press Enter to crop")); gimp_rectangle_tool_button_release (tool, coords, time, state, release_type, display); gimp_tool_control_halt (tool->control); }
/** * gimp_seamless_clone_tool_start: * @sc: The GimpSeamlessCloneTool to initialize for usage on the given * display * @display: The display to initialize the tool for * * A utility function to initialize a tool for working on a given * display. At the beginning of each function, we can check if the event's * display is the same as the tool's one, and if not call this. This is * not required by the gimptool interface or anything like that, but * this is a convenient way to do all the initialization work in one * place, and this is how the base class (GimpDrawTool) does that */ static void gimp_seamless_clone_tool_start (GimpSeamlessCloneTool *sc, GimpDisplay *display) { GimpTool *tool = GIMP_TOOL (sc); GimpImage *image = gimp_display_get_image (display); GimpDrawable *drawable = gimp_image_get_active_drawable (image); /* First handle the paste - we need to make sure we have one in order * to do anything else. */ if (sc->paste == NULL) { GimpBuffer *buffer = gimp_clipboard_get_buffer (tool->tool_info->gimp); if (! buffer) { gimp_tool_push_status (tool, display, "%s", _("There is no image data in the clipboard to paste.")); return; } sc->paste = gegl_buffer_dup (gimp_buffer_get_buffer (buffer)); g_object_unref (buffer); sc->width = gegl_buffer_get_width (sc->paste); sc->height = gegl_buffer_get_height (sc->paste); } /* Free resources which are relevant only for the previous display */ gimp_seamless_clone_tool_stop (sc, TRUE); tool->display = display; gimp_seamless_clone_tool_create_filter (sc, drawable); gimp_draw_tool_start (GIMP_DRAW_TOOL (sc), display); sc->tool_state = SC_STATE_RENDER_WAIT; }
static void gimp_align_tool_status_update (GimpTool *tool, GimpDisplay *display, GdkModifierType state, gboolean proximity) { GimpAlignTool *align_tool = GIMP_ALIGN_TOOL (tool); GdkModifierType extend_mask; extend_mask = gimp_get_extend_selection_mask (); gimp_tool_pop_status (tool, display); if (proximity) { gchar *status = NULL; if (! align_tool->selected_objects) { /* no need to suggest Shift if nothing is selected */ state |= extend_mask; } switch (align_tool->function) { case ALIGN_TOOL_IDLE: status = gimp_suggest_modifiers (_("Click on a layer, path or guide, " "or Click-Drag to pick several " "layers"), extend_mask & ~state, NULL, NULL, NULL); break; case ALIGN_TOOL_PICK_LAYER: status = gimp_suggest_modifiers (_("Click to pick this layer as " "first item"), extend_mask & ~state, NULL, NULL, NULL); break; case ALIGN_TOOL_ADD_LAYER: status = g_strdup (_("Click to add this layer to the list")); break; case ALIGN_TOOL_PICK_GUIDE: status = gimp_suggest_modifiers (_("Click to pick this guide as " "first item"), extend_mask & ~state, NULL, NULL, NULL); break; case ALIGN_TOOL_ADD_GUIDE: status = g_strdup (_("Click to add this guide to the list")); break; case ALIGN_TOOL_PICK_PATH: status = gimp_suggest_modifiers (_("Click to pick this path as " "first item"), extend_mask & ~state, NULL, NULL, NULL); break; case ALIGN_TOOL_ADD_PATH: status = g_strdup (_("Click to add this path to the list")); break; case ALIGN_TOOL_DRAG_BOX: break; } if (status) { gimp_tool_push_status (tool, display, "%s", status); g_free (status); } } }
static void gimp_selection_tool_oper_update (GimpTool *tool, const GimpCoords *coords, GdkModifierType state, gboolean proximity, GimpDisplay *display) { GimpSelectionTool *selection_tool = GIMP_SELECTION_TOOL (tool); GimpSelectionOptions *options = GIMP_SELECTION_TOOL_GET_OPTIONS (tool); GimpImage *image; GimpChannel *selection; GimpDrawable *drawable; GimpLayer *layer; GimpLayer *floating_sel; GdkModifierType extend_mask; GdkModifierType modify_mask; gboolean move_layer = FALSE; gboolean move_floating_sel = FALSE; gboolean selection_empty; image = gimp_display_get_image (display); selection = gimp_image_get_mask (image); drawable = gimp_image_get_active_drawable (image); layer = gimp_image_pick_layer (image, coords->x, coords->y); floating_sel = gimp_image_get_floating_selection (image); extend_mask = gimp_get_extend_selection_mask (); modify_mask = gimp_get_modify_selection_mask (); if (drawable) { if (floating_sel) { if (layer == floating_sel) move_floating_sel = TRUE; } else if (gimp_item_mask_intersect (GIMP_ITEM (drawable), NULL, NULL, NULL, NULL)) { move_layer = TRUE; } } selection_empty = gimp_channel_is_empty (selection); selection_tool->function = SELECTION_SELECT; if (selection_tool->allow_move && (state & GDK_MOD1_MASK) && (state & modify_mask) && move_layer) { /* move the selection */ selection_tool->function = SELECTION_MOVE; } else if (selection_tool->allow_move && (state & GDK_MOD1_MASK) && (state & extend_mask) && move_layer) { /* move a copy of the selection */ selection_tool->function = SELECTION_MOVE_COPY; } else if (selection_tool->allow_move && (state & GDK_MOD1_MASK) && ! selection_empty) { /* move the selection mask */ selection_tool->function = SELECTION_MOVE_MASK; } else if (selection_tool->allow_move && ! (state & (extend_mask | modify_mask)) && move_floating_sel) { /* move the selection */ selection_tool->function = SELECTION_MOVE; } else if ((state & modify_mask) || (state & extend_mask)) { /* select */ selection_tool->function = SELECTION_SELECT; } else if (floating_sel) { /* anchor the selection */ selection_tool->function = SELECTION_ANCHOR; } gimp_tool_pop_status (tool, display); if (proximity) { const gchar *status = NULL; gboolean free_status = FALSE; GdkModifierType modifiers = (extend_mask | modify_mask); if (! selection_empty) modifiers |= GDK_MOD1_MASK; switch (selection_tool->function) { case SELECTION_SELECT: switch (options->operation) { case GIMP_CHANNEL_OP_REPLACE: if (! selection_empty) { status = gimp_suggest_modifiers (_("Click-Drag to replace the " "current selection"), modifiers & ~state, NULL, NULL, NULL); free_status = TRUE; } else { status = _("Click-Drag to create a new selection"); } break; case GIMP_CHANNEL_OP_ADD: status = gimp_suggest_modifiers (_("Click-Drag to add to the " "current selection"), modifiers & ~(state | extend_mask), NULL, NULL, NULL); free_status = TRUE; break; case GIMP_CHANNEL_OP_SUBTRACT: status = gimp_suggest_modifiers (_("Click-Drag to subtract from the " "current selection"), modifiers & ~(state | modify_mask), NULL, NULL, NULL); free_status = TRUE; break; case GIMP_CHANNEL_OP_INTERSECT: status = gimp_suggest_modifiers (_("Click-Drag to intersect with " "the current selection"), modifiers & ~state, NULL, NULL, NULL); free_status = TRUE; break; } break; case SELECTION_MOVE_MASK: status = gimp_suggest_modifiers (_("Click-Drag to move the " "selection mask"), modifiers & ~state, NULL, NULL, NULL); free_status = TRUE; break; case SELECTION_MOVE: status = _("Click-Drag to move the selected pixels"); break; case SELECTION_MOVE_COPY: status = _("Click-Drag to move a copy of the selected pixels"); break; case SELECTION_ANCHOR: status = _("Click to anchor the floating selection"); break; default: g_return_if_reached (); } if (status) gimp_tool_push_status (tool, display, "%s", status); if (free_status) g_free ((gchar *) status); } }
static void gimp_cage_tool_options_notify (GimpTool *tool, GimpToolOptions *options, const GParamSpec *pspec) { GimpCageTool *ct = GIMP_CAGE_TOOL (tool); GIMP_TOOL_CLASS (parent_class)->options_notify (tool, options, pspec); if (! tool->display) return; gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool)); if (strcmp (pspec->name, "cage-mode") == 0) { GimpCageMode mode; g_object_get (options, "cage-mode", &mode, NULL); if (mode == GIMP_CAGE_MODE_DEFORM) { /* switch to deform mode */ gimp_cage_config_reset_displacement (ct->config); gimp_cage_config_reverse_cage_if_needed (ct->config); gimp_tool_push_status (tool, tool->display, _("Press ENTER to commit the transform")); ct->tool_state = DEFORM_STATE_WAIT; if (! ct->render_node) { gimp_cage_tool_create_render_node (ct); } if (ct->dirty_coef) { gimp_cage_tool_compute_coef (ct); gimp_cage_tool_render_node_update (ct); } if (! ct->image_map) { GimpImage *image = gimp_display_get_image (tool->display); GimpDrawable *drawable = gimp_image_get_active_drawable (image); gimp_cage_tool_create_image_map (ct, drawable); } gimp_cage_tool_image_map_update (ct); } else { /* switch to edit mode */ gimp_image_map_abort (ct->image_map); gimp_tool_pop_status (tool, tool->display); ct->tool_state = CAGE_STATE_WAIT; } } else if (strcmp (pspec->name, "fill-plain-color") == 0) { gimp_cage_tool_render_node_update (ct); gimp_cage_tool_image_map_update (ct); } gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool)); }
static void gimp_guide_tool_motion (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpDisplay *display) { GimpGuideTool *guide_tool = GIMP_GUIDE_TOOL (tool); GimpDisplayShell *shell = gimp_display_get_shell (display); GimpImage *image = gimp_display_get_image (display); gboolean delete_guide = FALSE; gint max_position; gint tx, ty; gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool)); gimp_display_shell_transform_xy (shell, coords->x, coords->y, &tx, &ty); if (guide_tool->guide_orientation == GIMP_ORIENTATION_HORIZONTAL) max_position = gimp_image_get_height (image); else max_position = gimp_image_get_width (image); if (tx < 0 || tx >= shell->disp_width || ty < 0 || ty >= shell->disp_height) { guide_tool->guide_position = GIMP_GUIDE_POSITION_UNDEFINED; delete_guide = TRUE; } else { if (guide_tool->guide_orientation == GIMP_ORIENTATION_HORIZONTAL) guide_tool->guide_position = RINT (coords->y); else guide_tool->guide_position = RINT (coords->x); if (guide_tool->guide_position < 0 || guide_tool->guide_position > max_position) { delete_guide = TRUE; } } gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool)); gimp_tool_pop_status (tool, display); /* custom guides are moved live */ if (guide_tool->guide_custom && guide_tool->guide_position != GIMP_GUIDE_POSITION_UNDEFINED) { gimp_image_move_guide (image, guide_tool->guide, CLAMP (guide_tool->guide_position, 0, max_position), TRUE); } if (delete_guide) { gimp_tool_push_status (tool, display, guide_tool->guide ? _("Remove Guide") : _("Cancel Guide")); } else if (guide_tool->guide) { gimp_tool_push_status_length (tool, display, _("Move Guide: "), SWAP_ORIENT (guide_tool->guide_orientation), guide_tool->guide_position - guide_tool->guide_old_position, NULL); } else { gimp_tool_push_status_length (tool, display, _("Add Guide: "), SWAP_ORIENT (guide_tool->guide_orientation), guide_tool->guide_position, NULL); } }
static void gimp_color_picker_tool_oper_update (GimpTool *tool, const GimpCoords *coords, GdkModifierType state, gboolean proximity, GimpDisplay *display) { GimpColorPickerTool *picker_tool = GIMP_COLOR_PICKER_TOOL (tool); GimpColorPickerOptions *options = GIMP_COLOR_PICKER_TOOL_GET_OPTIONS (tool); GdkModifierType toggle_mask; toggle_mask = gimp_get_toggle_behavior_mask (); GIMP_COLOR_TOOL (tool)->pick_mode = options->pick_mode; gimp_tool_pop_status (tool, display); if (proximity) { gchar *status_help = NULL; GdkModifierType shift_mod = 0; if (! picker_tool->gui) shift_mod = GDK_SHIFT_MASK; switch (options->pick_mode) { case GIMP_COLOR_PICK_MODE_NONE: status_help = gimp_suggest_modifiers (_("Click in any image to view" " its color"), shift_mod & ~state, NULL, NULL, NULL); break; case GIMP_COLOR_PICK_MODE_FOREGROUND: status_help = gimp_suggest_modifiers (_("Click in any image to pick" " the foreground color"), (shift_mod | toggle_mask) & ~state, NULL, NULL, NULL); break; case GIMP_COLOR_PICK_MODE_BACKGROUND: status_help = gimp_suggest_modifiers (_("Click in any image to pick" " the background color"), (shift_mod | toggle_mask) & ~state, NULL, NULL, NULL); break; case GIMP_COLOR_PICK_MODE_PALETTE: status_help = gimp_suggest_modifiers (_("Click in any image to add" " the color to the palette"), shift_mod & ~state, NULL, NULL, NULL); break; } if (status_help != NULL) { gimp_tool_push_status (tool, display, "%s", status_help); g_free (status_help); } } GIMP_TOOL_CLASS (parent_class)->oper_update (tool, coords, state, proximity, display); }
static void gimp_color_tool_motion (GimpTool *tool, GimpCoords *coords, guint32 time, GdkModifierType state, GimpDisplay *display) { GimpColorTool *color_tool = GIMP_COLOR_TOOL (tool); GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (display->shell); if (! color_tool->enabled) return; if (color_tool->moving_sample_point) { gint tx, ty; gboolean delete_point = FALSE; gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool)); gimp_display_shell_transform_xy (shell, coords->x, coords->y, &tx, &ty, FALSE); if (tx < 0 || tx > shell->disp_width || ty < 0 || ty > shell->disp_height) { color_tool->sample_point_x = -1; color_tool->sample_point_y = -1; delete_point = TRUE; } else { gint x, y, width, height; color_tool->sample_point_x = floor (coords->x); color_tool->sample_point_y = floor (coords->y); gimp_display_shell_untransform_viewport (shell, &x, &y, &width, &height); if ((color_tool->sample_point_x < x || color_tool->sample_point_x > (x + width - 1) || color_tool->sample_point_y < y || color_tool->sample_point_y > (y + height - 1))) { delete_point = TRUE; } } gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool)); gimp_tool_pop_status (tool, display); if (delete_point) { gimp_tool_push_status (tool, display, color_tool->sample_point ? _("Remove Sample Point") : _("Cancel Sample Point")); } else { gimp_tool_push_status_coords (tool, display, color_tool->sample_point ? _("Move Sample Point: ") : _("Add Sample Point: "), color_tool->sample_point_x, ", ", color_tool->sample_point_y, NULL); } } else { gint off_x, off_y; gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool)); 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_resume (GIMP_DRAW_TOOL (tool)); gimp_color_tool_pick (color_tool, GIMP_COLOR_PICK_STATE_UPDATE, coords->x, coords->y); } }
static void gimp_sample_point_tool_motion (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpDisplay *display) { GimpSamplePointTool *sp_tool = GIMP_SAMPLE_POINT_TOOL (tool); GimpDisplayShell *shell = gimp_display_get_shell (display); gboolean delete_point = FALSE; gint tx, ty; gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool)); gimp_display_shell_transform_xy (shell, coords->x, coords->y, &tx, &ty); if (tx < 0 || tx >= shell->disp_width || ty < 0 || ty >= shell->disp_height) { sp_tool->sample_point_x = GIMP_SAMPLE_POINT_POSITION_UNDEFINED; sp_tool->sample_point_y = GIMP_SAMPLE_POINT_POSITION_UNDEFINED; delete_point = TRUE; } else { GimpImage *image = gimp_display_get_image (display); gint width = gimp_image_get_width (image); gint height = gimp_image_get_height (image); sp_tool->sample_point_x = floor (coords->x); sp_tool->sample_point_y = floor (coords->y); if (sp_tool->sample_point_x < 0 || sp_tool->sample_point_x >= height || sp_tool->sample_point_y < 0 || sp_tool->sample_point_y >= width) { delete_point = TRUE; } } gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool)); gimp_tool_pop_status (tool, display); if (delete_point) { gimp_tool_push_status (tool, display, sp_tool->sample_point ? _("Remove Sample Point") : _("Cancel Sample Point")); } else if (sp_tool->sample_point) { gimp_tool_push_status_coords (tool, display, gimp_tool_control_get_precision (tool->control), _("Move Sample Point: "), sp_tool->sample_point_x - sp_tool->sample_point_old_x, ", ", sp_tool->sample_point_y - sp_tool->sample_point_old_y, NULL); } else { gimp_tool_push_status_coords (tool, display, gimp_tool_control_get_precision (tool->control), _("Add Sample Point: "), sp_tool->sample_point_x, ", ", sp_tool->sample_point_y, NULL); } }
static void gimp_move_tool_motion (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpDisplay *display) { GimpMoveTool *move = GIMP_MOVE_TOOL (tool); GimpDisplayShell *shell = gimp_display_get_shell (display); if (move->moving_guide) { gint tx, ty; gboolean delete_guide = FALSE; gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool)); gimp_display_shell_transform_xy (shell, coords->x, coords->y, &tx, &ty); if (tx < 0 || tx >= shell->disp_width || ty < 0 || ty >= shell->disp_height) { move->guide_position = GUIDE_POSITION_INVALID; delete_guide = TRUE; } else { gint x, y, width, height; if (move->guide_orientation == GIMP_ORIENTATION_HORIZONTAL) move->guide_position = RINT (coords->y); else move->guide_position = RINT (coords->x); gimp_display_shell_untransform_viewport (shell, &x, &y, &width, &height); switch (move->guide_orientation) { case GIMP_ORIENTATION_HORIZONTAL: if ((move->guide_position < y) || (move->guide_position > (y + height))) delete_guide = TRUE; break; case GIMP_ORIENTATION_VERTICAL: if ((move->guide_position < x) || (move->guide_position > (x + width))) delete_guide = TRUE; break; default: break; } } gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool)); gimp_tool_pop_status (tool, display); if (delete_guide) { gimp_tool_push_status (tool, display, move->guide ? _("Remove Guide") : _("Cancel Guide")); } else { gimp_tool_push_status_length (tool, display, move->guide ? _("Move Guide: ") : _("Add Guide: "), SWAP_ORIENT (move->guide_orientation), move->guide_position, NULL); } } }
static void gimp_color_tool_motion (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpDisplay *display) { GimpColorTool *color_tool = GIMP_COLOR_TOOL (tool); GimpDisplayShell *shell = gimp_display_get_shell (display); if (! color_tool->enabled) return; if (color_tool->moving_sample_point) { gint tx, ty; gboolean delete_point = FALSE; gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool)); gimp_display_shell_transform_xy (shell, coords->x, coords->y, &tx, &ty); if (tx < 0 || tx > shell->disp_width || ty < 0 || ty > shell->disp_height) { color_tool->sample_point_x = SAMPLE_POINT_POSITION_INVALID; color_tool->sample_point_y = SAMPLE_POINT_POSITION_INVALID; delete_point = TRUE; } else { GimpImage *image = gimp_display_get_image (display); gint width = gimp_image_get_width (image); gint height = gimp_image_get_height (image); color_tool->sample_point_x = floor (coords->x); color_tool->sample_point_y = floor (coords->y); if (color_tool->sample_point_x < 0 || color_tool->sample_point_x >= width || color_tool->sample_point_y < 0 || color_tool->sample_point_y >= height) { delete_point = TRUE; } } gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool)); gimp_tool_pop_status (tool, display); if (delete_point) { gimp_tool_push_status (tool, display, color_tool->sample_point ? _("Remove Sample Point") : _("Cancel Sample Point")); } else { gimp_tool_push_status_coords (tool, display, gimp_tool_control_get_precision (tool->control), color_tool->sample_point ? _("Move Sample Point: ") : _("Add Sample Point: "), color_tool->sample_point_x, ", ", color_tool->sample_point_y, NULL); } } else { 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_paint_tool_oper_update (GimpTool *tool, const GimpCoords *coords, GdkModifierType state, gboolean proximity, GimpDisplay *display) { GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool); GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (tool); GimpPaintOptions *paint_options = GIMP_PAINT_TOOL_GET_OPTIONS (tool); GimpPaintCore *core = paint_tool->core; GimpDisplayShell *shell = gimp_display_get_shell (display); GimpImage *image = gimp_display_get_image (display); GimpDrawable *drawable = gimp_image_get_active_drawable (image); if (gimp_color_tool_is_enabled (GIMP_COLOR_TOOL (tool))) { GIMP_TOOL_CLASS (parent_class)->oper_update (tool, coords, state, proximity, display); return; } 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_pop_status (tool, display); if (tool->display && tool->display != display && gimp_display_get_image (tool->display) == image) { /* if this is a different display, but the same image, HACK around * in tool internals AFTER stopping the current draw_tool, so * straight line drawing works across different views of the * same image. */ tool->display = display; } if (drawable && proximity) { gboolean constrain_mask = gimp_get_constrain_behavior_mask (); gint off_x, off_y; core->cur_coords = *coords; gimp_item_get_offset (GIMP_ITEM (drawable), &off_x, &off_y); core->cur_coords.x -= off_x; core->cur_coords.y -= off_y; if (display == tool->display && (state & GIMP_PAINT_TOOL_LINE_MASK)) { /* If shift is down and this is not the first paint stroke, * draw a line. */ gchar *status_help; gdouble dx, dy, dist; gimp_paint_core_round_line (core, paint_options, (state & constrain_mask) != 0); dx = core->cur_coords.x - core->last_coords.x; dy = core->cur_coords.y - core->last_coords.y; status_help = gimp_suggest_modifiers (paint_tool->status_line, constrain_mask & ~state, NULL, _("%s for constrained angles"), NULL); /* show distance in statusbar */ if (shell->unit == GIMP_UNIT_PIXEL) { dist = sqrt (SQR (dx) + SQR (dy)); gimp_tool_push_status (tool, display, "%.1f %s. %s", dist, _("pixels"), status_help); } else { gdouble xres; gdouble yres; gchar format_str[64]; gimp_image_get_resolution (image, &xres, &yres); g_snprintf (format_str, sizeof (format_str), "%%.%df %s. %%s", gimp_unit_get_digits (shell->unit), gimp_unit_get_symbol (shell->unit)); dist = (gimp_unit_get_factor (shell->unit) * sqrt (SQR (dx / xres) + SQR (dy / yres))); gimp_tool_push_status (tool, display, format_str, dist, status_help); } g_free (status_help); paint_tool->draw_line = TRUE; } else { gchar *status; GdkModifierType modifiers = 0; /* HACK: A paint tool may set status_ctrl to NULL to indicate that * it ignores the Ctrl modifier (temporarily or permanently), so * it should not be suggested. This is different from how * gimp_suggest_modifiers() would interpret this parameter. */ if (paint_tool->status_ctrl != NULL) modifiers |= constrain_mask; /* suggest drawing lines only after the first point is set */ if (display == tool->display) modifiers |= GIMP_PAINT_TOOL_LINE_MASK; status = gimp_suggest_modifiers (paint_tool->status, modifiers & ~state, _("%s for a straight line"), paint_tool->status_ctrl, NULL); gimp_tool_push_status (tool, display, "%s", status); g_free (status); paint_tool->draw_line = FALSE; } if (! gimp_draw_tool_is_active (draw_tool)) gimp_draw_tool_start (draw_tool, display); } else if (gimp_draw_tool_is_active (draw_tool)) { gimp_draw_tool_stop (draw_tool); } GIMP_TOOL_CLASS (parent_class)->oper_update (tool, coords, state, proximity, display); gimp_draw_tool_resume (draw_tool); }