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