static void gimp_align_tool_oper_update (GimpTool *tool, const GimpCoords *coords, GdkModifierType state, gboolean proximity, GimpDisplay *display) { GimpAlignTool *align_tool = GIMP_ALIGN_TOOL (tool); GimpDisplayShell *shell = gimp_display_get_shell (display); GimpImage *image = gimp_display_get_image (display); gint snap_distance = display->config->snap_distance; gboolean add; add = ((state & gimp_get_extend_selection_mask ()) && align_tool->selected_objects); if (gimp_draw_tool_on_vectors (GIMP_DRAW_TOOL (tool), display, coords, snap_distance, snap_distance, NULL, NULL, NULL, NULL, NULL, NULL)) { if (add) align_tool->function = ALIGN_TOOL_ADD_PATH; else align_tool->function = ALIGN_TOOL_PICK_PATH; } else if (gimp_display_shell_get_show_guides (shell) && gimp_image_find_guide (image, coords->x, coords->y, FUNSCALEX (shell, snap_distance), FUNSCALEY (shell, snap_distance))) { if (add) align_tool->function = ALIGN_TOOL_ADD_GUIDE; else align_tool->function = ALIGN_TOOL_PICK_GUIDE; } else { GimpLayer *layer; layer = gimp_image_pick_layer_by_bounds (image, coords->x, coords->y); if (layer) { if (add) align_tool->function = ALIGN_TOOL_ADD_LAYER; else align_tool->function = ALIGN_TOOL_PICK_LAYER; } else { align_tool->function = ALIGN_TOOL_IDLE; } } gimp_align_tool_status_update (tool, display, state, proximity); }
static void gimp_align_tool_oper_update (GimpTool *tool, GimpCoords *coords, GdkModifierType state, gboolean proximity, GimpDisplay *display) { GimpAlignTool *align_tool = GIMP_ALIGN_TOOL (tool); GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (display->shell); gint snap_distance; snap_distance = GIMP_DISPLAY_CONFIG (display->image->gimp->config)->snap_distance; if (gimp_draw_tool_on_vectors (GIMP_DRAW_TOOL (tool), display, coords, snap_distance, snap_distance, NULL, NULL, NULL, NULL, NULL, NULL)) { if ((state & GDK_SHIFT_MASK) && align_tool->selected_objects) align_tool->function = ALIGN_TOOL_ADD_PATH; else align_tool->function = ALIGN_TOOL_PICK_PATH; } else if (gimp_display_shell_get_show_guides (shell) && (NULL != gimp_image_find_guide (display->image, coords->x, coords->y, FUNSCALEX (shell, snap_distance), FUNSCALEY (shell, snap_distance)))) { if ((state & GDK_SHIFT_MASK) && align_tool->selected_objects) align_tool->function = ALIGN_TOOL_ADD_GUIDE; else align_tool->function = ALIGN_TOOL_PICK_GUIDE; } else { GimpLayer *layer = select_layer_by_coords (display->image, coords->x, coords->y); if (layer) { if ((state & GDK_SHIFT_MASK) && align_tool->selected_objects) align_tool->function = ALIGN_TOOL_ADD_LAYER; else align_tool->function = ALIGN_TOOL_PICK_LAYER; } else { align_tool->function = ALIGN_TOOL_IDLE; } } gimp_align_tool_status_update (tool, display, state, proximity); }
static void gimp_flip_tool_oper_update (GimpTool *tool, const GimpCoords *coords, GdkModifierType state, gboolean proximity, GimpDisplay *display) { GimpFlipTool *flip = GIMP_FLIP_TOOL (tool); GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (tool); GimpFlipOptions *options = GIMP_FLIP_TOOL_GET_OPTIONS (tool); GimpDisplayShell *shell = gimp_display_get_shell (display); GimpImage *image = gimp_display_get_image (display); GimpGuide *guide = NULL; if (gimp_display_shell_get_show_guides (shell) && proximity) { gint snap_distance = display->config->snap_distance; guide = gimp_image_pick_guide (image, coords->x, coords->y, FUNSCALEX (shell, snap_distance), FUNSCALEY (shell, snap_distance)); } if (flip->guide != guide || (guide && ! gimp_draw_tool_is_active (draw_tool))) { gimp_draw_tool_pause (draw_tool); if (gimp_draw_tool_is_active (draw_tool) && draw_tool->display != display) gimp_draw_tool_stop (draw_tool); flip->guide = guide; if (! gimp_draw_tool_is_active (draw_tool)) gimp_draw_tool_start (draw_tool, display); gimp_draw_tool_resume (draw_tool); } gtk_widget_set_sensitive (options->direction_frame, guide == NULL); GIMP_TOOL_CLASS (parent_class)->oper_update (tool, coords, state, proximity, display); }
static void gimp_color_tool_oper_update (GimpTool *tool, const GimpCoords *coords, GdkModifierType state, gboolean proximity, GimpDisplay *display) { GimpColorTool *color_tool = GIMP_COLOR_TOOL (tool); GimpDisplayShell *shell = gimp_display_get_shell (display); GimpImage *image = gimp_display_get_image (display); GimpSamplePoint *sample_point = NULL; if (color_tool->enabled && gimp_display_shell_get_show_sample_points (shell) && proximity) { gint snap_distance = display->config->snap_distance; sample_point = gimp_image_find_sample_point (image, coords->x, coords->y, FUNSCALEX (shell, snap_distance), FUNSCALEY (shell, snap_distance)); } if (color_tool->sample_point != sample_point) { GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (tool); gimp_draw_tool_pause (draw_tool); if (gimp_draw_tool_is_active (draw_tool) && draw_tool->display != display) gimp_draw_tool_stop (draw_tool); color_tool->sample_point = sample_point; if (! gimp_draw_tool_is_active (draw_tool)) gimp_draw_tool_start (draw_tool, display); gimp_draw_tool_resume (draw_tool); } }
static void gimp_move_tool_oper_update (GimpTool *tool, const GimpCoords *coords, GdkModifierType state, gboolean proximity, GimpDisplay *display) { GimpMoveTool *move = GIMP_MOVE_TOOL (tool); GimpMoveOptions *options = GIMP_MOVE_TOOL_GET_OPTIONS (tool); GimpDisplayShell *shell = gimp_display_get_shell (display); GimpImage *image = gimp_display_get_image (display); GimpGuide *guide = NULL; if (options->move_type == GIMP_TRANSFORM_TYPE_LAYER && ! options->move_current && gimp_display_shell_get_show_guides (shell) && proximity) { const gint snap_distance = display->config->snap_distance; guide = gimp_image_find_guide (image, coords->x, coords->y, FUNSCALEX (shell, snap_distance), FUNSCALEY (shell, snap_distance)); } if (move->guide != guide) { GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (tool); gimp_draw_tool_pause (draw_tool); if (gimp_draw_tool_is_active (draw_tool) && draw_tool->display != display) gimp_draw_tool_stop (draw_tool); move->guide = guide; if (! gimp_draw_tool_is_active (draw_tool)) gimp_draw_tool_start (draw_tool, display); gimp_draw_tool_resume (draw_tool); } }
gboolean gimp_image_map_tool_on_guide (GimpImageMapTool *im_tool, const GimpCoords *coords, GimpDisplay *display) { GimpDisplayShell *shell; g_return_val_if_fail (GIMP_IS_IMAGE_MAP_TOOL (im_tool), FALSE); g_return_val_if_fail (coords != NULL, FALSE); g_return_val_if_fail (GIMP_IS_DISPLAY (display), FALSE); shell = gimp_display_get_shell (display); if (im_tool->image_map && im_tool->percent_guide && gimp_display_shell_get_show_guides (shell)) { const gint snap_distance = display->config->snap_distance; GimpOrientationType orientation; gint position; orientation = gimp_guide_get_orientation (im_tool->percent_guide); position = gimp_guide_get_position (im_tool->percent_guide); if (orientation == GIMP_ORIENTATION_HORIZONTAL) { if (fabs (coords->y - position) <= FUNSCALEY (shell, snap_distance)) return TRUE; } else { if (fabs (coords->x - position) <= FUNSCALEX (shell, snap_distance)) return TRUE; } } return FALSE; }
static void gimp_color_tool_oper_update (GimpTool *tool, GimpCoords *coords, GdkModifierType state, gboolean proximity, GimpDisplay *display) { GimpColorTool *color_tool = GIMP_COLOR_TOOL (tool); GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (display->shell); GimpSamplePoint *sample_point = NULL; if (color_tool->enabled && gimp_display_shell_get_show_sample_points (shell) && proximity) { gint snap_distance; snap_distance = GIMP_DISPLAY_CONFIG (display->image->gimp->config)->snap_distance; sample_point = gimp_image_find_sample_point (display->image, coords->x, coords->y, FUNSCALEX (shell, snap_distance), FUNSCALEY (shell, snap_distance)); } if (color_tool->sample_point && color_tool->sample_point != sample_point) gimp_image_update_sample_point (shell->display->image, color_tool->sample_point); color_tool->sample_point = sample_point; if (color_tool->sample_point) gimp_display_shell_draw_sample_point (shell, color_tool->sample_point, TRUE); }
static void gimp_move_tool_cursor_update (GimpTool *tool, const GimpCoords *coords, GdkModifierType state, GimpDisplay *display) { GimpMoveOptions *options = GIMP_MOVE_TOOL_GET_OPTIONS (tool); GimpDisplayShell *shell = gimp_display_get_shell (display); GimpImage *image = gimp_display_get_image (display); GimpCursorType cursor = GIMP_CURSOR_MOUSE; GimpToolCursorType tool_cursor = GIMP_TOOL_CURSOR_MOVE; GimpCursorModifier modifier = GIMP_CURSOR_MODIFIER_NONE; if (options->move_type == GIMP_TRANSFORM_TYPE_PATH) { tool_cursor = GIMP_TOOL_CURSOR_PATHS; modifier = GIMP_CURSOR_MODIFIER_MOVE; if (options->move_current) { if (! gimp_image_get_active_vectors (image)) modifier = GIMP_CURSOR_MODIFIER_BAD; } else { if (gimp_draw_tool_on_vectors (GIMP_DRAW_TOOL (tool), display, coords, 7, 7, NULL, NULL, NULL, NULL, NULL, NULL)) { tool_cursor = GIMP_TOOL_CURSOR_HAND; } else { modifier = GIMP_CURSOR_MODIFIER_BAD; } } } else if (options->move_type == GIMP_TRANSFORM_TYPE_SELECTION) { tool_cursor = GIMP_TOOL_CURSOR_RECT_SELECT; modifier = GIMP_CURSOR_MODIFIER_MOVE; if (gimp_channel_is_empty (gimp_image_get_mask (image))) modifier = GIMP_CURSOR_MODIFIER_BAD; } else if (options->move_current) { if (! gimp_image_get_active_drawable (image)) modifier = GIMP_CURSOR_MODIFIER_BAD; } else { GimpGuide *guide; GimpLayer *layer; const gint snap_distance = display->config->snap_distance; if (gimp_display_shell_get_show_guides (shell) && (guide = gimp_image_find_guide (image, coords->x, coords->y, FUNSCALEX (shell, snap_distance), FUNSCALEY (shell, snap_distance)))) { tool_cursor = GIMP_TOOL_CURSOR_HAND; modifier = GIMP_CURSOR_MODIFIER_MOVE; } else if ((layer = gimp_image_pick_layer (image, coords->x, coords->y))) { /* if there is a floating selection, and this aint it... */ if (gimp_image_get_floating_selection (image) && ! gimp_layer_is_floating_sel (layer)) { tool_cursor = GIMP_TOOL_CURSOR_MOVE; modifier = GIMP_CURSOR_MODIFIER_ANCHOR; } else if (layer != gimp_image_get_active_layer (image)) { tool_cursor = GIMP_TOOL_CURSOR_HAND; modifier = GIMP_CURSOR_MODIFIER_MOVE; } } else { modifier = GIMP_CURSOR_MODIFIER_BAD; } } gimp_tool_control_set_cursor (tool->control, cursor); gimp_tool_control_set_tool_cursor (tool->control, tool_cursor); gimp_tool_control_set_cursor_modifier (tool->control, modifier); GIMP_TOOL_CLASS (parent_class)->cursor_update (tool, coords, state, display); }
static void gimp_move_tool_button_press (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpButtonPressType press_type, GimpDisplay *display) { GimpMoveTool *move = GIMP_MOVE_TOOL (tool); GimpMoveOptions *options = GIMP_MOVE_TOOL_GET_OPTIONS (tool); GimpDisplayShell *shell = gimp_display_get_shell (display); GimpImage *image = gimp_display_get_image (display); tool->display = display; move->floating_layer = NULL; move->guide = NULL; move->moving_guide = FALSE; move->old_active_layer = NULL; move->old_active_vectors = NULL; if (! options->move_current) { if (options->move_type == GIMP_TRANSFORM_TYPE_PATH) { GimpVectors *vectors; if (gimp_draw_tool_on_vectors (GIMP_DRAW_TOOL (tool), display, coords, 7, 7, NULL, NULL, NULL, NULL, NULL, &vectors)) { move->old_active_vectors = gimp_image_get_active_vectors (image); gimp_image_set_active_vectors (image, vectors); } else { /* no path picked */ return; } } else if (options->move_type == GIMP_TRANSFORM_TYPE_LAYER) { GimpGuide *guide; GimpLayer *layer; const gint snap_distance = display->config->snap_distance; if (gimp_display_shell_get_show_guides (shell) && (guide = gimp_image_find_guide (image, coords->x, coords->y, FUNSCALEX (shell, snap_distance), FUNSCALEY (shell, snap_distance)))) { move->guide = guide; move->moving_guide = TRUE; move->guide_position = gimp_guide_get_position (guide); move->guide_orientation = gimp_guide_get_orientation (guide); gimp_tool_control_set_scroll_lock (tool->control, TRUE); gimp_tool_control_set_precision (tool->control, GIMP_CURSOR_PRECISION_PIXEL_BORDER); gimp_tool_control_activate (tool->control); gimp_display_shell_selection_pause (shell); gimp_draw_tool_start (GIMP_DRAW_TOOL (tool), display); gimp_tool_push_status_length (tool, display, _("Move Guide: "), SWAP_ORIENT (move->guide_orientation), move->guide_position, NULL); return; } else if ((layer = gimp_image_pick_layer (image, coords->x, coords->y))) { if (gimp_image_get_floating_selection (image) && ! gimp_layer_is_floating_sel (layer)) { /* If there is a floating selection, and this aint it, * use the move tool to anchor it. */ move->floating_layer = gimp_image_get_floating_selection (image); gimp_tool_control_activate (tool->control); return; } else { move->old_active_layer = gimp_image_get_active_layer (image); gimp_image_set_active_layer (image, layer); } } else { /* no guide and no layer picked */ return; } } } switch (options->move_type) { case GIMP_TRANSFORM_TYPE_PATH: if (gimp_image_get_active_vectors (image)) gimp_edit_selection_tool_start (tool, display, coords, GIMP_TRANSLATE_MODE_VECTORS, TRUE); break; case GIMP_TRANSFORM_TYPE_SELECTION: if (! gimp_channel_is_empty (gimp_image_get_mask (image))) gimp_edit_selection_tool_start (tool, display, coords, GIMP_TRANSLATE_MODE_MASK, TRUE); break; case GIMP_TRANSFORM_TYPE_LAYER: { GimpDrawable *drawable = gimp_image_get_active_drawable (image); if (GIMP_IS_LAYER_MASK (drawable)) gimp_edit_selection_tool_start (tool, display, coords, GIMP_TRANSLATE_MODE_LAYER_MASK, TRUE); else if (GIMP_IS_CHANNEL (drawable)) gimp_edit_selection_tool_start (tool, display, coords, GIMP_TRANSLATE_MODE_CHANNEL, TRUE); else if (GIMP_IS_LAYER (drawable)) gimp_edit_selection_tool_start (tool, display, coords, GIMP_TRANSLATE_MODE_LAYER, TRUE); } break; } }
/* some rather complex logic here. If the user clicks without modifiers, * then we start a new list, and use the first object in it as reference. * If the user clicks using Shift, or draws a rubber-band box, then * we add objects to the list, but do not specify which one should * be used as reference. */ static void gimp_align_tool_button_release (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpButtonReleaseType release_type, GimpDisplay *display) { GimpAlignTool *align_tool = GIMP_ALIGN_TOOL (tool); GimpAlignOptions *options = GIMP_ALIGN_TOOL_GET_OPTIONS (tool); GimpDisplayShell *shell = gimp_display_get_shell (display); GObject *object = NULL; GimpImage *image = gimp_display_get_image (display); GdkModifierType extend_mask; gint i; extend_mask = gimp_get_extend_selection_mask (); gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool)); gimp_tool_control_halt (tool->control); if (release_type == GIMP_BUTTON_RELEASE_CANCEL) { align_tool->x2 = align_tool->x1; align_tool->y2 = align_tool->y1; gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool)); return; } if (! (state & extend_mask)) /* start a new list */ { gimp_align_tool_clear_selected (align_tool); align_tool->set_reference = FALSE; } /* if mouse has moved less than EPSILON pixels since button press, * select the nearest thing, otherwise make a rubber-band rectangle */ if (hypot (coords->x - align_tool->x1, coords->y - align_tool->y1) < EPSILON) { GimpVectors *vectors; GimpGuide *guide; GimpLayer *layer; gint snap_distance = display->config->snap_distance; if (gimp_draw_tool_on_vectors (GIMP_DRAW_TOOL (tool), display, coords, snap_distance, snap_distance, NULL, NULL, NULL, NULL, NULL, &vectors)) { object = G_OBJECT (vectors); } else if (gimp_display_shell_get_show_guides (shell) && (guide = gimp_image_find_guide (image, coords->x, coords->y, FUNSCALEX (shell, snap_distance), FUNSCALEY (shell, snap_distance)))) { object = G_OBJECT (guide); } else { if ((layer = gimp_image_pick_layer_by_bounds (image, coords->x, coords->y))) { object = G_OBJECT (layer); } } if (object) { if (! g_list_find (align_tool->selected_objects, object)) { align_tool->selected_objects = g_list_append (align_tool->selected_objects, object); g_signal_connect (object, "removed", G_CALLBACK (gimp_align_tool_object_removed), align_tool); /* if an object has been selected using unmodified click, * it should be used as the reference */ if (! (state & extend_mask)) align_tool->set_reference = TRUE; } } } else /* FIXME: look for vectors too */ { gint X0 = MIN (coords->x, align_tool->x1); gint X1 = MAX (coords->x, align_tool->x1); gint Y0 = MIN (coords->y, align_tool->y1); gint Y1 = MAX (coords->y, align_tool->y1); GList *all_layers; GList *list; all_layers = gimp_image_get_layer_list (image); for (list = all_layers; list; list = g_list_next (list)) { GimpLayer *layer = list->data; gint x0, y0, x1, y1; if (! gimp_item_get_visible (GIMP_ITEM (layer))) continue; gimp_item_get_offset (GIMP_ITEM (layer), &x0, &y0); x1 = x0 + gimp_item_get_width (GIMP_ITEM (layer)); y1 = y0 + gimp_item_get_height (GIMP_ITEM (layer)); if (x0 < X0 || y0 < Y0 || x1 > X1 || y1 > Y1) continue; if (g_list_find (align_tool->selected_objects, layer)) continue; align_tool->selected_objects = g_list_append (align_tool->selected_objects, layer); g_signal_connect (layer, "removed", G_CALLBACK (gimp_align_tool_object_removed), align_tool); } g_list_free (all_layers); } for (i = 0; i < ALIGN_OPTIONS_N_BUTTONS; i++) { if (options->button[i]) gtk_widget_set_sensitive (options->button[i], align_tool->selected_objects != NULL); } align_tool->x2 = align_tool->x1; align_tool->y2 = align_tool->y1; gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool)); }
/** * gimp_display_shell_scale_to_rectangle: * @shell: the #GimpDisplayShell * @zoom_type: whether to zoom in or out * @x: retangle's x in image coordinates * @y: retangle's y in image coordinates * @width: retangle's width in image coordinates * @height: retangle's height in image coordinates * @resize_window: whether the display window should be resized * * Scales and scrolls to a specific image rectangle **/ void gimp_display_shell_scale_to_rectangle (GimpDisplayShell *shell, GimpZoomType zoom_type, gdouble x, gdouble y, gdouble width, gdouble height, gboolean resize_window) { GimpImage *image; gdouble current_scale; gdouble new_scale; gdouble display_width; gdouble display_height; gdouble factor = 1.0; gint offset_x = 0; gint offset_y = 0; gdouble xres; gdouble yres; gdouble screen_xres; gdouble screen_yres; g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell)); image = gimp_display_get_image (shell->display); width = MAX (1.0, width); height = MAX (1.0, height); current_scale = gimp_zoom_model_get_factor (shell->zoom); display_width = FUNSCALEX (shell, shell->disp_width); display_height = FUNSCALEY (shell, shell->disp_height); switch (zoom_type) { case GIMP_ZOOM_IN: factor = MIN ((display_width / width), (display_height / height)); break; case GIMP_ZOOM_OUT: factor = MAX ((width / display_width), (height / display_height)); break; default: g_return_if_reached (); break; } new_scale = current_scale * factor; gimp_image_get_resolution (image, &xres, &yres); gimp_display_shell_scale_get_screen_resolution (shell, &screen_xres, &screen_yres); switch (zoom_type) { case GIMP_ZOOM_IN: /* move the center of the rectangle to the center of the * viewport: * * new_offset = center of rectangle in new scale screen coords * including offset * - * center of viewport in screen coords without * offset */ offset_x = RINT (new_scale * (x + width / 2.0) * screen_xres / xres - (shell->disp_width / 2.0)); offset_y = RINT (new_scale * (y + height / 2.0) * screen_yres / yres - (shell->disp_height / 2.0)); break; case GIMP_ZOOM_OUT: /* move the center of the viewport to the center of the * rectangle: * * new_offset = center of viewport in new scale screen coords * including offset * - * center of rectangle in screen coords without * offset */ offset_x = RINT (new_scale * UNSCALEX (shell, shell->offset_x + shell->disp_width / 2.0) * screen_xres / xres - (SCALEX (shell, x + width / 2.0) - shell->offset_x)); offset_y = RINT (new_scale * UNSCALEY (shell, shell->offset_y + shell->disp_height / 2.0) * screen_yres / yres - (SCALEY (shell, y + height / 2.0) - shell->offset_y)); break; default: break; } if (new_scale != current_scale || offset_x != shell->offset_x || offset_y != shell->offset_y) { gimp_display_shell_scale_by_values (shell, new_scale, offset_x, offset_y, resize_window); } }
/** * gimp_display_shell_scale_update_rulers: * @shell: * **/ void gimp_display_shell_scale_update_rulers (GimpDisplayShell *shell) { GimpImage *image; gint image_width; gint image_height; gdouble resolution_x = 1.0; gdouble resolution_y = 1.0; gdouble horizontal_lower; gdouble horizontal_upper; gdouble horizontal_max_size; gdouble vertical_lower; gdouble vertical_upper; gdouble vertical_max_size; if (! shell->display) return; image = gimp_display_get_image (shell->display); if (image) { image_width = gimp_image_get_width (image); image_height = gimp_image_get_height (image); gimp_image_get_resolution (image, &resolution_x, &resolution_y); } else { image_width = shell->disp_width; image_height = shell->disp_height; } /* Initialize values */ horizontal_lower = 0; vertical_lower = 0; if (image) { horizontal_upper = gimp_pixels_to_units (FUNSCALEX (shell, shell->disp_width), shell->unit, resolution_x); horizontal_max_size = gimp_pixels_to_units (MAX (image_width, image_height), shell->unit, resolution_x); vertical_upper = gimp_pixels_to_units (FUNSCALEY (shell, shell->disp_height), shell->unit, resolution_y); vertical_max_size = gimp_pixels_to_units (MAX (image_width, image_height), shell->unit, resolution_y); } else { horizontal_upper = image_width; horizontal_max_size = MAX (image_width, image_height); vertical_upper = image_height; vertical_max_size = MAX (image_width, image_height); } /* Adjust due to scrolling */ if (image) { gdouble offset_x; gdouble offset_y; offset_x = gimp_pixels_to_units (FUNSCALEX (shell, (gdouble) shell->offset_x), shell->unit, resolution_x); offset_y = gimp_pixels_to_units (FUNSCALEX (shell, (gdouble) shell->offset_y), shell->unit, resolution_y); horizontal_lower += offset_x; horizontal_upper += offset_x; vertical_lower += offset_y; vertical_upper += offset_y; } /* Finally setup the actual rulers */ gimp_ruler_set_range (GIMP_RULER (shell->hrule), horizontal_lower, horizontal_upper, horizontal_max_size); gimp_ruler_set_unit (GIMP_RULER (shell->hrule), shell->unit); gimp_ruler_set_range (GIMP_RULER (shell->vrule), vertical_lower, vertical_upper, vertical_max_size); gimp_ruler_set_unit (GIMP_RULER (shell->vrule), shell->unit); }
/* * some rather complex logic here. If the user clicks without modifiers, * then we start a new list, and use the first object in it as reference. * If the user clicks using Shift, or draws a rubber-band box, then * we add objects to the list, but do not specify which one should * be used as reference. */ static void gimp_align_tool_button_release (GimpTool *tool, GimpCoords *coords, guint32 time, GdkModifierType state, GimpButtonReleaseType release_type, GimpDisplay *display) { GimpAlignTool *align_tool = GIMP_ALIGN_TOOL (tool); GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (display->shell); GObject *object = NULL; GimpImage *image = display->image; gint i; gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool)); if (release_type == GIMP_BUTTON_RELEASE_CANCEL) { align_tool->x1 = align_tool->x0; align_tool->y1 = align_tool->y0; gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool)); return; } if (! (state & GDK_SHIFT_MASK)) /* start a new list */ { clear_all_selected_objects (align_tool); align_tool->set_reference = FALSE; } /* if mouse has moved less than EPSILON pixels since button press, select the nearest thing, otherwise make a rubber-band rectangle */ if (hypot (coords->x - align_tool->x0, coords->y - align_tool->y0) < EPSILON) { GimpVectors *vectors; GimpGuide *guide; GimpLayer *layer; gint snap_distance; snap_distance = GIMP_DISPLAY_CONFIG (display->image->gimp->config)->snap_distance; if (gimp_draw_tool_on_vectors (GIMP_DRAW_TOOL (tool), display, coords, snap_distance, snap_distance, NULL, NULL, NULL, NULL, NULL, &vectors)) { object = G_OBJECT (vectors); } else if (gimp_display_shell_get_show_guides (shell) && (guide = gimp_image_find_guide (display->image, coords->x, coords->y, FUNSCALEX (shell, snap_distance), FUNSCALEY (shell, snap_distance)))) { object = G_OBJECT (guide); } else { if ((layer = select_layer_by_coords (display->image, coords->x, coords->y))) { object = G_OBJECT (layer); } } if (object) { if (! g_list_find (align_tool->selected_objects, object)) { align_tool->selected_objects = g_list_append (align_tool->selected_objects, object); g_signal_connect (object, "removed", G_CALLBACK (clear_selected_object), (gpointer) align_tool); /* if an object has been selected using unmodified click, * it should be used as the reference */ if (! (state & (GDK_SHIFT_MASK | GDK_CONTROL_MASK))) align_tool->set_reference = TRUE; } } } else /* FIXME: look for vectors too */ { gint X0 = MIN (coords->x, align_tool->x0); gint X1 = MAX (coords->x, align_tool->x0); gint Y0 = MIN (coords->y, align_tool->y0); gint Y1 = MAX (coords->y, align_tool->y0); GList *list; for (list = GIMP_LIST (image->layers)->list; list; list = g_list_next (list)) { GimpLayer *layer = list->data; gint x0, y0, x1, y1; if (! gimp_item_get_visible (GIMP_ITEM (layer))) continue; gimp_item_offsets (GIMP_ITEM (layer), &x0, &y0); x1 = x0 + gimp_item_width (GIMP_ITEM (layer)); y1 = y0 + gimp_item_height (GIMP_ITEM (layer)); if (x0 < X0 || y0 < Y0 || x1 > X1 || y1 > Y1) continue; if (g_list_find (align_tool->selected_objects, layer)) continue; align_tool->selected_objects = g_list_append (align_tool->selected_objects, layer); g_signal_connect (layer, "removed", G_CALLBACK (clear_selected_object), (gpointer) align_tool); } } for (i = 0; i < ALIGN_TOOL_NUM_BUTTONS; i++) gtk_widget_set_sensitive (align_tool->button[i], (align_tool->selected_objects != NULL)); align_tool->x1 = align_tool->x0; align_tool->y1 = align_tool->y0; gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool)); }