static void gimp_blend_tool_active_modifier_key (GimpTool *tool, GdkModifierType key, gboolean press, GdkModifierType state, GimpDisplay *display) { GimpBlendTool *blend_tool = GIMP_BLEND_TOOL (tool); if (key == gimp_get_constrain_behavior_mask ()) { gimp_blend_tool_point_motion (blend_tool, press); gimp_tool_pop_status (tool, display); gimp_blend_tool_push_status (blend_tool, state, display); gimp_blend_tool_update_items (blend_tool); gimp_blend_tool_update_graph (blend_tool); gimp_drawable_filter_apply (blend_tool->filter, NULL); } else if (key == GDK_MOD1_MASK) { gimp_tool_pop_status (tool, display); gimp_blend_tool_push_status (blend_tool, state, display); } }
static void gimp_blend_tool_active_modifier_key (GimpTool *tool, GdkModifierType key, gboolean press, GdkModifierType state, GimpDisplay *display) { GimpBlendTool *blend_tool = GIMP_BLEND_TOOL (tool); GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (tool); if (key == gimp_get_constrain_behavior_mask ()) { gimp_draw_tool_pause (draw_tool); gimp_blend_tool_point_motion (blend_tool, press); gimp_draw_tool_resume (draw_tool); gimp_tool_pop_status (tool, display); gimp_blend_tool_push_status (blend_tool, state, display); gimp_blend_tool_update_preview_coords (blend_tool); gimp_image_map_apply (blend_tool->image_map, NULL); } else if (key == GDK_MOD1_MASK) { gimp_tool_pop_status (tool, display); gimp_blend_tool_push_status (blend_tool, state, display); } }
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_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_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 void gimp_blend_tool_active_modifier_key (GimpTool *tool, GdkModifierType key, gboolean press, GdkModifierType state, GimpDisplay *display) { GimpBlendTool *blend_tool = GIMP_BLEND_TOOL (tool); if (key == GDK_CONTROL_MASK) { blend_tool->end_x = blend_tool->mouse_x; blend_tool->end_y = blend_tool->mouse_y; /* Restrict to multiples of 15 degrees if ctrl is pressed */ if (press) { gimp_constrain_line (blend_tool->start_x, blend_tool->start_y, &blend_tool->end_x, &blend_tool->end_y, GIMP_CONSTRAIN_LINE_15_DEGREES); } gimp_tool_pop_status (tool, display); gimp_blend_tool_push_status (blend_tool, state, display); gimp_blend_tool_update_items (blend_tool); } }
static void gimp_tool_clear_status (GimpTool *tool) { g_return_if_fail (GIMP_IS_TOOL (tool)); while (tool->status_displays) gimp_tool_pop_status (tool, tool->status_displays->data); }
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 gboolean gimp_crop_tool_execute (GimpRectangleTool *rectangle, gint x, gint y, gint w, gint h) { GimpTool *tool = GIMP_TOOL (rectangle); GimpCropOptions *options = GIMP_CROP_TOOL_GET_OPTIONS (tool); GimpImage *image = gimp_display_get_image (tool->display); gimp_tool_pop_status (tool, tool->display); /* if rectangle exists, crop it */ if (w > 0 && h > 0) { if (options->layer_only) { GimpLayer *layer = gimp_image_get_active_layer (image); gint off_x, off_y; if (! layer) { gimp_tool_message_literal (tool, tool->display, _("There is no active layer to crop.")); return FALSE; } if (gimp_item_is_content_locked (GIMP_ITEM (layer))) { gimp_tool_message_literal (tool, tool->display, _("The active layer's pixels are locked.")); return FALSE; } gimp_item_get_offset (GIMP_ITEM (layer), &off_x, &off_y); off_x -= x; off_y -= y; gimp_item_resize (GIMP_ITEM (layer), GIMP_CONTEXT (options), w, h, off_x, off_y); } else { gimp_image_crop (image, GIMP_CONTEXT (options), x, y, w + x, h + y, TRUE); } gimp_image_flush (image); return TRUE; } return TRUE; }
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_warp_tool_button_press (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpButtonPressType press_type, GimpDisplay *display) { GimpWarpTool *wt = GIMP_WARP_TOOL (tool); GimpWarpOptions *options = GIMP_WARP_TOOL_GET_OPTIONS (wt); GeglNode *new_op; gint off_x, off_y; if (tool->display && display != tool->display) { gimp_tool_pop_status (tool, tool->display); gimp_warp_tool_halt (wt); } if (! tool->display) { if (! gimp_warp_tool_start (wt, display)) return; } wt->current_stroke = gegl_path_new (); new_op = gegl_node_new_child (NULL, "operation", "gegl:warp", "behavior", options->behavior, "strength", options->effect_strength, "size", options->effect_size, "hardness", options->effect_hardness, "stroke", wt->current_stroke, NULL); gimp_warp_tool_add_op (wt, new_op); g_object_unref (new_op); g_signal_connect (wt->current_stroke, "changed", G_CALLBACK (gimp_warp_tool_stroke_changed), wt); gimp_item_get_offset (GIMP_ITEM (tool->drawable), &off_x, &off_y); gegl_path_append (wt->current_stroke, 'M', coords->x - off_x, coords->y - off_y); wt->stroke_timer = g_timeout_add (STROKE_PERIOD, (GSourceFunc) gimp_warp_tool_stroke_timer, wt); gimp_tool_control_activate (tool->control); }
static void gimp_blend_tool_motion (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpDisplay *display) { GimpBlendTool *blend_tool = GIMP_BLEND_TOOL (tool); /* Save the mouse coordinates from last call */ gdouble last_x = blend_tool->mouse_x; gdouble last_y = blend_tool->mouse_y; blend_tool->mouse_x = coords->x; blend_tool->mouse_y = coords->y; if (blend_tool->grabbed_point == POINT_INIT_MODE) { GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (blend_tool); gimp_draw_tool_pause (draw_tool); blend_tool->grabbed_point = POINT_END; gimp_draw_tool_resume (draw_tool); } /* Move the whole line if alt is pressed */ if (state & GDK_MOD1_MASK) { gdouble dx = last_x - coords->x; gdouble dy = last_y - coords->y; blend_tool->start_x -= dx; blend_tool->start_y -= dy; blend_tool->end_x -= dx; blend_tool->end_y -= dy; } else { gimp_blend_tool_point_motion (blend_tool, state & gimp_get_constrain_behavior_mask ()); } gimp_tool_pop_status (tool, display); gimp_blend_tool_push_status (blend_tool, state, display); if (GIMP_IS_CANVAS_LINE (blend_tool->line)) gimp_blend_tool_update_items (blend_tool); gimp_blend_tool_update_preview_coords (blend_tool); gimp_image_map_apply (blend_tool->image_map, NULL); }
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_blend_tool_motion (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpDisplay *display) { GimpBlendTool *blend_tool = GIMP_BLEND_TOOL (tool); /* Save the mouse coordinates from last call */ gdouble last_x = blend_tool->mouse_x; gdouble last_y = blend_tool->mouse_y; blend_tool->mouse_x = coords->x; blend_tool->mouse_y = coords->y; if (blend_tool->grabbed_point == POINT_FILL_MODE || blend_tool->grabbed_point == POINT_INIT_MODE) { blend_tool->grabbed_point = POINT_END; gimp_blend_tool_start (blend_tool, display); } /* Move the whole line if alt is pressed */ if (blend_tool->grabbed_point == POINT_BOTH) { gdouble dx = last_x - coords->x; gdouble dy = last_y - coords->y; blend_tool->start_x -= dx; blend_tool->start_y -= dy; blend_tool->end_x -= dx; blend_tool->end_y -= dy; } else { gimp_blend_tool_point_motion (blend_tool, state & gimp_get_constrain_behavior_mask ()); } gimp_tool_pop_status (tool, display); gimp_blend_tool_push_status (blend_tool, state, display); gimp_blend_tool_update_items (blend_tool); gimp_blend_tool_update_graph (blend_tool); gimp_drawable_filter_apply (blend_tool->filter, NULL); }
static void gimp_perspective_clone_tool_widget_status (GimpToolWidget *widget, const gchar *status, GimpPerspectiveCloneTool *clone_tool) { GimpTool *tool = GIMP_TOOL (clone_tool); if (status) { gimp_tool_replace_status (tool, tool->display, "%s", status); } else { gimp_tool_pop_status (tool, tool->display); } }
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_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_blend_tool_motion (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpDisplay *display) { GimpBlendTool *blend_tool = GIMP_BLEND_TOOL (tool); blend_tool->mouse_x = coords->x; blend_tool->mouse_y = coords->y; /* Move the whole line if alt is pressed */ if (state & GDK_MOD1_MASK) { gdouble dx = blend_tool->last_x - coords->x; gdouble dy = blend_tool->last_y - coords->y; blend_tool->start_x -= dx; blend_tool->start_y -= dy; blend_tool->end_x -= dx; blend_tool->end_y -= dy; } else { blend_tool->end_x = coords->x; blend_tool->end_y = coords->y; } if (state & GDK_CONTROL_MASK) { gimp_constrain_line (blend_tool->start_x, blend_tool->start_y, &blend_tool->end_x, &blend_tool->end_y, GIMP_CONSTRAIN_LINE_15_DEGREES); } gimp_tool_pop_status (tool, display); gimp_blend_tool_push_status (blend_tool, state, display); blend_tool->last_x = coords->x; blend_tool->last_y = coords->y; gimp_blend_tool_update_items (blend_tool); }
static void gimp_tool_clear_status (GimpTool *tool) { GList *list; g_return_if_fail (GIMP_IS_TOOL (tool)); list = tool->status_displays; while (list) { GimpDisplay *display = list->data; /* get next element early because we modify the list */ list = g_list_next (list); gimp_tool_pop_status (tool, display); } }
static gboolean gimp_rectangle_select_tool_select (GimpRectangleTool *rectangle, gint x, gint y, gint w, gint h) { GimpTool *tool; GimpRectangleSelectTool *rect_sel_tool; GimpImage *image; gboolean rectangle_exists; GimpChannelOps operation; tool = GIMP_TOOL (rectangle); rect_sel_tool = GIMP_RECTANGLE_SELECT_TOOL (rectangle); image = gimp_display_get_image (tool->display); gimp_tool_pop_status (tool, tool->display); rectangle_exists = (x <= gimp_image_get_width (image) && y <= gimp_image_get_height (image) && x + w >= 0 && y + h >= 0 && w > 0 && h > 0); operation = gimp_rectangle_select_tool_get_operation (rect_sel_tool); /* if rectangle exists, turn it into a selection */ if (rectangle_exists) GIMP_RECTANGLE_SELECT_TOOL_GET_CLASS (rect_sel_tool)->select (rect_sel_tool, operation, x, y, w, h); return rectangle_exists; }
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_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_rectangle_select_tool_button_release (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpButtonReleaseType release_type, GimpDisplay *display) { GimpRectangleSelectTool *rect_sel_tool; GimpRectangleSelectToolPrivate *priv; GimpImage *image; rect_sel_tool = GIMP_RECTANGLE_SELECT_TOOL (tool); priv = GIMP_RECTANGLE_SELECT_TOOL_GET_PRIVATE (rect_sel_tool); image = gimp_display_get_image (tool->display); gimp_tool_control_halt (tool->control); gimp_tool_pop_status (tool, display); gimp_display_shell_set_show_selection (gimp_display_get_shell (display), priv->saved_show_selection); /* * if the user has not moved the mouse, we need to redo the operation * that was undone on button press. */ if (release_type == GIMP_BUTTON_RELEASE_CLICK) { GimpUndoStack *redo_stack = gimp_image_get_redo_stack (image); GimpUndo *redo = gimp_undo_stack_peek (redo_stack); if (redo && priv->redo == redo) { /* prevent this from halting the tool */ gimp_tool_control_push_preserve (tool->control, TRUE); gimp_image_redo (image); priv->redo = NULL; gimp_tool_control_pop_preserve (tool->control); } } gimp_rectangle_tool_button_release (tool, coords, time, state, release_type, display); if (release_type == GIMP_BUTTON_RELEASE_CANCEL) { if (priv->redo) { /* prevent this from halting the tool */ gimp_tool_control_push_preserve (tool->control, TRUE); gimp_image_redo (image); gimp_tool_control_pop_preserve (tool->control); } priv->use_saved_op = TRUE; /* is this correct? */ } priv->redo = 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_button_release (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpButtonReleaseType release_type, GimpDisplay *display) { GimpColorTool *color_tool = GIMP_COLOR_TOOL (tool); GimpDisplayShell *shell = gimp_display_get_shell (display); /* Chain up to halt the tool */ GIMP_TOOL_CLASS (parent_class)->button_release (tool, coords, time, state, release_type, display); if (! color_tool->enabled) return; if (color_tool->moving_sample_point) { GimpImage *image = gimp_display_get_image (display); gint width = gimp_image_get_width (image); gint height = gimp_image_get_height (image); gimp_tool_pop_status (tool, display); gimp_tool_control_set_scroll_lock (tool->control, FALSE); gimp_draw_tool_stop (GIMP_DRAW_TOOL (tool)); if (release_type == GIMP_BUTTON_RELEASE_CANCEL) { color_tool->moving_sample_point = FALSE; color_tool->sample_point_x = SAMPLE_POINT_POSITION_INVALID; color_tool->sample_point_y = SAMPLE_POINT_POSITION_INVALID; gimp_display_shell_selection_resume (shell); return; } if (color_tool->sample_point_x == SAMPLE_POINT_POSITION_INVALID || color_tool->sample_point_x < 0 || color_tool->sample_point_x >= width || color_tool->sample_point_y == SAMPLE_POINT_POSITION_INVALID || color_tool->sample_point_y < 0 || color_tool->sample_point_y >= height) { if (color_tool->sample_point) { gimp_image_remove_sample_point (image, color_tool->sample_point, TRUE); color_tool->sample_point = NULL; } } else { if (color_tool->sample_point) { gimp_image_move_sample_point (image, color_tool->sample_point, color_tool->sample_point_x, color_tool->sample_point_y, TRUE); } else { color_tool->sample_point = gimp_image_add_sample_point_at_pos (image, color_tool->sample_point_x, color_tool->sample_point_y, TRUE); } } gimp_display_shell_selection_resume (shell); gimp_image_flush (image); color_tool->moving_sample_point = FALSE; color_tool->sample_point_x = SAMPLE_POINT_POSITION_INVALID; color_tool->sample_point_y = SAMPLE_POINT_POSITION_INVALID; if (color_tool->sample_point) gimp_draw_tool_start (GIMP_DRAW_TOOL (tool), display); } else { gimp_draw_tool_stop (GIMP_DRAW_TOOL (tool)); } }
static void gimp_move_tool_button_release (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpButtonReleaseType release_type, GimpDisplay *display) { GimpMoveTool *move = GIMP_MOVE_TOOL (tool); GimpGuiConfig *config = GIMP_GUI_CONFIG (display->gimp->config); GimpDisplayShell *shell = gimp_display_get_shell (display); GimpImage *image = gimp_display_get_image (display); if (gimp_tool_control_is_active (tool->control)) gimp_tool_control_halt (tool->control); if (move->moving_guide) { gboolean delete_guide = FALSE; gint x, y, width, height; gimp_tool_pop_status (tool, display); gimp_tool_control_set_scroll_lock (tool->control, FALSE); gimp_tool_control_set_precision (tool->control, GIMP_CURSOR_PRECISION_PIXEL_CENTER); gimp_draw_tool_stop (GIMP_DRAW_TOOL (tool)); if (release_type == GIMP_BUTTON_RELEASE_CANCEL) { move->moving_guide = FALSE; move->guide_position = GUIDE_POSITION_INVALID; move->guide_orientation = GIMP_ORIENTATION_UNKNOWN; gimp_display_shell_selection_resume (shell); return; } 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; } if (delete_guide) { if (move->guide) { gimp_image_remove_guide (image, move->guide, TRUE); move->guide = NULL; } } else { if (move->guide) { gimp_image_move_guide (image, move->guide, move->guide_position, TRUE); } else { switch (move->guide_orientation) { case GIMP_ORIENTATION_HORIZONTAL: move->guide = gimp_image_add_hguide (image, move->guide_position, TRUE); break; case GIMP_ORIENTATION_VERTICAL: move->guide = gimp_image_add_vguide (image, move->guide_position, TRUE); break; default: g_assert_not_reached (); } } } gimp_display_shell_selection_resume (shell); gimp_image_flush (image); move->moving_guide = FALSE; move->guide_position = GUIDE_POSITION_INVALID; move->guide_orientation = GIMP_ORIENTATION_UNKNOWN; if (move->guide) gimp_draw_tool_start (GIMP_DRAW_TOOL (tool), display); } else { gboolean flush = FALSE; if (! config->move_tool_changes_active || (release_type == GIMP_BUTTON_RELEASE_CANCEL)) { if (move->old_active_layer) { gimp_image_set_active_layer (image, move->old_active_layer); move->old_active_layer = NULL; flush = TRUE; } if (move->old_active_vectors) { gimp_image_set_active_vectors (image, move->old_active_vectors); move->old_active_vectors = NULL; flush = TRUE; } } if (release_type != GIMP_BUTTON_RELEASE_CANCEL) { if (move->floating_layer) { floating_sel_anchor (move->floating_layer); flush = TRUE; } } if (flush) gimp_image_flush (image); } }
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_guide_tool_button_release (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpButtonReleaseType release_type, GimpDisplay *display) { GimpGuideTool *guide_tool = GIMP_GUIDE_TOOL (tool); GimpDisplayShell *shell = gimp_display_get_shell (display); GimpImage *image = gimp_display_get_image (display); gimp_tool_pop_status (tool, display); gimp_tool_control_halt (tool->control); gimp_draw_tool_stop (GIMP_DRAW_TOOL (tool)); if (release_type == GIMP_BUTTON_RELEASE_CANCEL) { /* custom guides are moved live */ if (guide_tool->guide_custom) gimp_image_move_guide (image, guide_tool->guide, guide_tool->guide_old_position, TRUE); } else { gint max_position; if (guide_tool->guide_orientation == GIMP_ORIENTATION_HORIZONTAL) max_position = gimp_image_get_height (image); else max_position = gimp_image_get_width (image); if (guide_tool->guide_position == GIMP_GUIDE_POSITION_UNDEFINED || guide_tool->guide_position < 0 || guide_tool->guide_position > max_position) { if (guide_tool->guide) { gimp_image_remove_guide (image, guide_tool->guide, TRUE); guide_tool->guide = NULL; } } else { if (guide_tool->guide) { /* custom guides are moved live */ if (! guide_tool->guide_custom) gimp_image_move_guide (image, guide_tool->guide, guide_tool->guide_position, TRUE); } else { switch (guide_tool->guide_orientation) { case GIMP_ORIENTATION_HORIZONTAL: guide_tool->guide = gimp_image_add_hguide (image, guide_tool->guide_position, TRUE); break; case GIMP_ORIENTATION_VERTICAL: guide_tool->guide = gimp_image_add_vguide (image, guide_tool->guide_position, TRUE); break; default: gimp_assert_not_reached (); } } } gimp_image_flush (image); } gimp_display_shell_selection_resume (shell); guide_tool->guide_position = GIMP_GUIDE_POSITION_UNDEFINED; guide_tool->guide_orientation = GIMP_ORIENTATION_UNKNOWN; tool_manager_pop_tool (display->gimp); g_object_unref (guide_tool); { GimpTool *active_tool = tool_manager_get_active (display->gimp); if (GIMP_IS_DRAW_TOOL (active_tool)) gimp_draw_tool_pause (GIMP_DRAW_TOOL (active_tool)); tool_manager_oper_update_active (display->gimp, coords, state, TRUE, display); tool_manager_cursor_update_active (display->gimp, coords, state, display); if (GIMP_IS_DRAW_TOOL (active_tool)) gimp_draw_tool_resume (GIMP_DRAW_TOOL (active_tool)); } }
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_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); } }