GimpCanvasItem * gimp_brush_tool_create_outline (GimpBrushTool *brush_tool, GimpDisplay *display, gdouble x, gdouble y) { GimpBrushCore *brush_core; GimpPaintOptions *options; GimpDisplayShell *shell; const GimpBezierDesc *boundary = NULL; gint width = 0; gint height = 0; g_return_val_if_fail (GIMP_IS_BRUSH_TOOL (brush_tool), NULL); g_return_val_if_fail (GIMP_IS_DISPLAY (display), NULL); if (! GIMP_PAINT_TOOL (brush_tool)->draw_brush) return NULL; brush_core = GIMP_BRUSH_CORE (GIMP_PAINT_TOOL (brush_tool)->core); options = GIMP_PAINT_TOOL_GET_OPTIONS (brush_tool); shell = gimp_display_get_shell (display); if (! brush_core->main_brush || ! brush_core->dynamics) return NULL; if (brush_core->scale > 0.0) boundary = gimp_brush_transform_boundary (brush_core->main_brush, brush_core->scale, brush_core->aspect_ratio, brush_core->angle, brush_core->hardness, &width, &height); /* don't draw the boundary if it becomes too small */ if (boundary && SCALEX (shell, width) > 4 && SCALEY (shell, height) > 4) { x -= width / 2.0; y -= height / 2.0; if (gimp_paint_options_get_brush_mode (options) == GIMP_BRUSH_HARD) { #define EPSILON 0.000001 /* Add EPSILON before rounding since e.g. * (5.0 - 0.5) may end up at (4.499999999....) * due to floating point fnords */ x = RINT (x + EPSILON); y = RINT (y + EPSILON); #undef EPSILON } return gimp_canvas_path_new (shell, boundary, x, y, FALSE, GIMP_PATH_STYLE_OUTLINE); } return NULL; }
void file_revert_cmd_callback (GtkAction *action, gpointer data) { GimpDisplay *display; GimpImage *image; GtkWidget *dialog; const gchar *uri; return_if_no_display (display, data); image = gimp_display_get_image (display); uri = gimp_image_get_uri (image); if (! uri) uri = gimp_image_get_imported_uri (image); dialog = g_object_get_data (G_OBJECT (image), REVERT_DATA_KEY); if (! uri) { gimp_message_literal (image->gimp, G_OBJECT (display), GIMP_MESSAGE_ERROR, _("Revert failed. " "No file name associated with this image.")); } else if (dialog) { gtk_window_present (GTK_WINDOW (dialog)); } else { gchar *filename; dialog = gimp_message_dialog_new (_("Revert Image"), GTK_STOCK_REVERT_TO_SAVED, GTK_WIDGET (gimp_display_get_shell (display)), 0, gimp_standard_help_func, GIMP_HELP_FILE_REVERT, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_REVERT_TO_SAVED, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); g_signal_connect_object (display, "disconnect", G_CALLBACK (gtk_widget_destroy), dialog, G_CONNECT_SWAPPED); g_signal_connect (dialog, "response", G_CALLBACK (file_revert_confirm_response), display); filename = file_utils_uri_display_name (uri); gimp_message_box_set_primary_text (GIMP_MESSAGE_DIALOG (dialog)->box, _("Revert '%s' to '%s'?"), gimp_image_get_display_name (image), filename); g_free (filename); gimp_message_box_set_text (GIMP_MESSAGE_DIALOG (dialog)->box, _("By reverting the image to the state saved " "on disk, you will lose all changes, " "including all undo information.")); g_object_set_data (G_OBJECT (image), REVERT_DATA_KEY, dialog); gtk_widget_show (dialog); } }
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; } }
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_tool_real_picked (GimpColorTool *color_tool, GimpColorPickState pick_state, gdouble x, gdouble y, const Babl *sample_format, gpointer pixel, const GimpRGB *color) { GimpTool *tool = GIMP_TOOL (color_tool); GimpDisplayShell *shell = gimp_display_get_shell (tool->display); GimpImageWindow *image_window; GimpDialogFactory *dialog_factory; GimpContext *context; image_window = gimp_display_shell_get_window (shell); dialog_factory = gimp_dock_container_get_dialog_factory (GIMP_DOCK_CONTAINER (image_window)); /* use this tool's own options here (NOT color_tool->options) */ context = GIMP_CONTEXT (gimp_tool_get_options (tool)); if (color_tool->pick_mode == GIMP_COLOR_PICK_MODE_FOREGROUND || color_tool->pick_mode == GIMP_COLOR_PICK_MODE_BACKGROUND) { GtkWidget *widget; if (babl_format_is_palette (sample_format)) { widget = gimp_dialog_factory_find_widget (dialog_factory, "gimp-indexed-palette"); if (widget) { GtkWidget *editor = gtk_bin_get_child (GTK_BIN (widget)); guchar *index = pixel; gimp_colormap_editor_set_index (GIMP_COLORMAP_EDITOR (editor), *index, NULL); } } widget = gimp_dialog_factory_find_widget (dialog_factory, "gimp-palette-editor"); if (widget) { GtkWidget *editor = gtk_bin_get_child (GTK_BIN (widget)); gint index; index = gimp_palette_editor_get_index (GIMP_PALETTE_EDITOR (editor), color); if (index != -1) gimp_palette_editor_set_index (GIMP_PALETTE_EDITOR (editor), index, NULL); } } switch (color_tool->pick_mode) { case GIMP_COLOR_PICK_MODE_NONE: break; case GIMP_COLOR_PICK_MODE_FOREGROUND: gimp_context_set_foreground (context, color); break; case GIMP_COLOR_PICK_MODE_BACKGROUND: gimp_context_set_background (context, color); break; case GIMP_COLOR_PICK_MODE_PALETTE: { GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (shell)); gint monitor = gimp_widget_get_monitor (GTK_WIDGET (shell)); GtkWidget *dockable; dockable = gimp_window_strategy_show_dockable_dialog (GIMP_WINDOW_STRATEGY (gimp_get_window_strategy (tool->display->gimp)), tool->display->gimp, dialog_factory, screen, monitor, "gimp-palette-editor"); if (dockable) { GtkWidget *palette_editor; GimpData *data; /* don't blink like mad when updating */ if (pick_state != GIMP_COLOR_PICK_STATE_START) gimp_dockable_blink_cancel (GIMP_DOCKABLE (dockable)); palette_editor = gtk_bin_get_child (GTK_BIN (dockable)); data = gimp_data_editor_get_data (GIMP_DATA_EDITOR (palette_editor)); if (! data) { data = GIMP_DATA (gimp_context_get_palette (context)); gimp_data_editor_set_data (GIMP_DATA_EDITOR (palette_editor), data); } gimp_palette_editor_pick_color (GIMP_PALETTE_EDITOR (palette_editor), color, pick_state); } } break; } }
void view_padding_color_cmd_callback (GtkAction *action, gint value, gpointer data) { GimpDisplay *display; GimpImageWindow *window; GimpDisplayShell *shell; GimpDisplayOptions *options; gboolean fullscreen; return_if_no_display (display, data); shell = gimp_display_get_shell (display); window = gimp_display_shell_get_window (shell); if (window) fullscreen = gimp_image_window_get_fullscreen (window); else fullscreen = FALSE; if (fullscreen) options = shell->fullscreen_options; else options = shell->options; #define PADDING_COLOR_DIALOG_KEY "gimp-padding-color-dialog" switch ((GimpCanvasPaddingMode) value) { case GIMP_CANVAS_PADDING_MODE_DEFAULT: case GIMP_CANVAS_PADDING_MODE_LIGHT_CHECK: case GIMP_CANVAS_PADDING_MODE_DARK_CHECK: dialogs_destroy_dialog (G_OBJECT (shell), PADDING_COLOR_DIALOG_KEY); options->padding_mode_set = TRUE; gimp_display_shell_set_padding (shell, (GimpCanvasPaddingMode) value, &options->padding_color); break; case GIMP_CANVAS_PADDING_MODE_CUSTOM: { GtkWidget *dialog; dialog = dialogs_get_dialog (G_OBJECT (shell), PADDING_COLOR_DIALOG_KEY); if (! dialog) { GimpImage *image = gimp_display_get_image (display); GimpDisplayShell *shell = gimp_display_get_shell (display); dialog = gimp_color_dialog_new (GIMP_VIEWABLE (image), action_data_get_context (data), _("Set Canvas Padding Color"), GIMP_ICON_FONT, _("Set Custom Canvas Padding Color"), GTK_WIDGET (shell), NULL, NULL, &options->padding_color, FALSE, FALSE); g_signal_connect (dialog, "update", G_CALLBACK (view_padding_color_dialog_update), shell); dialogs_attach_dialog (G_OBJECT (shell), PADDING_COLOR_DIALOG_KEY, dialog); } gtk_window_present (GTK_WINDOW (dialog)); } break; case GIMP_CANVAS_PADDING_MODE_RESET: dialogs_destroy_dialog (G_OBJECT (shell), PADDING_COLOR_DIALOG_KEY); { GimpDisplayOptions *default_options; options->padding_mode_set = FALSE; if (fullscreen) default_options = display->config->default_fullscreen_view; else default_options = display->config->default_view; gimp_display_shell_set_padding (shell, default_options->padding_mode, &default_options->padding_color); } break; } }
void view_actions_update (GimpActionGroup *group, gpointer data) { GimpDisplay *display = action_data_get_display (data); GimpImage *image = NULL; GimpDisplayShell *shell = NULL; GimpDisplayOptions *options = NULL; gchar *label = NULL; gboolean fullscreen = FALSE; gboolean revert_enabled = FALSE; /* able to revert zoom? */ gboolean use_gegl = FALSE; if (display) { GimpImageWindow *window; image = gimp_display_get_image (display); shell = gimp_display_get_shell (display); window = gimp_display_shell_get_window (shell); if (window) fullscreen = gimp_image_window_get_fullscreen (window); options = (image ? (fullscreen ? shell->fullscreen_options : shell->options) : shell->no_image_options); revert_enabled = gimp_display_shell_scale_can_revert (shell); if (image) use_gegl = gimp_image_get_projection (image)->use_gegl; } #define SET_ACTIVE(action,condition) \ gimp_action_group_set_action_active (group, action, (condition) != 0) #define SET_SENSITIVE(action,condition) \ gimp_action_group_set_action_sensitive (group, action, (condition) != 0) #define SET_COLOR(action,color) \ gimp_action_group_set_action_color (group, action, color, FALSE) SET_SENSITIVE ("view-new", image); SET_SENSITIVE ("view-close", image); SET_SENSITIVE ("view-dot-for-dot", image); SET_ACTIVE ("view-dot-for-dot", display && shell->dot_for_dot); SET_SENSITIVE ("view-zoom-revert", revert_enabled); if (revert_enabled) { label = g_strdup_printf (_("Re_vert Zoom (%d%%)"), ROUND (shell->last_scale * 100)); gimp_action_group_set_action_label (group, "view-zoom-revert", label); g_free (label); } else { gimp_action_group_set_action_label (group, "view-zoom-revert", _("Re_vert Zoom")); } SET_SENSITIVE ("view-zoom-out", image); SET_SENSITIVE ("view-zoom-in", image); SET_SENSITIVE ("view-zoom-fit-in", image); SET_SENSITIVE ("view-zoom-fill", image); SET_SENSITIVE ("view-zoom-16-1", image); SET_SENSITIVE ("view-zoom-8-1", image); SET_SENSITIVE ("view-zoom-4-1", image); SET_SENSITIVE ("view-zoom-2-1", image); SET_SENSITIVE ("view-zoom-1-1", image); SET_SENSITIVE ("view-zoom-1-2", image); SET_SENSITIVE ("view-zoom-1-4", image); SET_SENSITIVE ("view-zoom-1-8", image); SET_SENSITIVE ("view-zoom-1-16", image); SET_SENSITIVE ("view-zoom-other", image); if (image) view_actions_set_zoom (group, shell); SET_SENSITIVE ("view-navigation-window", image); SET_SENSITIVE ("view-display-filters", image); SET_SENSITIVE ("view-show-selection", image); SET_ACTIVE ("view-show-selection", display && options->show_selection); SET_SENSITIVE ("view-show-layer-boundary", image); SET_ACTIVE ("view-show-layer-boundary", display && options->show_layer_boundary); SET_SENSITIVE ("view-show-guides", image); SET_ACTIVE ("view-show-guides", display && options->show_guides); SET_SENSITIVE ("view-show-grid", image); SET_ACTIVE ("view-show-grid", display && options->show_grid); SET_SENSITIVE ("view-show-sample-points", image); SET_ACTIVE ("view-show-sample-points", display && options->show_sample_points); SET_SENSITIVE ("view-snap-to-guides", image); SET_ACTIVE ("view-snap-to-guides", display && shell->snap_to_guides); SET_SENSITIVE ("view-snap-to-grid", image); SET_ACTIVE ("view-snap-to-grid", display && shell->snap_to_grid); SET_SENSITIVE ("view-snap-to-canvas", image); SET_ACTIVE ("view-snap-to-canvas", display && shell->snap_to_canvas); SET_SENSITIVE ("view-snap-to-vectors", image); SET_ACTIVE ("view-snap-to-vectors", display && shell->snap_to_vectors); SET_SENSITIVE ("view-padding-color-theme", image); SET_SENSITIVE ("view-padding-color-light-check", image); SET_SENSITIVE ("view-padding-color-dark-check", image); SET_SENSITIVE ("view-padding-color-custom", image); SET_SENSITIVE ("view-padding-color-prefs", image); if (display) { SET_COLOR ("view-padding-color-menu", &options->padding_color); if (shell->canvas) { GtkStyle *style = gtk_widget_get_style (shell->canvas); GimpRGB color; gtk_widget_ensure_style (shell->canvas); gimp_rgb_set_gdk_color (&color, style->bg + GTK_STATE_NORMAL); gimp_rgb_set_alpha (&color, GIMP_OPACITY_OPAQUE); SET_COLOR ("view-padding-color-theme", &color); } } SET_SENSITIVE ("view-show-menubar", image); SET_ACTIVE ("view-show-menubar", display && options->show_menubar); SET_SENSITIVE ("view-show-rulers", image); SET_ACTIVE ("view-show-rulers", display && options->show_rulers); SET_SENSITIVE ("view-show-scrollbars", image); SET_ACTIVE ("view-show-scrollbars", display && options->show_scrollbars); SET_SENSITIVE ("view-show-statusbar", image); SET_ACTIVE ("view-show-statusbar", display && options->show_statusbar); SET_SENSITIVE ("view-shrink-wrap", image); SET_SENSITIVE ("view-fullscreen", image); SET_ACTIVE ("view-fullscreen", display && fullscreen); SET_ACTIVE ("view-use-gegl", use_gegl); if (GIMP_IS_IMAGE_WINDOW (group->user_data) || GIMP_IS_GIMP (group->user_data)) { GtkWidget *window = NULL; if (shell) window = gtk_widget_get_toplevel (GTK_WIDGET (shell)); /* see view_actions_setup() */ if (GTK_IS_WINDOW (window)) window_actions_update (group, window); } #undef SET_ACTIVE #undef SET_SENSITIVE #undef SET_COLOR }
void debug_dump_keyboard_shortcuts_cmd_callback (GtkAction *action, gpointer data) { GimpDisplay *display; GimpImageWindow *window; GtkUIManager *manager; GtkAccelGroup *accel_group; GList *group_it; GList *strings = NULL; return_if_no_display (display, data); window = gimp_display_shell_get_window (gimp_display_get_shell (display)); manager = GTK_UI_MANAGER (gimp_image_window_get_ui_manager (window)); accel_group = gtk_ui_manager_get_accel_group (manager); /* Gather formated strings of keyboard shortcuts */ for (group_it = gtk_ui_manager_get_action_groups (manager); group_it; group_it = g_list_next (group_it)) { GimpActionGroup *group = group_it->data; GList *actions = NULL; GList *action_it = NULL; actions = gtk_action_group_list_actions (GTK_ACTION_GROUP (group)); actions = g_list_sort (actions, (GCompareFunc) gimp_action_name_compare); for (action_it = actions; action_it; action_it = g_list_next (action_it)) { GtkAction *action = action_it->data; const gchar *name = gtk_action_get_name (action); GClosure *accel_closure = NULL; if (strstr (name, "-menu") || strstr (name, "-popup") || name[0] == '<') continue; accel_closure = gtk_action_get_accel_closure (action); if (accel_closure) { GtkAccelKey *key = gtk_accel_group_find (accel_group, debug_accel_find_func, accel_closure); if (key && key->accel_key && key->accel_flags & GTK_ACCEL_VISIBLE) { const gchar *label_tmp; gchar *label; gchar *key_string; label_tmp = gtk_action_get_label (action); label = gimp_strip_uline (label_tmp); key_string = gtk_accelerator_get_label (key->accel_key, key->accel_mods); strings = g_list_prepend (strings, g_strdup_printf ("%-20s %s", key_string, label)); g_free (key_string); g_free (label); } } } g_list_free (actions); } /* Sort and prints the strings */ { GList *string_it = NULL; strings = g_list_sort (strings, (GCompareFunc) strcmp); for (string_it = strings; string_it; string_it = g_list_next (string_it)) { g_print ("%s\n", (gchar *) string_it->data); g_free (string_it->data); } g_list_free (strings); } }
static void gimp_color_picker_tool_info_create (GimpColorPickerTool *picker_tool) { GimpTool *tool = GIMP_TOOL (picker_tool); GimpDisplayShell *shell; GtkWidget *hbox; GtkWidget *frame; GimpRGB color; g_return_if_fail (tool->display != NULL); g_return_if_fail (tool->drawable != NULL); shell = gimp_display_get_shell (tool->display); picker_tool->gui = gimp_tool_gui_new (tool->tool_info, _("Color Picker Information"), gtk_widget_get_screen (GTK_WIDGET (shell)), gimp_widget_get_monitor (GTK_WIDGET (shell)), TRUE, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL); gimp_tool_gui_set_auto_overlay (picker_tool->gui, TRUE); gimp_tool_gui_set_focus_on_map (picker_tool->gui, FALSE); gimp_tool_gui_set_viewable (picker_tool->gui, GIMP_VIEWABLE (tool->drawable)); g_signal_connect (picker_tool->gui, "response", G_CALLBACK (gimp_color_picker_tool_info_response), picker_tool); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (gimp_tool_gui_get_vbox (picker_tool->gui)), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); picker_tool->color_frame1 = gimp_color_frame_new (); gimp_color_frame_set_mode (GIMP_COLOR_FRAME (picker_tool->color_frame1), GIMP_COLOR_FRAME_MODE_PIXEL); gtk_box_pack_start (GTK_BOX (hbox), picker_tool->color_frame1, FALSE, FALSE, 0); gtk_widget_show (picker_tool->color_frame1); picker_tool->color_frame2 = gimp_color_frame_new (); gimp_color_frame_set_mode (GIMP_COLOR_FRAME (picker_tool->color_frame2), GIMP_COLOR_FRAME_MODE_RGB); gtk_box_pack_start (GTK_BOX (hbox), picker_tool->color_frame2, FALSE, FALSE, 0); gtk_widget_show (picker_tool->color_frame2); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0); gtk_widget_show (frame); gimp_rgba_set (&color, 0.0, 0.0, 0.0, 0.0); picker_tool->color_area = gimp_color_area_new (&color, gimp_drawable_has_alpha (tool->drawable) ? GIMP_COLOR_AREA_LARGE_CHECKS : GIMP_COLOR_AREA_FLAT, GDK_BUTTON1_MASK | GDK_BUTTON2_MASK); gtk_widget_set_size_request (picker_tool->color_area, 48, -1); gtk_drag_dest_unset (picker_tool->color_area); gtk_container_add (GTK_CONTAINER (frame), picker_tool->color_area); gtk_widget_show (picker_tool->color_area); }
static void gimp_foreground_select_tool_oper_update (GimpTool *tool, const GimpCoords *coords, GdkModifierType state, gboolean proximity, GimpDisplay *display) { GimpForegroundSelectTool *fg_select = GIMP_FOREGROUND_SELECT_TOOL (tool); GimpForegroundSelectOptions *options = GIMP_FOREGROUND_SELECT_TOOL_GET_OPTIONS (fg_select); const gchar *status_stage = NULL; const gchar *status_mode = NULL; GimpDisplayShell *shell = gimp_display_get_shell (display); GimpImage *image = gimp_display_get_image (display); GIMP_TOOL_CLASS (parent_class)->oper_update (tool, coords, state, proximity, display); if (fg_select->state == MATTING_STATE_FREE_SELECT) { if (GIMP_SELECTION_TOOL (tool)->function == SELECTION_SELECT) status_stage = _("Roughly outline the object to extract"); } else { GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (tool); gimp_draw_tool_pause (draw_tool); fg_select->last_coords = *coords; gimp_draw_tool_resume (draw_tool); if (options->draw_mode == GIMP_MATTING_DRAW_MODE_FOREGROUND) status_mode = _("Selecting foreground, "); else if (options->draw_mode == GIMP_MATTING_DRAW_MODE_BACKGROUND) status_mode = _("Selecting background, "); else status_mode = _("Selecting unknown, "); if (fg_select->state == MATTING_STATE_PAINT_TRIMAP) status_stage = _("press Enter to preview."); else status_stage = _("press Escape to exit preview or Enter to apply."); } if (proximity && status_stage) { if (status_mode) gimp_tool_replace_status (tool, display, "%s%s", status_mode, status_stage); else gimp_tool_replace_status (tool, display, "%s", status_stage); } gimp_foreground_select_tool_update_gui (fg_select); gimp_tool_gui_set_shell (fg_select->gui, shell); gimp_tool_gui_set_viewable (fg_select->gui, GIMP_VIEWABLE (image)); gimp_tool_gui_show (fg_select->gui); }
void text_tool_load_cmd_callback (GtkAction *action, gpointer data) { GimpTextTool *text_tool = GIMP_TEXT_TOOL (data); GtkWidget *dialog; GtkWidget *parent = NULL; GtkFileChooser *chooser; dialog = g_object_get_data (G_OBJECT (text_tool), "gimp-text-file-dialog"); if (dialog) { gtk_window_present (GTK_WINDOW (dialog)); return; } if (GIMP_TOOL (text_tool)->display) { GimpDisplayShell *shell; shell = gimp_display_get_shell (GIMP_TOOL (text_tool)->display); parent = gtk_widget_get_toplevel (GTK_WIDGET (shell)); } dialog = gtk_file_chooser_dialog_new (_("Open Text File (UTF-8)"), parent ? GTK_WINDOW (parent) : NULL, GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL); chooser = GTK_FILE_CHOOSER (dialog); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); g_object_set_data (G_OBJECT (text_tool), "gimp-text-file-dialog", dialog); g_signal_connect (dialog, "destroy", G_CALLBACK (text_tool_load_dialog_destroyed), text_tool); gtk_window_set_role (GTK_WINDOW (chooser), "gimp-text-load-file"); gtk_window_set_position (GTK_WINDOW (chooser), GTK_WIN_POS_MOUSE); gtk_dialog_set_default_response (GTK_DIALOG (chooser), GTK_RESPONSE_OK); g_signal_connect (chooser, "response", G_CALLBACK (text_tool_load_dialog_response), text_tool); g_signal_connect (chooser, "delete-event", G_CALLBACK (gtk_true), NULL); gtk_widget_show (GTK_WIDGET (chooser)); }
static void gimp_color_tool_real_picked (GimpColorTool *color_tool, GimpColorPickState pick_state, const Babl *sample_format, const GimpRGB *color, gint color_index) { GimpTool *tool = GIMP_TOOL (color_tool); GimpContext *context; /* use this tool's own options here (NOT color_tool->options) */ context = GIMP_CONTEXT (gimp_tool_get_options (tool)); if (color_tool->pick_mode == GIMP_COLOR_PICK_MODE_FOREGROUND || color_tool->pick_mode == GIMP_COLOR_PICK_MODE_BACKGROUND) { GtkWidget *widget; if (babl_format_is_palette (sample_format)) { widget = gimp_dialog_factory_find_widget (gimp_dialog_factory_get_singleton (), "gimp-indexed-palette"); if (widget) { GimpColormapEditor *editor; editor = GIMP_COLORMAP_EDITOR (gtk_bin_get_child (GTK_BIN (widget))); gimp_colormap_editor_set_index (editor, color_index, NULL); } } if (TRUE) { widget = gimp_dialog_factory_find_widget (gimp_dialog_factory_get_singleton (), "gimp-palette-editor"); if (widget) { GimpPaletteEditor *editor; gint index; editor = GIMP_PALETTE_EDITOR (gtk_bin_get_child (GTK_BIN (widget))); index = gimp_palette_editor_get_index (editor, color); if (index != -1) gimp_palette_editor_set_index (editor, index, NULL); } } } switch (color_tool->pick_mode) { case GIMP_COLOR_PICK_MODE_NONE: break; case GIMP_COLOR_PICK_MODE_FOREGROUND: gimp_context_set_foreground (context, color); break; case GIMP_COLOR_PICK_MODE_BACKGROUND: gimp_context_set_background (context, color); break; case GIMP_COLOR_PICK_MODE_PALETTE: { GimpDisplayShell *shell = gimp_display_get_shell (tool->display); GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (shell)); GtkWidget *dockable; dockable = gimp_window_strategy_show_dockable_dialog (GIMP_WINDOW_STRATEGY (gimp_get_window_strategy (tool->display->gimp)), tool->display->gimp, gimp_dialog_factory_get_singleton (), screen, "gimp-palette-editor"); if (dockable) { GtkWidget *palette_editor; GimpData *data; /* don't blink like mad when updating */ if (pick_state == GIMP_COLOR_PICK_STATE_UPDATE) gimp_dockable_blink_cancel (GIMP_DOCKABLE (dockable)); palette_editor = gtk_bin_get_child (GTK_BIN (dockable)); data = gimp_data_editor_get_data (GIMP_DATA_EDITOR (palette_editor)); if (! data) { data = GIMP_DATA (gimp_context_get_palette (context)); gimp_data_editor_set_data (GIMP_DATA_EDITOR (palette_editor), data); } gimp_palette_editor_pick_color (GIMP_PALETTE_EDITOR (palette_editor), color, pick_state); } } break; } }
static void gui_restore_after_callback (Gimp *gimp, GimpInitStatusFunc status_callback) { GimpGuiConfig *gui_config = GIMP_GUI_CONFIG (gimp->config); GimpDisplay *display; if (gimp->be_verbose) g_print ("INIT: %s\n", G_STRFUNC); gimp->message_handler = GIMP_MESSAGE_BOX; if (gui_config->restore_accels) menus_restore (gimp); ui_configurer = g_object_new (GIMP_TYPE_UI_CONFIGURER, "gimp", gimp, NULL); image_ui_manager = gimp_menu_factory_manager_new (global_menu_factory, "<Image>", gimp, gui_config->tearoff_menus); gimp_ui_manager_update (image_ui_manager, gimp); #ifdef GDK_WINDOWING_QUARTZ { GtkosxApplication *osx_app; GtkWidget *menu; GtkWidget *item; osx_app = gtkosx_application_get (); menu = gtk_ui_manager_get_widget (GTK_UI_MANAGER (image_ui_manager), "/image-menubar"); if (GTK_IS_MENU_ITEM (menu)) menu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (menu)); gtkosx_application_set_menu_bar (osx_app, GTK_MENU_SHELL (menu)); gtkosx_application_set_use_quartz_accelerators (osx_app, FALSE); gui_add_to_app_menu (image_ui_manager, osx_app, "/image-menubar/Help/dialogs-about", 0); #define PREFERENCES "/image-menubar/Edit/Preferences/" gui_add_to_app_menu (image_ui_manager, osx_app, PREFERENCES "dialogs-preferences", 2); gui_add_to_app_menu (image_ui_manager, osx_app, PREFERENCES "dialogs-input-devices", 3); gui_add_to_app_menu (image_ui_manager, osx_app, PREFERENCES "dialogs-keyboard-shortcuts", 4); gui_add_to_app_menu (image_ui_manager, osx_app, PREFERENCES "dialogs-module-dialog", 5); gui_add_to_app_menu (image_ui_manager, osx_app, PREFERENCES "plug-in-unit-editor", 6); #undef PREFERENCES item = gtk_separator_menu_item_new (); gtkosx_application_insert_app_menu_item (osx_app, item, 7); item = gtk_ui_manager_get_widget (GTK_UI_MANAGER (image_ui_manager), "/image-menubar/File/file-quit"); gtk_widget_hide (item); g_signal_connect (osx_app, "NSApplicationBlockTermination", G_CALLBACK (gui_quartz_quit_callback), image_ui_manager); gtkosx_application_ready (osx_app); } #endif /* GDK_WINDOWING_QUARTZ */ g_signal_connect_object (gui_config, "notify::single-window-mode", G_CALLBACK (gui_single_window_mode_notify), ui_configurer, 0); g_signal_connect_object (gui_config, "notify::tearoff-menus", G_CALLBACK (gui_tearoff_menus_notify), image_ui_manager, 0); g_signal_connect (image_ui_manager, "show-tooltip", G_CALLBACK (gui_menu_show_tooltip), gimp); g_signal_connect (image_ui_manager, "hide-tooltip", G_CALLBACK (gui_menu_hide_tooltip), gimp); gimp_devices_restore (gimp); gimp_controllers_restore (gimp, image_ui_manager); if (status_callback == splash_update) splash_destroy (); color_history_restore (gimp); if (gimp_get_show_gui (gimp)) { GimpDisplayShell *shell; /* create the empty display */ display = GIMP_DISPLAY (gimp_create_display (gimp, NULL, GIMP_UNIT_PIXEL, 1.0)); shell = gimp_display_get_shell (display); if (gui_config->restore_session) session_restore (gimp); /* move keyboard focus to the display */ gtk_window_present (GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (shell)))); } /* indicate that the application has finished loading */ gdk_notify_startup_complete (); }
static void gimp_text_tool_ensure_proxy (GimpTextTool *text_tool) { GimpTool *tool = GIMP_TOOL (text_tool); GimpDisplayShell *shell = gimp_display_get_shell (tool->display); if (text_tool->offscreen_window && gtk_widget_get_screen (text_tool->offscreen_window) != gtk_widget_get_screen (GTK_WIDGET (shell))) { gtk_window_set_screen (GTK_WINDOW (text_tool->offscreen_window), gtk_widget_get_screen (GTK_WIDGET (shell))); gtk_window_move (GTK_WINDOW (text_tool->offscreen_window), -200, -200); } else if (! text_tool->offscreen_window) { text_tool->offscreen_window = gtk_window_new (GTK_WINDOW_POPUP); gtk_window_set_screen (GTK_WINDOW (text_tool->offscreen_window), gtk_widget_get_screen (GTK_WIDGET (shell))); gtk_window_move (GTK_WINDOW (text_tool->offscreen_window), -200, -200); gtk_widget_show (text_tool->offscreen_window); text_tool->proxy_text_view = gimp_text_proxy_new (); gtk_container_add (GTK_CONTAINER (text_tool->offscreen_window), text_tool->proxy_text_view); gtk_widget_show (text_tool->proxy_text_view); g_signal_connect_swapped (text_tool->proxy_text_view, "move-cursor", G_CALLBACK (gimp_text_tool_move_cursor), text_tool); g_signal_connect_swapped (text_tool->proxy_text_view, "insert-at-cursor", G_CALLBACK (gimp_text_tool_insert_at_cursor), text_tool); g_signal_connect_swapped (text_tool->proxy_text_view, "delete-from-cursor", G_CALLBACK (gimp_text_tool_delete_from_cursor), text_tool); g_signal_connect_swapped (text_tool->proxy_text_view, "backspace", G_CALLBACK (gimp_text_tool_backspace), text_tool); g_signal_connect_swapped (text_tool->proxy_text_view, "cut-clipboard", G_CALLBACK (gimp_text_tool_cut_clipboard), text_tool); g_signal_connect_swapped (text_tool->proxy_text_view, "copy-clipboard", G_CALLBACK (gimp_text_tool_copy_clipboard), text_tool); g_signal_connect_swapped (text_tool->proxy_text_view, "paste-clipboard", G_CALLBACK (gimp_text_tool_paste_clipboard), text_tool); g_signal_connect_swapped (text_tool->proxy_text_view, "toggle-overwrite", G_CALLBACK (gimp_text_tool_toggle_overwrite), text_tool); g_signal_connect_swapped (text_tool->proxy_text_view, "select-all", G_CALLBACK (gimp_text_tool_select_all), text_tool); g_signal_connect_swapped (text_tool->proxy_text_view, "change-size", G_CALLBACK (gimp_text_tool_change_size), text_tool); g_signal_connect_swapped (text_tool->proxy_text_view, "change-baseline", G_CALLBACK (gimp_text_tool_change_baseline), text_tool); g_signal_connect_swapped (text_tool->proxy_text_view, "change-kerning", G_CALLBACK (gimp_text_tool_change_kerning), text_tool); } }
static void gimp_source_tool_draw (GimpDrawTool *draw_tool) { GimpSourceTool *source_tool = GIMP_SOURCE_TOOL (draw_tool); GimpSourceOptions *options = GIMP_SOURCE_TOOL_GET_OPTIONS (draw_tool); GimpSourceCore *source; source = GIMP_SOURCE_CORE (GIMP_PAINT_TOOL (draw_tool)->core); GIMP_DRAW_TOOL_CLASS (parent_class)->draw (draw_tool); if (options->use_source && source->src_drawable && source_tool->src_display) { GimpDisplayShell *src_shell; gint off_x; gint off_y; src_shell = gimp_display_get_shell (source_tool->src_display); gimp_item_get_offset (GIMP_ITEM (source->src_drawable), &off_x, &off_y); if (source_tool->src_outline) { gimp_display_shell_remove_item (src_shell, source_tool->src_outline); source_tool->src_outline = NULL; } if (source_tool->show_source_outline) { source_tool->src_outline = gimp_brush_tool_create_outline (GIMP_BRUSH_TOOL (source_tool), source_tool->src_display, source_tool->src_x + off_x, source_tool->src_y + off_y, FALSE); if (source_tool->src_outline) { gimp_display_shell_add_item (src_shell, source_tool->src_outline); g_object_unref (source_tool->src_outline); } } if (! source_tool->src_handle) { source_tool->src_handle = gimp_canvas_handle_new (src_shell, GIMP_HANDLE_CROSS, GIMP_HANDLE_ANCHOR_CENTER, source_tool->src_x + off_x, source_tool->src_y + off_y, GIMP_TOOL_HANDLE_SIZE_CROSS, GIMP_TOOL_HANDLE_SIZE_CROSS); gimp_display_shell_add_item (src_shell, source_tool->src_handle); g_object_unref (source_tool->src_handle); } else { gimp_canvas_handle_set_position (source_tool->src_handle, source_tool->src_x + off_x, source_tool->src_y + off_y); } } }
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)); gimp_color_tool_pick (color_tool, GIMP_COLOR_PICK_STATE_END, coords->x, coords->y); } }
void gimp_display_shell_canvas_size_allocate (GtkWidget *widget, GtkAllocation *allocation, GimpDisplayShell *shell) { /* are we in destruction? */ if (! shell->display || ! gimp_display_get_shell (shell->display)) return; if ((shell->disp_width != allocation->width) || (shell->disp_height != allocation->height)) { if (shell->zoom_on_resize && shell->disp_width > 64 && shell->disp_height > 64 && allocation->width > 64 && allocation->height > 64) { gdouble scale = gimp_zoom_model_get_factor (shell->zoom); gint offset_x; gint offset_y; /* FIXME: The code is a bit of a mess */ /* multiply the zoom_factor with the ratio of the new and * old canvas diagonals */ scale *= (sqrt (SQR (allocation->width) + SQR (allocation->height)) / sqrt (SQR (shell->disp_width) + SQR (shell->disp_height))); offset_x = UNSCALEX (shell, shell->offset_x); offset_y = UNSCALEX (shell, shell->offset_y); gimp_zoom_model_zoom (shell->zoom, GIMP_ZOOM_TO, scale); shell->offset_x = SCALEX (shell, offset_x); shell->offset_y = SCALEY (shell, offset_y); } shell->disp_width = allocation->width; shell->disp_height = allocation->height; /* When we size-allocate due to resize of the top level window, * we want some additional logic. Don't apply it on * zoom_on_resize though. */ if (shell->size_allocate_from_configure_event && ! shell->zoom_on_resize) { gboolean center_horizontally; gboolean center_vertically; gint target_offset_x; gint target_offset_y; gint sw; gint sh; gimp_display_shell_scale_get_image_size (shell, &sw, &sh); center_horizontally = sw <= shell->disp_width; center_vertically = sh <= shell->disp_height; gimp_display_shell_scroll_center_image (shell, center_horizontally, center_vertically); /* This is basically the best we can do before we get an * API for storing the image offset at the start of an * image window resize using the mouse */ target_offset_x = shell->offset_x; target_offset_y = shell->offset_y; if (! center_horizontally) { target_offset_x = MAX (shell->offset_x, 0); } if (! center_vertically) { target_offset_y = MAX (shell->offset_y, 0); } gimp_display_shell_scroll_set_offset (shell, target_offset_x, target_offset_y); } gimp_display_shell_scroll_clamp_and_update (shell); gimp_display_shell_scaled (shell); /* Reset */ shell->size_allocate_from_configure_event = FALSE; } }
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); } }
gboolean gimp_draw_tool_on_handle (GimpDrawTool *draw_tool, GimpDisplay *display, gdouble x, gdouble y, GimpHandleType type, gdouble handle_x, gdouble handle_y, gint width, gint height, GimpHandleAnchor anchor) { GimpDisplayShell *shell; gdouble tx, ty; gdouble handle_tx, handle_ty; g_return_val_if_fail (GIMP_IS_DRAW_TOOL (draw_tool), FALSE); g_return_val_if_fail (GIMP_IS_DISPLAY (display), FALSE); shell = gimp_display_get_shell (display); gimp_display_shell_transform_xy_f (shell, x, y, &tx, &ty); gimp_display_shell_transform_xy_f (shell, handle_x, handle_y, &handle_tx, &handle_ty); switch (type) { case GIMP_HANDLE_SQUARE: case GIMP_HANDLE_FILLED_SQUARE: case GIMP_HANDLE_CROSS: gimp_canvas_item_shift_to_north_west (anchor, handle_tx, handle_ty, width, height, &handle_tx, &handle_ty); return (tx == CLAMP (tx, handle_tx, handle_tx + width) && ty == CLAMP (ty, handle_ty, handle_ty + height)); case GIMP_HANDLE_CIRCLE: case GIMP_HANDLE_FILLED_CIRCLE: gimp_canvas_item_shift_to_center (anchor, handle_tx, handle_ty, width, height, &handle_tx, &handle_ty); /* FIXME */ if (width != height) width = (width + height) / 2; width /= 2; return ((SQR (handle_tx - tx) + SQR (handle_ty - ty)) < SQR (width)); default: g_warning ("%s: invalid handle type %d", G_STRFUNC, type); break; } return FALSE; }
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_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_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_guide_tool_start (GimpTool *parent_tool, GimpDisplay *display, GimpGuide *guide, GimpOrientationType orientation) { GimpGuideTool *guide_tool; GimpTool *tool; guide_tool = g_object_new (GIMP_TYPE_GUIDE_TOOL, "tool-info", parent_tool->tool_info, NULL); tool = GIMP_TOOL (guide_tool); gimp_display_shell_selection_pause (gimp_display_get_shell (display)); if (guide) { guide_tool->guide = guide; guide_tool->guide_old_position = gimp_guide_get_position (guide); guide_tool->guide_position = gimp_guide_get_position (guide); guide_tool->guide_orientation = gimp_guide_get_orientation (guide); guide_tool->guide_custom = gimp_guide_is_custom (guide); } else { guide_tool->guide = NULL; guide_tool->guide_old_position = 0; guide_tool->guide_position = GIMP_GUIDE_POSITION_UNDEFINED; guide_tool->guide_orientation = orientation; guide_tool->guide_custom = FALSE; } gimp_tool_set_cursor (tool, display, GIMP_CURSOR_MOUSE, GIMP_TOOL_CURSOR_HAND, GIMP_CURSOR_MODIFIER_MOVE); tool_manager_push_tool (display->gimp, tool); tool->display = display; gimp_tool_control_activate (tool->control); gimp_draw_tool_start (GIMP_DRAW_TOOL (guide_tool), display); 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 gui_restore_after_callback (Gimp *gimp, GimpInitStatusFunc status_callback) { GimpGuiConfig *gui_config = GIMP_GUI_CONFIG (gimp->config); GimpDisplay *display; if (gimp->be_verbose) g_print ("INIT: %s\n", G_STRFUNC); gimp->message_handler = GIMP_MESSAGE_BOX; /* load the recent documents after gimp_real_restore() because we * need the mime-types implemented by plug-ins */ status_callback (NULL, _("Documents"), 0.9); gimp_recent_list_load (gimp); /* enable this to always have icons everywhere */ if (g_getenv ("GIMP_ICONS_LIKE_A_BOSS")) { GdkScreen *screen = gdk_screen_get_default (); g_object_set (G_OBJECT (gtk_settings_get_for_screen (screen)), "gtk-button-images", TRUE, "gtk-menu-images", TRUE, NULL); } if (gui_config->restore_accels) menus_restore (gimp); ui_configurer = g_object_new (GIMP_TYPE_UI_CONFIGURER, "gimp", gimp, NULL); image_ui_manager = gimp_menu_factory_manager_new (global_menu_factory, "<Image>", gimp, gui_config->tearoff_menus); gimp_ui_manager_update (image_ui_manager, gimp); gimp_action_history_init (gimp); #ifdef GDK_WINDOWING_QUARTZ { GtkosxApplication *osx_app; GtkWidget *menu; GtkWidget *item; osx_app = gtkosx_application_get (); menu = gtk_ui_manager_get_widget (GTK_UI_MANAGER (image_ui_manager), "/image-menubar"); if (GTK_IS_MENU_ITEM (menu)) menu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (menu)); gtkosx_application_set_menu_bar (osx_app, GTK_MENU_SHELL (menu)); gtkosx_application_set_use_quartz_accelerators (osx_app, FALSE); gui_add_to_app_menu (image_ui_manager, osx_app, "/image-menubar/Help/dialogs-about", 0); gui_add_to_app_menu (image_ui_manager, osx_app, "/image-menubar/Help/dialogs-search-action", 1); #define PREFERENCES "/image-menubar/Edit/Preferences/" gui_add_to_app_menu (image_ui_manager, osx_app, PREFERENCES "dialogs-preferences", 3); gui_add_to_app_menu (image_ui_manager, osx_app, PREFERENCES "dialogs-input-devices", 4); gui_add_to_app_menu (image_ui_manager, osx_app, PREFERENCES "dialogs-keyboard-shortcuts", 5); gui_add_to_app_menu (image_ui_manager, osx_app, PREFERENCES "dialogs-module-dialog", 6); gui_add_to_app_menu (image_ui_manager, osx_app, PREFERENCES "plug-in-unit-editor", 7); #undef PREFERENCES item = gtk_separator_menu_item_new (); gtkosx_application_insert_app_menu_item (osx_app, item, 8); item = gtk_ui_manager_get_widget (GTK_UI_MANAGER (image_ui_manager), "/image-menubar/File/file-quit"); gtk_widget_hide (item); g_signal_connect (osx_app, "NSApplicationBlockTermination", G_CALLBACK (gui_quartz_quit_callback), image_ui_manager); gtkosx_application_ready (osx_app); } #endif /* GDK_WINDOWING_QUARTZ */ g_signal_connect_object (gui_config, "notify::single-window-mode", G_CALLBACK (gui_single_window_mode_notify), ui_configurer, 0); g_signal_connect_object (gui_config, "notify::tearoff-menus", G_CALLBACK (gui_tearoff_menus_notify), image_ui_manager, 0); g_signal_connect (image_ui_manager, "show-tooltip", G_CALLBACK (gui_menu_show_tooltip), gimp); g_signal_connect (image_ui_manager, "hide-tooltip", G_CALLBACK (gui_menu_hide_tooltip), gimp); gimp_devices_restore (gimp); gimp_controllers_restore (gimp, image_ui_manager); if (status_callback == splash_update) splash_destroy (); color_history_restore (gimp); if (gimp_get_show_gui (gimp)) { GimpDisplayShell *shell; GtkWidget *toplevel; /* create the empty display */ display = GIMP_DISPLAY (gimp_create_display (gimp, NULL, GIMP_UNIT_PIXEL, 1.0, G_OBJECT (initial_screen), initial_monitor)); shell = gimp_display_get_shell (display); if (gui_config->restore_session) session_restore (gimp, initial_screen, initial_monitor); /* move keyboard focus to the display */ toplevel = gtk_widget_get_toplevel (GTK_WIDGET (shell)); gtk_window_present (GTK_WINDOW (toplevel)); } /* indicate that the application has finished loading */ gdk_notify_startup_complete (); /* clear startup monitor variables */ initial_screen = NULL; initial_monitor = -1; }
static void gimp_seamless_clone_tool_filter_update (GimpSeamlessCloneTool *sc) { GimpTool *tool = GIMP_TOOL (sc); GimpDisplayShell *shell = gimp_display_get_shell (tool->display); GimpItem *item = GIMP_ITEM (tool->drawable); gint x, y; gint w, h; gint off_x, off_y; GeglRectangle visible; GeglOperation *op = NULL; GimpProgress *progress; GeglNode *output; GeglProcessor *processor; gdouble value; progress = gimp_progress_start (GIMP_PROGRESS (sc), FALSE, _("Cloning the foreground object")); /* Find out at which x,y is the top left corner of the currently * displayed part */ gimp_display_shell_untransform_viewport (shell, &x, &y, &w, &h); /* Find out where is our drawable positioned */ gimp_item_get_offset (item, &off_x, &off_y); /* Create a rectangle from the intersection of the currently displayed * part with the drawable */ gimp_rectangle_intersect (x, y, w, h, off_x, off_y, gimp_item_get_width (item), gimp_item_get_height (item), &visible.x, &visible.y, &visible.width, &visible.height); /* Since the filter_apply function receives a rectangle describing * where it should update the preview, and since that rectangle should * be relative to the drawable's location, we now offset back by the * drawable's offsetts. */ visible.x -= off_x; visible.y -= off_y; g_object_get (sc->sc_node, "gegl-operation", &op, NULL); /* If any cache of the visible area was present, clear it! * We need to clear the cache in the sc_node, since that is * where the previous paste was located */ gegl_operation_invalidate (op, &visible, TRUE); g_object_unref (op); /* Now update the image map and show this area */ gimp_drawable_filter_apply (sc->filter, NULL); /* Show update progress. */ output = gegl_node_get_output_proxy (sc->render_node, "output"); processor = gegl_node_new_processor (output, NULL); while (gegl_processor_work (processor, &value)) { if (progress) gimp_progress_set_value (progress, value); } if (progress) gimp_progress_end (progress); g_object_unref (processor); }
static void gimp_paint_tool_button_press (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpButtonPressType press_type, GimpDisplay *display) { GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (tool); GimpPaintTool *paint_tool = GIMP_PAINT_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); GimpCoords curr_coords; gint off_x, off_y; GError *error = NULL; if (gimp_color_tool_is_enabled (GIMP_COLOR_TOOL (tool))) { GIMP_TOOL_CLASS (parent_class)->button_press (tool, coords, time, state, press_type, display); return; } if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable))) { gimp_tool_message_literal (tool, display, _("Cannot paint on layer groups.")); return; } if (gimp_item_is_content_locked (GIMP_ITEM (drawable))) { gimp_tool_message_literal (tool, display, _("The active layer's pixels are locked.")); return; } if (! gimp_item_is_visible (GIMP_ITEM (drawable))) { gimp_tool_message_literal (tool, display, _("The active layer is not visible.")); return; } curr_coords = *coords; gimp_item_get_offset (GIMP_ITEM (drawable), &off_x, &off_y); curr_coords.x -= off_x; curr_coords.y -= off_y; if (gimp_draw_tool_is_active (draw_tool)) gimp_draw_tool_stop (draw_tool); 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 (! gimp_paint_core_start (core, drawable, paint_options, &curr_coords, &error)) { gimp_tool_message_literal (tool, display, error->message); g_clear_error (&error); return; } if ((display != tool->display) || ! paint_tool->draw_line) { /* if this is a new display, resest the "last stroke's endpoint" * because there is none */ if (display != tool->display) core->start_coords = core->cur_coords; core->last_coords = core->cur_coords; core->distance = 0.0; core->pixel_dist = 0.0; } else if (paint_tool->draw_line) { gboolean constrain = (state & gimp_get_constrain_behavior_mask ()) != 0; /* If shift is down and this is not the first paint * stroke, then draw a line from the last coords to the pointer */ gimp_paint_core_round_line (core, paint_options, constrain); } /* chain up to activate the tool */ GIMP_TOOL_CLASS (parent_class)->button_press (tool, coords, time, state, press_type, display); /* pause the current selection */ gimp_display_shell_selection_pause (shell); /* Let the specific painting function initialize itself */ gimp_paint_core_paint (core, drawable, paint_options, GIMP_PAINT_STATE_INIT, time); /* Paint to the image */ if (paint_tool->draw_line) { gimp_paint_core_interpolate (core, drawable, paint_options, &core->cur_coords, time); } else { gimp_paint_core_paint (core, drawable, paint_options, GIMP_PAINT_STATE_MOTION, time); } gimp_projection_flush_now (gimp_image_get_projection (image)); gimp_display_flush_now (display); gimp_draw_tool_start (draw_tool, display); }
/* 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)); }
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); }
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_operation_tool_add_gui (GimpOperationTool *op_tool) { GtkSizeGroup *size_group = NULL; GtkWidget *options_gui; GtkWidget *options_box; GtkWidget *options_sw; GtkWidget *shell; GdkRectangle workarea; GtkRequisition minimum; GList *list; gboolean scrolling; options_gui = g_weak_ref_get (&op_tool->options_gui_ref); options_box = g_weak_ref_get (&op_tool->options_box_ref); options_sw = g_weak_ref_get (&op_tool->options_sw_ref); g_return_if_fail (options_gui && options_box && options_sw); for (list = op_tool->aux_inputs; list; list = g_list_next (list)) { AuxInput *input = list->data; GtkWidget *toggle; if (! size_group) size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); toggle = gimp_buffer_source_box_get_toggle (GIMP_BUFFER_SOURCE_BOX (input->box)); gtk_size_group_add_widget (size_group, toggle); gtk_box_pack_start (GTK_BOX (options_box), input->box, FALSE, FALSE, 0); gtk_widget_show (input->box); } if (size_group) g_object_unref (size_group); gtk_box_pack_start (GTK_BOX (options_box), options_gui, TRUE, TRUE, 0); gtk_widget_show (options_gui); shell = GTK_WIDGET (gimp_display_get_shell (GIMP_TOOL (op_tool)->display)); gdk_monitor_get_workarea (gimp_widget_get_monitor (shell), &workarea); gtk_widget_get_preferred_size (options_box, &minimum, NULL); scrolling = minimum.height > workarea.height / 2; gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (options_sw), GTK_POLICY_NEVER, scrolling ? GTK_POLICY_AUTOMATIC : GTK_POLICY_NEVER); if (scrolling) gtk_widget_set_size_request (options_sw, -1, workarea.height / 2); else gtk_widget_set_size_request (options_sw, -1, -1); g_object_unref (options_gui); g_object_unref (options_box); g_object_unref (options_sw); }