app/interface.c

   1 /* Dia -- an diagram creation/manipulation program
   2  * Copyright (C) 1998 Alexander Larsson
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17  */
  18
  19 #include <config.h>
  20
  21 #include <stdio.h>
  22 #include <string.h>
  23
  24 #include "diagram.h"
  25 #include "layer_dialog.h"
  26 #include "interface.h"
  27 #include "display.h"
  28 #include "pixmaps.h"
  29 #include "preferences.h"
  30 #include "commands.h"
  31 #include "dia_dirs.h"
  32 #include "diagram_tree_window.h"
  33 #include "intl.h"
  34 #include <gdk-pixbuf/gdk-pixbuf.h>
  35
  36 static const GtkTargetEntry create_object_targets[] = {
  37   { "application/x-dia-object", 0, 0 },
  38 };
  39
  40 ToolButton tool_data[] =
  41 {
  42   { (char **) arrow_xpm,
  43     N_("Modify object(s)"),
  44     N_("Modify"),
  45     { MODIFY_TOOL, NULL, NULL}
  46   },
  47   { (char **) magnify_xpm,
  48     N_("Magnify"),
  49     N_("Magnify"),
  50     { MAGNIFY_TOOL, NULL, NULL}
  51   },
  52   { (char **) scroll_xpm,
  53     N_("Scroll around the diagram"),
  54     N_("Scroll"),
  55     { SCROLL_TOOL, NULL, NULL}
  56   },
  57   { NULL,
  58     N_("Text"),
  59     N_("Text"),
  60     { CREATE_OBJECT_TOOL, "Standard - Text", NULL }
  61   },
  62   { NULL,
  63     N_("Box"),
  64     N_("Box"),
  65     { CREATE_OBJECT_TOOL, "Standard - Box", NULL }
  66   },
  67   { NULL,
  68     N_("Ellipse"),
  69     N_("Ellipse"),
  70     { CREATE_OBJECT_TOOL, "Standard - Ellipse", NULL }
  71   },
  72   { NULL,
  73     N_("Polygon"),
  74     N_("Polygon"),
  75     { CREATE_OBJECT_TOOL, "Standard - Polygon", NULL }
  76   },
  77   { NULL,
  78     N_("Beziergon"),
  79     N_("Beziergon"),
  80     { CREATE_OBJECT_TOOL, "Standard - Beziergon", NULL }
  81   },
  82   { NULL,
  83     N_("Line"),
  84     N_("Line"),
  85     { CREATE_OBJECT_TOOL, "Standard - Line", NULL }
  86   },
  87   { NULL,
  88     N_("Arc"),
  89     N_("Arc"),
  90     { CREATE_OBJECT_TOOL, "Standard - Arc", NULL }
  91   },
  92   { NULL,
  93     N_("Zigzagline"),
  94     N_("Zigzagline"),
  95     { CREATE_OBJECT_TOOL, "Standard - ZigZagLine", NULL }
  96   },
  97   { NULL,
  98     N_("Polyline"),
  99     N_("Polyline"),
 100     { CREATE_OBJECT_TOOL, "Standard - PolyLine", NULL }
 101   },
 102   { NULL,
 103     N_("Bezierline"),
 104     N_("Bezierline"),
 105     { CREATE_OBJECT_TOOL, "Standard - BezierLine", NULL }
 106   },
 107   { NULL,
 108     N_("Image"),
 109     N_("Image"),
 110     { CREATE_OBJECT_TOOL, "Standard - Image", NULL }
 111   }
 112 };
 113
 114 #define NUM_TOOLS (sizeof (tool_data) / sizeof (ToolButton))
 115 const int num_tools = NUM_TOOLS;
 116
 117 #define COLUMNS   4
 118 #define ROWS      3
 119
 120 static GtkWidget *toolbox_shell = NULL;
 121 static GtkWidget *tool_widgets[NUM_TOOLS];
 122 /*static*/ GtkTooltips *tool_tips;
 123 static GSList *tool_group = NULL;
 124
 125 GtkWidget *modify_tool_button;
 126
 127 static void
 128 grid_toggle_snap(GtkWidget *widget, gpointer data)
 129 {
 130   DDisplay *ddisp = (DDisplay *)data;
 131   ddisplay_set_snap_to_grid(ddisp,
 132                             gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)));
 133 }
 134
 135 /*  The popup shell is a pointer to the display shell that posted the latest
 136  *  popup menu.  When this is null, and a command is invoked, then the
 137  *  assumption is that the command was a result of a keyboard accelerator
 138  */
 139 GtkWidget *popup_shell = NULL;
 140
 141 static gint
 142 origin_button_press(GtkWidget *widget, GdkEventButton *event, gpointer data)
 143 {
 144   DDisplay *ddisp = (DDisplay *)data;
 145
 146   display_set_active(ddisp);
 147   ddisplay_popup_menu(ddisp, event);
 148
 149   /* stop the signal emission so the button doesn't grab the
 150    * pointer from us */
 151   gtk_signal_emit_stop_by_name(GTK_OBJECT(widget), "button_press_event");
 152
 153   return FALSE;
 154 }
 155
 156 static void
 157 zoom_activate_callback(GtkWidget *item, gpointer user_data) {
 158   DDisplay *ddisp = (DDisplay *)user_data;
 159   const gchar *zoom_text =
 160       gtk_entry_get_text(GTK_ENTRY(gtk_object_get_user_data(GTK_OBJECT(ddisp->zoom_status))));
 161   float zoom_amount, magnify;
 162   gchar *zoomamount = g_object_get_data(G_OBJECT(item), "zoomamount");
 163   if (zoomamount != NULL) {
 164     zoom_text = zoomamount;
 165   }
 166
 167   if (sscanf(zoom_text, "%f", &zoom_amount) == 1) {
 168     Point middle;
 169     Rectangle *visible;
 170
 171     magnify = (zoom_amount*DDISPLAY_NORMAL_ZOOM/100.0)/ddisp->zoom_factor;
 172     if (fabs(magnify - 1.0) > 0.000001) {
 173       visible = &ddisp->visible;
 174       middle.x = visible->left*0.5 + visible->right*0.5;
 175       middle.y = visible->top*0.5 + visible->bottom*0.5;
 176       ddisplay_zoom(ddisp, &middle, magnify);
 177     }
 178   }
 179 }
 180
 181 static void
 182 zoom_add_zoom_amount(GtkWidget *menu, gchar *text, DDisplay *ddisp) {
 183   GtkWidget *menuitem = gtk_menu_item_new_with_label(text);
 184   gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
 185   gtk_signal_connect(GTK_OBJECT(menuitem),
 186                      "activate", (GtkSignalFunc)zoom_activate_callback,
 187                      ddisp);
 188   g_object_set_data(G_OBJECT(menuitem), "zoomamount", text);
 189 }
 190
 191 static void
 192 zoom_popup_menu(GtkWidget *button, GdkEventButton *event, gpointer user_data) {
 193   /* display_set_active(ddisp); */
 194   /* ddisplay_popup_menu(ddisp, event); */
 195
 196   GtkMenu *menu = GTK_MENU(user_data);
 197
 198   gtk_menu_popup(menu, NULL, NULL, NULL, NULL,
 199                  event->button, event->time);
 200   /* stop the signal emission so the button doesn't grab the
 201    * pointer from us */
 202   gtk_signal_emit_stop_by_name(GTK_OBJECT(button), "button_press_event");
 203 }
 204
 205 static GtkWidget*
 206 create_zoom_widget(DDisplay *ddisp) {
 207   GtkWidget *combo;
 208   GtkWidget *entry;
 209   GtkWidget *menu;
 210   GtkWidget *button;
 211   GtkWidget *arrow;
 212
 213   combo = gtk_hbox_new(FALSE, 0);
 214   entry = gtk_entry_new();
 215   gtk_signal_connect (GTK_OBJECT (entry), "activate",
 216                       (GtkSignalFunc) zoom_activate_callback,
 217                       ddisp);
 218   gtk_box_pack_start_defaults(GTK_BOX(combo), entry);
 219   gtk_object_set_user_data(GTK_OBJECT(combo), entry);
 220   gtk_entry_set_width_chars(GTK_ENTRY(entry), 8);
 221   gtk_widget_show(entry);
 222
 223   button = gtk_button_new();
 224   GTK_WIDGET_UNSET_FLAGS(button, GTK_CAN_FOCUS);
 225   arrow = gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_OUT);
 226   gtk_container_add(GTK_CONTAINER(button), arrow);
 227   gtk_box_pack_start_defaults(GTK_BOX(combo), button);
 228   gtk_object_set_user_data(GTK_OBJECT(combo), entry);
 229   gtk_widget_show_all(button);
 230
 231   menu = gtk_menu_new();
 232   zoom_add_zoom_amount(menu, "400%", ddisp);
 233   zoom_add_zoom_amount(menu, "283%", ddisp);
 234   zoom_add_zoom_amount(menu, "200%", ddisp);
 235   zoom_add_zoom_amount(menu, "141%", ddisp);
 236   zoom_add_zoom_amount(menu, "100%", ddisp);
 237   zoom_add_zoom_amount(menu, "85%", ddisp);
 238   zoom_add_zoom_amount(menu, "70.7%", ddisp);
 239   zoom_add_zoom_amount(menu, "50%", ddisp);
 240   zoom_add_zoom_amount(menu, "35.4%", ddisp);
 241   zoom_add_zoom_amount(menu, "25%", ddisp);
 242
 243   gtk_widget_show_all(menu);
 244
 245   gtk_signal_connect (GTK_OBJECT (button), "button_press_event",
 246                       (GtkSignalFunc) zoom_popup_menu,
 247                       menu);
 248
 249   return combo;
 250 }
 251
 252 static gboolean
 253 display_drop_callback(GtkWidget *widget, GdkDragContext *context,
 254                       gint x, gint y, guint time)
 255 {
 256   if (gtk_drag_get_source_widget(context) != NULL) {
 257     /* we only accept drops from the same instance of the application,
 258      * as the drag data is a pointer in our address space */
 259     return TRUE;
 260   }
 261   gtk_drag_finish (context, FALSE, FALSE, time);
 262   return FALSE;
 263 }
 264
 265 static void
 266 display_data_received_callback (GtkWidget *widget, GdkDragContext *context,
 267                                 gint x, gint y, GtkSelectionData *data,
 268                                 guint info, guint time, DDisplay *ddisp)
 269 {
 270   if (data->format == 8 && data->length == sizeof(ToolButtonData *) &&
 271       gtk_drag_get_source_widget(context) != NULL) {
 272     ToolButtonData *tooldata = *(ToolButtonData **)data->data;
 273
 274     /* g_message("Tool drop %s at (%d, %d)", (gchar *)tooldata->extra_data, x, y);*/
 275     ddisplay_drop_object(ddisp, x, y,
 276                          object_get_type((gchar *)tooldata->extra_data),
 277                          tooldata->user_data);
 278
 279     gtk_drag_finish (context, TRUE, FALSE, time);
 280   } else
 281     gtk_drag_finish (context, FALSE, FALSE, time);
 282 }
 283
 284 void
 285 create_display_shell(DDisplay *ddisp,
 286                      int width, int height,
 287                      char *title, int use_mbar, int top_level_window)
 288 {
 289   GtkWidget *table, *widget;
 290   GtkWidget *status_hbox;
 291   GtkWidget *root_vbox = NULL;
 292   GtkWidget *zoom_hbox, *zoom_label;
 293   int s_width, s_height;
 294
 295   s_width = gdk_screen_width ();
 296   s_height = gdk_screen_height ();
 297   if (width > s_width)
 298     width = s_width;
 299   if (height > s_height)
 300     width = s_width;
 301
 302   /*  The adjustment datums  */
 303   ddisp->hsbdata = GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, width, 1, (width-1)/4, width-1));
 304   ddisp->vsbdata = GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, height, 1, (height-1)/4, height-1));
 305
 306   /*  The toplevel shell */
 307   if (top_level_window) {
 308     ddisp->shell = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 309     gtk_window_set_title (GTK_WINDOW (ddisp->shell), title);
 310     gtk_window_set_role (GTK_WINDOW (ddisp->shell), "diagram_window");
 311   } else {
 312     ddisp->shell = gtk_event_box_new ();
 313   }
 314   gtk_object_set_user_data (GTK_OBJECT (ddisp->shell), (gpointer) ddisp);
 315
 316   gtk_widget_set_events (ddisp->shell,
 317                          GDK_POINTER_MOTION_MASK |
 318                          GDK_POINTER_MOTION_HINT_MASK |
 319                          GDK_FOCUS_CHANGE_MASK);
 320                       /* GDK_ALL_EVENTS_MASK */
 321
 322   gtk_signal_connect (GTK_OBJECT (ddisp->shell), "delete_event",
 323                       GTK_SIGNAL_FUNC (ddisplay_delete),
 324                       ddisp);
 325   gtk_signal_connect (GTK_OBJECT (ddisp->shell), "destroy",
 326                       GTK_SIGNAL_FUNC (ddisplay_destroy),
 327                       ddisp);
 328   gtk_signal_connect (GTK_OBJECT (ddisp->shell), "focus_out_event",
 329                       GTK_SIGNAL_FUNC (ddisplay_focus_out_event),
 330                       ddisp);
 331   gtk_signal_connect (GTK_OBJECT (ddisp->shell), "focus_in_event",
 332                       GTK_SIGNAL_FUNC (ddisplay_focus_in_event),
 333                       ddisp);
 334   gtk_signal_connect (GTK_OBJECT (ddisp->shell), "realize",
 335                       GTK_SIGNAL_FUNC (ddisplay_realize),
 336                       ddisp);
 337   gtk_signal_connect (GTK_OBJECT (ddisp->shell), "unrealize",
 338                       GTK_SIGNAL_FUNC (ddisplay_unrealize),
 339                       ddisp);
 340 /*FIXME?:
 341   gtk_signal_connect (GTK_OBJECT (ddisp->shell), "size_allocate",
 342                       GTK_SIGNAL_FUNC (ddisplay_size_allocate),
 343                       ddisp);
 344 */
 345
 346   /*  the table containing all widgets  */
 347   table = gtk_table_new (4, 3, FALSE);
 348   gtk_table_set_col_spacing (GTK_TABLE (table), 0, 1);
 349   gtk_table_set_col_spacing (GTK_TABLE (table), 1, 2);
 350   gtk_table_set_row_spacing (GTK_TABLE (table), 0, 1);
 351   gtk_table_set_row_spacing (GTK_TABLE (table), 1, 2);
 352   gtk_container_set_border_width (GTK_CONTAINER (table), 2);
 353   if (use_mbar)
 354   {
 355       root_vbox = gtk_vbox_new (FALSE, 1);
 356       gtk_container_add (GTK_CONTAINER (ddisp->shell), root_vbox);
 357       gtk_box_pack_end (GTK_BOX (root_vbox), table, TRUE, TRUE, 0);
 358   }
 359   else
 360   {
 361       gtk_container_add (GTK_CONTAINER (ddisp->shell), table);
 362   }
 363
 364
 365   /*  scrollbars, rulers, canvas, menu popup button  */
 366   if (!use_mbar) {
 367       ddisp->origin = gtk_button_new();
 368       GTK_WIDGET_UNSET_FLAGS(ddisp->origin, GTK_CAN_FOCUS);
 369       widget = gtk_arrow_new(GTK_ARROW_RIGHT, GTK_SHADOW_OUT);
 370       gtk_container_add(GTK_CONTAINER(ddisp->origin), widget);
 371       gtk_tooltips_set_tip(tool_tips, widget, _("Diagram menu."), NULL);
 372       gtk_widget_show(widget);
 373       gtk_signal_connect(GTK_OBJECT(ddisp->origin), "button_press_event",
 374                      GTK_SIGNAL_FUNC(origin_button_press), ddisp);
 375   }
 376   else {
 377       ddisp->origin = gtk_frame_new (NULL);
 378       gtk_frame_set_shadow_type (GTK_FRAME (ddisp->origin), GTK_SHADOW_OUT);
 379   }
 380
 381
 382   ddisp->hrule = gtk_hruler_new ();
 383   gtk_signal_connect_object (GTK_OBJECT (ddisp->shell), "motion_notify_event",
 384                              (GtkSignalFunc) GTK_WIDGET_GET_CLASS (ddisp->hrule)->motion_notify_event,
 385                              GTK_OBJECT (ddisp->hrule));
 386
 387   ddisp->vrule = gtk_vruler_new ();
 388   gtk_signal_connect_object (GTK_OBJECT (ddisp->shell), "motion_notify_event",
 389                              (GtkSignalFunc) GTK_WIDGET_GET_CLASS (ddisp->vrule)->motion_notify_event,
 390                              GTK_OBJECT (ddisp->vrule));
 391
 392   ddisp->hsb = gtk_hscrollbar_new (ddisp->hsbdata);
 393   GTK_WIDGET_UNSET_FLAGS (ddisp->hsb, GTK_CAN_FOCUS);
 394   ddisp->vsb = gtk_vscrollbar_new (ddisp->vsbdata);
 395   GTK_WIDGET_UNSET_FLAGS (ddisp->vsb, GTK_CAN_FOCUS);
 396
 397
 398   /*  set up the scrollbar observers  */
 399   gtk_signal_connect (GTK_OBJECT (ddisp->hsbdata), "value_changed",
 400                       (GtkSignalFunc) ddisplay_hsb_update,
 401                       ddisp);
 402   gtk_signal_connect (GTK_OBJECT (ddisp->vsbdata), "value_changed",
 403                       (GtkSignalFunc) ddisplay_vsb_update,
 404                       ddisp);
 405
 406   ddisp->canvas = gtk_drawing_area_new ();
 407   /* Dia's canvas does it' double buffering alone so switch off GTK's */
 408   gtk_widget_set_double_buffered (ddisp->canvas, FALSE);
 409   gtk_drawing_area_size (GTK_DRAWING_AREA (ddisp->canvas), width, height);
 410   gtk_widget_set_events (ddisp->canvas, CANVAS_EVENT_MASK);
 411   GTK_WIDGET_SET_FLAGS (ddisp->canvas, GTK_CAN_FOCUS);
 412   gtk_signal_connect (GTK_OBJECT (ddisp->canvas), "event",
 413                       (GtkSignalFunc) ddisplay_canvas_events,
 414                       ddisp);
 415
 416   gtk_drag_dest_set(ddisp->canvas, GTK_DEST_DEFAULT_ALL,
 417                     create_object_targets, 1, GDK_ACTION_COPY);
 418   gtk_signal_connect (GTK_OBJECT (ddisp->canvas), "drag_drop",
 419                       GTK_SIGNAL_FUNC(display_drop_callback), NULL);
 420   gtk_signal_connect (GTK_OBJECT (ddisp->canvas), "drag_data_received",
 421                       GTK_SIGNAL_FUNC(display_data_received_callback), ddisp);
 422
 423   gtk_object_set_user_data (GTK_OBJECT (ddisp->canvas), (gpointer) ddisp);
 424   /*  pack all the widgets  */
 425   gtk_table_attach (GTK_TABLE (table), ddisp->origin, 0, 1, 0, 1,
 426                     GTK_FILL, GTK_FILL, 0, 0);
 427   gtk_table_attach (GTK_TABLE (table), ddisp->hrule, 1, 2, 0, 1,
 428                     GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0);
 429   gtk_table_attach (GTK_TABLE (table), ddisp->vrule, 0, 1, 1, 2,
 430                     GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
 431   gtk_table_attach (GTK_TABLE (table), ddisp->canvas, 1, 2, 1, 2,
 432                     GTK_EXPAND | GTK_SHRINK | GTK_FILL,
 433                     GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
 434   gtk_table_attach (GTK_TABLE (table), ddisp->hsb, 0, 2, 2, 3,
 435                     GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0);
 436   gtk_table_attach (GTK_TABLE (table), ddisp->vsb, 2, 3, 0, 2,
 437                     GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
 438
 439   menus_get_image_menu (NULL, &ddisp->accel_group);
 440   if (top_level_window)
 441     gtk_window_add_accel_group(GTK_WINDOW(ddisp->shell), ddisp->accel_group);
 442   if (use_mbar)
 443   {
 444     GString *path;
 445     char *display = "<DisplayMBar>";
 446
 447     menus_get_image_menubar(&ddisp->menu_bar, &ddisp->mbar_item_factory);
 448     gtk_box_pack_start (GTK_BOX (root_vbox), ddisp->menu_bar, FALSE, TRUE, 0);
 449
 450     path = g_string_new (display);
 451     g_string_append (path,"/View/Show Rulers");
 452     ddisp->rulers       = menus_get_item_from_path(path->str, ddisp->mbar_item_factory);
 453     g_string_append (g_string_assign(path, display),"/View/Show Grid");
 454     ddisp->visible_grid = menus_get_item_from_path(path->str, ddisp->mbar_item_factory);
 455     g_string_append (g_string_assign(path, display),"/View/Snap To Grid");
 456     ddisp->snap_to_grid = menus_get_item_from_path(path->str, ddisp->mbar_item_factory);
 457     g_string_append (g_string_assign(path, display),"/View/Show Connection Points");
 458     ddisp->show_cx_pts_mitem  = menus_get_item_from_path(path->str, ddisp->mbar_item_factory);
 459
 460 #ifdef HAVE_LIBART
 461     g_string_append (g_string_assign(path, display),"/View/AntiAliased");
 462     ddisp->antialiased  = menus_get_item_from_path(path->str, ddisp->mbar_item_factory);
 463 #endif
 464
 465     menus_initialize_updatable_items (&ddisp->updatable_menu_items, ddisp->mbar_item_factory, display);
 466     g_string_free (path,FALSE);
 467   }
 468
 469   /* the statusbars */
 470   status_hbox = gtk_hbox_new (FALSE, 2);
 471
 472   /*
 473     gtk_signal_connect(GTK_OBJECT(ddisp->origin), "button_press_event",
 474     GTK_SIGNAL_FUNC(origin_button_press), ddisp);
 475   */
 476
 477   /* Zoom status pseudo-optionmenu */
 478   ddisp->zoom_status = create_zoom_widget(ddisp);
 479   zoom_hbox = gtk_hbox_new(FALSE, 0);
 480   zoom_label = gtk_label_new(_("Zoom"));
 481   gtk_box_pack_start (GTK_BOX(zoom_hbox), zoom_label,
 482                       FALSE, FALSE, 0);
 483   gtk_box_pack_start (GTK_BOX(zoom_hbox), ddisp->zoom_status,
 484                       FALSE, FALSE, 0);
 485
 486   gtk_box_pack_start (GTK_BOX (status_hbox), zoom_hbox, FALSE, FALSE, 0);
 487
 488   /* Grid on/off button */
 489   ddisp->grid_status = gtk_toggle_button_new();
 490
 491   g_signal_connect(G_OBJECT(ddisp->grid_status), "toggled",
 492                    grid_toggle_snap, ddisp);
 493   gtk_tooltips_set_tip(tool_tips, ddisp->grid_status,
 494                        _("Toggles snap-to-grid for this window."), NULL);
 495   gtk_box_pack_start (GTK_BOX (status_hbox), ddisp->grid_status,
 496                       FALSE, FALSE, 0);
 497
 498   /* Statusbar */
 499   ddisp->modified_status = gtk_statusbar_new ();
 500
 501   gtk_box_pack_start (GTK_BOX (status_hbox), ddisp->modified_status,
 502                       TRUE, TRUE, 0);
 503
 504   gtk_table_attach (GTK_TABLE (table), status_hbox, 0, 3, 3, 4,
 505                     GTK_FILL, GTK_FILL, 0, 0);
 506
 507   gtk_widget_show (ddisp->hsb);
 508   gtk_widget_show (ddisp->vsb);
 509   gtk_widget_show (ddisp->origin);
 510   gtk_widget_show (ddisp->hrule);
 511   gtk_widget_show (ddisp->vrule);
 512   gtk_widget_show (ddisp->canvas);
 513   gtk_widget_show (ddisp->zoom_status);
 514   gtk_widget_show (zoom_hbox);
 515   gtk_widget_show (zoom_label);
 516   gtk_widget_show (ddisp->grid_status);
 517   gtk_widget_show (ddisp->modified_status);
 518   gtk_widget_show (status_hbox);
 519   gtk_widget_show (table);
 520   if (use_mbar)
 521   {
 522       gtk_widget_show (ddisp->menu_bar);
 523       gtk_widget_show (root_vbox);
 524   }
 525   gtk_widget_show (ddisp->shell);
 526
 527   /*  set the focus to the canvas area  */
 528   gtk_widget_grab_focus (ddisp->canvas);
 529 }
 530
 531 void
 532 tool_select_update (GtkWidget *w,
 533                      gpointer   data)
 534 {
 535   ToolButtonData *tooldata = (ToolButtonData *) data;
 536
 537   if (tooldata == NULL) {
 538     g_warning(_("NULL tooldata in tool_select_update"));
 539     return;
 540   }
 541
 542   if (tooldata->type != -1) {
 543     gint x, y;
 544     GdkModifierType mask;
 545     /*  get the modifiers  */
 546     gdk_window_get_pointer (gtk_widget_get_parent_window(w), &x, &y, &mask);
 547     tool_select (tooldata->type, tooldata->extra_data, tooldata->user_data,
 548                  w, mask&1);
 549   }
 550 }
 551
 552 static gint
 553 tool_button_press (GtkWidget      *w,
 554                     GdkEventButton *event,
 555                     gpointer        data)
 556 {
 557   ToolButtonData *tooldata = (ToolButtonData *) data;
 558
 559   if ((event->type == GDK_2BUTTON_PRESS) &&
 560       (event->button == 1)) {
 561     tool_options_dialog_show (tooldata->type, tooldata->extra_data,
 562                               tooldata->user_data, w, event->state&1);
 563     return TRUE;
 564   }
 565
 566   return FALSE;
 567 }
 568
 569 static void
 570 tool_drag_data_get (GtkWidget *widget, GdkDragContext *context,
 571                     GtkSelectionData *selection_data, guint info,
 572                     guint32 time, ToolButtonData *tooldata)
 573 {
 574   if (info == 0) {
 575     gtk_selection_data_set(selection_data, selection_data->target,
 576                            8, (guchar *)&tooldata, sizeof(ToolButtonData *));
 577   }
 578 }
 579
 580 static void
 581 tool_setup_drag_source(GtkWidget *button, ToolButtonData *tooldata,
 582                        GdkPixmap *pixmap, GdkBitmap *mask)
 583 {
 584   g_return_if_fail(tooldata->type == CREATE_OBJECT_TOOL);
 585
 586   gtk_drag_source_set(button, GDK_BUTTON1_MASK,
 587                       create_object_targets, 1,
 588                       GDK_ACTION_DEFAULT|GDK_ACTION_COPY);
 589   gtk_signal_connect(GTK_OBJECT(button), "drag_data_get",
 590                      GTK_SIGNAL_FUNC(tool_drag_data_get), tooldata);
 591   if (pixmap)
 592     gtk_drag_source_set_icon(button, gtk_widget_get_colormap(button),
 593                              pixmap, mask);
 594 }
 595
 596 /*
 597 void
 598 tool_select_callback(GtkWidget *widget, gpointer data) {
 599   ToolButtonData *tooldata = (ToolButtonData *)data;
 600
 601   if (tooldata == NULL) {
 602     g_warning("NULL tooldata in tool_select_callback");
 603     return;
 604   }
 605
 606   if (tooldata->type != -1) {
 607     tool_select (tooldata->type, tooldata->extra_data,
 608                  tooldata->user_data,widget);
 609   }
 610 }
 611 */
 612
 613 static void
 614 create_tools(GtkWidget *parent)
 615 {
 616   GtkWidget *button;
 617   GtkWidget *pixmapwidget;
 618   GdkPixmap *pixmap;
 619   GdkBitmap *mask;
 620   GtkStyle *style;
 621   char **pixmap_data;
 622   int i;
 623
 624   for (i = 0; i < NUM_TOOLS; i++) {
 625     tool_widgets[i] = button = gtk_radio_button_new (tool_group);
 626     gtk_container_set_border_width (GTK_CONTAINER (button), 0);
 627     tool_group = gtk_radio_button_group (GTK_RADIO_BUTTON (button));
 628     gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (button), FALSE);
 629
 630     gtk_wrap_box_pack(GTK_WRAP_BOX(parent), button,
 631                       TRUE, TRUE, FALSE, TRUE);
 632
 633     if (tool_data[i].callback_data.type == MODIFY_TOOL) {
 634       modify_tool_button = GTK_WIDGET(button);
 635     }
 636
 637     if (tool_data[i].icon_data==NULL) {
 638       ObjectType *type;
 639       type =
 640         object_get_type((char *)tool_data[i].callback_data.extra_data);
 641       if (type == NULL)
 642         pixmap_data = tool_data[0].icon_data;
 643       else
 644         pixmap_data = type->pixmap;
 645     } else {
 646       pixmap_data = tool_data[i].icon_data;
 647     }
 648
 649     style = gtk_widget_get_style(button);
 650     pixmap = gdk_pixmap_colormap_create_from_xpm_d(NULL,
 651                 gtk_widget_get_colormap(button), &mask,
 652                 &style->bg[GTK_STATE_NORMAL], pixmap_data);
 653
 654     pixmapwidget = gtk_pixmap_new(pixmap, mask);
 655
 656     /* GTKBUG:? padding changes */
 657     gtk_misc_set_padding(GTK_MISC(pixmapwidget), 2, 2);
 658
 659     gtk_container_add (GTK_CONTAINER (button), pixmapwidget);
 660
 661     gtk_signal_connect (GTK_OBJECT (button), "clicked",
 662                         GTK_SIGNAL_FUNC (tool_select_update),
 663                         &tool_data[i].callback_data);
 664
 665     gtk_signal_connect (GTK_OBJECT (button), "button_press_event",
 666                         GTK_SIGNAL_FUNC (tool_button_press),
 667                         &tool_data[i].callback_data);
 668
 669     if (tool_data[i].callback_data.type == CREATE_OBJECT_TOOL)
 670       tool_setup_drag_source(button, &tool_data[i].callback_data,
 671                              pixmap, mask);
 672
 673     gdk_pixmap_unref(pixmap);
 674     if (mask) gdk_bitmap_unref(mask);
 675
 676     tool_data[i].callback_data.widget = button;
 677
 678     gtk_tooltips_set_tip (tool_tips, button,
 679                           gettext(tool_data[i].tool_desc), NULL);
 680
 681     gtk_widget_show (pixmapwidget);
 682     gtk_widget_show (button);
 683   }
 684 }
 685
 686 static GtkWidget *sheet_option_menu;
 687 static GtkWidget *sheet_menu;
 688 static GtkWidget *sheet_wbox;
 689
 690 #if 0
 691 static GtkWidget *
 692 create_sheet_page(GtkWidget *parent, Sheet *sheet)
 693 {
 694   GSList *list;
 695   SheetObject *sheet_obj;
 696   GtkWidget *table;
 697   GtkWidget *button;
 698   GtkWidget *pixmapwidget;
 699   GdkPixmap *pixmap;
 700   GdkBitmap *mask;
 701   ToolButtonData *data;
 702   GtkStyle *style;
 703   GtkWidget *scrolled_window;
 704   int i;
 705   int rows;
 706
 707   scrolled_window = gtk_scrolled_window_new(NULL, NULL);
 708   gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(scrolled_window),
 709                                   GTK_POLICY_AUTOMATIC,
 710                                   GTK_POLICY_AUTOMATIC);
 711
 712   rows = ceil(g_slist_length(sheet->objects) / (double)COLUMNS);
 713   if (rows<1)
 714     rows = 1;
 715
 716   table = gtk_hwrap_box_new(FALSE);
 717   gtk_wrap_box_set_aspect_ratio(GTK_WRAP_BOX(table), COLUMNS * 1.0 / rows);
 718   gtk_wrap_box_set_justify(GTK_WRAP_BOX(table), GTK_JUSTIFY_TOP);
 719   gtk_wrap_box_set_line_justify(GTK_WRAP_BOX(table), GTK_JUSTIFY_LEFT);
 720
 721   style = gtk_widget_get_style(parent);
 722
 723   i = 0;
 724   list = sheet->objects;
 725   while (list != NULL) {
 726     sheet_obj = (SheetObject *) list->data;
 727
 728
 729     if (sheet_obj->pixmap != NULL) {
 730       pixmap = gdk_pixmap_colormap_create_from_xpm_d(NULL,
 731                         gtk_widget_get_colormap(parent), &mask,
 732                         &style->bg[GTK_STATE_NORMAL], sheet_obj->pixmap);
 733     } else if (sheet_obj->pixmap_file != NULL) {
 734       pixmap = gdk_pixmap_colormap_create_from_xpm(NULL,
 735                         gtk_widget_get_colormap(parent), &mask,
 736                         &style->bg[GTK_STATE_NORMAL], sheet_obj->pixmap_file);
 737     } else {
 738       ObjectType *type;
 739       type = object_get_type(sheet_obj->object_type);
 740       pixmap = gdk_pixmap_colormap_create_from_xpm_d(NULL,
 741                         gtk_widget_get_colormap(parent), &mask,
 742                         &style->bg[GTK_STATE_NORMAL], type->pixmap);
 743     }
 744
 745     pixmapwidget = gtk_pixmap_new(pixmap, mask);
 746
 747
 748     button = gtk_radio_button_new (tool_group);
 749     gtk_container_set_border_width (GTK_CONTAINER (button), 0);
 750     tool_group = gtk_radio_button_group (GTK_RADIO_BUTTON (button));
 751
 752     gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (button), FALSE);
 753
 754
 755     gtk_container_add (GTK_CONTAINER (button), pixmapwidget);
 756     gtk_wrap_box_pack_wrapped(GTK_WRAP_BOX(table), button,
 757                       FALSE, TRUE, FALSE, sheet_obj->line_break);
 758
 759     /* This is a Memory leak, these can't be freed.
 760        Doesn't matter much anyway... */
 761
 762     data = g_new(ToolButtonData, 1);
 763     data->type = CREATE_OBJECT_TOOL;
 764     data->extra_data = sheet_obj->object_type;
 765     data->user_data = sheet_obj->user_data;
 766
 767     gtk_signal_connect (GTK_OBJECT (button), "clicked",
 768                         GTK_SIGNAL_FUNC (tool_select_update),
 769                         data);
 770
 771     gtk_signal_connect (GTK_OBJECT (button), "button_press_event",
 772                         GTK_SIGNAL_FUNC (tool_button_press),
 773                         data);
 774
 775     gtk_tooltips_set_tip (tool_tips, button,
 776                           gettext(sheet_obj->description), NULL);
 777
 778     list = g_slist_next(list);
 779     i++;
 780   }
 781
 782   gtk_widget_show(table);
 783   gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_window), table);
 784
 785   return scrolled_window;
 786 }
 787 #endif
 788
 789 gchar *interface_current_sheet_name;
 790
 791 static void
 792 fill_sheet_wbox(GtkWidget *menu_item, Sheet *sheet)
 793 {
 794   int rows;
 795   GtkStyle *style;
 796   GSList *tmp;
 797   GtkWidget *first_button = NULL;
 798
 799   gtk_container_foreach(GTK_CONTAINER(sheet_wbox),
 800                         (GtkCallback)gtk_widget_destroy, NULL);
 801   tool_group = gtk_radio_button_group(GTK_RADIO_BUTTON(tool_widgets[0]));
 802
 803   /* Remember sheet 'name' for 'Sheets and Objects' dialog */
 804   interface_current_sheet_name = sheet->name;
 805
 806   /* set the aspect ratio on the wbox */
 807   rows = ceil(g_slist_length(sheet->objects) / (double)COLUMNS);
 808   if (rows<1) rows = 1;
 809   gtk_wrap_box_set_aspect_ratio(GTK_WRAP_BOX(sheet_wbox),
 810                                 COLUMNS * 1.0 / rows);
 811   style = gtk_widget_get_style(sheet_wbox);
 812   for (tmp = sheet->objects; tmp != NULL; tmp = tmp->next) {
 813     SheetObject *sheet_obj = tmp->data;
 814     GdkPixmap *pixmap = NULL;
 815     GdkBitmap *mask = NULL;
 816     GtkWidget *pixmapwidget;
 817     GtkWidget *button;
 818     ToolButtonData *data;
 819
 820     if (sheet_obj->pixmap != NULL) {
 821       pixmap = gdk_pixmap_colormap_create_from_xpm_d(NULL,
 822                         gtk_widget_get_colormap(sheet_wbox), &mask,
 823                         &style->bg[GTK_STATE_NORMAL], sheet_obj->pixmap);
 824     } else if (sheet_obj->pixmap_file != NULL) {
 825       GdkPixbuf *pixbuf;
 826       GError* gerror = NULL;
 827
 828       pixbuf = gdk_pixbuf_new_from_file(sheet_obj->pixmap_file, &gerror);
 829       if (pixbuf != NULL) {
 830           gdk_pixbuf_render_pixmap_and_mask(pixbuf, &pixmap, &mask, 1.0);
 831           gdk_pixbuf_unref(pixbuf);
 832       } else {
 833
 834           g_warning("failed to load pixbuf for file %s; cause=%s",
 835                     sheet_obj->pixmap_file,gerror?gerror->message:"[NULL]");
 836       }
 837     } else {
 838       ObjectType *type;
 839       type = object_get_type(sheet_obj->object_type);
 840       pixmap = gdk_pixmap_colormap_create_from_xpm_d(NULL,
 841                         gtk_widget_get_colormap(sheet_wbox), &mask,
 842                         &style->bg[GTK_STATE_NORMAL], type->pixmap);
 843     }
 844     if (pixmap) {
 845       pixmapwidget = gtk_pixmap_new(pixmap, mask);
 846       gdk_pixmap_unref(pixmap);
 847       if (mask) gdk_bitmap_unref(mask);
 848     } else {
 849       pixmapwidget = gtk_type_new(gtk_pixmap_get_type());
 850     }
 851
 852     button = gtk_radio_button_new (tool_group);
 853     gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (button), FALSE);
 854     gtk_container_set_border_width (GTK_CONTAINER (button), 0);
 855     tool_group = gtk_radio_button_group (GTK_RADIO_BUTTON (button));
 856
 857     gtk_container_add (GTK_CONTAINER (button), pixmapwidget);
 858     gtk_widget_show(pixmapwidget);
 859
 860     gtk_wrap_box_pack_wrapped(GTK_WRAP_BOX(sheet_wbox), button,
 861                       FALSE, TRUE, FALSE, TRUE, sheet_obj->line_break);
 862     gtk_widget_show(button);
 863
 864     data = g_new(ToolButtonData, 1);
 865     data->type = CREATE_OBJECT_TOOL;
 866     data->extra_data = sheet_obj->object_type;
 867     data->user_data = sheet_obj->user_data;
 868     gtk_object_set_data_full(GTK_OBJECT(button), "Dia::ToolButtonData",
 869                              data, (GdkDestroyNotify)g_free);
 870     if (first_button == NULL) first_button = button;
 871
 872     gtk_signal_connect (GTK_OBJECT (button), "clicked",
 873                         GTK_SIGNAL_FUNC (tool_select_update), data);
 874     gtk_signal_connect (GTK_OBJECT (button), "button_press_event",
 875                         GTK_SIGNAL_FUNC (tool_button_press), data);
 876
 877     tool_setup_drag_source(button, data, pixmap, mask);
 878
 879     gtk_tooltips_set_tip (tool_tips, button,
 880                           gettext(sheet_obj->description), NULL);
 881   }
 882   /* If the selection is in the old sheet, steal it */
 883   if (active_tool != NULL &&
 884       active_tool->type == CREATE_OBJECT_TOOL &&
 885       first_button != NULL)
 886     gtk_signal_emit_by_name(GTK_OBJECT(first_button), "toggled",
 887                             GTK_BUTTON(first_button), NULL);
 888 }
 889
 890 void
 891 fill_sheet_menu(void)
 892 {
 893   GSList *tmp;
 894   GtkWidget *activate = NULL;
 895   int index = 0;
 896
 897   gtk_container_foreach(GTK_CONTAINER(sheet_menu),
 898                         (GtkCallback)gtk_widget_destroy, NULL);
 899   gtk_widget_ref(sheet_menu);
 900   gtk_option_menu_remove_menu(GTK_OPTION_MENU(sheet_option_menu));
 901   gtk_container_add(GTK_CONTAINER(sheet_menu), gtk_tearoff_menu_item_new());
 902   for (tmp = get_sheets_list(); tmp != NULL; tmp = tmp->next) {
 903     Sheet *sheet = tmp->data;
 904     GtkWidget *menuitem = NULL;
 905
 906     if (sheet->objects == NULL)
 907       continue;
 908
 909     menuitem = gtk_menu_item_new_with_label(gettext(sheet->name));
 910     gtk_signal_connect(GTK_OBJECT(menuitem), "activate",
 911                        GTK_SIGNAL_FUNC(fill_sheet_wbox), sheet);
 912     gtk_container_add(GTK_CONTAINER(sheet_menu), menuitem);
 913
 914     /* off by one with gtk_option_menu_<get/set>_history should start
 915      * with 0 but it counts from one, gtk- or my-error ? --hb */
 916     index++;
 917     if (prefs.recent_sheet == index)
 918       activate = menuitem;
 919   }
 920   gtk_option_menu_set_menu(GTK_OPTION_MENU(sheet_option_menu), sheet_menu);
 921   gtk_widget_unref(sheet_menu);
 922
 923   if (activate)
 924     {
 925       gtk_option_menu_set_history(GTK_OPTION_MENU(sheet_option_menu), prefs.recent_sheet);
 926       /* simple gtk_option_menu_set_history() isn't enough,
 927        * cause we need fill_sheet_wbox to be called */
 928       gtk_menu_item_activate(GTK_MENU_ITEM(activate));
 929     }
 930   gtk_widget_show_all(sheet_menu);
 931 }
 932
 933 void
 934 create_sheets(GtkWidget *parent)
 935 {
 936   GtkWidget *separator;
 937   GtkWidget *label;
 938   GtkWidget *swin;
 939
 940   separator = gtk_hseparator_new ();
 941   /* add a bit of padding around the separator */
 942   label = gtk_vbox_new(FALSE, 0);
 943   gtk_box_pack_start(GTK_BOX(label), separator, TRUE, TRUE, 3);
 944   gtk_widget_show(label);
 945
 946   gtk_wrap_box_pack_wrapped (GTK_WRAP_BOX(parent), label, TRUE,TRUE, FALSE,FALSE, TRUE);
 947   gtk_widget_show(separator);
 948
 949   sheet_option_menu = gtk_option_menu_new();
 950   gtk_widget_set_size_request(sheet_option_menu, 20, -1);
 951   sheet_menu = gtk_menu_new();
 952   gtk_option_menu_set_menu(GTK_OPTION_MENU(sheet_option_menu), sheet_menu);
 953   gtk_wrap_box_pack_wrapped(GTK_WRAP_BOX(parent), sheet_option_menu,
 954                     TRUE, TRUE, FALSE, FALSE, TRUE);
 955   gtk_widget_show(sheet_option_menu);
 956
 957   swin = gtk_scrolled_window_new(NULL, NULL);
 958   gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(swin),
 959                                  GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 960   gtk_wrap_box_pack_wrapped(GTK_WRAP_BOX(parent), swin, TRUE, TRUE, TRUE, TRUE, TRUE);
 961   gtk_widget_show(swin);
 962
 963   sheet_wbox = gtk_hwrap_box_new(FALSE);
 964   gtk_wrap_box_set_justify(GTK_WRAP_BOX(sheet_wbox), GTK_JUSTIFY_TOP);
 965   gtk_wrap_box_set_line_justify(GTK_WRAP_BOX(sheet_wbox), GTK_JUSTIFY_LEFT);
 966   gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(swin), sheet_wbox);
 967   gtk_widget_show(sheet_wbox);
 968
 969   fill_sheet_menu();
 970 }
 971
 972 static void
 973 create_color_area (GtkWidget *parent)
 974 {
 975   GtkWidget *frame;
 976   GtkWidget *alignment;
 977   GtkWidget *col_area;
 978   GtkWidget *line_area;
 979   GdkPixmap *default_pixmap;
 980   GdkBitmap *default_mask;
 981   GdkPixmap *swap_pixmap;
 982   GdkBitmap *swap_mask;
 983   GtkStyle *style;
 984   GtkWidget *hbox;
 985
 986   gtk_widget_ensure_style(parent);
 987   style = gtk_widget_get_style(parent);
 988
 989   default_pixmap =
 990     gdk_pixmap_colormap_create_from_xpm_d(NULL,
 991                 gtk_widget_get_colormap(parent), &default_mask,
 992                 &style->bg[GTK_STATE_NORMAL], default_xpm);
 993   swap_pixmap =
 994     gdk_pixmap_colormap_create_from_xpm_d(NULL,
 995                 gtk_widget_get_colormap(parent), &swap_mask,
 996                 &style->bg[GTK_STATE_NORMAL], swap_xpm);
 997
 998   frame = gtk_frame_new (NULL);
 999   gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
1000   gtk_wrap_box_pack_wrapped(GTK_WRAP_BOX(parent), frame, TRUE, TRUE, FALSE, FALSE, TRUE);
1001   gtk_widget_realize (frame);
1002
1003   hbox = gtk_hbox_new (FALSE, 1);
1004   gtk_container_set_border_width (GTK_CONTAINER (hbox), 0);
1005   gtk_container_add (GTK_CONTAINER (frame), hbox);
1006
1007   /* Color area: */
1008   alignment = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
1009   gtk_container_set_border_width (GTK_CONTAINER (alignment), 3);
1010
1011   col_area = color_area_create (54, 42,
1012                                 default_pixmap, default_mask,
1013                                 swap_pixmap, swap_mask);
1014   gtk_container_add (GTK_CONTAINER (alignment), col_area);
1015
1016
1017   gtk_box_pack_start (GTK_BOX (hbox), alignment, TRUE, TRUE, 0);
1018
1019   gtk_tooltips_set_tip (tool_tips, col_area,
1020                         _("Foreground & background colors for new objects.  "
1021                           "The small black and white squares reset colors.  "
1022                           "The small arrows swap colors.  Double click to "
1023                           "change colors."),
1024                         NULL);
1025
1026   gtk_widget_show (alignment);
1027
1028   /* Linewidth area: */
1029   alignment = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
1030   gtk_container_set_border_width (GTK_CONTAINER (alignment), 3);
1031
1032   line_area = linewidth_area_create ();
1033   gtk_container_add (GTK_CONTAINER (alignment), line_area);
1034   gtk_box_pack_start (GTK_BOX (hbox), alignment, TRUE, TRUE, 0);
1035   gtk_tooltips_set_tip(tool_tips, line_area, _("Line widths.  Click on a line to set the default line width for new objects.  Double-click to set the line width more precisely."), NULL);
1036   gtk_widget_show (alignment);
1037
1038   gtk_widget_show (col_area);
1039   gtk_widget_show (line_area);
1040   gtk_widget_show (hbox);
1041   gtk_widget_show (frame);
1042 }
1043
1044 static void
1045 change_start_arrow_style(Arrow arrow, gpointer user_data)
1046 {
1047   attributes_set_default_start_arrow(arrow);
1048 }
1049 static void
1050 change_end_arrow_style(Arrow arrow, gpointer user_data)
1051 {
1052   attributes_set_default_end_arrow(arrow);
1053 }
1054 static void
1055 change_line_style(LineStyle lstyle, real dash_length, gpointer user_data)
1056 {
1057   attributes_set_default_line_style(lstyle, dash_length);
1058 }
1059
1060 static void
1061 create_lineprops_area(GtkWidget *parent)
1062 {
1063   GtkWidget *chooser;
1064
1065   chooser = dia_arrow_chooser_new(TRUE, change_start_arrow_style, NULL);
1066   gtk_wrap_box_pack_wrapped(GTK_WRAP_BOX(parent), chooser, FALSE, TRUE, FALSE, TRUE, TRUE);
1067   gtk_tooltips_set_tip(tool_tips, chooser, _("Arrow style at the beginning of new lines.  Click to pick an arrow, or set arrow parameters with Details..."), NULL);
1068   gtk_widget_show(chooser);
1069
1070   chooser = dia_line_chooser_new(change_line_style, NULL);
1071   gtk_wrap_box_pack(GTK_WRAP_BOX(parent), chooser, TRUE, TRUE, FALSE, TRUE);
1072   gtk_tooltips_set_tip(tool_tips, chooser, _("Line style for new lines.  Click to pick a line style, or set line style parameters with Details..."), NULL);
1073   gtk_widget_show(chooser);
1074
1075   chooser = dia_arrow_chooser_new(FALSE, change_end_arrow_style, NULL);
1076   gtk_wrap_box_pack(GTK_WRAP_BOX(parent), chooser, FALSE, TRUE, FALSE, TRUE);
1077   gtk_tooltips_set_tip(tool_tips, chooser, _("Arrow style at the end of new lines.  Click to pick an arrow, or set arrow parameters with Details..."), NULL);
1078   gtk_widget_show(chooser);
1079 }
1080
1081 static void
1082 toolbox_destroy (GtkWidget *widget, gpointer data)
1083 {
1084   prefs.recent_sheet = gtk_option_menu_get_history(GTK_OPTION_MENU(sheet_option_menu));
1085
1086   app_exit();
1087 }
1088
1089 static void
1090 toolbox_delete (GtkWidget *widget, GdkEvent *event, gpointer data)
1091 {
1092   if (!app_is_embedded()) {
1093     gulong handlerid;
1094     /** Stop toolbox_destroy from being called */
1095     handlerid = g_signal_handler_find(widget, G_SIGNAL_MATCH_FUNC,
1096                                       0, 0, NULL, toolbox_destroy, NULL);
1097     if (handlerid != 0)
1098       g_signal_handler_disconnect (GTK_OBJECT (widget), handlerid);
1099     prefs.recent_sheet = gtk_option_menu_get_history(GTK_OPTION_MENU(sheet_option_menu));
1100
1101     app_exit();
1102   }
1103 }
1104
1105
1106 /* HB: file dnd stuff lent by The Gimp, not fully understood but working ...
1107  */
1108 enum
1109 {
1110   DIA_DND_TYPE_URI_LIST,
1111   DIA_DND_TYPE_TEXT_PLAIN,
1112 };
1113
1114 static GtkTargetEntry toolbox_target_table[] =
1115 {
1116   { "text/uri-list", 0, DIA_DND_TYPE_URI_LIST },
1117   { "text/plain", 0, DIA_DND_TYPE_TEXT_PLAIN }
1118 };
1119
1120 static guint toolbox_n_targets = (sizeof (toolbox_target_table) /
1121                                  sizeof (toolbox_target_table[0]));
1122
1123 static void
1124 dia_dnd_file_drag_data_received (GtkWidget        *widget,
1125                                  GdkDragContext   *context,
1126                                  gint              x,
1127                                  gint              y,
1128                                  GtkSelectionData *data,
1129                                  guint             info,
1130                                  guint             time)
1131 {
1132   switch (context->action)
1133     {
1134     case GDK_ACTION_DEFAULT:
1135     case GDK_ACTION_COPY:
1136     case GDK_ACTION_MOVE:
1137     case GDK_ACTION_LINK:
1138     case GDK_ACTION_ASK:
1139     default:
1140       {
1141         Diagram *diagram = NULL;
1142         DDisplay *ddisp;
1143         gchar *sPath = NULL, *pFrom, *pTo;
1144
1145         pFrom = strstr((gchar *) data->data, "file:");
1146         while (pFrom) {
1147           GError *error = NULL;
1148
1149           pTo = pFrom;
1150           while (*pTo != 0 && *pTo != 0xd && *pTo != 0xa) pTo ++;
1151           sPath = g_strndup(pFrom, pTo - pFrom);
1152
1153           /* format changed with Gtk+2.0, use conversion */
1154           pFrom = g_filename_from_uri (sPath, NULL, &error);
1155           diagram = diagram_load (pFrom, NULL);
1156           g_free (pFrom);
1157           g_free(sPath);
1158
1159           if (diagram != NULL) {
1160             diagram_update_extents(diagram);
1161             layer_dialog_set_diagram(diagram);
1162
1163             ddisp = new_display(diagram);
1164           }
1165
1166           pFrom = strstr(pTo, "file:");
1167         } /* while */
1168         gtk_drag_finish (context, TRUE, FALSE, time);
1169       }
1170       break;
1171     }
1172   return;
1173 }
1174
1175 void
1176 create_toolbox ()
1177 {
1178   GtkWidget *window;
1179   GtkWidget *main_vbox;
1180   GtkWidget *wrapbox;
1181   GtkWidget *menubar;
1182   GtkAccelGroup *accel_group;
1183
1184 #ifdef GNOME
1185   window = gnome_app_new ("Dia", _("Diagram Editor"));
1186 #else
1187   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1188   gtk_widget_ref (window);
1189   gtk_window_set_title (GTK_WINDOW (window), "Dia v" VERSION);
1190 #endif
1191   gtk_window_set_role (GTK_WINDOW (window), "toolbox_window");
1192   gtk_window_set_default_size(GTK_WINDOW(window), 146, 349);
1193
1194   gtk_signal_connect (GTK_OBJECT (window), "delete_event",
1195                       GTK_SIGNAL_FUNC (toolbox_delete),
1196                       window);
1197
1198   gtk_signal_connect (GTK_OBJECT (window), "destroy",
1199                       GTK_SIGNAL_FUNC (toolbox_destroy),
1200                       window);
1201
1202   main_vbox = gtk_vbox_new (FALSE, 1);
1203   gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 1);
1204 #ifdef GNOME
1205   gnome_app_set_contents(GNOME_APP(window), main_vbox);
1206 #else
1207   gtk_container_add (GTK_CONTAINER (window), main_vbox);
1208 #endif
1209   gtk_widget_show (main_vbox);
1210
1211   /*  tooltips  */
1212   tool_tips = gtk_tooltips_new ();
1213
1214   /*  gtk_tooltips_set_colors (tool_tips,
1215                            &colors[11],
1216                            &main_vbox->style->fg[GTK_STATE_NORMAL]);*/
1217
1218   wrapbox = gtk_hwrap_box_new(FALSE);
1219   gtk_wrap_box_set_aspect_ratio(GTK_WRAP_BOX(wrapbox), 144.0 / 318.0);
1220   gtk_wrap_box_set_justify(GTK_WRAP_BOX(wrapbox), GTK_JUSTIFY_TOP);
1221   gtk_wrap_box_set_line_justify(GTK_WRAP_BOX(wrapbox), GTK_JUSTIFY_LEFT);
1222
1223
1224   /* pack the rest of the stuff */
1225   gtk_box_pack_end (GTK_BOX (main_vbox), wrapbox, TRUE, TRUE, 0);
1226   gtk_container_set_border_width (GTK_CONTAINER (wrapbox), 0);
1227   gtk_widget_show (wrapbox);
1228
1229   create_tools (wrapbox);
1230   create_sheets (wrapbox);
1231   create_color_area (wrapbox);
1232   create_lineprops_area (wrapbox);
1233
1234   /* Setup toolbox area as file drop destination */
1235   gtk_drag_dest_set (wrapbox,
1236                      GTK_DEST_DEFAULT_ALL,
1237                      toolbox_target_table, toolbox_n_targets,
1238                      GDK_ACTION_COPY);
1239   gtk_signal_connect (GTK_OBJECT (wrapbox), "drag_data_received",
1240                       GTK_SIGNAL_FUNC (dia_dnd_file_drag_data_received),
1241                       wrapbox);
1242
1243   /* menus -- initialised afterwards, because initing the display menus
1244    * uses the tool buttons*/
1245   menus_get_toolbox_menubar(&menubar, &accel_group);
1246   gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
1247 #ifdef GNOME
1248   gnome_app_set_menus(GNOME_APP(window), GTK_MENU_BAR(menubar));
1249 #else
1250   gtk_box_pack_start (GTK_BOX (main_vbox), menubar, FALSE, TRUE, 0);
1251   gtk_widget_show (menubar);
1252 #endif
1253
1254   toolbox_shell = window;
1255 }
1256
1257 void
1258 toolbox_show(void)
1259 {
1260   gtk_widget_show(toolbox_shell);
1261 }
1262
1263 void
1264 toolbox_hide(void)
1265 {
1266   gtk_widget_hide(toolbox_shell);
1267 }
1268
1269 void
1270 create_tree_window(void)
1271 {
1272   GtkCheckMenuItem *item = GTK_CHECK_MENU_ITEM
1273     (menus_get_item_from_path("<Toolbox>/File/Diagram tree", NULL));
1274   create_diagram_tree_window(&prefs.dia_tree, GTK_WIDGET(item));
1275 }
1276
1277 GtkWidget *
1278 interface_get_toolbox_shell(void)
1279 {
1280   return toolbox_shell;
1281 }