/* The GIMP -- an image manipulation program * Copyright (C) 1995 Spencer Kimball and Peter Mattis * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "config.h" #include #include "appenv.h" #include "app_procs.h" #include "color_area.h" #include "commands.h" #include "devices.h" #include "dialog_handler.h" #include "disp_callbacks.h" #include "fileops.h" #include "gdisplay.h" #include "gdisplay_ops.h" #include "gimage.h" #include "gimpdnd.h" #include "gimphelp.h" #include "gimprc.h" #include "gimpui.h" #include "gtkhwrapbox.h" #include "gtkvwrapbox.h" #include "indicator_area.h" #include "interface.h" #include "menus.h" #include "nav_window.h" #include "qmask.h" #include "session.h" #include "tools.h" #include "pixmaps.h" #include "pixmaps/qmasksel.xpm" #include "pixmaps/qmasknosel.xpm" #include "pixmaps/navbutton.xpm" #include "libgimp/gimpintl.h" /* local functions */ static void tools_select_update (GtkWidget *widget, gpointer data); static gint tools_button_press (GtkWidget *widget, GdkEventButton *bevent, gpointer data); static void gdisplay_destroy (GtkWidget *widget, GDisplay *display); static gint gdisplay_delete (GtkWidget *widget, GdkEvent *event, GDisplay *display); static void toolbox_destroy (void); static gint toolbox_delete (GtkWidget *widget, GdkEvent *event, gpointer data); static gint toolbox_check_device (GtkWidget *widget, GdkEvent *event, gpointer data); static GdkPixmap *create_pixmap (GdkWindow *parent, GdkBitmap **mask, gchar **data, gint width, gint height); static void toolbox_set_drag_dest (GtkWidget *); static void toolbox_drag_data_received (GtkWidget *, GdkDragContext *, gint, gint, GtkSelectionData *, guint, guint); static gboolean toolbox_drag_drop (GtkWidget *, GdkDragContext *, gint, gint, guint); static ToolType toolbox_drag_tool (GtkWidget *, gpointer); static void toolbox_drop_tool (GtkWidget *, ToolType, gpointer); static void gimp_dnd_open_files (gchar *); static int pixmap_colors[8][3] = { { 0x00, 0x00, 0x00 }, /* a - 0 */ { 0x24, 0x24, 0x24 }, /* b - 36 */ { 0x49, 0x49, 0x49 }, /* c - 73 */ { 0x6D, 0x6D, 0x6D }, /* d - 109 */ { 0x92, 0x92, 0x92 }, /* e - 146 */ { 0xB6, 0xB6, 0xB6 }, /* f - 182 */ { 0xDB, 0xDB, 0xDB }, /* g - 219 */ { 0xFF, 0xFF, 0xFF }, /* h - 255 */ }; #define COLUMNS 3 #define ROWS 8 #define MARGIN 2 /* local variables */ static GdkColor colors[11]; static GtkWidget * toolbox_shell = NULL; static GtkTargetEntry toolbox_target_table[] = { GIMP_TARGET_URI_LIST, GIMP_TARGET_TEXT_PLAIN, GIMP_TARGET_NETSCAPE_URL, GIMP_TARGET_LAYER, GIMP_TARGET_CHANNEL, GIMP_TARGET_LAYER_MASK, GIMP_TARGET_TOOL }; static guint toolbox_n_targets = (sizeof (toolbox_target_table) / sizeof (toolbox_target_table[0])); static GtkTargetEntry tool_target_table[] = { GIMP_TARGET_TOOL }; static guint tool_n_targets = (sizeof (tool_target_table) / sizeof (tool_target_table[0])); static GtkTargetEntry display_target_table[] = { GIMP_TARGET_LAYER, GIMP_TARGET_CHANNEL, GIMP_TARGET_LAYER_MASK, GIMP_TARGET_COLOR, GIMP_TARGET_PATTERN }; static guint display_n_targets = (sizeof (display_target_table) / sizeof (display_target_table[0])); static void tools_select_update (GtkWidget *widget, gpointer data) { ToolType tool_type; tool_type = (ToolType) data; if ((tool_type != -1) && GTK_TOGGLE_BUTTON (widget)->active) gimp_context_set_tool (gimp_context_get_user (), tool_type); } static gint tools_button_press (GtkWidget *widget, GdkEventButton *event, gpointer data) { GDisplay * gdisp; gdisp = data; if ((event->type == GDK_2BUTTON_PRESS) && (event->button == 1)) tool_options_dialog_show (); return FALSE; } static gint toolbox_delete (GtkWidget *widget, GdkEvent *event, gpointer data) { app_exit (FALSE); return TRUE; } static void toolbox_destroy (void) { app_exit_finish (); } static gint toolbox_check_device (GtkWidget *widget, GdkEvent *event, gpointer data) { devices_check_change (event); return FALSE; } static void gdisplay_destroy (GtkWidget *widget, GDisplay *gdisp) { gdisplay_remove_and_delete (gdisp); } static gint gdisplay_delete (GtkWidget *widget, GdkEvent *event, GDisplay *gdisp) { gdisplay_close_window (gdisp, FALSE); return TRUE; } static void allocate_colors (GtkWidget *parent) { GdkColormap *colormap; gint i; gtk_widget_realize (parent); colormap = gdk_window_get_colormap (parent->window); for (i = 0; i < 8; i++) { colors[i].red = pixmap_colors[i][0] << 8; colors[i].green = pixmap_colors[i][1] << 8; colors[i].blue = pixmap_colors[i][2] << 8; gdk_color_alloc (colormap, &colors[i]); } colors[8] = parent->style->bg[GTK_STATE_NORMAL]; gdk_color_alloc (colormap, &colors[8]); colors[9] = parent->style->bg[GTK_STATE_ACTIVE]; gdk_color_alloc (colormap, &colors[9]); colors[10] = parent->style->bg[GTK_STATE_PRELIGHT]; gdk_color_alloc (colormap, &colors[10]); } static void create_indicator_area (GtkWidget *parent) { GtkWidget *frame; GtkWidget *alignment; GtkWidget *ind_area; gtk_widget_realize (parent); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT); gtk_wrap_box_pack (GTK_WRAP_BOX (parent), frame, FALSE, TRUE, FALSE, TRUE); gtk_widget_realize (frame); alignment = gtk_alignment_new (0.5, 0.5, 0.0, 0.0); gtk_container_set_border_width (GTK_CONTAINER (alignment), 3); gtk_container_add (GTK_CONTAINER (frame), alignment); gimp_help_set_help_data (alignment, NULL, "#indicator_area"); ind_area = indicator_area_create (); gtk_container_add (GTK_CONTAINER (alignment), ind_area); gtk_widget_show (ind_area); gtk_widget_show (alignment); gtk_widget_show (frame); } static void create_color_area (GtkWidget *parent) { GtkWidget *frame; GtkWidget *alignment; GtkWidget *col_area; GdkPixmap *default_pixmap; GdkPixmap *swap_pixmap; gtk_widget_realize (parent); default_pixmap = create_pixmap (parent->window, NULL, default_bits, default_width, default_height); swap_pixmap = create_pixmap (parent->window, NULL, swap_bits, swap_width, swap_height); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT); gtk_wrap_box_pack (GTK_WRAP_BOX (parent), frame, FALSE, TRUE, FALSE, TRUE); gtk_widget_realize (frame); alignment = gtk_alignment_new (0.5, 0.5, 0.0, 0.0); gtk_container_set_border_width (GTK_CONTAINER (alignment), 3); gtk_container_add (GTK_CONTAINER (frame), alignment); gimp_help_set_help_data (alignment, NULL, "#color_area"); col_area = color_area_create (54, 42, default_pixmap, swap_pixmap); gtk_container_add (GTK_CONTAINER (alignment), col_area); gimp_help_set_help_data (col_area, _("Foreground & background colors. The black " "and white squares reset colors. The arrows swap colors. Double " "click to select a color from a colorrequester."), NULL); gtk_widget_show (col_area); gtk_widget_show (alignment); gtk_widget_show (frame); } GdkPixmap * create_tool_pixmap (GtkWidget *parent, ToolType type) { /* * FIXME this really should be dones without using the #defined tool names * but it should work this way for now */ if (type == SCALE || type == SHEAR || type == PERSPECTIVE) type = ROTATE; if (tool_info[(int) type].icon_data) return create_pixmap (parent->window, NULL, tool_info[(int) type].icon_data, 22, 22); else return create_pixmap (parent->window, NULL, dialog_bits, 22, 22); g_return_val_if_fail (FALSE, NULL); return NULL; /* not reached */ } static void create_tools (GtkWidget *parent) { GtkWidget *wbox; GtkWidget *button; GtkWidget *alignment; GtkWidget *pixmap; GSList *group; gint i, j; /*create_logo (parent);*/ wbox = gtk_hwrap_box_new (FALSE); gtk_wrap_box_set_aspect_ratio (GTK_WRAP_BOX (wbox), .36); gtk_container_set_border_width (GTK_CONTAINER (wbox), 0); gtk_wrap_box_pack (GTK_WRAP_BOX (parent), wbox, TRUE, TRUE, TRUE, TRUE); gtk_widget_realize (gtk_widget_get_toplevel (wbox)); group = NULL; i = 0; for (j = 0; j < num_tools; j++) { if (tool_info[j].icon_data) { tool_info[j].tool_widget = button = gtk_radio_button_new (group); gtk_container_set_border_width (GTK_CONTAINER (button), 0); group = gtk_radio_button_group (GTK_RADIO_BUTTON (button)); gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (button), FALSE); gtk_wrap_box_pack (GTK_WRAP_BOX (wbox), button, FALSE, TRUE, FALSE, TRUE); alignment = gtk_alignment_new (0.5, 0.5, 0.0, 0.0); gtk_container_set_border_width (GTK_CONTAINER (alignment), 0); gtk_container_add (GTK_CONTAINER (button), alignment); pixmap = create_pixmap_widget (wbox->window, tool_info[j].icon_data, 22, 22); gtk_container_add (GTK_CONTAINER (alignment), pixmap); gtk_signal_connect (GTK_OBJECT (button), "toggled", GTK_SIGNAL_FUNC (tools_select_update), (gpointer) tool_info[j].tool_id); gtk_signal_connect (GTK_OBJECT (button), "button_press_event", GTK_SIGNAL_FUNC (tools_button_press), (gpointer) tool_info[j].tool_id); /* dnd stuff */ gtk_drag_source_set (tool_info[j].tool_widget, GDK_BUTTON2_MASK, tool_target_table, tool_n_targets, GDK_ACTION_COPY); gimp_dnd_tool_source_set (tool_info[j].tool_widget, toolbox_drag_tool, (gpointer) j); gimp_help_set_help_data (button, gettext(tool_info[j].tool_desc), tool_info[j].private_tip); gtk_widget_show (pixmap); gtk_widget_show (alignment); gtk_widget_show (button); i++; } else { tool_info[j].tool_widget = button = gtk_radio_button_new (group); group = gtk_radio_button_group (GTK_RADIO_BUTTON (button)); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (tools_select_update), (gpointer) tool_info[j].tool_id); } } gtk_widget_show (wbox); } static GdkPixmap * create_pixmap (GdkWindow *parent, GdkBitmap **mask, gchar **data, gint width, gint height) { GdkPixmap *pixmap; GdkImage *image; GdkGC *gc; GdkVisual *visual; GdkColormap *cmap; gint r, s, t, cnt; guchar *mem; guchar value; guint32 pixel; visual = gdk_window_get_visual (parent); cmap = gdk_window_get_colormap (parent); image = gdk_image_new (GDK_IMAGE_NORMAL, visual, width, height); pixmap = gdk_pixmap_new (parent, width, height, -1); gc = NULL; if (mask) { GdkColor tmp_color; *mask = gdk_pixmap_new (parent, width, height, 1); gc = gdk_gc_new (*mask); gdk_draw_rectangle (*mask, gc, TRUE, 0, 0, -1, -1); tmp_color.pixel = 1; gdk_gc_set_foreground (gc, &tmp_color); } for (r = 0; r < height; r++) { mem = image->mem; mem += image->bpl * r; for (s = 0, cnt = 0; s < width; s++) { value = data[r][s]; if (value == '.') { pixel = colors[8].pixel; if (mask) { if (cnt < s) gdk_draw_line (*mask, gc, cnt, r, s - 1, r); cnt = s + 1; } } else { pixel = colors[value - 'a'].pixel; } if (image->byte_order == GDK_LSB_FIRST) { for (t = 0; t < image->bpp; t++) *mem++ = (unsigned char) ((pixel >> (t * 8)) & 0xFF); } else { for (t = 0; t < image->bpp; t++) *mem++ = (unsigned char) ((pixel >> ((image->bpp - t - 1) * 8)) & 0xFF); } } if (mask && (cnt < s)) gdk_draw_line (*mask, gc, cnt, r, s - 1, r); } if (mask) gdk_gc_destroy (gc); gc = gdk_gc_new (parent); gdk_draw_image (pixmap, gc, image, 0, 0, 0, 0, width, height); gdk_gc_destroy (gc); gdk_image_destroy (image); return pixmap; } GtkWidget* create_pixmap_widget (GdkWindow *parent, gchar **data, gint width, gint height) { GdkPixmap *pixmap; GdkBitmap *mask; pixmap = create_pixmap (parent, &mask, data, width, height); return gtk_pixmap_new (pixmap, mask); } void create_toolbox (void) { GtkWidget *window; GtkWidget *main_vbox; GtkWidget *wbox; GtkWidget *menubar; GList *list; GtkAccelGroup *table; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); /* Register dialog */ dialog_register_toolbox (window); gtk_window_set_wmclass (GTK_WINDOW (window), "toolbox", "Gimp"); gtk_window_set_title (GTK_WINDOW (window), _("The GIMP")); gtk_window_set_policy (GTK_WINDOW (window), TRUE, TRUE, FALSE); session_set_window_geometry (window, &toolbox_session_info, TRUE); gtk_signal_connect (GTK_OBJECT (window), "delete_event", GTK_SIGNAL_FUNC (toolbox_delete), NULL); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC (toolbox_destroy), NULL); /* We need to know when the current device changes, so we can update * the correct tool - to do this we connect to motion events. * We can't just use EXTENSION_EVENTS_CURSOR though, since that * would get us extension events for the mouse pointer, and our * device would change to that and not change back. So we check * manually that all devices have a cursor, before establishing the check. */ for (list = gdk_input_list_devices (); list; list = g_list_next (list)) { if (!((GdkDeviceInfo *) (list->data))->has_cursor) break; } if (!list) /* all devices have cursor */ { gtk_signal_connect (GTK_OBJECT (window), "motion_notify_event", GTK_SIGNAL_FUNC (toolbox_check_device), NULL); gtk_widget_set_events (window, GDK_POINTER_MOTION_MASK); gtk_widget_set_extension_events (window, GDK_EXTENSION_EVENTS_CURSOR); } main_vbox = gtk_vbox_new (FALSE, 1); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 1); gtk_container_add (GTK_CONTAINER (window), main_vbox); gtk_widget_show (main_vbox); /* allocate the colors for creating pixmaps */ allocate_colors (main_vbox); /* tooltips */ gimp_help_init (); if (!show_tool_tips) gimp_help_disable_tooltips (); /* Build the menu bar with menus */ menus_get_toolbox_menubar (&menubar, &table); gtk_box_pack_start (GTK_BOX (main_vbox), menubar, FALSE, TRUE, 0); gtk_widget_show (menubar); /* Install the accelerator table in the main window */ gtk_window_add_accel_group (GTK_WINDOW (window), table); /* Connect the "F1" help key */ gimp_help_connect_help_accel (window, gimp_standard_help_func, "toolbox/toolbox.html"); wbox = gtk_vwrap_box_new (FALSE); gtk_wrap_box_set_justify (GTK_WRAP_BOX (wbox), GTK_JUSTIFY_FILL); gtk_container_set_border_width (GTK_CONTAINER (wbox), 0); gtk_box_pack_start (GTK_BOX (main_vbox), wbox, TRUE, TRUE, 0); gtk_widget_show (wbox); create_tools (wbox); create_color_area (wbox); if (show_indicators) create_indicator_area (wbox); gtk_widget_show (window); toolbox_set_drag_dest (window); toolbox_shell = window; } void toolbox_free (void) { gint i; session_get_window_info (toolbox_shell, &toolbox_session_info); gtk_widget_destroy (toolbox_shell); for (i = 0; i < num_tools; i++) { if (!tool_info[i].icon_data) gtk_object_sink (GTK_OBJECT (tool_info[i].tool_widget)); } gimp_help_free (); } void toolbox_raise_callback (GtkWidget *widget, gpointer client_data) { gdk_window_raise (toolbox_shell->window); } void create_display_shell (GDisplay* gdisp, gint width, gint height, gchar *title, gint type) { static GtkWidget *image_popup_menu = NULL; static GtkAccelGroup *image_accel_group = NULL; GtkWidget *vbox; GtkWidget *table; GtkWidget *table_inner; GtkWidget *table_lower; GtkWidget *frame; GtkWidget *arrow; GtkWidget *pixmap; GtkWidget *evbox; GtkWidget *navhbox; GSList *group = NULL; gint n_width, n_height; gint s_width, s_height; gint scalesrc, scaledest; gint contextid; { /* adjust the initial scale -- so that window fits on screen */ s_width = gdk_screen_width (); s_height = gdk_screen_height (); scalesrc = SCALESRC (gdisp); scaledest = SCALEDEST (gdisp); n_width = SCALEX (gdisp, width); n_height = SCALEX (gdisp, height); /* Limit to the size of the screen... */ while (n_width > s_width || n_height > s_height) { if (scaledest > 1) scaledest--; else if (scalesrc < 0xff) scalesrc++; n_width = width * (scaledest * SCREEN_XRES (gdisp)) / (scalesrc * gdisp->gimage->xresolution); n_height = height * (scaledest * SCREEN_XRES (gdisp)) / (scalesrc * gdisp->gimage->xresolution); } gdisp->scale = (scaledest << 8) + scalesrc; } /* The adjustment datums */ gdisp->hsbdata = GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, width, 1, 1, width)); gdisp->vsbdata = GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, height, 1, 1, height)); /* The toplevel shell */ gdisp->shell = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_widget_ref (gdisp->shell); gtk_window_set_title (GTK_WINDOW (gdisp->shell), title); gtk_window_set_wmclass (GTK_WINDOW (gdisp->shell), "image_window", "Gimp"); gtk_window_set_policy (GTK_WINDOW (gdisp->shell), TRUE, TRUE, TRUE); gtk_object_set_user_data (GTK_OBJECT (gdisp->shell), (gpointer) gdisp); gtk_widget_set_events (gdisp->shell, GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK); gtk_signal_connect (GTK_OBJECT (gdisp->shell), "delete_event", GTK_SIGNAL_FUNC (gdisplay_delete), gdisp); gtk_signal_connect (GTK_OBJECT (gdisp->shell), "destroy", GTK_SIGNAL_FUNC (gdisplay_destroy), gdisp); /* active display callback */ gtk_signal_connect (GTK_OBJECT (gdisp->shell), "button_press_event", GTK_SIGNAL_FUNC (gdisplay_shell_events), gdisp); gtk_signal_connect (GTK_OBJECT (gdisp->shell), "key_press_event", GTK_SIGNAL_FUNC (gdisplay_shell_events), gdisp); /* dnd stuff */ gtk_drag_dest_set (gdisp->shell, GTK_DEST_DEFAULT_ALL, display_target_table, display_n_targets, GDK_ACTION_COPY); gtk_signal_connect (GTK_OBJECT (gdisp->shell), "drag_drop", GTK_SIGNAL_FUNC (gdisplay_drag_drop), gdisp); gimp_dnd_color_dest_set (gdisp->shell, gdisplay_drop_color, gdisp); gimp_dnd_pattern_dest_set (gdisp->shell, gdisplay_drop_pattern, gdisp); /* the vbox, table containing all widgets */ vbox = gtk_vbox_new (FALSE, 2); gtk_container_add (GTK_CONTAINER (gdisp->shell), vbox); gtk_container_set_border_width (GTK_CONTAINER (vbox), 2); /* the table widget is pretty stupid so we need 2 tables or it treats rulers and canvas with equal weight when allocating space, ugh. */ table = gtk_table_new (2, 2, FALSE); gtk_table_set_col_spacing (GTK_TABLE (table), 0, 1); gtk_table_set_row_spacing (GTK_TABLE (table), 0, 1); gtk_box_pack_start(GTK_BOX (vbox), table, TRUE, TRUE, 0); table_inner = gtk_table_new (2, 2, FALSE); gtk_table_set_col_spacing (GTK_TABLE (table_inner), 0, 1); gtk_table_set_row_spacing (GTK_TABLE (table_inner), 0, 1); table_lower = gtk_table_new (1,4,FALSE); gtk_table_set_col_spacing (GTK_TABLE (table_lower), 0, 1); /* gtk_table_set_row_spacing (GTK_TABLE (table_lower), 0, 1); */ /* hbox for statusbar area */ evbox = gtk_event_box_new (); gtk_box_pack_start (GTK_BOX (vbox), evbox, FALSE, TRUE, 0); gtk_widget_show (evbox); gimp_help_set_help_data (evbox, NULL, "#status_area"); gdisp->statusarea = gtk_hbox_new (FALSE, 2); gtk_container_add (GTK_CONTAINER (evbox), gdisp->statusarea); /* scrollbars, rulers, canvas, menu popup button */ gdisp->origin = gtk_button_new (); GTK_WIDGET_UNSET_FLAGS (gdisp->origin, GTK_CAN_FOCUS); gtk_widget_set_events (GTK_WIDGET (gdisp->origin), GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK); gtk_signal_connect (GTK_OBJECT (gdisp->origin), "button_press_event", GTK_SIGNAL_FUNC (gdisplay_origin_button_press), gdisp); gimp_help_set_help_data (gdisp->origin, NULL, "#origin_button"); arrow = gtk_arrow_new (GTK_ARROW_RIGHT, GTK_SHADOW_OUT); gtk_container_set_border_width (GTK_CONTAINER (gdisp->origin), 0); gtk_container_add (GTK_CONTAINER (gdisp->origin), arrow); gdisp->hrule = gtk_hruler_new (); gtk_widget_set_events (GTK_WIDGET (gdisp->hrule), GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK); gtk_signal_connect_object (GTK_OBJECT (gdisp->shell), "motion_notify_event", GTK_SIGNAL_FUNC (GTK_WIDGET_CLASS (GTK_OBJECT (gdisp->hrule)->klass)->motion_notify_event), GTK_OBJECT (gdisp->hrule)); gtk_signal_connect (GTK_OBJECT (gdisp->hrule), "button_press_event", GTK_SIGNAL_FUNC (gdisplay_hruler_button_press), gdisp); gimp_help_set_help_data (gdisp->hrule, NULL, "#ruler"); gdisp->vrule = gtk_vruler_new (); gtk_widget_set_events (GTK_WIDGET (gdisp->vrule), GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK); gtk_signal_connect_object (GTK_OBJECT (gdisp->shell), "motion_notify_event", GTK_SIGNAL_FUNC (GTK_WIDGET_CLASS (GTK_OBJECT (gdisp->vrule)->klass)->motion_notify_event), GTK_OBJECT (gdisp->vrule)); gtk_signal_connect (GTK_OBJECT (gdisp->vrule), "button_press_event", GTK_SIGNAL_FUNC (gdisplay_vruler_button_press), gdisp); gimp_help_set_help_data (gdisp->vrule, NULL, "#ruler"); /* The nav window button */ evbox = gtk_event_box_new (); gtk_widget_show (evbox); navhbox = gtk_hbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (evbox), navhbox); GTK_WIDGET_UNSET_FLAGS (evbox, GTK_CAN_FOCUS); gtk_signal_connect (GTK_OBJECT (evbox), "button_press_event", GTK_SIGNAL_FUNC (nav_popup_click_handler), gdisp); gimp_help_set_help_data (evbox, NULL, "#nav_window_button"); gdisp->hsb = gtk_hscrollbar_new (gdisp->hsbdata); GTK_WIDGET_UNSET_FLAGS (gdisp->hsb, GTK_CAN_FOCUS); gdisp->vsb = gtk_vscrollbar_new (gdisp->vsbdata); GTK_WIDGET_UNSET_FLAGS (gdisp->vsb, GTK_CAN_FOCUS); /* The qmask buttons buttons */ gdisp->qmaskoff = gtk_radio_button_new (group); group = gtk_radio_button_group (GTK_RADIO_BUTTON (gdisp->qmaskoff)); gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (gdisp->qmaskoff), FALSE); gtk_signal_connect (GTK_OBJECT (gdisp->qmaskoff), "toggled", GTK_SIGNAL_FUNC (qmask_deactivate), gdisp); gtk_signal_connect (GTK_OBJECT (gdisp->qmaskoff), "button_press_event", GTK_SIGNAL_FUNC (qmask_click_handler), gdisp); gimp_help_set_help_data (gdisp->qmaskoff, NULL, "#qmask_off_button"); gdisp->qmaskon = gtk_radio_button_new (group); group = gtk_radio_button_group (GTK_RADIO_BUTTON (gdisp->qmaskon)); gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (gdisp->qmaskon), FALSE); gtk_signal_connect (GTK_OBJECT (gdisp->qmaskon), "toggled", GTK_SIGNAL_FUNC (qmask_activate), gdisp); gtk_signal_connect (GTK_OBJECT (gdisp->qmaskon), "button_press_event", GTK_SIGNAL_FUNC (qmask_click_handler), gdisp); gimp_help_set_help_data (gdisp->qmaskon, NULL, "#qmask_on_button"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (gdisp->qmaskoff), TRUE); gtk_widget_set_usize (GTK_WIDGET (gdisp->qmaskon), 15, 15); gtk_widget_set_usize (GTK_WIDGET (gdisp->qmaskoff), 15, 15); /* Draw pixmaps - note: you must realize the parent prior to doing the rest! */ { GdkPixmap *pxmp; GdkBitmap *mask; GtkStyle *style; gtk_widget_realize (gdisp->shell); style = gtk_widget_get_style (gdisp->shell); pxmp = gdk_pixmap_create_from_xpm_d (gdisp->shell->window, &mask, &style->bg[GTK_STATE_NORMAL], qmasksel_xpm); pixmap = gtk_pixmap_new (pxmp, mask); gtk_container_add (GTK_CONTAINER (gdisp->qmaskon), pixmap); gtk_widget_show (pixmap); pxmp = gdk_pixmap_create_from_xpm_d (gdisp->shell->window, &mask, &style->bg[GTK_STATE_NORMAL], qmasknosel_xpm); pixmap = gtk_pixmap_new (pxmp, mask); gtk_container_add (GTK_CONTAINER (gdisp->qmaskoff), pixmap); gtk_widget_show (pixmap); /* nav button pixmap */ pxmp = gdk_pixmap_create_from_xpm_d (gdisp->shell->window, &mask, &style->bg[GTK_STATE_NORMAL], navbutton_xpm); pixmap = gtk_pixmap_new (pxmp, mask); gtk_container_add (GTK_CONTAINER (navhbox), pixmap); gtk_widget_show (pixmap); } gdisp->canvas = gtk_drawing_area_new (); gtk_drawing_area_size (GTK_DRAWING_AREA (gdisp->canvas), n_width, n_height); gtk_widget_set_events (gdisp->canvas, CANVAS_EVENT_MASK); gtk_widget_set_extension_events (gdisp->canvas, GDK_EXTENSION_EVENTS_ALL); GTK_WIDGET_SET_FLAGS (gdisp->canvas, GTK_CAN_FOCUS); gtk_object_set_user_data (GTK_OBJECT (gdisp->canvas), (gpointer) gdisp); /* set the active display before doing any other canvas event processing */ gtk_signal_connect (GTK_OBJECT (gdisp->canvas), "event", GTK_SIGNAL_FUNC (gdisplay_shell_events), gdisp); gtk_signal_connect (GTK_OBJECT (gdisp->canvas), "event", GTK_SIGNAL_FUNC (gdisplay_canvas_events), gdisp); /* pack all the widgets */ gtk_table_attach (GTK_TABLE (table), table_inner, 0, 1, 0, 1, GTK_FILL | GTK_EXPAND | GTK_SHRINK, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 0); /* sneak in an extra table here */ gtk_table_attach (GTK_TABLE (table_lower), evbox, 3, 4, 0, 1, GTK_SHRINK, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0); gtk_table_attach (GTK_TABLE (table_lower), gdisp->hsb, 2, 3, 0, 1, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0); gtk_table_attach (GTK_TABLE (table_lower), gdisp->qmaskoff, 0, 1, 0, 1, GTK_SHRINK, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0); gtk_table_attach (GTK_TABLE (table_lower), gdisp->qmaskon, 1, 2, 0, 1, GTK_SHRINK, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0); gtk_table_attach (GTK_TABLE (table), table_lower, 0, 2, 1, 2, GTK_FILL | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0); gtk_table_attach (GTK_TABLE (table), gdisp->vsb, 1, 2, 0, 1, GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0); gtk_table_attach (GTK_TABLE (table_inner), gdisp->origin, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0); gtk_table_attach (GTK_TABLE (table_inner), gdisp->hrule, 1, 2, 0, 1, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0); gtk_table_attach (GTK_TABLE (table_inner), gdisp->vrule, 0, 1, 1, 2, GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0); gtk_table_attach (GTK_TABLE (table_inner), gdisp->canvas, 1, 2, 1, 2, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0); if (! image_popup_menu) menus_get_image_menu (&image_popup_menu, &image_accel_group); gtk_container_set_resize_mode (GTK_CONTAINER (gdisp->statusarea), GTK_RESIZE_QUEUE); /* cursor, statusbar, progressbar */ frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (gdisp->statusarea), frame, FALSE, TRUE, 0); gdisp->cursor_label = gtk_label_new (" "); gtk_container_add (GTK_CONTAINER (frame), gdisp->cursor_label); /* we need to realize the cursor_label widget here, so the size gets computed correctly */ gtk_widget_realize (gdisp->cursor_label); gdisplay_resize_cursor_label (gdisp); gdisp->statusbar = gtk_statusbar_new (); gtk_widget_set_usize (gdisp->statusbar, 1, -1); gtk_container_set_resize_mode (GTK_CONTAINER (gdisp->statusbar), GTK_RESIZE_QUEUE); gtk_box_pack_start (GTK_BOX (gdisp->statusarea), gdisp->statusbar, TRUE, TRUE, 0); contextid = gtk_statusbar_get_context_id (GTK_STATUSBAR (gdisp->statusbar), "title"); gtk_statusbar_push (GTK_STATUSBAR (gdisp->statusbar), contextid, title); gdisp->progressbar = gtk_progress_bar_new (); gtk_widget_set_usize (gdisp->progressbar, 80, -1); gtk_box_pack_start (GTK_BOX (gdisp->statusarea), gdisp->progressbar, FALSE, TRUE, 0); gdisp->cancelbutton = gtk_button_new_with_label(_("Cancel")); gtk_box_pack_start (GTK_BOX (gdisp->statusarea), gdisp->cancelbutton, FALSE, TRUE, 0); gtk_widget_set_sensitive (gdisp->cancelbutton, FALSE); /* the popup menu */ gdisp->popup = image_popup_menu; /* The accelerator table for images */ gtk_window_add_accel_group (GTK_WINDOW (gdisp->shell), image_accel_group); /* Connect the "F1" help key */ gimp_help_connect_help_accel (gdisp->shell, gimp_standard_help_func, "image/image_window.html"); gtk_widget_show (arrow); gtk_widget_show (gdisp->qmaskon); gtk_widget_show (gdisp->qmaskoff); gtk_widget_show (navhbox); gtk_widget_show (gdisp->hsb); gtk_widget_show (gdisp->vsb); if (show_rulers) { gtk_widget_show (gdisp->origin); gtk_widget_show (gdisp->hrule); gtk_widget_show (gdisp->vrule); } gtk_widget_show (gdisp->canvas); gtk_widget_show (frame); gtk_widget_show (gdisp->cursor_label); gtk_widget_show (gdisp->statusbar); gtk_widget_show (gdisp->progressbar); gtk_widget_show (gdisp->cancelbutton); gtk_widget_show (table_lower); gtk_widget_show (table_inner); gtk_widget_show (table); if (show_statusbar) { gtk_widget_show (gdisp->statusarea); } gtk_widget_show (vbox); gtk_widget_show (gdisp->shell); gtk_widget_realize (gdisp->canvas); gdk_window_set_back_pixmap (gdisp->canvas->window, NULL, 0); /* set the focus to the canvas area */ gtk_widget_grab_focus (gdisp->canvas); } /* DnD functions */ static void toolbox_set_drag_dest (GtkWidget *object) { gtk_drag_dest_set (object, GTK_DEST_DEFAULT_ALL, toolbox_target_table, toolbox_n_targets, GDK_ACTION_COPY); gtk_signal_connect (GTK_OBJECT (object), "drag_data_received", GTK_SIGNAL_FUNC (toolbox_drag_data_received), object); gtk_signal_connect (GTK_OBJECT (object), "drag_drop", GTK_SIGNAL_FUNC (toolbox_drag_drop), NULL); gimp_dnd_tool_dest_set (object, toolbox_drop_tool, NULL); } static void toolbox_drag_data_received (GtkWidget *widget, GdkDragContext *context, gint x, gint y, GtkSelectionData *data, guint info, guint time) { switch (context->action) { case GDK_ACTION_DEFAULT: case GDK_ACTION_COPY: case GDK_ACTION_MOVE: case GDK_ACTION_LINK: case GDK_ACTION_ASK: default: gimp_dnd_open_files ((gchar *) data->data); gtk_drag_finish (context, TRUE, FALSE, time); break; } return; } static gboolean toolbox_drag_drop (GtkWidget *widget, GdkDragContext *context, gint x, gint y, guint time) { GtkWidget *src_widget; gboolean return_val = FALSE; if ((src_widget = gtk_drag_get_source_widget (context))) { GimpDrawable *drawable = NULL; Layer *layer = NULL; Channel *channel = NULL; LayerMask *layer_mask = NULL; GImage *component = NULL; ChannelType component_type = -1; layer = (Layer *) gtk_object_get_data (GTK_OBJECT (src_widget), "gimp_layer"); channel = (Channel *) gtk_object_get_data (GTK_OBJECT (src_widget), "gimp_channel"); layer_mask = (LayerMask *) gtk_object_get_data (GTK_OBJECT (src_widget), "gimp_layer_mask"); component = (GImage *) gtk_object_get_data (GTK_OBJECT (src_widget), "gimp_component"); if (layer) { drawable = GIMP_DRAWABLE (layer); } else if (channel) { drawable = GIMP_DRAWABLE (channel); } else if (layer_mask) { drawable = GIMP_DRAWABLE (layer_mask); } else if (component) { component_type = (ChannelType) gtk_object_get_data (GTK_OBJECT (src_widget), "gimp_component_type"); } if (drawable) { GImage *gimage; GImage *new_gimage; Layer *new_layer; gint width, height; gint off_x, off_y; gint bytes; GimpImageBaseType type; gimage = gimp_drawable_gimage (drawable); width = gimp_drawable_width (drawable); height = gimp_drawable_height (drawable); bytes = gimp_drawable_bytes (drawable); switch (gimp_drawable_type (drawable)) { case RGB_GIMAGE: case RGBA_GIMAGE: type = RGB; break; case GRAY_GIMAGE: case GRAYA_GIMAGE: type = GRAY; break; case INDEXED_GIMAGE: case INDEXEDA_GIMAGE: type = INDEXED; break; default: type = RGB; break; } new_gimage = gimage_new (width, height, type); gimage_disable_undo (new_gimage); gimage_set_resolution (new_gimage, gimage->xresolution, gimage->yresolution); gimage_set_unit (new_gimage, gimage->unit); if (layer) { new_layer = layer_copy (layer, FALSE); } else { /* a non-layer drawable can't have an alpha channel, * so add one */ PixelRegion srcPR, destPR; TileManager *tiles; tiles = tile_manager_new (width, height, bytes + 1); pixel_region_init (&srcPR, gimp_drawable_data (drawable), 0, 0, width, height, FALSE); pixel_region_init (&destPR, tiles, 0, 0, width, height, TRUE); add_alpha_region (&srcPR, &destPR); new_layer = layer_new_from_tiles (new_gimage, gimp_image_base_type_with_alpha(new_gimage), tiles, "", OPAQUE_OPACITY, NORMAL_MODE); tile_manager_destroy (tiles); } gimp_drawable_set_gimage (GIMP_DRAWABLE (new_layer), new_gimage); layer_set_name (GIMP_LAYER (new_layer), gimp_drawable_get_name (drawable)); if (layer) { LayerMask *mask; LayerMask *new_mask; mask = layer_get_mask (layer); new_mask = layer_get_mask (new_layer); if (new_mask) { gimp_drawable_set_name (GIMP_DRAWABLE (new_mask), gimp_drawable_get_name (GIMP_DRAWABLE (mask))); } } gimp_drawable_offsets (GIMP_DRAWABLE (new_layer), &off_x, &off_y); layer_translate (new_layer, -off_x, -off_y); gimage_add_layer (new_gimage, new_layer, 0); gimp_context_set_display (gimp_context_get_user (), gdisplay_new (new_gimage, 0x0101)); gimage_enable_undo (new_gimage); return_val = TRUE; } } gtk_drag_finish (context, return_val, FALSE, time); return return_val; } static ToolType toolbox_drag_tool (GtkWidget *widget, gpointer data) { return (ToolType) data; } static void toolbox_drop_tool (GtkWidget *widget, ToolType tool, gpointer data) { gimp_context_set_tool (gimp_context_get_user (), tool); } static void gimp_dnd_open_files (gchar *buffer) { gchar name_buffer[1024]; const gchar *data_type = "file:"; const gint sig_len = strlen (data_type); while (*buffer) { gchar *name = name_buffer; gint len = 0; while ((*buffer != 0) && (*buffer != '\n') && len < 1024) { *name++ = *buffer++; len++; } if (len == 0) break; if (*(name - 1) == 0xd) /* gmc uses RETURN+NEWLINE as delimiter */ *(name - 1) = '\0'; else *name = '\0'; name = name_buffer; if ((sig_len < len) && (! strncmp (name, data_type, sig_len))) name += sig_len; file_open (name, name); if (*buffer) buffer++; } }