src/xo-callbacks.c

   1 #ifdef HAVE_CONFIG_H
   2 #  include <config.h>
   3 #endif
   4
   5 #include <math.h>
   6 #include <string.h>
   7 #include <gtk/gtk.h>
   8 #include <libgnomecanvas/libgnomecanvas.h>
   9 #include <time.h>
  10 #include <libgnomeprintui/gnome-print-dialog.h>
  11 #include <glib/gstdio.h>
  12
  13 #include "xournal.h"
  14 #include "xo-callbacks.h"
  15 #include "xo-interface.h"
  16 #include "xo-support.h"
  17 #include "xo-misc.h"
  18 #include "xo-file.h"
  19 #include "xo-paint.h"
  20 #include "xo-print.h"
  21
  22 void
  23 on_fileNew_activate                    (GtkMenuItem     *menuitem,
  24                                         gpointer         user_data)
  25 {
  26   end_text();
  27   reset_focus();
  28   if (close_journal()) {
  29     new_journal();
  30     ui.zoom = ui.startup_zoom;
  31     update_page_stuff();
  32     gtk_adjustment_set_value(gtk_layout_get_vadjustment(GTK_LAYOUT(canvas)), 0);
  33     gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
  34   }
  35 }
  36
  37
  38 void
  39 on_fileNewBackground_activate          (GtkMenuItem     *menuitem,
  40                                         gpointer         user_data)
  41 {
  42   GtkWidget *dialog, *attach_opt;
  43   GtkFileFilter *filt_all, *filt_pdf;
  44   char *filename;
  45   int file_domain;
  46   gboolean success;
  47
  48   end_text();
  49   reset_focus();
  50   if (!ok_to_close()) return; // user aborted on save confirmation
  51
  52   dialog = gtk_file_chooser_dialog_new("Open PDF", GTK_WINDOW (winMain),
  53      GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
  54      GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL);
  55
  56   filt_all = gtk_file_filter_new();
  57   gtk_file_filter_set_name(filt_all, "All files");
  58   gtk_file_filter_add_pattern(filt_all, "*");
  59   filt_pdf = gtk_file_filter_new();
  60   gtk_file_filter_set_name(filt_pdf, "PDF files");
  61   gtk_file_filter_add_pattern(filt_pdf, "*.pdf");
  62   gtk_file_filter_add_pattern(filt_pdf, "*.PDF");
  63   gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_pdf);
  64   gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_all);
  65
  66   if (ui.default_path!=NULL) gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (dialog), ui.default_path);
  67
  68   attach_opt = gtk_check_button_new_with_label("Attach file to the journal");
  69   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(attach_opt), FALSE);
  70   gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER (dialog), attach_opt);
  71
  72   if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
  73     gtk_widget_destroy(dialog);
  74     return;
  75   }
  76   filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
  77   if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(attach_opt)))
  78        file_domain = DOMAIN_ATTACH;
  79   else file_domain = DOMAIN_ABSOLUTE;
  80
  81   gtk_widget_destroy(dialog);
  82
  83   set_cursor_busy(TRUE);
  84   ui.saved = TRUE; // force close_journal to work
  85   close_journal();
  86   while (bgpdf.status != STATUS_NOT_INIT) {
  87     // waiting for pdf processes to finish dying
  88     gtk_main_iteration();
  89   }
  90   new_journal();
  91   ui.zoom = ui.startup_zoom;
  92   gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
  93   update_page_stuff();
  94   success = init_bgpdf(filename, TRUE, file_domain);
  95   set_cursor_busy(FALSE);
  96   if (success) {
  97     g_free(filename);
  98     return;
  99   }
 100
 101   /* open failed */
 102   dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
 103     GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Error opening file '%s'", filename);
 104   gtk_dialog_run(GTK_DIALOG(dialog));
 105   gtk_widget_destroy(dialog);
 106   g_free(filename);
 107 }
 108
 109
 110 void
 111 on_fileOpen_activate                   (GtkMenuItem     *menuitem,
 112                                         gpointer         user_data)
 113 {
 114   GtkWidget *dialog;
 115   GtkFileFilter *filt_all, *filt_xoj;
 116   char *filename;
 117   gboolean success;
 118
 119   end_text();
 120   reset_focus();
 121   if (!ok_to_close()) return; // user aborted on save confirmation
 122
 123   dialog = gtk_file_chooser_dialog_new("Open Journal", GTK_WINDOW (winMain),
 124      GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 125      GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL);
 126
 127   filt_all = gtk_file_filter_new();
 128   gtk_file_filter_set_name(filt_all, "All files");
 129   gtk_file_filter_add_pattern(filt_all, "*");
 130   filt_xoj = gtk_file_filter_new();
 131   gtk_file_filter_set_name(filt_xoj, "Xournal files");
 132   gtk_file_filter_add_pattern(filt_xoj, "*.xoj");
 133   gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_xoj);
 134   gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_all);
 135
 136   if (ui.default_path!=NULL) gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (dialog), ui.default_path);
 137
 138   if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
 139     gtk_widget_destroy(dialog);
 140     return;
 141   }
 142   filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
 143   gtk_widget_destroy(dialog);
 144
 145   set_cursor_busy(TRUE);
 146   success = open_journal(filename);
 147   set_cursor_busy(FALSE);
 148   if (success) { g_free(filename); return; }
 149
 150   /* open failed */
 151   dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
 152     GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Error opening file '%s'", filename);
 153   gtk_dialog_run(GTK_DIALOG(dialog));
 154   gtk_widget_destroy(dialog);
 155   g_free(filename);
 156
 157 }
 158
 159
 160 void
 161 on_fileSave_activate                   (GtkMenuItem     *menuitem,
 162                                         gpointer         user_data)
 163 {
 164   GtkWidget *dialog;
 165
 166   end_text();
 167   reset_focus();
 168   if (ui.filename == NULL) {
 169     on_fileSaveAs_activate(menuitem, user_data);
 170     return;
 171   }
 172   set_cursor_busy(TRUE);
 173   if (save_journal(ui.filename)) { // success
 174     set_cursor_busy(FALSE);
 175     ui.saved = TRUE;
 176     return;
 177   }
 178   set_cursor_busy(FALSE);
 179   /* save failed */
 180   dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
 181     GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Error saving file '%s'", ui.filename);
 182   gtk_dialog_run(GTK_DIALOG(dialog));
 183   gtk_widget_destroy(dialog);
 184 }
 185
 186
 187 void
 188 on_fileSaveAs_activate                 (GtkMenuItem     *menuitem,
 189                                         gpointer         user_data)
 190 {
 191   GtkWidget *dialog, *warning_dialog;
 192   GtkFileFilter *filt_all, *filt_xoj;
 193   char *filename;
 194   char stime[30];
 195   time_t curtime;
 196   gboolean warn;
 197   struct stat stat_buf;
 198
 199   end_text();
 200   reset_focus();
 201   dialog = gtk_file_chooser_dialog_new("Save Journal", GTK_WINDOW (winMain),
 202      GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 203      GTK_STOCK_SAVE, GTK_RESPONSE_OK, NULL);
 204
 205   if (ui.filename!=NULL) {
 206     gtk_file_chooser_set_filename(GTK_FILE_CHOOSER (dialog), ui.filename);
 207     gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), g_basename(ui.filename));
 208   }
 209   else
 210   if (bgpdf.status!=STATUS_NOT_INIT && bgpdf.file_domain == DOMAIN_ABSOLUTE
 211       && bgpdf.filename != NULL) {
 212     filename = g_strdup_printf("%s.xoj", bgpdf.filename->s);
 213     gtk_file_chooser_set_filename(GTK_FILE_CHOOSER (dialog), filename);
 214     gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), g_basename(filename));
 215     g_free(filename);
 216   }
 217   else {
 218     curtime = time(NULL);
 219     strftime(stime, 30, "%F-Note-%H-%M.xoj", localtime(&curtime));
 220     if (ui.default_path!=NULL)
 221       gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (dialog), ui.default_path);
 222     gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), stime);
 223   }
 224
 225   filt_all = gtk_file_filter_new();
 226   gtk_file_filter_set_name(filt_all, "All files");
 227   gtk_file_filter_add_pattern(filt_all, "*");
 228   filt_xoj = gtk_file_filter_new();
 229   gtk_file_filter_set_name(filt_xoj, "Xournal files");
 230   gtk_file_filter_add_pattern(filt_xoj, "*.xoj");
 231   gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_xoj);
 232   gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_all);
 233
 234   // somehow this doesn't seem to be set by default
 235   gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
 236
 237   do {
 238     if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
 239       gtk_widget_destroy(dialog);
 240       return;
 241     }
 242     filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
 243     warn = g_file_test (filename, G_FILE_TEST_EXISTS);
 244     if (warn) { // ok to overwrite an empty file
 245       if (!g_stat(filename, &stat_buf))
 246         if (stat_buf.st_size == 0) warn=FALSE;
 247     }
 248     if (warn && ui.filename!=NULL) { // ok to overwrite oneself
 249       if (ui.filename[0]=='/' && !strcmp(ui.filename, filename)) warn=FALSE;
 250       if (ui.filename[0]!='/' && g_str_has_suffix(filename, ui.filename)) warn=FALSE;
 251     }
 252     if (warn) {
 253       warning_dialog = gtk_message_dialog_new(GTK_WINDOW(winMain),
 254         GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO,
 255         "Should the file %s be overwritten?", filename);
 256       if (gtk_dialog_run(GTK_DIALOG(warning_dialog)) == GTK_RESPONSE_YES)
 257         warn = FALSE;
 258       gtk_widget_destroy(warning_dialog);
 259     }
 260   } while (warn);
 261
 262   gtk_widget_destroy(dialog);
 263
 264   set_cursor_busy(TRUE);
 265   if (save_journal(filename)) { // success
 266     ui.saved = TRUE;
 267     set_cursor_busy(FALSE);
 268     update_file_name(filename);
 269     return;
 270   }
 271   set_cursor_busy(FALSE);
 272   /* save failed */
 273   dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
 274     GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Error saving file '%s'", filename);
 275   gtk_dialog_run(GTK_DIALOG(dialog));
 276   gtk_widget_destroy(dialog);
 277   g_free(filename);
 278 }
 279
 280
 281 void
 282 on_filePrintOptions_activate           (GtkMenuItem     *menuitem,
 283                                         gpointer         user_data)
 284 {
 285
 286 }
 287
 288
 289 void
 290 on_filePrint_activate                  (GtkMenuItem     *menuitem,
 291                                         gpointer         user_data)
 292 {
 293   GtkWidget *printDialog, *preview;
 294   GnomePrintJob *gpj;
 295   int fromPage, toPage;
 296   int response;
 297   char *in_fn;
 298   guchar *s;
 299   GnomePrintConfig *config = gnome_print_config_default();
 300
 301   end_text();
 302   reset_focus();
 303   if (ui.filename!=NULL) {
 304     if (g_str_has_suffix(ui.filename, ".xoj")) {
 305       in_fn = g_strdup(ui.filename);
 306       g_strlcpy(g_strrstr(in_fn, "xoj"), "pdf", 4);
 307     }
 308     else
 309       in_fn = g_strdup_printf("%s.pdf", ui.filename);
 310     gnome_print_config_set(config, (guchar *)"Printer", (guchar *)"PDF");
 311     gnome_print_config_set(config, (guchar *)GNOME_PRINT_KEY_OUTPUT_FILENAME, (guchar *)in_fn);
 312     gnome_print_config_set(config, (guchar *)"Settings.Transport.Backend.FileName", (guchar *)in_fn);
 313     g_strlcpy(g_strrstr(in_fn, "pdf"), "ps", 3);
 314     gnome_print_config_set(config, (guchar *)"Printer", (guchar *)"GENERIC");
 315     gnome_print_config_set (config, (guchar *)GNOME_PRINT_KEY_OUTPUT_FILENAME, (guchar *)in_fn);
 316     s = gnome_print_config_get(config, (guchar *)"Settings.Transport.Backend.FileName");
 317     if (s != NULL) {
 318       g_free(s);
 319       gnome_print_config_set(config, (guchar *)"Settings.Transport.Backend.FileName", (guchar *)in_fn);
 320     }
 321     g_free(in_fn);
 322   }
 323
 324   gpj = gnome_print_job_new(config); /* was NULL */
 325   gnome_print_config_unref(config);
 326 /* end */
 327   printDialog = gnome_print_dialog_new(gpj, (guchar *)"Print", GNOME_PRINT_DIALOG_RANGE);
 328   gnome_print_dialog_construct_range_page(GNOME_PRINT_DIALOG(printDialog),
 329     GNOME_PRINT_RANGE_ALL | GNOME_PRINT_RANGE_RANGE,
 330     1, journal.npages, (guchar *)"Current page", (guchar *)"Pages");
 331   /* don't have "Current page" as option, else it becomes the default!! */
 332
 333   gtk_dialog_set_response_sensitive(GTK_DIALOG(printDialog),
 334                          GNOME_PRINT_DIALOG_RESPONSE_PREVIEW, FALSE);
 335   /* the print-job-preview "feature" is completely, hopelessly broken */
 336
 337   response = gtk_dialog_run(GTK_DIALOG(printDialog));
 338   if (response <= 0) {
 339     gtk_widget_destroy(printDialog);
 340     return;
 341   }
 342
 343 /*
 344   if (response == GNOME_PRINT_DIALOG_RESPONSE_PREVIEW) {
 345     print_job_render(gpj, 0, journal.npages-1);
 346     gtk_widget_destroy(printDialog);
 347     preview = gnome_print_job_preview_new(gpj, (guchar *)"Preview");
 348     try_fix_print_preview_ui(preview);
 349     gtk_window_set_modal(GTK_WINDOW(preview), TRUE);
 350     gtk_widget_show_all(preview);
 351   }
 352 */
 353
 354   if (response == GNOME_PRINT_DIALOG_RESPONSE_PRINT) {
 355     switch(gnome_print_dialog_get_range(GNOME_PRINT_DIALOG(printDialog))) {
 356       case GNOME_PRINT_RANGE_RANGE:
 357         gnome_print_dialog_get_range_page(GNOME_PRINT_DIALOG(printDialog), &fromPage, &toPage);
 358         fromPage--;
 359         toPage--;
 360         break;
 361       default:
 362         fromPage = 0;
 363         toPage = journal.npages-1;
 364     }
 365
 366     gtk_widget_destroy(printDialog);
 367     print_job_render(gpj, fromPage, toPage);
 368   }
 369 }
 370
 371
 372 void
 373 on_filePrintPDF_activate               (GtkMenuItem     *menuitem,
 374                                         gpointer         user_data)
 375 {
 376
 377   GtkWidget *dialog, *warning_dialog;
 378   GtkFileFilter *filt_all, *filt_pdf;
 379   char *filename, *in_fn;
 380   char stime[30];
 381   time_t curtime;
 382   int response;
 383   gboolean warn;
 384
 385   end_text();
 386   reset_focus();
 387   dialog = gtk_file_chooser_dialog_new("Export to PDF", GTK_WINDOW (winMain),
 388      GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 389      GTK_STOCK_SAVE, GTK_RESPONSE_OK, NULL);
 390
 391   if (ui.filename!=NULL) {
 392     if (g_str_has_suffix(ui.filename, ".xoj")) {
 393       in_fn = g_strdup(ui.filename);
 394       g_strlcpy(g_strrstr(in_fn, "xoj"), "pdf", 4);
 395     }
 396     else
 397       in_fn = g_strdup_printf("%s.pdf", ui.filename);
 398     gtk_file_chooser_set_filename(GTK_FILE_CHOOSER (dialog), in_fn);
 399     gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), g_basename(in_fn));
 400   } else {
 401     curtime = time(NULL);
 402     strftime(stime, 30, "%F-Note-%H-%M.pdf", localtime(&curtime));
 403     if (ui.default_path!=NULL)
 404       gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (dialog), ui.default_path);
 405     gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), stime);
 406     in_fn = NULL;
 407   }
 408
 409   filt_all = gtk_file_filter_new();
 410   gtk_file_filter_set_name(filt_all, "All files");
 411   gtk_file_filter_add_pattern(filt_all, "*");
 412   filt_pdf = gtk_file_filter_new();
 413   gtk_file_filter_set_name(filt_pdf, "PDF files");
 414   gtk_file_filter_add_pattern(filt_pdf, "*.pdf");
 415   gtk_file_filter_add_pattern(filt_pdf, "*.PDF");
 416   gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_pdf);
 417   gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_all);
 418   gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
 419   g_free(in_fn);
 420
 421   do {
 422     if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
 423       gtk_widget_destroy(dialog);
 424       return;
 425     }
 426     filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
 427     warn = g_file_test(filename, G_FILE_TEST_EXISTS);
 428     if (warn) {
 429       warning_dialog = gtk_message_dialog_new(GTK_WINDOW(winMain),
 430         GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO,
 431         "Should the file %s be overwritten?", filename);
 432       if (gtk_dialog_run(GTK_DIALOG(warning_dialog)) == GTK_RESPONSE_YES)
 433         warn = FALSE;
 434       gtk_widget_destroy(warning_dialog);
 435     }
 436   } while(warn);
 437
 438   gtk_widget_destroy(dialog);
 439
 440   set_cursor_busy(TRUE);
 441   if (!print_to_pdf(filename)) {
 442     set_cursor_busy(FALSE);
 443     dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
 444       GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Error creating file '%s'", filename);
 445     gtk_dialog_run(GTK_DIALOG(dialog));
 446     gtk_widget_destroy(dialog);
 447   }
 448   set_cursor_busy(FALSE);
 449   g_free(filename);
 450 }
 451
 452
 453 void
 454 on_fileQuit_activate                   (GtkMenuItem     *menuitem,
 455                                         gpointer         user_data)
 456 {
 457   end_text();
 458   reset_focus();
 459   if (ok_to_close()) gtk_main_quit ();
 460 }
 461
 462
 463 void
 464 on_editUndo_activate                   (GtkMenuItem     *menuitem,
 465                                         gpointer         user_data)
 466 {
 467   struct UndoItem *u;
 468   GList *list, *itemlist;
 469   struct UndoErasureData *erasure;
 470   struct Item *it;
 471   struct Brush tmp_brush;
 472   struct Background *tmp_bg;
 473   double tmp_x, tmp_y;
 474   gchar *tmpstr;
 475
 476   end_text();
 477   reset_focus();
 478   if (undo == NULL) return; // nothing to undo!
 479   reset_selection(); // safer
 480   if (undo->type == ITEM_STROKE || undo->type == ITEM_TEXT) {
 481     // we're keeping the stroke info, but deleting the canvas item
 482     gtk_object_destroy(GTK_OBJECT(undo->item->canvas_item));
 483     undo->item->canvas_item = NULL;
 484     // we also remove the object from its layer!
 485     undo->layer->items = g_list_remove(undo->layer->items, undo->item);
 486     undo->layer->nitems--;
 487   }
 488   else if (undo->type == ITEM_ERASURE) {
 489     for (list = undo->erasurelist; list!=NULL; list = list->next) {
 490       erasure = (struct UndoErasureData *)list->data;
 491       // delete all the created items
 492       for (itemlist = erasure->replacement_items; itemlist!=NULL; itemlist = itemlist->next) {
 493         it = (struct Item *)itemlist->data;
 494         gtk_object_destroy(GTK_OBJECT(it->canvas_item));
 495         it->canvas_item = NULL;
 496         undo->layer->items = g_list_remove(undo->layer->items, it);
 497         undo->layer->nitems--;
 498       }
 499       // recreate the deleted one
 500       make_canvas_item_one(undo->layer->group, erasure->item);
 501
 502       undo->layer->items = g_list_insert(undo->layer->items, erasure->item,
 503                                                              erasure->npos);
 504       if (erasure->npos == 0)
 505         lower_canvas_item_to(undo->layer->group, erasure->item->canvas_item, NULL);
 506       else
 507         lower_canvas_item_to(undo->layer->group, erasure->item->canvas_item,
 508           ((struct Item *)g_list_nth_data(undo->layer->items, erasure->npos-1))->canvas_item);
 509       undo->layer->nitems++;
 510     }
 511   }
 512   else if (undo->type == ITEM_NEW_BG_ONE || undo->type == ITEM_NEW_BG_RESIZE
 513            || undo->type == ITEM_PAPER_RESIZE) {
 514     if (undo->type != ITEM_PAPER_RESIZE) {
 515       // swap the two bg's
 516       tmp_bg = undo->page->bg;
 517       undo->page->bg = undo->bg;
 518       undo->bg = tmp_bg;
 519       undo->page->bg->canvas_item = undo->bg->canvas_item;
 520       undo->bg->canvas_item = NULL;
 521     }
 522     if (undo->type != ITEM_NEW_BG_ONE) {
 523       tmp_x = undo->page->width;
 524       tmp_y = undo->page->height;
 525       undo->page->width = undo->val_x;
 526       undo->page->height = undo->val_y;
 527       undo->val_x = tmp_x;
 528       undo->val_y = tmp_y;
 529       make_page_clipbox(undo->page);
 530     }
 531     update_canvas_bg(undo->page);
 532     do_switch_page(g_list_index(journal.pages, undo->page), TRUE, TRUE);
 533   }
 534   else if (undo->type == ITEM_NEW_DEFAULT_BG) {
 535     tmp_bg = ui.default_page.bg;
 536     ui.default_page.bg = undo->bg;
 537     undo->bg = tmp_bg;
 538     tmp_x = ui.default_page.width;
 539     tmp_y = ui.default_page.height;
 540     ui.default_page.width = undo->val_x;
 541     ui.default_page.height = undo->val_y;
 542     undo->val_x = tmp_x;
 543     undo->val_y = tmp_y;
 544   }
 545   else if (undo->type == ITEM_NEW_PAGE) {
 546     // unmap the page; keep the page & its empty layer in memory
 547     if (undo->page->group!=NULL) gtk_object_destroy(GTK_OBJECT(undo->page->group));
 548       // also destroys the background and layer's canvas items
 549     undo->page->group = NULL;
 550     undo->page->bg->canvas_item = NULL;
 551     journal.pages = g_list_remove(journal.pages, undo->page);
 552     journal.npages--;
 553     if (ui.cur_page == undo->page) ui.cur_page = NULL;
 554         // so do_switch_page() won't try to remap the layers of the defunct page
 555     if (ui.pageno >= undo->val) ui.pageno--;
 556     if (ui.pageno < 0) ui.pageno = 0;
 557     do_switch_page(ui.pageno, TRUE, TRUE);
 558   }
 559   else if (undo->type == ITEM_DELETE_PAGE) {
 560     journal.pages = g_list_insert(journal.pages, undo->page, undo->val);
 561     journal.npages++;
 562     make_canvas_items(); // re-create the canvas items
 563     do_switch_page(undo->val, TRUE, TRUE);
 564   }
 565   else if (undo->type == ITEM_MOVESEL) {
 566     for (itemlist = undo->itemlist; itemlist != NULL; itemlist = itemlist->next) {
 567       it = (struct Item *)itemlist->data;
 568       if (it->canvas_item != NULL) {
 569         if (undo->layer != undo->layer2)
 570           gnome_canvas_item_reparent(it->canvas_item, undo->layer->group);
 571         gnome_canvas_item_move(it->canvas_item, -undo->val_x, -undo->val_y);
 572       }
 573     }
 574     move_journal_items_by(undo->itemlist, -undo->val_x, -undo->val_y,
 575                             undo->layer2, undo->layer, undo->auxlist);
 576   }
 577   else if (undo->type == ITEM_PASTE) {
 578     for (itemlist = undo->itemlist; itemlist != NULL; itemlist = itemlist->next) {
 579       it = (struct Item *)itemlist->data;
 580       gtk_object_destroy(GTK_OBJECT(it->canvas_item));
 581       it->canvas_item = NULL;
 582       undo->layer->items = g_list_remove(undo->layer->items, it);
 583       undo->layer->nitems--;
 584     }
 585   }
 586   else if (undo->type == ITEM_NEW_LAYER) {
 587     // unmap the layer; keep the empty layer in memory
 588     if (undo->layer->group!=NULL) gtk_object_destroy(GTK_OBJECT(undo->layer->group));
 589     undo->layer->group = NULL;
 590     undo->page->layers = g_list_remove(undo->page->layers, undo->layer);
 591     undo->page->nlayers--;
 592     do_switch_page(ui.pageno, FALSE, FALSE); // don't stay with bad cur_layer info
 593   }
 594   else if (undo->type == ITEM_DELETE_LAYER) {
 595     // special case of -1: deleted the last layer, created a new one
 596     if (undo->val == -1) {
 597       if (undo->layer2->group!=NULL) gtk_object_destroy(GTK_OBJECT(undo->layer2->group));
 598       undo->layer2->group = NULL;
 599       undo->page->layers = g_list_remove(undo->page->layers, undo->layer2);
 600       undo->page->nlayers--;
 601     }
 602     // re-map the layer
 603     undo->layer->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
 604       undo->page->group, gnome_canvas_group_get_type(), NULL);
 605     lower_canvas_item_to(undo->page->group, GNOME_CANVAS_ITEM(undo->layer->group),
 606       (undo->val >= 1) ? GNOME_CANVAS_ITEM(((struct Layer *)
 607             g_list_nth_data(undo->page->layers, undo->val-1))->group) :
 608             undo->page->bg->canvas_item);
 609     undo->page->layers = g_list_insert(undo->page->layers, undo->layer,
 610                                      (undo->val >= 0) ? undo->val:0);
 611     undo->page->nlayers++;
 612
 613     for (itemlist = undo->layer->items; itemlist!=NULL; itemlist = itemlist->next)
 614       make_canvas_item_one(undo->layer->group, (struct Item *)itemlist->data);
 615
 616     do_switch_page(ui.pageno, FALSE, FALSE); // show the restored layer & others...
 617   }
 618   else if (undo->type == ITEM_REPAINTSEL) {
 619     for (itemlist = undo->itemlist, list = undo->auxlist; itemlist!=NULL;
 620            itemlist = itemlist->next, list = list->next) {
 621       it = (struct Item *)itemlist->data;
 622       g_memmove(&tmp_brush, &(it->brush), sizeof(struct Brush));
 623       g_memmove(&(it->brush), list->data, sizeof(struct Brush));
 624       g_memmove(list->data, &tmp_brush, sizeof(struct Brush));
 625       if (it->type == ITEM_STROKE && it->canvas_item != NULL)
 626         gnome_canvas_item_set(it->canvas_item,
 627           "fill-color-rgba", it->brush.color_rgba,
 628           "width-units", it->brush.thickness, NULL);
 629       if (it->type == ITEM_TEXT && it->canvas_item != NULL)
 630         gnome_canvas_item_set(it->canvas_item,
 631           "fill-color-rgba", it->brush.color_rgba, NULL);
 632     }
 633   }
 634   else if (undo->type == ITEM_TEXT_EDIT) {
 635     tmpstr = undo->str;
 636     undo->str = undo->item->text;
 637     undo->item->text = tmpstr;
 638     gnome_canvas_item_set(undo->item->canvas_item, "text", tmpstr, NULL);
 639     update_item_bbox(undo->item);
 640   }
 641   else if (undo->type == ITEM_TEXT_ATTRIB) {
 642     tmpstr = undo->str;
 643     undo->str = undo->item->font_name;
 644     undo->item->font_name = tmpstr;
 645     tmp_x = undo->val_x;
 646     undo->val_x = undo->item->font_size;
 647     undo->item->font_size = tmp_x;
 648     g_memmove(&tmp_brush, undo->brush, sizeof(struct Brush));
 649     g_memmove(undo->brush, &(undo->item->brush), sizeof(struct Brush));
 650     g_memmove(&(undo->item->brush), &tmp_brush, sizeof(struct Brush));
 651     gnome_canvas_item_set(undo->item->canvas_item,
 652       "fill-color-rgba", undo->item->brush.color_rgba, NULL);
 653     update_text_item_displayfont(undo->item);
 654     update_item_bbox(undo->item);
 655   }
 656
 657   // move item from undo to redo stack
 658   u = undo;
 659   undo = undo->next;
 660   u->next = redo;
 661   redo = u;
 662   ui.saved = FALSE;
 663   update_undo_redo_enabled();
 664   if (u->multiop & MULTIOP_CONT_UNDO) on_editUndo_activate(NULL,NULL); // loop
 665 }
 666
 667
 668 void
 669 on_editRedo_activate                   (GtkMenuItem     *menuitem,
 670                                         gpointer         user_data)
 671 {
 672   struct UndoItem *u;
 673   GList *list, *itemlist, *target;
 674   struct UndoErasureData *erasure;
 675   struct Item *it;
 676   struct Brush tmp_brush;
 677   struct Background *tmp_bg;
 678   struct Layer *l;
 679   double tmp_x, tmp_y;
 680   gchar *tmpstr;
 681
 682   end_text();
 683   reset_focus();
 684   if (redo == NULL) return; // nothing to redo!
 685   reset_selection(); // safer
 686   if (redo->type == ITEM_STROKE || redo->type == ITEM_TEXT) {
 687     // re-create the canvas_item
 688     make_canvas_item_one(redo->layer->group, redo->item);
 689     // reinsert the item on its layer
 690     redo->layer->items = g_list_append(redo->layer->items, redo->item);
 691     redo->layer->nitems++;
 692   }
 693   else if (redo->type == ITEM_ERASURE) {
 694     for (list = redo->erasurelist; list!=NULL; list = list->next) {
 695       erasure = (struct UndoErasureData *)list->data;
 696       target = g_list_find(redo->layer->items, erasure->item);
 697       // re-create all the created items
 698       for (itemlist = erasure->replacement_items; itemlist!=NULL; itemlist = itemlist->next) {
 699         it = (struct Item *)itemlist->data;
 700         make_canvas_item_one(redo->layer->group, it);
 701         redo->layer->items = g_list_insert_before(redo->layer->items, target, it);
 702         redo->layer->nitems++;
 703         lower_canvas_item_to(redo->layer->group, it->canvas_item, erasure->item->canvas_item);
 704       }
 705       // re-delete the deleted one
 706       gtk_object_destroy(GTK_OBJECT(erasure->item->canvas_item));
 707       erasure->item->canvas_item = NULL;
 708       redo->layer->items = g_list_delete_link(redo->layer->items, target);
 709       redo->layer->nitems--;
 710     }
 711   }
 712   else if (redo->type == ITEM_NEW_BG_ONE || redo->type == ITEM_NEW_BG_RESIZE
 713            || redo->type == ITEM_PAPER_RESIZE) {
 714     if (redo->type != ITEM_PAPER_RESIZE) {
 715       // swap the two bg's
 716       tmp_bg = redo->page->bg;
 717       redo->page->bg = redo->bg;
 718       redo->bg = tmp_bg;
 719       redo->page->bg->canvas_item = redo->bg->canvas_item;
 720       redo->bg->canvas_item = NULL;
 721     }
 722     if (redo->type != ITEM_NEW_BG_ONE) {
 723       tmp_x = redo->page->width;
 724       tmp_y = redo->page->height;
 725       redo->page->width = redo->val_x;
 726       redo->page->height = redo->val_y;
 727       redo->val_x = tmp_x;
 728       redo->val_y = tmp_y;
 729       make_page_clipbox(redo->page);
 730     }
 731     update_canvas_bg(redo->page);
 732     do_switch_page(g_list_index(journal.pages, redo->page), TRUE, TRUE);
 733   }
 734   else if (redo->type == ITEM_NEW_DEFAULT_BG) {
 735     tmp_bg = ui.default_page.bg;
 736     ui.default_page.bg = redo->bg;
 737     redo->bg = tmp_bg;
 738     tmp_x = ui.default_page.width;
 739     tmp_y = ui.default_page.height;
 740     ui.default_page.width = redo->val_x;
 741     ui.default_page.height = redo->val_y;
 742     redo->val_x = tmp_x;
 743     redo->val_y = tmp_y;
 744   }
 745   else if (redo->type == ITEM_NEW_PAGE) {
 746     // remap the page
 747     redo->page->bg->canvas_item = NULL;
 748     redo->page->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
 749       gnome_canvas_root(canvas), gnome_canvas_clipgroup_get_type(), NULL);
 750     make_page_clipbox(redo->page);
 751     update_canvas_bg(redo->page);
 752     l = (struct Layer *)redo->page->layers->data;
 753     l->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
 754       redo->page->group, gnome_canvas_group_get_type(), NULL);
 755
 756     journal.pages = g_list_insert(journal.pages, redo->page, redo->val);
 757     journal.npages++;
 758     do_switch_page(redo->val, TRUE, TRUE);
 759   }
 760   else if (redo->type == ITEM_DELETE_PAGE) {
 761     // unmap all the canvas items
 762     gtk_object_destroy(GTK_OBJECT(redo->page->group));
 763     redo->page->group = NULL;
 764     redo->page->bg->canvas_item = NULL;
 765     for (list = redo->page->layers; list!=NULL; list = list->next) {
 766       l = (struct Layer *)list->data;
 767       for (itemlist = l->items; itemlist!=NULL; itemlist = itemlist->next)
 768         ((struct Item *)itemlist->data)->canvas_item = NULL;
 769       l->group = NULL;
 770     }
 771     journal.pages = g_list_remove(journal.pages, redo->page);
 772     journal.npages--;
 773     if (ui.pageno > undo->val || ui.pageno == journal.npages) ui.pageno--;
 774     ui.cur_page = NULL;
 775       // so do_switch_page() won't try to remap the layers of the defunct page
 776     do_switch_page(ui.pageno, TRUE, TRUE);
 777   }
 778   else if (redo->type == ITEM_MOVESEL) {
 779     for (itemlist = redo->itemlist; itemlist != NULL; itemlist = itemlist->next) {
 780       it = (struct Item *)itemlist->data;
 781       if (it->canvas_item != NULL) {
 782         if (redo->layer != redo->layer2)
 783           gnome_canvas_item_reparent(it->canvas_item, redo->layer2->group);
 784         gnome_canvas_item_move(it->canvas_item, redo->val_x, redo->val_y);
 785       }
 786     }
 787     move_journal_items_by(redo->itemlist, redo->val_x, redo->val_y,
 788                             redo->layer, redo->layer2, NULL);
 789   }
 790   else if (redo->type == ITEM_PASTE) {
 791     for (itemlist = redo->itemlist; itemlist != NULL; itemlist = itemlist->next) {
 792       it = (struct Item *)itemlist->data;
 793       make_canvas_item_one(redo->layer->group, it);
 794       redo->layer->items = g_list_append(redo->layer->items, it);
 795       redo->layer->nitems++;
 796     }
 797   }
 798   else if (redo->type == ITEM_NEW_LAYER) {
 799     redo->layer->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
 800         redo->page->group, gnome_canvas_group_get_type(), NULL);
 801     lower_canvas_item_to(redo->page->group, GNOME_CANVAS_ITEM(redo->layer->group),
 802       (redo->val >= 1) ? GNOME_CANVAS_ITEM(((struct Layer *)
 803             g_list_nth_data(redo->page->layers, redo->val-1))->group) :
 804             redo->page->bg->canvas_item);
 805     redo->page->layers = g_list_insert(redo->page->layers, redo->layer, redo->val);
 806     redo->page->nlayers++;
 807     do_switch_page(ui.pageno, FALSE, FALSE);
 808   }
 809   else if (redo->type == ITEM_DELETE_LAYER) {
 810     gtk_object_destroy(GTK_OBJECT(redo->layer->group));
 811     redo->layer->group = NULL;
 812     for (list=redo->layer->items; list!=NULL; list=list->next)
 813       ((struct Item *)list->data)->canvas_item = NULL;
 814     redo->page->layers = g_list_remove(redo->page->layers, redo->layer);
 815     redo->page->nlayers--;
 816     if (redo->val == -1) {
 817       redo->layer2->group = (GnomeCanvasGroup *)gnome_canvas_item_new(
 818         redo->page->group, gnome_canvas_group_get_type(), NULL);
 819       redo->page->layers = g_list_append(redo->page->layers, redo->layer2);
 820       redo->page->nlayers++;
 821     }
 822     do_switch_page(ui.pageno, FALSE, FALSE);
 823   }
 824   else if (redo->type == ITEM_REPAINTSEL) {
 825     for (itemlist = redo->itemlist, list = redo->auxlist; itemlist!=NULL;
 826            itemlist = itemlist->next, list = list->next) {
 827       it = (struct Item *)itemlist->data;
 828       g_memmove(&tmp_brush, &(it->brush), sizeof(struct Brush));
 829       g_memmove(&(it->brush), list->data, sizeof(struct Brush));
 830       g_memmove(list->data, &tmp_brush, sizeof(struct Brush));
 831       if (it->type == ITEM_STROKE && it->canvas_item != NULL)
 832         gnome_canvas_item_set(it->canvas_item,
 833           "fill-color-rgba", it->brush.color_rgba,
 834           "width-units", it->brush.thickness, NULL);
 835       if (it->type == ITEM_TEXT && it->canvas_item != NULL)
 836         gnome_canvas_item_set(it->canvas_item,
 837           "fill-color-rgba", it->brush.color_rgba, NULL);
 838     }
 839   }
 840   else if (redo->type == ITEM_TEXT_EDIT) {
 841     tmpstr = redo->str;
 842     redo->str = redo->item->text;
 843     redo->item->text = tmpstr;
 844     gnome_canvas_item_set(redo->item->canvas_item, "text", tmpstr, NULL);
 845     update_item_bbox(redo->item);
 846   }
 847   else if (redo->type == ITEM_TEXT_ATTRIB) {
 848     tmpstr = redo->str;
 849     redo->str = redo->item->font_name;
 850     redo->item->font_name = tmpstr;
 851     tmp_x = redo->val_x;
 852     redo->val_x = redo->item->font_size;
 853     redo->item->font_size = tmp_x;
 854     g_memmove(&tmp_brush, redo->brush, sizeof(struct Brush));
 855     g_memmove(redo->brush, &(redo->item->brush), sizeof(struct Brush));
 856     g_memmove(&(redo->item->brush), &tmp_brush, sizeof(struct Brush));
 857     gnome_canvas_item_set(redo->item->canvas_item,
 858       "fill-color-rgba", redo->item->brush.color_rgba, NULL);
 859     update_text_item_displayfont(redo->item);
 860     update_item_bbox(redo->item);
 861   }
 862
 863   // move item from redo to undo stack
 864   u = redo;
 865   redo = redo->next;
 866   u->next = undo;
 867   undo = u;
 868   ui.saved = FALSE;
 869   update_undo_redo_enabled();
 870   if (u->multiop & MULTIOP_CONT_REDO) on_editRedo_activate(NULL,NULL); // loop
 871 }
 872
 873
 874 void
 875 on_editCut_activate                    (GtkMenuItem     *menuitem,
 876                                         gpointer         user_data)
 877 {
 878   end_text();
 879   reset_focus();
 880   selection_to_clip();
 881   selection_delete();
 882 }
 883
 884
 885 void
 886 on_editCopy_activate                   (GtkMenuItem     *menuitem,
 887                                         gpointer         user_data)
 888 {
 889   end_text();
 890   reset_focus();
 891   selection_to_clip();
 892 }
 893
 894
 895 void
 896 on_editPaste_activate                  (GtkMenuItem     *menuitem,
 897                                         gpointer         user_data)
 898 {
 899   end_text();
 900   reset_focus();
 901   clipboard_paste();
 902 }
 903
 904
 905 void
 906 on_editDelete_activate                 (GtkMenuItem     *menuitem,
 907                                         gpointer         user_data)
 908 {
 909   end_text();
 910   reset_focus();
 911   selection_delete();
 912 }
 913
 914
 915 void
 916 on_viewContinuous_activate             (GtkMenuItem     *menuitem,
 917                                         gpointer         user_data)
 918 {
 919   GtkAdjustment *v_adj;
 920   double yscroll;
 921   struct Page *pg;
 922
 923   reset_focus();
 924   if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
 925   if (ui.view_continuous) return;
 926   ui.view_continuous = TRUE;
 927   v_adj = gtk_layout_get_vadjustment(GTK_LAYOUT(canvas));
 928   pg = ui.cur_page;
 929   yscroll = gtk_adjustment_get_value(v_adj) - pg->voffset*ui.zoom;
 930   update_page_stuff();
 931   gtk_adjustment_set_value(v_adj, yscroll + pg->voffset*ui.zoom);
 932   // force a refresh
 933   gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
 934 }
 935
 936
 937 void
 938 on_viewOnePage_activate                (GtkMenuItem     *menuitem,
 939                                         gpointer         user_data)
 940 {
 941   GtkAdjustment *v_adj;
 942   double yscroll;
 943
 944   reset_focus();
 945   if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
 946   if (!ui.view_continuous) return;
 947   ui.view_continuous = FALSE;
 948   v_adj = gtk_layout_get_vadjustment(GTK_LAYOUT(canvas));
 949   yscroll = gtk_adjustment_get_value(v_adj) - ui.cur_page->voffset*ui.zoom;
 950   update_page_stuff();
 951   gtk_adjustment_set_value(v_adj, yscroll + ui.cur_page->voffset*ui.zoom);
 952   // force a refresh
 953   gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
 954 }
 955
 956
 957 void
 958 on_viewZoomIn_activate                 (GtkMenuItem     *menuitem,
 959                                         gpointer         user_data)
 960 {
 961   reset_focus();
 962   if (ui.zoom > MAX_ZOOM) return;
 963   ui.zoom *= ui.zoom_step_factor;
 964   gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
 965   rescale_text_items();
 966   rescale_bg_pixmaps();
 967 }
 968
 969
 970 void
 971 on_viewZoomOut_activate                (GtkMenuItem     *menuitem,
 972                                         gpointer         user_data)
 973 {
 974   reset_focus();
 975   if (ui.zoom < MIN_ZOOM) return;
 976   ui.zoom /= ui.zoom_step_factor;
 977   gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
 978   rescale_text_items();
 979   rescale_bg_pixmaps();
 980 }
 981
 982
 983 void
 984 on_viewNormalSize_activate             (GtkMenuItem     *menuitem,
 985                                         gpointer         user_data)
 986 {
 987   reset_focus();
 988   ui.zoom = DEFAULT_ZOOM;
 989   gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
 990   rescale_text_items();
 991   rescale_bg_pixmaps();
 992 }
 993
 994
 995 void
 996 on_viewPageWidth_activate              (GtkMenuItem     *menuitem,
 997                                         gpointer         user_data)
 998 {
 999   reset_focus();
1000   ui.zoom = (GTK_WIDGET(canvas))->allocation.width/ui.cur_page->width;
1001   gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
1002   rescale_text_items();
1003   rescale_bg_pixmaps();
1004 }
1005
1006
1007 void
1008 on_viewFirstPage_activate              (GtkMenuItem     *menuitem,
1009                                         gpointer         user_data)
1010 {
1011   end_text();
1012   reset_focus();
1013   do_switch_page(0, TRUE, FALSE);
1014 }
1015
1016
1017 void
1018 on_viewPreviousPage_activate           (GtkMenuItem     *menuitem,
1019                                         gpointer         user_data)
1020 {
1021   end_text();
1022   reset_focus();
1023   if (ui.pageno == 0) return;
1024   do_switch_page(ui.pageno-1, TRUE, FALSE);
1025 }
1026
1027
1028 void
1029 on_viewNextPage_activate               (GtkMenuItem     *menuitem,
1030                                         gpointer         user_data)
1031 {
1032   end_text();
1033   reset_focus();
1034   if (ui.pageno == journal.npages-1) { // create a page at end
1035     if (page_ops_forbidden()) return;
1036     on_journalNewPageEnd_activate(menuitem, user_data);
1037     return;
1038   }
1039   do_switch_page(ui.pageno+1, TRUE, FALSE);
1040 }
1041
1042
1043 void
1044 on_viewLastPage_activate               (GtkMenuItem     *menuitem,
1045                                         gpointer         user_data)
1046 {
1047   end_text();
1048   reset_focus();
1049   do_switch_page(journal.npages-1, TRUE, FALSE);
1050 }
1051
1052
1053 void
1054 on_viewShowLayer_activate              (GtkMenuItem     *menuitem,
1055                                         gpointer         user_data)
1056 {
1057   end_text();
1058   reset_focus();
1059   if (ui.layerno == ui.cur_page->nlayers-1) return;
1060   reset_selection();
1061   ui.layerno++;
1062   ui.cur_layer = g_list_nth_data(ui.cur_page->layers, ui.layerno);
1063   gnome_canvas_item_show(GNOME_CANVAS_ITEM(ui.cur_layer->group));
1064   update_page_stuff();
1065 }
1066
1067
1068 void
1069 on_viewHideLayer_activate              (GtkMenuItem     *menuitem,
1070                                         gpointer         user_data)
1071 {
1072   end_text();
1073   reset_focus();
1074   if (ui.layerno == -1) return;
1075   reset_selection();
1076   gnome_canvas_item_hide(GNOME_CANVAS_ITEM(ui.cur_layer->group));
1077   ui.layerno--;
1078   if (ui.layerno<0) ui.cur_layer = NULL;
1079   else ui.cur_layer = g_list_nth_data(ui.cur_page->layers, ui.layerno);
1080   update_page_stuff();
1081 }
1082
1083
1084 void
1085 on_journalNewPageBefore_activate       (GtkMenuItem     *menuitem,
1086                                         gpointer         user_data)
1087 {
1088   struct Page *pg;
1089
1090   end_text();
1091   reset_focus();
1092   if (page_ops_forbidden()) return;
1093   reset_selection();
1094   pg = new_page(ui.cur_page);
1095   journal.pages = g_list_insert(journal.pages, pg, ui.pageno);
1096   journal.npages++;
1097   do_switch_page(ui.pageno, TRUE, TRUE);
1098
1099   prepare_new_undo();
1100   undo->type = ITEM_NEW_PAGE;
1101   undo->val = ui.pageno;
1102   undo->page = pg;
1103 }
1104
1105
1106 void
1107 on_journalNewPageAfter_activate        (GtkMenuItem     *menuitem,
1108                                         gpointer         user_data)
1109 {
1110   struct Page *pg;
1111
1112   end_text();
1113   reset_focus();
1114   if (page_ops_forbidden()) return;
1115   reset_selection();
1116   pg = new_page(ui.cur_page);
1117   journal.pages = g_list_insert(journal.pages, pg, ui.pageno+1);
1118   journal.npages++;
1119   do_switch_page(ui.pageno+1, TRUE, TRUE);
1120
1121   prepare_new_undo();
1122   undo->type = ITEM_NEW_PAGE;
1123   undo->val = ui.pageno;
1124   undo->page = pg;
1125 }
1126
1127
1128 void
1129 on_journalNewPageEnd_activate          (GtkMenuItem     *menuitem,
1130                                         gpointer         user_data)
1131 {
1132   struct Page *pg;
1133
1134   end_text();
1135   reset_focus();
1136   if (page_ops_forbidden()) return;
1137   reset_selection();
1138   pg = new_page((struct Page *)g_list_last(journal.pages)->data);
1139   journal.pages = g_list_append(journal.pages, pg);
1140   journal.npages++;
1141   do_switch_page(journal.npages-1, TRUE, TRUE);
1142
1143   prepare_new_undo();
1144   undo->type = ITEM_NEW_PAGE;
1145   undo->val = ui.pageno;
1146   undo->page = pg;
1147 }
1148
1149
1150 void
1151 on_journalDeletePage_activate          (GtkMenuItem     *menuitem,
1152                                         gpointer         user_data)
1153 {
1154   GList *layerlist, *itemlist;
1155   struct Layer *l;
1156
1157   end_text();
1158   reset_focus();
1159   if (page_ops_forbidden()) return;
1160   if (journal.npages == 1) return;
1161   reset_selection();
1162   prepare_new_undo();
1163   undo->type = ITEM_DELETE_PAGE;
1164   undo->val = ui.pageno;
1165   undo->page = ui.cur_page;
1166
1167   // unmap all the canvas items
1168   gtk_object_destroy(GTK_OBJECT(ui.cur_page->group));
1169   ui.cur_page->group = NULL;
1170   ui.cur_page->bg->canvas_item = NULL;
1171   for (layerlist = ui.cur_page->layers; layerlist!=NULL; layerlist = layerlist->next) {
1172     l = (struct Layer *)layerlist->data;
1173     for (itemlist = l->items; itemlist!=NULL; itemlist = itemlist->next)
1174       ((struct Item *)itemlist->data)->canvas_item = NULL;
1175     l->group = NULL;
1176   }
1177
1178   journal.pages = g_list_remove(journal.pages, ui.cur_page);
1179   journal.npages--;
1180   if (ui.pageno == journal.npages) ui.pageno--;
1181   ui.cur_page = NULL;
1182      // so do_switch_page() won't try to remap the layers of the defunct page
1183   do_switch_page(ui.pageno, TRUE, TRUE);
1184 }
1185
1186
1187 void
1188 on_journalNewLayer_activate            (GtkMenuItem     *menuitem,
1189                                         gpointer         user_data)
1190 {
1191   struct Layer *l;
1192
1193   end_text();
1194   reset_focus();
1195   reset_selection();
1196   l = g_new(struct Layer, 1);
1197   l->items = NULL;
1198   l->nitems = 0;
1199   l->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
1200     ui.cur_page->group, gnome_canvas_group_get_type(), NULL);
1201   lower_canvas_item_to(ui.cur_page->group, GNOME_CANVAS_ITEM(l->group),
1202     (ui.cur_layer!=NULL)?(GNOME_CANVAS_ITEM(ui.cur_layer->group)):(ui.cur_page->bg->canvas_item));
1203   ui.cur_page->layers = g_list_insert(ui.cur_page->layers, l, ui.layerno+1);
1204   ui.cur_layer = l;
1205   ui.layerno++;
1206   ui.cur_page->nlayers++;
1207   update_page_stuff();
1208
1209   prepare_new_undo();
1210   undo->type = ITEM_NEW_LAYER;
1211   undo->val = ui.layerno;
1212   undo->layer = l;
1213   undo->page = ui.cur_page;
1214 }
1215
1216
1217 void
1218 on_journalDeleteLayer_activate         (GtkMenuItem     *menuitem,
1219                                         gpointer         user_data)
1220 {
1221   GList *list;
1222
1223   end_text();
1224   reset_focus();
1225   if (ui.cur_layer == NULL) return;
1226   reset_selection();
1227   prepare_new_undo();
1228   undo->type = ITEM_DELETE_LAYER;
1229   undo->val = ui.layerno;
1230   undo->layer = ui.cur_layer;
1231   undo->layer2 = NULL;
1232   undo->page = ui.cur_page;
1233   // delete all the canvas items
1234   gtk_object_destroy(GTK_OBJECT(ui.cur_layer->group));
1235   ui.cur_layer->group = NULL;
1236   for (list=ui.cur_layer->items; list!=NULL; list=list->next)
1237     ((struct Item *)list->data)->canvas_item = NULL;
1238
1239   ui.cur_page->layers = g_list_remove(ui.cur_page->layers, ui.cur_layer);
1240
1241   if (ui.cur_page->nlayers>=2) {
1242     ui.cur_page->nlayers--;
1243     ui.layerno--;
1244     if (ui.layerno<0) ui.cur_layer = NULL;
1245     else ui.cur_layer = (struct Layer *)g_list_nth_data(ui.cur_page->layers, ui.layerno);
1246   }
1247   else { // special case: can't remove the last layer
1248     ui.cur_layer = g_new(struct Layer, 1);
1249     ui.cur_layer->items = NULL;
1250     ui.cur_layer->nitems = 0;
1251     ui.cur_layer->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
1252       ui.cur_page->group, gnome_canvas_group_get_type(), NULL);
1253     ui.cur_page->layers = g_list_append(NULL, ui.cur_layer);
1254     undo->val = -1;
1255     undo->layer2 = ui.cur_layer;
1256   }
1257
1258   update_page_stuff();
1259 }
1260
1261
1262 void
1263 on_journalFlatten_activate             (GtkMenuItem     *menuitem,
1264                                         gpointer         user_data)
1265 {
1266
1267 }
1268
1269
1270 // the paper sizes dialog
1271
1272 GtkWidget *papersize_dialog;
1273 int papersize_std, papersize_unit;
1274 double papersize_width, papersize_height;
1275 gboolean papersize_need_init, papersize_width_valid, papersize_height_valid;
1276
1277 #define STD_SIZE_A4 0
1278 #define STD_SIZE_A4R 1
1279 #define STD_SIZE_LETTER 2
1280 #define STD_SIZE_LETTER_R 3
1281 #define STD_SIZE_CUSTOM 4
1282
1283 double unit_sizes[4] = {28.346, 72., 72./DISPLAY_DPI_DEFAULT, 1.};
1284 double std_widths[STD_SIZE_CUSTOM] =  {595.27, 841.89, 612., 792.};
1285 double std_heights[STD_SIZE_CUSTOM] = {841.89, 595.27, 792., 612.};
1286 double std_units[STD_SIZE_CUSTOM] = {UNIT_CM, UNIT_CM, UNIT_IN, UNIT_IN};
1287
1288 void
1289 on_journalPaperSize_activate           (GtkMenuItem     *menuitem,
1290                                         gpointer         user_data)
1291 {
1292   int i, response;
1293   struct Page *pg;
1294   GList *pglist;
1295
1296   end_text();
1297   reset_focus();
1298   papersize_dialog = create_papersizeDialog();
1299   papersize_width = ui.cur_page->width;
1300   papersize_height = ui.cur_page->height;
1301   papersize_unit = ui.default_unit;
1302   unit_sizes[UNIT_PX] = 1./DEFAULT_ZOOM;
1303 //  if (ui.cur_page->bg->type == BG_PIXMAP) papersize_unit = UNIT_PX;
1304   papersize_std = STD_SIZE_CUSTOM;
1305   for (i=0;i<STD_SIZE_CUSTOM;i++)
1306     if (fabs(papersize_width - std_widths[i])<0.1 &&
1307         fabs(papersize_height - std_heights[i])<0.1)
1308       { papersize_std = i; papersize_unit = std_units[i]; }
1309   papersize_need_init = TRUE;
1310   papersize_width_valid = papersize_height_valid = TRUE;
1311
1312   gtk_widget_show(papersize_dialog);
1313   on_comboStdSizes_changed(GTK_COMBO_BOX(g_object_get_data(
1314        G_OBJECT(papersize_dialog), "comboStdSizes")), NULL);
1315   gtk_dialog_set_default_response(GTK_DIALOG(papersize_dialog), GTK_RESPONSE_OK);
1316
1317   response = gtk_dialog_run(GTK_DIALOG(papersize_dialog));
1318   gtk_widget_destroy(papersize_dialog);
1319   if (response != GTK_RESPONSE_OK) return;
1320
1321   pg = ui.cur_page;
1322   for (pglist = journal.pages; pglist!=NULL; pglist = pglist->next) {
1323     if (ui.bg_apply_all_pages) pg = (struct Page *)pglist->data;
1324     prepare_new_undo();
1325     if (ui.bg_apply_all_pages) {
1326       if (pglist->next!=NULL) undo->multiop |= MULTIOP_CONT_REDO;
1327       if (pglist->prev!=NULL) undo->multiop |= MULTIOP_CONT_UNDO;
1328     }
1329     undo->type = ITEM_PAPER_RESIZE;
1330     undo->page = pg;
1331     undo->val_x = pg->width;
1332     undo->val_y = pg->height;
1333     if (papersize_width_valid) pg->width = papersize_width;
1334     if (papersize_height_valid) pg->height = papersize_height;
1335     make_page_clipbox(pg);
1336     update_canvas_bg(pg);
1337     if (!ui.bg_apply_all_pages) break;
1338   }
1339   do_switch_page(ui.pageno, TRUE, TRUE);
1340 }
1341
1342
1343 void
1344 on_papercolorWhite_activate            (GtkMenuItem     *menuitem,
1345                                         gpointer         user_data)
1346 {
1347   end_text();
1348   reset_focus();
1349   process_papercolor_activate(menuitem, COLOR_WHITE);
1350 }
1351
1352
1353 void
1354 on_papercolorYellow_activate           (GtkMenuItem     *menuitem,
1355                                         gpointer         user_data)
1356 {
1357   end_text();
1358   reset_focus();
1359   process_papercolor_activate(menuitem, COLOR_YELLOW);
1360 }
1361
1362
1363 void
1364 on_papercolorPink_activate             (GtkMenuItem     *menuitem,
1365                                         gpointer         user_data)
1366 {
1367   end_text();
1368   reset_focus();
1369   process_papercolor_activate(menuitem, COLOR_RED);
1370 }
1371
1372
1373 void
1374 on_papercolorOrange_activate           (GtkMenuItem     *menuitem,
1375                                         gpointer         user_data)
1376 {
1377   end_text();
1378   reset_focus();
1379   process_papercolor_activate(menuitem, COLOR_ORANGE);
1380 }
1381
1382
1383 void
1384 on_papercolorBlue_activate             (GtkMenuItem     *menuitem,
1385                                         gpointer         user_data)
1386 {
1387   end_text();
1388   reset_focus();
1389   process_papercolor_activate(menuitem, COLOR_BLUE);
1390 }
1391
1392
1393 void
1394 on_papercolorGreen_activate            (GtkMenuItem     *menuitem,
1395                                         gpointer         user_data)
1396 {
1397   end_text();
1398   reset_focus();
1399   process_papercolor_activate(menuitem, COLOR_GREEN);
1400 }
1401
1402
1403 void
1404 on_papercolorOther_activate            (GtkMenuItem     *menuitem,
1405                                         gpointer         user_data)
1406 {
1407
1408 }
1409
1410
1411 void
1412 on_paperstylePlain_activate            (GtkMenuItem     *menuitem,
1413                                         gpointer         user_data)
1414 {
1415   end_text();
1416   reset_focus();
1417   process_paperstyle_activate(menuitem, RULING_NONE);
1418 }
1419
1420
1421 void
1422 on_paperstyleLined_activate            (GtkMenuItem     *menuitem,
1423                                         gpointer         user_data)
1424 {
1425   end_text();
1426   reset_focus();
1427   process_paperstyle_activate(menuitem, RULING_LINED);
1428 }
1429
1430
1431 void
1432 on_paperstyleRuled_activate            (GtkMenuItem     *menuitem,
1433                                         gpointer         user_data)
1434 {
1435   end_text();
1436   reset_focus();
1437   process_paperstyle_activate(menuitem, RULING_RULED);
1438 }
1439
1440
1441 void
1442 on_paperstyleGraph_activate            (GtkMenuItem     *menuitem,
1443                                         gpointer         user_data)
1444 {
1445   end_text();
1446   reset_focus();
1447   process_paperstyle_activate(menuitem, RULING_GRAPH);
1448 }
1449
1450
1451 void
1452 on_journalLoadBackground_activate      (GtkMenuItem     *menuitem,
1453                                         gpointer         user_data)
1454 {
1455   GtkWidget *dialog, *attach_opt;
1456   struct Background *bg;
1457   struct Page *pg;
1458   int pageno;
1459   GList *bglist, *bglistiter;
1460   GtkFileFilter *filt_all, *filt_pix, *filt_pspdf;
1461   char *filename;
1462   gboolean attach;
1463
1464   end_text();
1465   reset_focus();
1466   dialog = gtk_file_chooser_dialog_new("Open Background", GTK_WINDOW (winMain),
1467      GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1468      GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL);
1469
1470   filt_all = gtk_file_filter_new();
1471   gtk_file_filter_set_name(filt_all, "All files");
1472   gtk_file_filter_add_pattern(filt_all, "*");
1473   gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_all);
1474
1475 #if GTK_CHECK_VERSION(2,6,0)
1476
1477   if (!gtk_check_version(2, 6, 0)) {
1478     filt_pix = gtk_file_filter_new();
1479     gtk_file_filter_set_name(filt_pix, "Bitmap files");
1480     gtk_file_filter_add_pixbuf_formats(filt_pix);
1481     gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_pix);
1482   }
1483
1484 #endif
1485
1486   filt_pspdf = gtk_file_filter_new();
1487   gtk_file_filter_set_name(filt_pspdf, "PS/PDF files (as bitmaps)");
1488   gtk_file_filter_add_pattern(filt_pspdf, "*.ps");
1489   gtk_file_filter_add_pattern(filt_pspdf, "*.PS");
1490   gtk_file_filter_add_pattern(filt_pspdf, "*.pdf");
1491   gtk_file_filter_add_pattern(filt_pspdf, "*.PDF");
1492   gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_pspdf);
1493
1494   attach_opt = gtk_check_button_new_with_label("Attach file to the journal");
1495   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(attach_opt), FALSE);
1496   gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER (dialog), attach_opt);
1497
1498   if (ui.default_path!=NULL) gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (dialog), ui.default_path);
1499
1500   if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
1501     gtk_widget_destroy(dialog);
1502     return;
1503   }
1504   filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
1505   attach = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(attach_opt));
1506   gtk_widget_destroy(dialog);
1507
1508   set_cursor_busy(TRUE);
1509   bg = attempt_load_pix_bg(filename, attach);
1510   if (bg != NULL) bglist = g_list_append(NULL, bg);
1511   else bglist = attempt_load_gv_bg(filename);
1512   set_cursor_busy(FALSE);
1513
1514   if (bglist == NULL) {
1515     dialog = gtk_message_dialog_new(GTK_WINDOW(winMain), GTK_DIALOG_MODAL,
1516       GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
1517       "Error opening background '%s'", filename);
1518     gtk_dialog_run(GTK_DIALOG(dialog));
1519     gtk_widget_destroy(dialog);
1520     g_free(filename);
1521     return;
1522   }
1523
1524   g_free(filename);
1525   reset_selection();
1526   pageno = ui.pageno;
1527
1528   for (bglistiter = bglist, pageno = ui.pageno;
1529            bglistiter!=NULL; bglistiter = bglistiter->next, pageno++) {
1530     prepare_new_undo();
1531     if (bglistiter->next!=NULL) undo->multiop |= MULTIOP_CONT_REDO;
1532     if (bglistiter->prev!=NULL) undo->multiop |= MULTIOP_CONT_UNDO;
1533
1534     bg = (struct Background *)bglistiter->data;
1535
1536     if (pageno == journal.npages) {
1537       undo->type = ITEM_NEW_PAGE;
1538       pg = new_page_with_bg(bg,
1539               gdk_pixbuf_get_width(bg->pixbuf)/bg->pixbuf_scale,
1540               gdk_pixbuf_get_height(bg->pixbuf)/bg->pixbuf_scale);
1541       journal.pages = g_list_append(journal.pages, pg);
1542       journal.npages++;
1543       undo->val = pageno;
1544       undo->page = pg;
1545     } else
1546     {
1547       pg = g_list_nth_data(journal.pages, pageno);
1548       undo->type = ITEM_NEW_BG_RESIZE;
1549       undo->page = pg;
1550       undo->bg = pg->bg;
1551       bg->canvas_item = undo->bg->canvas_item;
1552       undo->bg->canvas_item = NULL;
1553       undo->val_x = pg->width;
1554       undo->val_y = pg->height;
1555       pg->bg = bg;
1556       pg->width = gdk_pixbuf_get_width(bg->pixbuf)/bg->pixbuf_scale;
1557       pg->height = gdk_pixbuf_get_height(bg->pixbuf)/bg->pixbuf_scale;
1558       make_page_clipbox(pg);
1559       update_canvas_bg(pg);
1560     }
1561   }
1562
1563   g_list_free(bglist);
1564   if (ui.zoom != DEFAULT_ZOOM) {
1565     ui.zoom = DEFAULT_ZOOM;
1566     gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
1567     rescale_text_items();
1568     rescale_bg_pixmaps();
1569   }
1570   do_switch_page(ui.pageno, TRUE, TRUE);
1571 }
1572
1573 void
1574 on_journalScreenshot_activate          (GtkMenuItem     *menuitem,
1575                                         gpointer         user_data)
1576 {
1577   struct Background *bg;
1578
1579   end_text();
1580   reset_focus();
1581   reset_selection();
1582   gtk_window_iconify(GTK_WINDOW(winMain)); // hide ourselves
1583   gdk_display_sync(gdk_display_get_default());
1584
1585   if (ui.cursor!=NULL)
1586     gdk_cursor_unref(ui.cursor);
1587   ui.cursor = gdk_cursor_new(GDK_TCROSS);
1588
1589   bg = attempt_screenshot_bg();
1590
1591   gtk_window_deiconify(GTK_WINDOW(winMain));
1592   update_cursor();
1593   if (bg==NULL) return;
1594
1595   prepare_new_undo();
1596   undo->type = ITEM_NEW_BG_RESIZE;
1597   undo->page = ui.cur_page;
1598   undo->bg = ui.cur_page->bg;
1599   bg->canvas_item = undo->bg->canvas_item;
1600   undo->bg->canvas_item = NULL;
1601   undo->val_x = ui.cur_page->width;
1602   undo->val_y = ui.cur_page->height;
1603
1604   ui.cur_page->bg = bg;
1605   ui.cur_page->width = gdk_pixbuf_get_width(bg->pixbuf)/bg->pixbuf_scale;
1606   ui.cur_page->height = gdk_pixbuf_get_height(bg->pixbuf)/bg->pixbuf_scale;
1607
1608   make_page_clipbox(ui.cur_page);
1609   update_canvas_bg(ui.cur_page);
1610
1611   if (ui.zoom != DEFAULT_ZOOM) {
1612     ui.zoom = DEFAULT_ZOOM;
1613     gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
1614     rescale_text_items();
1615     rescale_bg_pixmaps();
1616   }
1617   do_switch_page(ui.pageno, TRUE, TRUE);
1618 }
1619
1620
1621 void
1622 on_journalApplyAllPages_activate       (GtkMenuItem     *menuitem,
1623                                         gpointer         user_data)
1624 {
1625   gboolean active;
1626
1627   end_text();
1628   reset_focus();
1629   active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
1630   if (active == ui.bg_apply_all_pages) return;
1631   ui.bg_apply_all_pages = active;
1632   update_page_stuff();
1633
1634 /* THIS IS THE OLD VERSION OF THE FEATURE -- APPLIED CURRENT BG TO ALL
1635   struct Page *page;
1636   GList *pglist;
1637
1638   if (ui.cur_page->bg->type != BG_SOLID) return;
1639   reset_selection();
1640   for (pglist = journal.pages; pglist!=NULL; pglist = pglist->next) {
1641     page = (struct Page *)pglist->data;
1642     prepare_new_undo();
1643     undo->type = ITEM_NEW_BG_RESIZE;
1644     undo->page = page;
1645     undo->bg = page->bg;
1646     undo->val_x = page->width;
1647     undo->val_y = page->height;
1648     if (pglist->next!=NULL) undo->multiop |= MULTIOP_CONT_REDO;
1649     if (pglist->prev!=NULL) undo->multiop |= MULTIOP_CONT_UNDO;
1650     page->bg = (struct Background *)g_memdup(ui.cur_page->bg, sizeof(struct Background));
1651     page->width = ui.cur_page->width;
1652     page->height = ui.cur_page->height;
1653     page->bg->canvas_item = undo->bg->canvas_item;
1654     undo->bg->canvas_item = NULL;
1655
1656     make_page_clipbox(page);
1657     update_canvas_bg(page);
1658   }
1659   do_switch_page(ui.pageno, TRUE, TRUE);
1660 */
1661
1662 }
1663
1664
1665 void
1666 on_toolsPen_activate                   (GtkMenuItem     *menuitem,
1667                                         gpointer         user_data)
1668 {
1669   if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1670     if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1671       return;
1672   } else {
1673     if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1674       return;
1675   }
1676
1677   if (ui.cur_mapping != 0) return;
1678   if (ui.toolno[0] == TOOL_PEN) return;
1679
1680   end_text();
1681   reset_focus();
1682   reset_selection();
1683   ui.toolno[0] = TOOL_PEN;
1684   ui.ruler[0] = FALSE;
1685   ui.cur_brush = &(ui.brushes[0][TOOL_PEN]);
1686   update_mapping_linkings(TOOL_PEN);
1687   update_tool_buttons();
1688   update_tool_menu();
1689   update_color_menu();
1690   update_cursor();
1691 }
1692
1693
1694 void
1695 on_toolsEraser_activate                (GtkMenuItem     *menuitem,
1696                                         gpointer         user_data)
1697 {
1698   if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1699     if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1700       return;
1701   } else {
1702     if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1703       return;
1704   }
1705
1706   if (ui.cur_mapping != 0) return;
1707   if (ui.toolno[0] == TOOL_ERASER) return;
1708
1709   end_text();
1710   reset_focus();
1711   reset_selection();
1712   ui.toolno[0] = TOOL_ERASER;
1713   ui.ruler[0] = FALSE;
1714   ui.cur_brush = &(ui.brushes[0][TOOL_ERASER]);
1715   update_mapping_linkings(TOOL_ERASER);
1716   update_tool_buttons();
1717   update_tool_menu();
1718   update_color_menu();
1719   update_cursor();
1720 }
1721
1722
1723 void
1724 on_toolsHighlighter_activate           (GtkMenuItem     *menuitem,
1725                                         gpointer         user_data)
1726 {
1727   if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1728     if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1729       return;
1730   } else {
1731     if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1732       return;
1733   }
1734
1735   if (ui.cur_mapping != 0) return; // not user-generated
1736   if (ui.toolno[0] == TOOL_HIGHLIGHTER) return;
1737
1738   end_text();
1739   reset_focus();
1740   reset_selection();
1741   ui.toolno[0] = TOOL_HIGHLIGHTER;
1742   ui.ruler[0] = FALSE;
1743   ui.cur_brush = &(ui.brushes[0][TOOL_HIGHLIGHTER]);
1744   update_mapping_linkings(TOOL_HIGHLIGHTER);
1745   update_tool_buttons();
1746   update_tool_menu();
1747   update_color_menu();
1748   update_cursor();
1749 }
1750
1751
1752 void
1753 on_toolsText_activate                  (GtkMenuItem     *menuitem,
1754                                         gpointer         user_data)
1755 {
1756   if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1757     if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1758       return;
1759   } else {
1760     if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1761       return;
1762   }
1763
1764   if (ui.cur_mapping != 0) return; // not user-generated
1765   if (ui.toolno[0] == TOOL_TEXT) return;
1766
1767   reset_focus();
1768   reset_selection();
1769   ui.toolno[0] = TOOL_TEXT;
1770   ui.ruler[0] = FALSE;
1771   ui.cur_brush = &(ui.brushes[0][TOOL_PEN]);
1772   update_mapping_linkings(-1);
1773   update_tool_buttons();
1774   update_tool_menu();
1775   update_color_menu();
1776   update_cursor();
1777 }
1778
1779
1780 void
1781 on_toolsSelectRegion_activate          (GtkMenuItem     *menuitem,
1782                                         gpointer         user_data)
1783 {
1784
1785 }
1786
1787
1788 void
1789 on_toolsSelectRectangle_activate       (GtkMenuItem     *menuitem,
1790                                         gpointer         user_data)
1791 {
1792   if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1793     if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1794       return;
1795   } else {
1796     if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1797       return;
1798   }
1799
1800   if (ui.cur_mapping != 0) return; // not user-generated
1801   if (ui.toolno[0] == TOOL_SELECTRECT) return;
1802
1803   end_text();
1804   reset_focus();
1805   ui.toolno[0] = TOOL_SELECTRECT;
1806   ui.ruler[0] = FALSE;
1807   update_mapping_linkings(-1);
1808   update_tool_buttons();
1809   update_tool_menu();
1810   update_color_menu();
1811   update_cursor();
1812 }
1813
1814
1815 void
1816 on_toolsVerticalSpace_activate         (GtkMenuItem     *menuitem,
1817                                         gpointer         user_data)
1818 {
1819   if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1820     if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1821       return;
1822   } else {
1823     if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1824       return;
1825   }
1826
1827   if (ui.cur_mapping != 0) return; // not user-generated
1828   if (ui.toolno[0] == TOOL_VERTSPACE) return;
1829
1830   end_text();
1831   reset_focus();
1832   reset_selection();
1833   ui.toolno[0] = TOOL_VERTSPACE;
1834   ui.ruler[0] = FALSE;
1835   update_mapping_linkings(-1);
1836   update_tool_buttons();
1837   update_tool_menu();
1838   update_color_menu();
1839   update_cursor();
1840 }
1841
1842
1843 void
1844 on_colorBlack_activate                 (GtkMenuItem     *menuitem,
1845                                         gpointer         user_data)
1846 {
1847   process_color_activate(menuitem, COLOR_BLACK);
1848 }
1849
1850
1851 void
1852 on_colorBlue_activate                  (GtkMenuItem     *menuitem,
1853                                         gpointer         user_data)
1854 {
1855   process_color_activate(menuitem, COLOR_BLUE);
1856
1857 }
1858
1859
1860 void
1861 on_colorRed_activate                   (GtkMenuItem     *menuitem,
1862                                         gpointer         user_data)
1863 {
1864   process_color_activate(menuitem, COLOR_RED);
1865 }
1866
1867
1868 void
1869 on_colorGreen_activate                 (GtkMenuItem     *menuitem,
1870                                         gpointer         user_data)
1871 {
1872   process_color_activate(menuitem, COLOR_GREEN);
1873 }
1874
1875
1876 void
1877 on_colorGray_activate                  (GtkMenuItem     *menuitem,
1878                                         gpointer         user_data)
1879 {
1880   process_color_activate(menuitem, COLOR_GRAY);
1881 }
1882
1883
1884 void
1885 on_colorLightBlue_activate             (GtkMenuItem     *menuitem,
1886                                         gpointer         user_data)
1887 {
1888   process_color_activate(menuitem, COLOR_LIGHTBLUE);
1889 }
1890
1891
1892 void
1893 on_colorLightGreen_activate            (GtkMenuItem     *menuitem,
1894                                         gpointer         user_data)
1895 {
1896   process_color_activate(menuitem, COLOR_LIGHTGREEN);
1897 }
1898
1899
1900 void
1901 on_colorMagenta_activate               (GtkMenuItem     *menuitem,
1902                                         gpointer         user_data)
1903 {
1904   process_color_activate(menuitem, COLOR_MAGENTA);
1905 }
1906
1907
1908 void
1909 on_colorOrange_activate                (GtkMenuItem     *menuitem,
1910                                         gpointer         user_data)
1911 {
1912   process_color_activate(menuitem, COLOR_ORANGE);
1913 }
1914
1915
1916 void
1917 on_colorYellow_activate                (GtkMenuItem     *menuitem,
1918                                         gpointer         user_data)
1919 {
1920   process_color_activate(menuitem, COLOR_YELLOW);
1921 }
1922
1923
1924 void
1925 on_colorWhite_activate                 (GtkMenuItem     *menuitem,
1926                                         gpointer         user_data)
1927 {
1928   process_color_activate(menuitem, COLOR_WHITE);
1929 }
1930
1931
1932 void
1933 on_colorOther_activate                 (GtkMenuItem     *menuitem,
1934                                         gpointer         user_data)
1935 {
1936
1937 }
1938
1939
1940 void
1941 on_penthicknessVeryFine_activate       (GtkMenuItem     *menuitem,
1942                                         gpointer         user_data)
1943 {
1944   process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_VERYFINE);
1945 }
1946
1947
1948 void
1949 on_penthicknessFine_activate           (GtkMenuItem     *menuitem,
1950                                         gpointer         user_data)
1951 {
1952   process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_FINE);
1953 }
1954
1955
1956 void
1957 on_penthicknessMedium_activate         (GtkMenuItem     *menuitem,
1958                                         gpointer         user_data)
1959 {
1960   process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_MEDIUM);
1961 }
1962
1963
1964 void
1965 on_penthicknessThick_activate          (GtkMenuItem     *menuitem,
1966                                         gpointer         user_data)
1967 {
1968   process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_THICK);
1969 }
1970
1971
1972 void
1973 on_penthicknessVeryThick_activate      (GtkMenuItem     *menuitem,
1974                                         gpointer         user_data)
1975 {
1976   process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_VERYTHICK);
1977 }
1978
1979
1980 void
1981 on_eraserFine_activate                 (GtkMenuItem     *menuitem,
1982                                         gpointer         user_data)
1983 {
1984   process_thickness_activate(menuitem, TOOL_ERASER, THICKNESS_FINE);
1985 }
1986
1987
1988 void
1989 on_eraserMedium_activate               (GtkMenuItem     *menuitem,
1990                                         gpointer         user_data)
1991 {
1992   process_thickness_activate(menuitem, TOOL_ERASER, THICKNESS_MEDIUM);
1993 }
1994
1995
1996 void
1997 on_eraserThick_activate                (GtkMenuItem     *menuitem,
1998                                         gpointer         user_data)
1999 {
2000   process_thickness_activate(menuitem, TOOL_ERASER, THICKNESS_THICK);
2001 }
2002
2003
2004 void
2005 on_eraserStandard_activate             (GtkMenuItem     *menuitem,
2006                                         gpointer         user_data)
2007 {
2008   if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
2009   end_text();
2010   reset_focus();
2011   ui.brushes[0][TOOL_ERASER].tool_options = TOOLOPT_ERASER_STANDARD;
2012   update_mapping_linkings(TOOL_ERASER);
2013 }
2014
2015
2016 void
2017 on_eraserWhiteout_activate             (GtkMenuItem     *menuitem,
2018                                         gpointer         user_data)
2019 {
2020   if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
2021   end_text();
2022   reset_focus();
2023   ui.brushes[0][TOOL_ERASER].tool_options = TOOLOPT_ERASER_WHITEOUT;
2024   update_mapping_linkings(TOOL_ERASER);
2025 }
2026
2027
2028 void
2029 on_eraserDeleteStrokes_activate        (GtkMenuItem     *menuitem,
2030                                         gpointer         user_data)
2031 {
2032   if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
2033   end_text();
2034   reset_focus();
2035   ui.brushes[0][TOOL_ERASER].tool_options = TOOLOPT_ERASER_STROKES;
2036   update_mapping_linkings(TOOL_ERASER);
2037 }
2038
2039
2040 void
2041 on_highlighterFine_activate            (GtkMenuItem     *menuitem,
2042                                         gpointer         user_data)
2043 {
2044   process_thickness_activate(menuitem, TOOL_HIGHLIGHTER, THICKNESS_FINE);
2045 }
2046
2047
2048 void
2049 on_highlighterMedium_activate          (GtkMenuItem     *menuitem,
2050                                         gpointer         user_data)
2051 {
2052   process_thickness_activate(menuitem, TOOL_HIGHLIGHTER, THICKNESS_MEDIUM);
2053 }
2054
2055
2056 void
2057 on_highlighterThick_activate           (GtkMenuItem     *menuitem,
2058                                         gpointer         user_data)
2059 {
2060   process_thickness_activate(menuitem, TOOL_HIGHLIGHTER, THICKNESS_THICK);
2061 }
2062
2063
2064 void
2065 on_toolsTextFont_activate              (GtkMenuItem     *menuitem,
2066                                         gpointer         user_data)
2067 {
2068   GtkWidget *dialog;
2069   gchar *str;
2070
2071   dialog = gtk_font_selection_dialog_new("Select Font");
2072   str = make_cur_font_name();
2073   gtk_font_selection_dialog_set_font_name(GTK_FONT_SELECTION_DIALOG(dialog), str);
2074   g_free(str);
2075   if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
2076     gtk_widget_destroy(dialog);
2077     reset_focus();
2078     return;
2079   }
2080   str = gtk_font_selection_dialog_get_font_name(GTK_FONT_SELECTION_DIALOG(dialog));
2081   gtk_widget_destroy(dialog);
2082   process_font_sel(str);
2083 }
2084
2085 void
2086 on_toolsDefaultPen_activate            (GtkMenuItem     *menuitem,
2087                                         gpointer         user_data)
2088 {
2089   switch_mapping(0);
2090   end_text();
2091   reset_focus();
2092   reset_selection();
2093   g_memmove(&(ui.brushes[0][TOOL_PEN]), ui.default_brushes+TOOL_PEN, sizeof(struct Brush));
2094   ui.toolno[0] = TOOL_PEN;
2095   ui.cur_brush = &(ui.brushes[0][TOOL_PEN]);
2096   ui.ruler[0] = FALSE;
2097   update_mapping_linkings(TOOL_PEN);
2098   update_tool_buttons();
2099   update_tool_menu();
2100   update_pen_props_menu();
2101   update_color_menu();
2102   update_cursor();
2103 }
2104
2105
2106 void
2107 on_toolsDefaultEraser_activate         (GtkMenuItem     *menuitem,
2108                                         gpointer         user_data)
2109 {
2110   switch_mapping(0);
2111   end_text();
2112   reset_focus();
2113   reset_selection();
2114   g_memmove(&(ui.brushes[0][TOOL_ERASER]), ui.default_brushes+TOOL_ERASER, sizeof(struct Brush));
2115   ui.toolno[0] = TOOL_ERASER;
2116   ui.cur_brush = &(ui.brushes[0][TOOL_ERASER]);
2117   ui.ruler[0] = FALSE;
2118   update_mapping_linkings(TOOL_ERASER);
2119   update_tool_buttons();
2120   update_tool_menu();
2121   update_eraser_props_menu();
2122   update_color_menu();
2123   update_cursor();
2124 }
2125
2126
2127 void
2128 on_toolsDefaultHighlighter_activate    (GtkMenuItem     *menuitem,
2129                                         gpointer         user_data)
2130 {
2131   switch_mapping(0);
2132   end_text();
2133   reset_focus();
2134   reset_selection();
2135   g_memmove(&(ui.brushes[0][TOOL_HIGHLIGHTER]), ui.default_brushes+TOOL_HIGHLIGHTER, sizeof(struct Brush));
2136   ui.toolno[0] = TOOL_HIGHLIGHTER;
2137   ui.cur_brush = &(ui.brushes[0][TOOL_HIGHLIGHTER]);
2138   ui.ruler[0] = FALSE;
2139   update_mapping_linkings(TOOL_HIGHLIGHTER);
2140   update_tool_buttons();
2141   update_tool_menu();
2142   update_highlighter_props_menu();
2143   update_color_menu();
2144   update_cursor();
2145 }
2146
2147 void
2148 on_toolsDefaultText_activate           (GtkMenuItem     *menuitem,
2149                                         gpointer         user_data)
2150 {
2151   switch_mapping(0);
2152   if (ui.toolno[0]!=TOOL_TEXT) end_text();
2153   reset_focus();
2154   reset_selection();
2155   ui.toolno[0] = TOOL_TEXT;
2156   ui.ruler[0] = FALSE;
2157   ui.cur_brush = &(ui.brushes[0][TOOL_PEN]);
2158   ui.cur_brush->color_no = ui.default_brushes[TOOL_PEN].color_no;
2159   ui.cur_brush->color_rgba = ui.default_brushes[TOOL_PEN].color_rgba;
2160   g_free(ui.font_name);
2161   ui.font_name = g_strdup(ui.default_font_name);
2162   ui.font_size = ui.default_font_size;
2163   if (ui.cur_item_type == ITEM_TEXT) {
2164     refont_text_item(ui.cur_item, ui.font_name, ui.font_size);
2165   }
2166   update_font_button();
2167   update_mapping_linkings(-1);
2168   update_tool_buttons();
2169   update_tool_menu();
2170   update_color_menu();
2171   update_cursor();
2172 }
2173
2174
2175 void
2176 on_toolsSetAsDefault_activate          (GtkMenuItem     *menuitem,
2177                                         gpointer         user_data)
2178 {
2179   struct Item *it;
2180
2181   if (ui.cur_mapping!=0) return;
2182   if (ui.toolno[0] < NUM_STROKE_TOOLS)
2183     g_memmove(ui.default_brushes+ui.toolno[0], &(ui.brushes[0][ui.toolno[0]]), sizeof(struct Brush));
2184   if (ui.toolno[0] == TOOL_TEXT) {
2185     if (ui.cur_item_type == ITEM_TEXT) {
2186       g_free(ui.font_name);
2187       ui.font_name = g_strdup(ui.cur_item->font_name);
2188       ui.font_size = ui.cur_item->font_size;
2189     }
2190     else if (ui.selection!=NULL && ui.selection->items!=NULL &&
2191              ui.selection->items->next==NULL &&
2192              (it=(struct Item*)ui.selection->items->data)->type == ITEM_TEXT) {
2193       g_free(ui.font_name);
2194       ui.font_name = g_strdup(it->font_name);
2195       ui.font_size = it->font_size;
2196     }
2197     g_free(ui.default_font_name);
2198     ui.default_font_name = g_strdup(ui.font_name);
2199     ui.default_font_size = ui.font_size;
2200   }
2201   end_text();
2202   reset_focus();
2203 }
2204
2205
2206 void
2207 on_toolsRuler_activate                 (GtkMenuItem     *menuitem,
2208                                         gpointer         user_data)
2209 {
2210   gboolean active;
2211
2212   if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_CHECK_MENU_ITEM)
2213     active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
2214   else
2215     active = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem));
2216
2217   if (ui.cur_mapping != 0) return;
2218   if (active == ui.ruler[0]) return;
2219
2220   end_text();
2221   reset_focus();
2222   if (active && (ui.toolno[0]!=TOOL_PEN && ui.toolno[0]!=TOOL_HIGHLIGHTER)) {
2223     reset_selection();
2224     ui.toolno[0] = TOOL_PEN;
2225     ui.cur_brush = &(ui.brushes[0][TOOL_PEN]);
2226     update_color_menu();
2227     update_tool_buttons();
2228     update_tool_menu();
2229     update_cursor();
2230   }
2231
2232   ui.ruler[0] = active;
2233   update_mapping_linkings(ui.toolno[0]);
2234   update_ruler_indicator();
2235 }
2236
2237
2238 void
2239 on_optionsSavePreferences_activate     (GtkMenuItem     *menuitem,
2240                                         gpointer         user_data)
2241 {
2242   end_text();
2243   reset_focus();
2244   save_config_to_file();
2245 }
2246
2247
2248 void
2249 on_helpIndex_activate                  (GtkMenuItem     *menuitem,
2250                                         gpointer         user_data)
2251 {
2252
2253 }
2254
2255
2256 void
2257 on_helpAbout_activate                  (GtkMenuItem     *menuitem,
2258                                         gpointer         user_data)
2259 {
2260   GtkWidget *aboutDialog;
2261   GtkLabel *labelTitle;
2262
2263   end_text();
2264   reset_focus();
2265   aboutDialog = create_aboutDialog ();
2266   labelTitle = GTK_LABEL(g_object_get_data(G_OBJECT(aboutDialog), "labelTitle"));
2267   gtk_label_set_markup(labelTitle,
2268     "<span size=\"xx-large\" weight=\"bold\">Xournal " VERSION "</span>");
2269   gtk_dialog_run (GTK_DIALOG(aboutDialog));
2270   gtk_widget_destroy(aboutDialog);
2271 }
2272
2273
2274 void
2275 on_buttonToolDefault_clicked           (GtkToolButton   *toolbutton,
2276                                         gpointer         user_data)
2277 {
2278   if (ui.toolno[0]==TOOL_TEXT) {
2279     on_toolsDefaultText_activate(NULL, NULL);
2280     return;
2281   }
2282   end_text();
2283   reset_focus();
2284   switch_mapping(0);
2285   if (ui.toolno[0] < NUM_STROKE_TOOLS) {
2286     g_memmove(&(ui.brushes[0][ui.toolno[0]]), ui.default_brushes+ui.toolno[0], sizeof(struct Brush));
2287     ui.ruler[0] = FALSE;
2288     update_mapping_linkings(ui.toolno[0]);
2289     update_thickness_buttons();
2290     update_color_buttons();
2291     update_color_menu();
2292     if (ui.toolno[0] == TOOL_PEN) update_pen_props_menu();
2293     if (ui.toolno[0] == TOOL_ERASER) update_eraser_props_menu();
2294     if (ui.toolno[0] == TOOL_HIGHLIGHTER) update_highlighter_props_menu();
2295     update_cursor();
2296   }
2297 }
2298
2299
2300 void
2301 on_buttonFine_clicked                  (GtkToolButton   *toolbutton,
2302                                         gpointer         user_data)
2303 {
2304   if (ui.cur_mapping != 0) return;
2305   process_thickness_activate((GtkMenuItem*)toolbutton, ui.toolno[0], THICKNESS_FINE);
2306 }
2307
2308
2309 void
2310 on_buttonMedium_clicked                (GtkToolButton   *toolbutton,
2311                                         gpointer         user_data)
2312 {
2313   if (ui.cur_mapping != 0) return;
2314   process_thickness_activate((GtkMenuItem*)toolbutton, ui.toolno[0], THICKNESS_MEDIUM);
2315 }
2316
2317
2318 void
2319 on_buttonThick_clicked                 (GtkToolButton   *toolbutton,
2320                                         gpointer         user_data)
2321 {
2322   if (ui.cur_mapping != 0) return;
2323   process_thickness_activate((GtkMenuItem*)toolbutton, ui.toolno[0], THICKNESS_THICK);
2324 }
2325
2326
2327 gboolean
2328 on_canvas_button_press_event           (GtkWidget       *widget,
2329                                         GdkEventButton  *event,
2330                                         gpointer         user_data)
2331 {
2332   double pt[2];
2333   gboolean page_change;
2334   struct Page *tmppage;
2335   GtkWidget *dialog;
2336   int mapping;
2337   gboolean is_core;
2338   struct Item *item;
2339
2340   is_core = (event->device == gdk_device_get_core_pointer());
2341   if (!ui.use_xinput && !is_core) return FALSE;
2342   if (ui.use_xinput && is_core && ui.discard_corepointer) return FALSE;
2343   if (event->button > 3) return FALSE; // no painting with the mouse wheel!
2344   if (!is_core) {
2345     // re-get the axis values since Synaptics sends bogus ones
2346     gdk_device_get_state(event->device, event->window, event->axes, NULL);
2347     fix_xinput_coords((GdkEvent *)event);
2348   }
2349
2350   if (ui.cur_item_type == ITEM_TEXT && !is_event_within_textview(event))
2351     end_text();
2352   if (ui.cur_item_type != ITEM_NONE) return FALSE; // we're already doing something
2353
2354   ui.is_corestroke = is_core;
2355
2356   if (ui.use_erasertip && event->device->source == GDK_SOURCE_ERASER)
2357        mapping = NUM_BUTTONS;
2358   else mapping = event->button-1;
2359
2360   // check whether we're in a page
2361   page_change = FALSE;
2362   tmppage = ui.cur_page;
2363   get_pointer_coords((GdkEvent *)event, pt);
2364   while (ui.view_continuous && (pt[1] < - VIEW_CONTINUOUS_SKIP)) {
2365     if (ui.pageno == 0) break;
2366     page_change = TRUE;
2367     ui.pageno--;
2368     tmppage = g_list_nth_data(journal.pages, ui.pageno);
2369     pt[1] += tmppage->height + VIEW_CONTINUOUS_SKIP;
2370   }
2371   while (ui.view_continuous && (pt[1] > tmppage->height + VIEW_CONTINUOUS_SKIP)) {
2372     if (ui.pageno == journal.npages-1) break;
2373     pt[1] -= tmppage->height + VIEW_CONTINUOUS_SKIP;
2374     page_change = TRUE;
2375     ui.pageno++;
2376     tmppage = g_list_nth_data(journal.pages, ui.pageno);
2377   }
2378   if (page_change) do_switch_page(ui.pageno, FALSE, FALSE);
2379
2380   // can't paint on the background...
2381
2382   if (ui.cur_layer == NULL) {
2383     /* warn */
2384     dialog = gtk_message_dialog_new(GTK_WINDOW(winMain), GTK_DIALOG_MODAL,
2385       GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, "Drawing is not allowed on the "
2386       "background layer.\n Switching to Layer 1.");
2387     gtk_dialog_run(GTK_DIALOG(dialog));
2388     gtk_widget_destroy(dialog);
2389     on_viewShowLayer_activate(NULL, NULL);
2390     return;
2391   }
2392
2393   // switch mappings if needed
2394
2395   ui.which_mouse_button = event->button;
2396   switch_mapping(mapping);
2397
2398   // in text tool, clicking in a text area edits it
2399   if (ui.toolno[mapping] == TOOL_TEXT) {
2400     item = click_is_in_text(ui.cur_layer, pt[0], pt[1]);
2401     if (item!=NULL) {
2402       reset_selection();
2403       start_text((GdkEvent *)event, item);
2404       return FALSE;
2405     }
2406   }
2407
2408   // if this can be a selection move, then it takes precedence over anything else
2409   if (start_movesel((GdkEvent *)event)) return FALSE;
2410
2411   if (ui.toolno[mapping] != TOOL_SELECTREGION && ui.toolno[mapping] != TOOL_SELECTRECT)
2412     reset_selection();
2413
2414   // process the event
2415
2416   if (ui.toolno[mapping] == TOOL_HAND) {
2417     ui.cur_item_type = ITEM_HAND;
2418     get_pointer_coords((GdkEvent *)event, ui.hand_refpt);
2419   }
2420   else if (ui.toolno[mapping] == TOOL_PEN || ui.toolno[mapping] == TOOL_HIGHLIGHTER ||
2421         (ui.toolno[mapping] == TOOL_ERASER && ui.cur_brush->tool_options == TOOLOPT_ERASER_WHITEOUT)) {
2422     create_new_stroke((GdkEvent *)event);
2423   }
2424   else if (ui.toolno[mapping] == TOOL_ERASER) {
2425     ui.cur_item_type = ITEM_ERASURE;
2426     do_eraser((GdkEvent *)event, ui.cur_brush->thickness/2,
2427                ui.cur_brush->tool_options == TOOLOPT_ERASER_STROKES);
2428   }
2429   else if (ui.toolno[mapping] == TOOL_SELECTRECT) {
2430     start_selectrect((GdkEvent *)event);
2431   }
2432   else if (ui.toolno[mapping] == TOOL_VERTSPACE) {
2433     start_vertspace((GdkEvent *)event);
2434   }
2435   else if (ui.toolno[mapping] == TOOL_TEXT) {
2436     start_text((GdkEvent *)event, NULL);
2437   }
2438   return FALSE;
2439 }
2440
2441
2442 gboolean
2443 on_canvas_button_release_event         (GtkWidget       *widget,
2444                                         GdkEventButton  *event,
2445                                         gpointer         user_data)
2446 {
2447   gboolean is_core;
2448
2449   if (ui.cur_item_type == ITEM_NONE) return FALSE; // not doing anything
2450
2451   if (event->button != ui.which_mouse_button) return FALSE; // ignore
2452
2453   is_core = (event->device == gdk_device_get_core_pointer());
2454   if (!ui.use_xinput && !is_core) return FALSE;
2455   if (ui.use_xinput && is_core && !ui.is_corestroke) return FALSE;
2456   if (!is_core) fix_xinput_coords((GdkEvent *)event);
2457
2458   if (ui.cur_item_type == ITEM_STROKE) {
2459     finalize_stroke();
2460   }
2461   else if (ui.cur_item_type == ITEM_ERASURE) {
2462     finalize_erasure();
2463   }
2464   else if (ui.cur_item_type == ITEM_SELECTRECT) {
2465     finalize_selectrect();
2466   }
2467   else if (ui.cur_item_type == ITEM_MOVESEL || ui.cur_item_type == ITEM_MOVESEL_VERT) {
2468     finalize_movesel();
2469   }
2470   else if (ui.cur_item_type == ITEM_HAND) {
2471     ui.cur_item_type = ITEM_NONE;
2472   }
2473
2474   switch_mapping(0);
2475   return FALSE;
2476 }
2477
2478
2479 gboolean
2480 on_canvas_enter_notify_event           (GtkWidget       *widget,
2481                                         GdkEventCrossing *event,
2482                                         gpointer         user_data)
2483 {
2484
2485   return FALSE;
2486 }
2487
2488
2489 gboolean
2490 on_canvas_expose_event                 (GtkWidget       *widget,
2491                                         GdkEventExpose  *event,
2492                                         gpointer         user_data)
2493 {
2494   if (ui.view_continuous && ui.progressive_bg) rescale_bg_pixmaps();
2495   return FALSE;
2496 }
2497
2498
2499 gboolean
2500 on_canvas_key_press_event              (GtkWidget       *widget,
2501                                         GdkEventKey     *event,
2502                                         gpointer         user_data)
2503 {
2504   return FALSE;
2505 }
2506
2507
2508 gboolean
2509 on_canvas_motion_notify_event          (GtkWidget       *widget,
2510                                         GdkEventMotion  *event,
2511                                         gpointer         user_data)
2512 {
2513   gboolean looks_wrong, is_core;
2514   double pt[2];
2515
2516   if (ui.cur_item_type == ITEM_NONE) return FALSE; // we don't care
2517
2518   is_core = (event->device == gdk_device_get_core_pointer());
2519   if (!ui.use_xinput && !is_core) return FALSE;
2520   if (ui.use_xinput && is_core && !ui.is_corestroke) return FALSE;
2521   if (!is_core) fix_xinput_coords((GdkEvent *)event);
2522
2523   looks_wrong = !(event->state & (1<<(7+ui.which_mouse_button)));
2524
2525   if (looks_wrong) { /* mouse button shouldn't be up... give up */
2526     if (ui.cur_item_type == ITEM_STROKE) {
2527       finalize_stroke();
2528     }
2529     else if (ui.cur_item_type == ITEM_ERASURE) {
2530       finalize_erasure();
2531     }
2532     else if (ui.cur_item_type == ITEM_SELECTRECT) {
2533       finalize_selectrect();
2534     }
2535     else if (ui.cur_item_type == ITEM_MOVESEL || ui.cur_item_type == ITEM_MOVESEL_VERT) {
2536       finalize_movesel();
2537     }
2538     switch_mapping(0);
2539     return FALSE;
2540   }
2541
2542   if (ui.cur_item_type == ITEM_STROKE) {
2543     continue_stroke((GdkEvent *)event);
2544   }
2545   else if (ui.cur_item_type == ITEM_ERASURE) {
2546     do_eraser((GdkEvent *)event, ui.cur_brush->thickness/2,
2547                ui.cur_brush->tool_options == TOOLOPT_ERASER_STROKES);
2548   }
2549   else if (ui.cur_item_type == ITEM_SELECTRECT) {
2550     get_pointer_coords((GdkEvent *)event, pt);
2551     ui.selection->bbox.right = pt[0];
2552     ui.selection->bbox.bottom = pt[1];
2553     gnome_canvas_item_set(ui.selection->canvas_item,
2554                                "x2", pt[0], "y2", pt[1], NULL);
2555   }
2556   else if (ui.cur_item_type == ITEM_MOVESEL || ui.cur_item_type == ITEM_MOVESEL_VERT) {
2557     continue_movesel((GdkEvent *)event);
2558   }
2559   else if (ui.cur_item_type == ITEM_HAND) {
2560     do_hand((GdkEvent *)event);
2561   }
2562
2563   return FALSE;
2564 }
2565
2566 void
2567 on_comboLayer_changed                  (GtkComboBox     *combobox,
2568                                         gpointer         user_data)
2569 {
2570   int val;
2571
2572   if (ui.in_update_page_stuff) return; // avoid a bad retroaction
2573
2574   end_text();
2575   reset_focus();
2576
2577   val = gtk_combo_box_get_active(combobox);
2578   if (val == -1) return;
2579   val = ui.cur_page->nlayers-1-val;
2580   if (val == ui.layerno) return;
2581
2582   reset_selection();
2583   while (val>ui.layerno) {
2584     ui.layerno++;
2585     ui.cur_layer = g_list_nth_data(ui.cur_page->layers, ui.layerno);
2586     gnome_canvas_item_show(GNOME_CANVAS_ITEM(ui.cur_layer->group));
2587   }
2588   while (val<ui.layerno) {
2589     gnome_canvas_item_hide(GNOME_CANVAS_ITEM(ui.cur_layer->group));
2590     ui.layerno--;
2591     if (ui.layerno<0) ui.cur_layer = NULL;
2592     else ui.cur_layer = g_list_nth_data(ui.cur_page->layers, ui.layerno);
2593   }
2594   update_page_stuff();
2595 }
2596
2597
2598 gboolean
2599 on_winMain_delete_event                (GtkWidget       *widget,
2600                                         GdkEvent        *event,
2601                                         gpointer         user_data)
2602 {
2603   end_text();
2604   reset_focus();
2605   if (ok_to_close()) gtk_main_quit();
2606   return TRUE;
2607 }
2608
2609
2610 void
2611 on_optionsUseXInput_activate           (GtkMenuItem     *menuitem,
2612                                         gpointer         user_data)
2613 {
2614   end_text();
2615   reset_focus();
2616   ui.allow_xinput = ui.use_xinput =
2617     gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
2618   gtk_widget_set_extension_events(GTK_WIDGET (canvas),
2619       ui.use_xinput?GDK_EXTENSION_EVENTS_ALL:GDK_EXTENSION_EVENTS_NONE);
2620   update_mappings_menu();
2621 }
2622
2623 void
2624 on_vscroll_changed                     (GtkAdjustment   *adjustment,
2625                                         gpointer         user_data)
2626 {
2627   gboolean need_update;
2628   double viewport_top, viewport_bottom;
2629   struct Page *tmppage;
2630
2631   if (!ui.view_continuous) return;
2632
2633   if (ui.progressive_bg) rescale_bg_pixmaps();
2634   need_update = FALSE;
2635   viewport_top = adjustment->value / ui.zoom;
2636   viewport_bottom = (adjustment->value + adjustment->page_size) / ui.zoom;
2637   tmppage = ui.cur_page;
2638   while (viewport_top > tmppage->voffset + tmppage->height) {
2639     if (ui.pageno == journal.npages-1) break;
2640     need_update = TRUE;
2641     ui.pageno++;
2642     tmppage = g_list_nth_data(journal.pages, ui.pageno);
2643   }
2644   while (viewport_bottom < tmppage->voffset) {
2645     if (ui.pageno == 0) break;
2646     need_update = TRUE;
2647     ui.pageno--;
2648     tmppage = g_list_nth_data(journal.pages, ui.pageno);
2649   }
2650   if (need_update) {
2651     end_text();
2652     do_switch_page(ui.pageno, FALSE, FALSE);
2653   }
2654   reset_focus();
2655   return;
2656 }
2657
2658 void
2659 on_spinPageNo_value_changed            (GtkSpinButton   *spinbutton,
2660                                         gpointer         user_data)
2661 {
2662   int val;
2663
2664   if (ui.in_update_page_stuff) return; // avoid a bad retroaction
2665
2666   end_text();
2667   reset_focus();
2668
2669   val = gtk_spin_button_get_value_as_int(spinbutton) - 1;
2670
2671   if (val == journal.npages) { // create a page at end
2672     if (page_ops_forbidden()) return;
2673     on_journalNewPageEnd_activate(NULL, NULL);
2674     return;
2675   }
2676
2677   if (val == ui.pageno) return;
2678   if (val < 0) val = 0;
2679   if (val > journal.npages-1) val = journal.npages-1;
2680   do_switch_page(val, TRUE, FALSE);
2681 }
2682
2683
2684 void
2685 on_journalDefaultBackground_activate   (GtkMenuItem     *menuitem,
2686                                         gpointer         user_data)
2687 {
2688   struct Page *pg;
2689   GList *pglist;
2690
2691   end_text();
2692   reset_focus();
2693   reset_selection();
2694
2695   pg = ui.cur_page;
2696   for (pglist = journal.pages; pglist!=NULL; pglist = pglist->next) {
2697     if (ui.bg_apply_all_pages) pg = (struct Page *)pglist->data;
2698     prepare_new_undo();
2699     if (ui.bg_apply_all_pages) {
2700       if (pglist->next!=NULL) undo->multiop |= MULTIOP_CONT_REDO;
2701       if (pglist->prev!=NULL) undo->multiop |= MULTIOP_CONT_UNDO;
2702     }
2703     undo->type = ITEM_NEW_BG_RESIZE;
2704     undo->page = pg;
2705     undo->bg = pg->bg;
2706     undo->val_x = pg->width;
2707     undo->val_y = pg->height;
2708     pg->bg = (struct Background *)g_memdup(ui.default_page.bg, sizeof(struct Background));
2709     pg->width = ui.default_page.width;
2710     pg->height = ui.default_page.height;
2711     pg->bg->canvas_item = undo->bg->canvas_item;
2712     undo->bg->canvas_item = NULL;
2713
2714     make_page_clipbox(pg);
2715     update_canvas_bg(pg);
2716     if (!ui.bg_apply_all_pages) break;
2717   }
2718   do_switch_page(ui.pageno, TRUE, TRUE);
2719 }
2720
2721
2722 void
2723 on_journalSetAsDefault_activate        (GtkMenuItem     *menuitem,
2724                                         gpointer         user_data)
2725 {
2726   if (ui.cur_page->bg->type != BG_SOLID) return;
2727
2728   end_text();
2729   reset_focus();
2730   prepare_new_undo();
2731   undo->type = ITEM_NEW_DEFAULT_BG;
2732   undo->val_x = ui.default_page.width;
2733   undo->val_y = ui.default_page.height;
2734   undo->bg = ui.default_page.bg;
2735
2736   ui.default_page.width = ui.cur_page->width;
2737   ui.default_page.height = ui.cur_page->height;
2738   ui.default_page.bg = (struct Background *)g_memdup(ui.cur_page->bg, sizeof(struct Background));
2739   ui.default_page.bg->canvas_item = NULL;
2740 }
2741
2742
2743 void
2744 on_comboStdSizes_changed               (GtkComboBox     *combobox,
2745                                         gpointer         user_data)
2746 {
2747   GtkEntry *entry;
2748   GtkComboBox *comboUnit;
2749   int val;
2750   gchar text[20];
2751
2752   if (papersize_need_init) {
2753     gtk_combo_box_set_active(combobox, papersize_std);
2754     papersize_need_init = FALSE;
2755   } else {
2756     val = gtk_combo_box_get_active(combobox);
2757     if (val == -1 || val == papersize_std) return;
2758     papersize_std = val;
2759     if (val == STD_SIZE_CUSTOM) return;
2760     papersize_unit = std_units[val];
2761     papersize_width = std_widths[val];
2762     papersize_height = std_heights[val];
2763   }
2764   comboUnit = GTK_COMBO_BOX(g_object_get_data(G_OBJECT(papersize_dialog), "comboUnit"));
2765   gtk_combo_box_set_active(comboUnit, papersize_unit);
2766   entry = GTK_ENTRY(g_object_get_data(G_OBJECT(papersize_dialog), "entryWidth"));
2767   g_snprintf(text, 20, "%.2f", papersize_width/unit_sizes[papersize_unit]);
2768   if (g_str_has_suffix(text, ".00"))
2769     g_snprintf(text, 20, "%d", (int) (papersize_width/unit_sizes[papersize_unit]));
2770   gtk_entry_set_text(entry, text);
2771   entry = GTK_ENTRY(g_object_get_data(G_OBJECT(papersize_dialog), "entryHeight"));
2772   g_snprintf(text, 20, "%.2f", papersize_height/unit_sizes[papersize_unit]);
2773   if (g_str_has_suffix(text, ".00"))
2774     g_snprintf(text, 20, "%d", (int) (papersize_height/unit_sizes[papersize_unit]));
2775   gtk_entry_set_text(entry, text);
2776 }
2777
2778
2779 void
2780 on_entryWidth_changed                  (GtkEditable     *editable,
2781                                         gpointer         user_data)
2782 {
2783   double val;
2784   const gchar *text;
2785   gchar *ptr;
2786   GtkComboBox *comboStdSizes;
2787
2788   text = gtk_entry_get_text(GTK_ENTRY(editable));
2789   val = strtod(text, &ptr);
2790   papersize_width_valid = (*ptr == 0 && val > 0.);
2791   if (!papersize_width_valid) return; // invalid entry
2792   val *= unit_sizes[papersize_unit];
2793   if (fabs(val - papersize_width) < 0.1) return; // no change
2794   papersize_std = STD_SIZE_CUSTOM;
2795   papersize_width = val;
2796   comboStdSizes = GTK_COMBO_BOX(g_object_get_data(G_OBJECT(papersize_dialog), "comboStdSizes"));
2797   gtk_combo_box_set_active(comboStdSizes, papersize_std);
2798 }
2799
2800
2801 void
2802 on_entryHeight_changed                 (GtkEditable     *editable,
2803                                         gpointer         user_data)
2804 {
2805   double val;
2806   const gchar *text;
2807   gchar *ptr;
2808   GtkComboBox *comboStdSizes;
2809
2810   text = gtk_entry_get_text(GTK_ENTRY(editable));
2811   val = strtod(text, &ptr);
2812   papersize_height_valid = (*ptr == 0 && val > 0.);
2813   if (!papersize_height_valid) return; // invalid entry
2814   val *= unit_sizes[papersize_unit];
2815   if (fabs(val - papersize_height) < 0.1) return; // no change
2816   papersize_std = STD_SIZE_CUSTOM;
2817   papersize_height = val;
2818   comboStdSizes = GTK_COMBO_BOX(g_object_get_data(G_OBJECT(papersize_dialog), "comboStdSizes"));
2819   gtk_combo_box_set_active(comboStdSizes, papersize_std);
2820 }
2821
2822
2823 void
2824 on_comboUnit_changed                   (GtkComboBox     *combobox,
2825                                         gpointer         user_data)
2826 {
2827   GtkEntry *entry;
2828   int val;
2829   gchar text[20];
2830
2831   val = gtk_combo_box_get_active(combobox);
2832   if (val == -1 || val == papersize_unit) return;
2833   papersize_unit = val;
2834   entry = GTK_ENTRY(g_object_get_data(G_OBJECT(papersize_dialog), "entryWidth"));
2835   if (papersize_width_valid) {
2836     g_snprintf(text, 20, "%.2f", papersize_width/unit_sizes[papersize_unit]);
2837     if (g_str_has_suffix(text, ".00"))
2838       g_snprintf(text, 20, "%d", (int) (papersize_width/unit_sizes[papersize_unit]));
2839   } else *text = 0;
2840   gtk_entry_set_text(entry, text);
2841   if (papersize_height_valid) {
2842     entry = GTK_ENTRY(g_object_get_data(G_OBJECT(papersize_dialog), "entryHeight"));
2843     g_snprintf(text, 20, "%.2f", papersize_height/unit_sizes[papersize_unit]);
2844     if (g_str_has_suffix(text, ".00"))
2845       g_snprintf(text, 20, "%d", (int) (papersize_height/unit_sizes[papersize_unit]));
2846   } else *text = 0;
2847   gtk_entry_set_text(entry, text);
2848 }
2849
2850
2851 void
2852 on_viewFullscreen_activate             (GtkMenuItem     *menuitem,
2853                                         gpointer         user_data)
2854 {
2855   gboolean active;
2856
2857   if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_CHECK_MENU_ITEM)
2858     active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
2859   else
2860     active = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem));
2861
2862   if (active == ui.fullscreen) return;
2863   end_text();
2864   reset_focus();
2865   ui.fullscreen = active;
2866   gtk_check_menu_item_set_active(
2867     GTK_CHECK_MENU_ITEM(GET_COMPONENT("viewFullscreen")), ui.fullscreen);
2868   gtk_toggle_tool_button_set_active(
2869     GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonFullscreen")), ui.fullscreen);
2870
2871   if (ui.fullscreen) gtk_window_fullscreen(GTK_WINDOW(winMain));
2872   else gtk_window_unfullscreen(GTK_WINDOW(winMain));
2873
2874   update_vbox_order(ui.vertical_order[ui.fullscreen?1:0]);
2875 }
2876
2877
2878 void
2879 on_optionsButtonMappings_activate      (GtkMenuItem     *menuitem,
2880                                         gpointer         user_data)
2881 {
2882   end_text();
2883   reset_focus();
2884   ui.use_erasertip =
2885     gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
2886   update_mappings_menu();
2887 }
2888
2889
2890 void
2891 on_optionsAntialiasBG_activate         (GtkMenuItem     *menuitem,
2892                                         gpointer         user_data)
2893 {
2894   gboolean active;
2895
2896   active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
2897   if (ui.antialias_bg == active) return;
2898   end_text();
2899   reset_focus();
2900   ui.antialias_bg = active;
2901   rescale_bg_pixmaps();
2902 }
2903
2904
2905 void
2906 on_optionsProgressiveBG_activate       (GtkMenuItem     *menuitem,
2907                                         gpointer         user_data)
2908 {
2909   gboolean active;
2910
2911   active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
2912   if (ui.progressive_bg == active) return;
2913   end_text();
2914   reset_focus();
2915   ui.progressive_bg = active;
2916   if (!ui.progressive_bg) rescale_bg_pixmaps();
2917 }
2918
2919
2920 void
2921 on_mru_activate                        (GtkMenuItem     *menuitem,
2922                                         gpointer         user_data)
2923 {
2924   int which;
2925   gboolean success;
2926   GtkWidget *dialog;
2927
2928   end_text();
2929   reset_focus();
2930   if (!ok_to_close()) return; // user aborted on save confirmation
2931
2932   for (which = 0 ; which < MRU_SIZE; which++) {
2933     if (ui.mrumenu[which] == GTK_WIDGET(menuitem)) break;
2934   }
2935   if (which == MRU_SIZE || ui.mru[which] == NULL) return; // not found...
2936
2937   set_cursor_busy(TRUE);
2938   success = open_journal(ui.mru[which]);
2939   set_cursor_busy(FALSE);
2940   if (success) return;
2941
2942   /* open failed */
2943   dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
2944     GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Error opening file '%s'", ui.mru[which]);
2945   gtk_dialog_run(GTK_DIALOG(dialog));
2946   gtk_widget_destroy(dialog);
2947   delete_mru_entry(which);
2948 }
2949
2950
2951 void
2952 on_button2Pen_activate                 (GtkMenuItem     *menuitem,
2953                                         gpointer         user_data)
2954 {
2955   process_mapping_activate(menuitem, 1, TOOL_PEN);
2956 }
2957
2958
2959 void
2960 on_button2Eraser_activate              (GtkMenuItem     *menuitem,
2961                                         gpointer         user_data)
2962 {
2963   process_mapping_activate(menuitem, 1, TOOL_ERASER);
2964 }
2965
2966
2967 void
2968 on_button2Highlighter_activate         (GtkMenuItem     *menuitem,
2969                                         gpointer         user_data)
2970 {
2971   process_mapping_activate(menuitem, 1, TOOL_HIGHLIGHTER);
2972 }
2973
2974
2975 void
2976 on_button2Text_activate                (GtkMenuItem     *menuitem,
2977                                         gpointer         user_data)
2978 {
2979   process_mapping_activate(menuitem, 1, TOOL_TEXT);
2980 }
2981
2982
2983 void
2984 on_button2SelectRegion_activate        (GtkMenuItem     *menuitem,
2985                                         gpointer         user_data)
2986 {
2987   process_mapping_activate(menuitem, 1, TOOL_SELECTREGION);
2988 }
2989
2990
2991 void
2992 on_button2SelectRectangle_activate     (GtkMenuItem     *menuitem,
2993                                         gpointer         user_data)
2994 {
2995   process_mapping_activate(menuitem, 1, TOOL_SELECTRECT);
2996 }
2997
2998
2999 void
3000 on_button2VerticalSpace_activate       (GtkMenuItem     *menuitem,
3001                                         gpointer         user_data)
3002 {
3003   process_mapping_activate(menuitem, 1, TOOL_VERTSPACE);
3004 }
3005
3006
3007 void
3008 on_button2LinkBrush_activate           (GtkMenuItem     *menuitem,
3009                                         gpointer         user_data)
3010 {
3011   int i;
3012
3013   if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem))) return;
3014   end_text();
3015   reset_focus();
3016   ui.linked_brush[1] = BRUSH_LINKED;
3017   for (i=0;i<NUM_STROKE_TOOLS;i++) update_mapping_linkings(i);
3018 }
3019
3020
3021 void
3022 on_button2CopyBrush_activate           (GtkMenuItem     *menuitem,
3023                                         gpointer         user_data)
3024 {
3025   if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem))) return;
3026   end_text();
3027   reset_focus();
3028   if (ui.toolno[1] >= NUM_STROKE_TOOLS) {
3029     ui.linked_brush[1] = BRUSH_STATIC;
3030     update_mappings_menu_linkings();
3031     return;
3032   }
3033   ui.linked_brush[1] = BRUSH_COPIED;
3034   g_memmove(&(ui.brushes[1][ui.toolno[1]]), &(ui.brushes[0][ui.toolno[1]]), sizeof(struct Brush));
3035   ui.ruler[1] = ui.ruler[0];
3036   if (ui.toolno[1]!=TOOL_PEN && ui.toolno[1]!=TOOL_HIGHLIGHTER)
3037     ui.ruler[1] = FALSE;
3038 }
3039
3040
3041 void
3042 on_button3Pen_activate                 (GtkMenuItem     *menuitem,
3043                                         gpointer         user_data)
3044 {
3045   process_mapping_activate(menuitem, 2, TOOL_PEN);
3046 }
3047
3048
3049 void
3050 on_button3Eraser_activate              (GtkMenuItem     *menuitem,
3051                                         gpointer         user_data)
3052 {
3053   process_mapping_activate(menuitem, 2, TOOL_ERASER);
3054 }
3055
3056
3057 void
3058 on_button3Highlighter_activate         (GtkMenuItem     *menuitem,
3059                                         gpointer         user_data)
3060 {
3061   process_mapping_activate(menuitem, 2, TOOL_HIGHLIGHTER);
3062 }
3063
3064
3065 void
3066 on_button3Text_activate                (GtkMenuItem     *menuitem,
3067                                         gpointer         user_data)
3068 {
3069   process_mapping_activate(menuitem, 2, TOOL_TEXT);
3070 }
3071
3072
3073 void
3074 on_button3SelectRegion_activate        (GtkMenuItem     *menuitem,
3075                                         gpointer         user_data)
3076 {
3077   process_mapping_activate(menuitem, 2, TOOL_SELECTREGION);
3078 }
3079
3080
3081 void
3082 on_button3SelectRectangle_activate     (GtkMenuItem     *menuitem,
3083                                         gpointer         user_data)
3084 {
3085   process_mapping_activate(menuitem, 2, TOOL_SELECTRECT);
3086 }
3087
3088
3089 void
3090 on_button3VerticalSpace_activate       (GtkMenuItem     *menuitem,
3091                                         gpointer         user_data)
3092 {
3093   process_mapping_activate(menuitem, 2, TOOL_VERTSPACE);
3094 }
3095
3096
3097 void
3098 on_button3LinkBrush_activate           (GtkMenuItem     *menuitem,
3099                                         gpointer         user_data)
3100 {
3101   int i;
3102
3103   if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem))) return;
3104   end_text();
3105   reset_focus();
3106   ui.linked_brush[2] = BRUSH_LINKED;
3107   for (i=0;i<NUM_STROKE_TOOLS;i++) update_mapping_linkings(i);
3108 }
3109
3110
3111 void
3112 on_button3CopyBrush_activate           (GtkMenuItem     *menuitem,
3113                                         gpointer         user_data)
3114 {
3115   if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem))) return;
3116   end_text();
3117   reset_focus();
3118   if (ui.toolno[2] >= NUM_STROKE_TOOLS) {
3119     ui.linked_brush[2] = BRUSH_STATIC;
3120     update_mappings_menu_linkings();
3121     return;
3122   }
3123   ui.linked_brush[2] = BRUSH_COPIED;
3124   g_memmove(&(ui.brushes[2][ui.toolno[2]]), &(ui.brushes[0][ui.toolno[2]]), sizeof(struct Brush));
3125   ui.ruler[2] = ui.ruler[0];
3126   if (ui.toolno[2]!=TOOL_PEN && ui.toolno[2]!=TOOL_HIGHLIGHTER)
3127     ui.ruler[2] = FALSE;
3128 }
3129
3130 // the set zoom dialog
3131
3132 GtkWidget *zoom_dialog;
3133 double zoom_percent;
3134
3135 void
3136 on_viewSetZoom_activate                (GtkMenuItem     *menuitem,
3137                                         gpointer         user_data)
3138 {
3139   int response;
3140   double test_w, test_h;
3141   GtkSpinButton *spinZoom;
3142
3143   end_text();
3144   reset_focus();
3145   zoom_dialog = create_zoomDialog();
3146   zoom_percent = 100*ui.zoom / DEFAULT_ZOOM;
3147   spinZoom = GTK_SPIN_BUTTON(g_object_get_data(G_OBJECT(zoom_dialog), "spinZoom"));
3148   gtk_spin_button_set_increments(spinZoom, ui.zoom_step_increment, 5*ui.zoom_step_increment);
3149   gtk_spin_button_set_value(spinZoom, zoom_percent);
3150   test_w = 100*(GTK_WIDGET(canvas))->allocation.width/ui.cur_page->width/DEFAULT_ZOOM;
3151   test_h = 100*(GTK_WIDGET(canvas))->allocation.height/ui.cur_page->height/DEFAULT_ZOOM;
3152   if (zoom_percent > 99.9 && zoom_percent < 100.1)
3153     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_object_get_data(
3154            G_OBJECT(zoom_dialog), "radioZoom100")), TRUE);
3155   else if (zoom_percent > test_w-0.1 && zoom_percent < test_w+0.1)
3156     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_object_get_data(
3157            G_OBJECT(zoom_dialog), "radioZoomWidth")), TRUE);
3158   else if (zoom_percent > test_h-0.1 && zoom_percent < test_h+0.1)
3159     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_object_get_data(
3160            G_OBJECT(zoom_dialog), "radioZoomHeight")), TRUE);
3161   else gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_object_get_data(
3162            G_OBJECT(zoom_dialog), "radioZoom")), TRUE);
3163   gtk_widget_show(zoom_dialog);
3164
3165   do {
3166     response = gtk_dialog_run(GTK_DIALOG(zoom_dialog));
3167     if (response == GTK_RESPONSE_OK || response == GTK_RESPONSE_APPLY) {
3168       ui.zoom = DEFAULT_ZOOM*zoom_percent/100;
3169       gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
3170       rescale_text_items();
3171       rescale_bg_pixmaps();
3172     }
3173   } while (response == GTK_RESPONSE_APPLY);
3174
3175   gtk_widget_destroy(zoom_dialog);
3176 }
3177
3178
3179 void
3180 on_spinZoom_value_changed              (GtkSpinButton   *spinbutton,
3181                                         gpointer         user_data)
3182 {
3183   double val;
3184
3185   val = gtk_spin_button_get_value(GTK_SPIN_BUTTON(g_object_get_data(
3186              G_OBJECT(zoom_dialog), "spinZoom")));
3187   if (val<1) return;
3188   if (val<10) val=10.;
3189   if (val>1500) val=1500.;
3190   if (val<zoom_percent-1 || val>zoom_percent+1)
3191     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_object_get_data(
3192            G_OBJECT(zoom_dialog), "radioZoom")), TRUE);
3193   zoom_percent = val;
3194 }
3195
3196
3197 void
3198 on_radioZoom_toggled                   (GtkToggleButton *togglebutton,
3199                                         gpointer         user_data)
3200 {
3201   // nothing to do
3202 }
3203
3204
3205 void
3206 on_radioZoom100_toggled                (GtkToggleButton *togglebutton,
3207                                         gpointer         user_data)
3208 {
3209   if (!gtk_toggle_button_get_active(togglebutton)) return;
3210   zoom_percent = 100.;
3211   gtk_spin_button_set_value(GTK_SPIN_BUTTON(g_object_get_data(
3212         G_OBJECT(zoom_dialog), "spinZoom")), zoom_percent);
3213 }
3214
3215
3216 void
3217 on_radioZoomWidth_toggled              (GtkToggleButton *togglebutton,
3218                                         gpointer         user_data)
3219 {
3220   if (!gtk_toggle_button_get_active(togglebutton)) return;
3221   zoom_percent = 100*(GTK_WIDGET(canvas))->allocation.width/ui.cur_page->width/DEFAULT_ZOOM;
3222   gtk_spin_button_set_value(GTK_SPIN_BUTTON(g_object_get_data(
3223         G_OBJECT(zoom_dialog), "spinZoom")), zoom_percent);
3224 }
3225
3226
3227 void
3228 on_radioZoomHeight_toggled             (GtkToggleButton *togglebutton,
3229                                         gpointer         user_data)
3230 {
3231   if (!gtk_toggle_button_get_active(togglebutton)) return;
3232   zoom_percent = 100*(GTK_WIDGET(canvas))->allocation.height/ui.cur_page->height/DEFAULT_ZOOM;
3233   gtk_spin_button_set_value(GTK_SPIN_BUTTON(g_object_get_data(
3234         G_OBJECT(zoom_dialog), "spinZoom")), zoom_percent);
3235 }
3236
3237
3238 void
3239 on_toolsHand_activate                  (GtkMenuItem     *menuitem,
3240                                         gpointer         user_data)
3241 {
3242   if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
3243     if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
3244       return;
3245   } else {
3246     if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
3247       return;
3248   }
3249
3250   if (ui.cur_mapping != 0) return;
3251   if (ui.toolno[0] == TOOL_HAND) return;
3252
3253   end_text();
3254   reset_focus();
3255   reset_selection();
3256   ui.toolno[0] = TOOL_HAND;
3257   ui.ruler[0] = FALSE;
3258   update_mapping_linkings(-1);
3259   update_tool_buttons();
3260   update_tool_menu();
3261   update_color_menu();
3262   update_cursor();
3263 }
3264
3265
3266 void
3267 on_button2Hand_activate                (GtkMenuItem     *menuitem,
3268                                         gpointer         user_data)
3269 {
3270   process_mapping_activate(menuitem, 1, TOOL_HAND);
3271 }
3272
3273
3274 void
3275 on_button3Hand_activate                (GtkMenuItem     *menuitem,
3276                                         gpointer         user_data)
3277 {
3278   process_mapping_activate(menuitem, 2, TOOL_HAND);
3279 }
3280
3281
3282 void
3283 on_optionsPrintRuling_activate         (GtkMenuItem     *menuitem,
3284                                         gpointer         user_data)
3285 {
3286   end_text();
3287   reset_focus();
3288   ui.print_ruling = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
3289 }
3290
3291 void
3292 on_optionsDiscardCore_activate         (GtkMenuItem     *menuitem,
3293                                         gpointer         user_data)
3294 {
3295   end_text();
3296   reset_focus();
3297   ui.discard_corepointer =
3298     gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
3299   update_mappings_menu();
3300 }
3301
3302 void
3303 on_fontButton_font_set                 (GtkFontButton   *fontbutton,
3304                                         gpointer         user_data)
3305 {
3306   gchar *str;
3307
3308   str = g_strdup(gtk_font_button_get_font_name(fontbutton));
3309   process_font_sel(str);
3310 }
3311