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   if (close_journal()) {
  27     new_journal();
  28     ui.zoom = DEFAULT_ZOOM;
  29     update_page_stuff();
  30     gtk_adjustment_set_value(gtk_layout_get_vadjustment(GTK_LAYOUT(canvas)), 0);
  31     gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
  32   }
  33 }
  34
  35
  36 void
  37 on_fileNewBackground_activate          (GtkMenuItem     *menuitem,
  38                                         gpointer         user_data)
  39 {
  40   GtkWidget *dialog, *attach_opt;
  41   GtkFileFilter *filt_all, *filt_pdf;
  42   char *filename;
  43   int file_domain;
  44   gboolean success;
  45
  46   if (!ok_to_close()) return; // user aborted on save confirmation
  47
  48   dialog = gtk_file_chooser_dialog_new("Open PDF", GTK_WINDOW (winMain),
  49      GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
  50      GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);
  51
  52   filt_all = gtk_file_filter_new();
  53   gtk_file_filter_set_name(filt_all, "All files");
  54   gtk_file_filter_add_pattern(filt_all, "*");
  55   filt_pdf = gtk_file_filter_new();
  56   gtk_file_filter_set_name(filt_pdf, "PDF files");
  57   gtk_file_filter_add_pattern(filt_pdf, "*.pdf");
  58   gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_pdf);
  59   gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_all);
  60
  61   attach_opt = gtk_check_button_new_with_label("Attach file to the journal");
  62   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(attach_opt), FALSE);
  63   gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER (dialog), attach_opt);
  64
  65   if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
  66     gtk_widget_destroy(dialog);
  67     return;
  68   }
  69   filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
  70   if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(attach_opt)))
  71        file_domain = DOMAIN_ATTACH;
  72   else file_domain = DOMAIN_ABSOLUTE;
  73
  74   gtk_widget_destroy(dialog);
  75
  76   set_cursor_busy(TRUE);
  77   ui.saved = TRUE; // force close_journal to work
  78   close_journal();
  79   while (bgpdf.status != STATUS_NOT_INIT) {
  80     // waiting for pdf processes to finish dying
  81     gtk_main_iteration();
  82   }
  83   new_journal();
  84   ui.zoom = DEFAULT_ZOOM;
  85   gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
  86   update_page_stuff();
  87   success = init_bgpdf(filename, TRUE, file_domain);
  88   set_cursor_busy(FALSE);
  89   if (success) {
  90     g_free(filename);
  91     return;
  92   }
  93
  94   /* open failed */
  95   dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
  96     GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Error opening file '%s'", filename);
  97   gtk_dialog_run(GTK_DIALOG(dialog));
  98   gtk_widget_destroy(dialog);
  99   g_free(filename);
 100 }
 101
 102
 103 void
 104 on_fileOpen_activate                   (GtkMenuItem     *menuitem,
 105                                         gpointer         user_data)
 106 {
 107   GtkWidget *dialog;
 108   GtkFileFilter *filt_all, *filt_xoj;
 109   char *filename;
 110   gboolean success;
 111
 112   if (!ok_to_close()) return; // user aborted on save confirmation
 113
 114   dialog = gtk_file_chooser_dialog_new("Open Journal", GTK_WINDOW (winMain),
 115      GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 116      GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);
 117
 118   filt_all = gtk_file_filter_new();
 119   gtk_file_filter_set_name(filt_all, "All files");
 120   gtk_file_filter_add_pattern(filt_all, "*");
 121   filt_xoj = gtk_file_filter_new();
 122   gtk_file_filter_set_name(filt_xoj, "Xournal files");
 123   gtk_file_filter_add_pattern(filt_xoj, "*.xoj");
 124   gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_xoj);
 125   gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_all);
 126
 127   if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
 128     gtk_widget_destroy(dialog);
 129     return;
 130   }
 131   filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
 132   gtk_widget_destroy(dialog);
 133
 134   set_cursor_busy(TRUE);
 135   success = open_journal(filename);
 136   set_cursor_busy(FALSE);
 137   if (success) return;
 138
 139   /* open failed */
 140   dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
 141     GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Error opening file '%s'", filename);
 142   gtk_dialog_run(GTK_DIALOG(dialog));
 143   gtk_widget_destroy(dialog);
 144   g_free(filename);
 145
 146 }
 147
 148
 149 void
 150 on_fileSave_activate                   (GtkMenuItem     *menuitem,
 151                                         gpointer         user_data)
 152 {
 153   GtkWidget *dialog;
 154
 155   if (ui.filename == NULL) {
 156     on_fileSaveAs_activate(menuitem, user_data);
 157     return;
 158   }
 159   set_cursor_busy(TRUE);
 160   if (save_journal(ui.filename)) { // success
 161     set_cursor_busy(FALSE);
 162     ui.saved = TRUE;
 163     return;
 164   }
 165   set_cursor_busy(FALSE);
 166   /* save failed */
 167   dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
 168     GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Error saving file '%s'", ui.filename);
 169   gtk_dialog_run(GTK_DIALOG(dialog));
 170   gtk_widget_destroy(dialog);
 171 }
 172
 173
 174 void
 175 on_fileSaveAs_activate                 (GtkMenuItem     *menuitem,
 176                                         gpointer         user_data)
 177 {
 178   GtkWidget *dialog, *warning_dialog;
 179   GtkFileFilter *filt_all, *filt_xoj;
 180   char *filename;
 181   char stime[30];
 182   time_t curtime;
 183   gboolean warn;
 184   struct stat stat_buf;
 185
 186   dialog = gtk_file_chooser_dialog_new("Save Journal", GTK_WINDOW (winMain),
 187      GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 188      GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL);
 189
 190   if (ui.filename!=NULL) {
 191     if (ui.filename[0] == '/')
 192       gtk_file_chooser_set_filename(GTK_FILE_CHOOSER (dialog), ui.filename);
 193     else
 194       gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), ui.filename);
 195   } else {
 196     curtime = time(NULL);
 197     strftime(stime, 30, "%F-Note-%H-%M.xoj", localtime(&curtime));
 198     gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), stime);
 199   }
 200
 201   filt_all = gtk_file_filter_new();
 202   gtk_file_filter_set_name(filt_all, "All files");
 203   gtk_file_filter_add_pattern(filt_all, "*");
 204   filt_xoj = gtk_file_filter_new();
 205   gtk_file_filter_set_name(filt_xoj, "Xournal files");
 206   gtk_file_filter_add_pattern(filt_xoj, "*.xoj");
 207   gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_xoj);
 208   gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_all);
 209
 210   // somehow this doesn't seem to be set by default
 211   gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
 212
 213   do {
 214     if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
 215       gtk_widget_destroy(dialog);
 216       return;
 217     }
 218     filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
 219     warn = g_file_test (filename, G_FILE_TEST_EXISTS);
 220     if (warn) { // ok to overwrite an empty file
 221       if (!g_stat(filename, &stat_buf))
 222         if (stat_buf.st_size == 0) warn=FALSE;
 223     }
 224     if (warn && ui.filename!=NULL) { // ok to overwrite oneself
 225       if (ui.filename[0]=='/' && !strcmp(ui.filename, filename)) warn=FALSE;
 226       if (ui.filename[0]!='/' && g_str_has_suffix(filename, ui.filename)) warn=FALSE;
 227     }
 228     if (warn) {
 229       warning_dialog = gtk_message_dialog_new(GTK_WINDOW(winMain),
 230         GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO,
 231         "Should the file %s be overwritten?", filename);
 232       if (gtk_dialog_run(GTK_DIALOG(warning_dialog)) == GTK_RESPONSE_YES)
 233         warn = FALSE;
 234       gtk_widget_destroy(warning_dialog);
 235     }
 236   } while (warn);
 237
 238   gtk_widget_destroy(dialog);
 239
 240   set_cursor_busy(TRUE);
 241   if (save_journal(filename)) { // success
 242     ui.saved = TRUE;
 243     set_cursor_busy(FALSE);
 244     update_file_name(filename);
 245     return;
 246   }
 247   set_cursor_busy(FALSE);
 248   /* save failed */
 249   dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
 250     GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Error saving file '%s'", filename);
 251   gtk_dialog_run(GTK_DIALOG(dialog));
 252   gtk_widget_destroy(dialog);
 253   g_free(filename);
 254 }
 255
 256
 257 void
 258 on_filePrintOptions_activate           (GtkMenuItem     *menuitem,
 259                                         gpointer         user_data)
 260 {
 261
 262 }
 263
 264
 265 void
 266 on_filePrint_activate                  (GtkMenuItem     *menuitem,
 267                                         gpointer         user_data)
 268 {
 269   GtkWidget *printDialog, *preview;
 270   GnomePrintJob *gpj;
 271   int fromPage, toPage;
 272   int response;
 273   char *in_fn;
 274   guchar *s;
 275   GnomePrintConfig *config = gnome_print_config_default();
 276
 277   if (ui.filename!=NULL) {
 278     if (g_str_has_suffix(ui.filename, ".xoj")) {
 279       in_fn = g_strdup(ui.filename);
 280       g_strlcpy(g_strrstr(in_fn, "xoj"), "pdf", 4);
 281     }
 282     else
 283       in_fn = g_strdup_printf("%s.pdf", ui.filename);
 284     gnome_print_config_set(config, (guchar *)"Printer", (guchar *)"PDF");
 285     gnome_print_config_set(config, (guchar *)GNOME_PRINT_KEY_OUTPUT_FILENAME, (guchar *)in_fn);
 286     gnome_print_config_set(config, (guchar *)"Settings.Transport.Backend.FileName", (guchar *)in_fn);
 287     g_strlcpy(g_strrstr(in_fn, "pdf"), "ps", 3);
 288     gnome_print_config_set(config, (guchar *)"Printer", (guchar *)"GENERIC");
 289     gnome_print_config_set (config, (guchar *)GNOME_PRINT_KEY_OUTPUT_FILENAME, (guchar *)in_fn);
 290     s = gnome_print_config_get(config, (guchar *)"Settings.Transport.Backend.FileName");
 291     if (s != NULL) {
 292       g_free(s);
 293       gnome_print_config_set(config, (guchar *)"Settings.Transport.Backend.FileName", (guchar *)in_fn);
 294     }
 295     g_free(in_fn);
 296   }
 297
 298   gpj = gnome_print_job_new(config); /* was NULL */
 299   gnome_print_config_unref(config);
 300 /* end */
 301   printDialog = gnome_print_dialog_new(gpj, (guchar *)"Print", GNOME_PRINT_DIALOG_RANGE);
 302   gnome_print_dialog_construct_range_page(GNOME_PRINT_DIALOG(printDialog),
 303     GNOME_PRINT_RANGE_ALL | GNOME_PRINT_RANGE_RANGE,
 304     1, journal.npages, (guchar *)"Current page", (guchar *)"Pages");
 305   /* don't have "Current page" as option, else it becomes the default!! */
 306
 307   gtk_dialog_set_response_sensitive(GTK_DIALOG(printDialog),
 308                          GNOME_PRINT_DIALOG_RESPONSE_PREVIEW, FALSE);
 309   /* the print-job-preview "feature" is completely, hopelessly broken */
 310
 311   response = gtk_dialog_run(GTK_DIALOG(printDialog));
 312   if (response <= 0) {
 313     gtk_widget_destroy(printDialog);
 314     return;
 315   }
 316
 317 /*
 318   if (response == GNOME_PRINT_DIALOG_RESPONSE_PREVIEW) {
 319     print_job_render(gpj, 0, journal.npages-1);
 320     gtk_widget_destroy(printDialog);
 321     preview = gnome_print_job_preview_new(gpj, (guchar *)"Preview");
 322     try_fix_print_preview_ui(preview);
 323     gtk_window_set_modal(GTK_WINDOW(preview), TRUE);
 324     gtk_widget_show_all(preview);
 325   }
 326 */
 327
 328   if (response == GNOME_PRINT_DIALOG_RESPONSE_PRINT) {
 329     switch(gnome_print_dialog_get_range(GNOME_PRINT_DIALOG(printDialog))) {
 330       case GNOME_PRINT_RANGE_RANGE:
 331         gnome_print_dialog_get_range_page(GNOME_PRINT_DIALOG(printDialog), &fromPage, &toPage);
 332         break;
 333       default:
 334         fromPage = 0;
 335         toPage = journal.npages-1;
 336     }
 337
 338     gtk_widget_destroy(printDialog);
 339     print_job_render(gpj, fromPage, toPage);
 340   }
 341 }
 342
 343
 344 void
 345 on_filePrintPDF_activate               (GtkMenuItem     *menuitem,
 346                                         gpointer         user_data)
 347 {
 348
 349   GtkWidget *dialog;
 350   GtkFileFilter *filt_all, *filt_pdf;
 351   char *filename, *in_fn;
 352   char stime[30];
 353   time_t curtime;
 354   GnomePrintJob *gpj;
 355   GnomePrintConfig *config;
 356
 357
 358   dialog = gtk_file_chooser_dialog_new("Print to PDF", GTK_WINDOW (winMain),
 359      GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 360      GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL);
 361
 362   if (ui.filename!=NULL) {
 363     if (g_str_has_suffix(ui.filename, ".xoj")) {
 364       in_fn = g_strdup(ui.filename);
 365       g_strlcpy(g_strrstr(in_fn, "xoj"), "pdf", 4);
 366     }
 367     else
 368       in_fn = g_strdup_printf("%s.pdf", ui.filename);
 369     if (in_fn[0] == '/')
 370       gtk_file_chooser_set_filename(GTK_FILE_CHOOSER (dialog), in_fn);
 371     gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), in_fn);
 372   } else {
 373     curtime = time(NULL);
 374     strftime(stime, 30, "%F-Note-%H-%M.pdf", localtime(&curtime));
 375     gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), stime);
 376     in_fn = NULL;
 377   }
 378
 379   filt_all = gtk_file_filter_new();
 380   gtk_file_filter_set_name(filt_all, "All files");
 381   gtk_file_filter_add_pattern(filt_all, "*");
 382   filt_pdf = gtk_file_filter_new();
 383   gtk_file_filter_set_name(filt_pdf, "PDF files");
 384   gtk_file_filter_add_pattern(filt_pdf, "*.pdf");
 385   gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_pdf);
 386   gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_all);
 387
 388   // somehow this doesn't seem to be set by default
 389   gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
 390
 391   if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
 392     g_free(in_fn);
 393     gtk_widget_destroy(dialog);
 394     return;
 395   }
 396   filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
 397   g_free(in_fn);
 398   gtk_widget_destroy(dialog);
 399
 400   config = gnome_print_config_default();
 401   gnome_print_config_set(config, (guchar *)"Printer", (guchar *)"PDF");
 402   gpj = gnome_print_job_new(config);
 403   gnome_print_job_print_to_file(gpj, filename);
 404
 405   print_job_render(gpj, 0, journal.npages-1);
 406   gnome_print_config_unref(config);
 407
 408   g_free(filename);
 409 }
 410
 411
 412 void
 413 on_fileQuit_activate                   (GtkMenuItem     *menuitem,
 414                                         gpointer         user_data)
 415 {
 416   if (ok_to_close()) gtk_main_quit ();
 417 }
 418
 419
 420 void
 421 on_editUndo_activate                   (GtkMenuItem     *menuitem,
 422                                         gpointer         user_data)
 423 {
 424   struct UndoItem *u;
 425   GList *list, *itemlist;
 426   struct UndoErasureData *erasure;
 427   struct Item *it;
 428   struct Background *tmp_bg;
 429   double tmp_x, tmp_y;
 430
 431   if (undo == NULL) return; // nothing to undo!
 432   reset_selection(); // safer
 433   if (undo->type == ITEM_STROKE) {
 434     // we're keeping the stroke info, but deleting the canvas item
 435     gtk_object_destroy(GTK_OBJECT(undo->item->canvas_item));
 436     undo->item->canvas_item = NULL;
 437     // we also remove the object from its layer!
 438     undo->layer->items = g_list_remove(undo->layer->items, undo->item);
 439     undo->layer->nitems--;
 440   }
 441   else if (undo->type == ITEM_ERASURE) {
 442     for (list = undo->erasurelist; list!=NULL; list = list->next) {
 443       erasure = (struct UndoErasureData *)list->data;
 444       // delete all the created items
 445       for (itemlist = erasure->replacement_items; itemlist!=NULL; itemlist = itemlist->next) {
 446         it = (struct Item *)itemlist->data;
 447         gtk_object_destroy(GTK_OBJECT(it->canvas_item));
 448         it->canvas_item = NULL;
 449         undo->layer->items = g_list_remove(undo->layer->items, it);
 450         undo->layer->nitems--;
 451       }
 452       // recreate the deleted one
 453       erasure->item->canvas_item = gnome_canvas_item_new(undo->layer->group,
 454              gnome_canvas_line_get_type(), "points", erasure->item->path,
 455              "cap-style", GDK_CAP_ROUND, "join-style", GDK_JOIN_ROUND,
 456              "fill-color-rgba", erasure->item->brush.color_rgba,
 457              "width-units", erasure->item->brush.thickness, NULL);
 458       undo->layer->items = g_list_insert(undo->layer->items, erasure->item,
 459                                                              erasure->npos);
 460       if (erasure->npos == 0)
 461         lower_canvas_item_to(undo->layer->group, erasure->item->canvas_item, NULL);
 462       else
 463         lower_canvas_item_to(undo->layer->group, erasure->item->canvas_item,
 464           ((struct Item *)g_list_nth_data(undo->layer->items, erasure->npos-1))->canvas_item);
 465       undo->layer->nitems++;
 466     }
 467   }
 468   else if (undo->type == ITEM_NEW_BG_ONE || undo->type == ITEM_NEW_BG_RESIZE
 469            || undo->type == ITEM_PAPER_RESIZE) {
 470     if (undo->type != ITEM_PAPER_RESIZE) {
 471       // swap the two bg's
 472       tmp_bg = undo->page->bg;
 473       undo->page->bg = undo->bg;
 474       undo->bg = tmp_bg;
 475       undo->page->bg->canvas_item = undo->bg->canvas_item;
 476       undo->bg->canvas_item = NULL;
 477     }
 478     if (undo->type != ITEM_NEW_BG_ONE) {
 479       tmp_x = undo->page->width;
 480       tmp_y = undo->page->height;
 481       undo->page->width = undo->val_x;
 482       undo->page->height = undo->val_y;
 483       undo->val_x = tmp_x;
 484       undo->val_y = tmp_y;
 485       make_page_clipbox(undo->page);
 486     }
 487     update_canvas_bg(undo->page);
 488     do_switch_page(g_list_index(journal.pages, undo->page), TRUE);
 489   }
 490   else if (undo->type == ITEM_NEW_DEFAULT_BG) {
 491     tmp_bg = ui.default_page.bg;
 492     ui.default_page.bg = undo->bg;
 493     undo->bg = tmp_bg;
 494     tmp_x = ui.default_page.width;
 495     tmp_y = ui.default_page.height;
 496     ui.default_page.width = undo->val_x;
 497     ui.default_page.height = undo->val_y;
 498     undo->val_x = tmp_x;
 499     undo->val_y = tmp_y;
 500   }
 501   else if (undo->type == ITEM_NEW_PAGE) {
 502     // unmap the page; keep the page & its empty layer in memory
 503     if (undo->page->group!=NULL) gtk_object_destroy(GTK_OBJECT(undo->page->group));
 504       // also destroys the background and layer's canvas items
 505     undo->page->group = NULL;
 506     undo->page->bg->canvas_item = NULL;
 507     journal.pages = g_list_remove(journal.pages, undo->page);
 508     journal.npages--;
 509     if (ui.cur_page == undo->page) ui.cur_page = NULL;
 510         // so do_switch_page() won't try to remap the layers of the defunct page
 511     if (ui.pageno >= undo->val) ui.pageno--;
 512     if (ui.pageno < 0) ui.pageno = 0;
 513     do_switch_page(ui.pageno, TRUE);
 514   }
 515   else if (undo->type == ITEM_DELETE_PAGE) {
 516     journal.pages = g_list_insert(journal.pages, undo->page, undo->val);
 517     journal.npages++;
 518     make_canvas_items(); // re-create the canvas items
 519     do_switch_page(undo->val, TRUE);
 520   }
 521   else if (undo->type == ITEM_MOVESEL) {
 522     for (itemlist = undo->itemlist; itemlist != NULL; itemlist = itemlist->next) {
 523       it = (struct Item *)itemlist->data;
 524       if (it->canvas_item != NULL)
 525         gnome_canvas_item_move(it->canvas_item, -undo->val_x, -undo->val_y);
 526     }
 527     move_journal_items_by(undo->itemlist, -undo->val_x, -undo->val_y);
 528   }
 529   else if (undo->type == ITEM_PASTE) {
 530     for (itemlist = undo->itemlist; itemlist != NULL; itemlist = itemlist->next) {
 531       it = (struct Item *)itemlist->data;
 532       gtk_object_destroy(GTK_OBJECT(it->canvas_item));
 533       it->canvas_item = NULL;
 534       undo->layer->items = g_list_remove(undo->layer->items, it);
 535       undo->layer->nitems--;
 536     }
 537   }
 538   else if (undo->type == ITEM_NEW_LAYER) {
 539     // unmap the layer; keep the empty layer in memory
 540     if (undo->layer->group!=NULL) gtk_object_destroy(GTK_OBJECT(undo->layer->group));
 541     undo->layer->group = NULL;
 542     undo->page->layers = g_list_remove(undo->page->layers, undo->layer);
 543     undo->page->nlayers--;
 544     do_switch_page(ui.pageno, FALSE); // don't stay with bad cur_layer info
 545   }
 546   else if (undo->type == ITEM_DELETE_LAYER) {
 547     // special case of -1: deleted the last layer, created a new one
 548     if (undo->val == -1) {
 549       if (undo->layer2->group!=NULL) gtk_object_destroy(GTK_OBJECT(undo->layer2->group));
 550       undo->layer2->group = NULL;
 551       undo->page->layers = g_list_remove(undo->page->layers, undo->layer2);
 552       undo->page->nlayers--;
 553     }
 554     // re-map the layer
 555     undo->layer->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
 556       undo->page->group, gnome_canvas_group_get_type(), NULL);
 557     lower_canvas_item_to(undo->page->group, GNOME_CANVAS_ITEM(undo->layer->group),
 558       (undo->val >= 1) ? GNOME_CANVAS_ITEM(((struct Layer *)
 559             g_list_nth_data(undo->page->layers, undo->val-1))->group) :
 560             undo->page->bg->canvas_item);
 561     undo->page->layers = g_list_insert(undo->page->layers, undo->layer,
 562                                      (undo->val >= 0) ? undo->val:0);
 563     undo->page->nlayers++;
 564
 565     for (itemlist = undo->layer->items; itemlist!=NULL; itemlist = itemlist->next) {
 566       it = (struct Item *)itemlist->data;
 567       if (it->type == ITEM_STROKE) {
 568         it->canvas_item = gnome_canvas_item_new(undo->layer->group,
 569             gnome_canvas_line_get_type(), "points", it->path,
 570             "cap-style", GDK_CAP_ROUND, "join-style", GDK_JOIN_ROUND,
 571             "fill-color-rgba", it->brush.color_rgba,
 572             "width-units", it->brush.thickness, NULL);
 573       }
 574     }
 575     do_switch_page(ui.pageno, FALSE); // show the restored layer & others...
 576   }
 577
 578   // move item from undo to redo stack
 579   u = undo;
 580   undo = undo->next;
 581   u->next = redo;
 582   redo = u;
 583   ui.saved = FALSE;
 584   update_undo_redo_enabled();
 585   if (u->multiop & MULTIOP_CONT_UNDO) on_editUndo_activate(NULL,NULL); // loop
 586 }
 587
 588
 589 void
 590 on_editRedo_activate                   (GtkMenuItem     *menuitem,
 591                                         gpointer         user_data)
 592 {
 593   struct UndoItem *u;
 594   GList *list, *itemlist, *target;
 595   struct UndoErasureData *erasure;
 596   struct Item *it;
 597   struct Background *tmp_bg;
 598   struct Layer *l;
 599   double tmp_x, tmp_y;
 600
 601   if (redo == NULL) return; // nothing to redo!
 602   reset_selection(); // safer
 603   if (redo->type == ITEM_STROKE) {
 604     // re-create the canvas_item
 605     redo->item->canvas_item = gnome_canvas_item_new(redo->layer->group,
 606      gnome_canvas_line_get_type(), "points", redo->item->path,
 607      "cap-style", GDK_CAP_ROUND, "join-style", GDK_JOIN_ROUND,
 608      "fill-color-rgba", redo->item->brush.color_rgba,
 609      "width-units", redo->item->brush.thickness, NULL);
 610     // reinsert the item on its layer
 611     redo->layer->items = g_list_append(redo->layer->items, redo->item);
 612     redo->layer->nitems++;
 613   }
 614   else if (redo->type == ITEM_ERASURE) {
 615     for (list = redo->erasurelist; list!=NULL; list = list->next) {
 616       erasure = (struct UndoErasureData *)list->data;
 617       target = g_list_find(redo->layer->items, erasure->item);
 618       // re-create all the created items
 619       for (itemlist = erasure->replacement_items; itemlist!=NULL; itemlist = itemlist->next) {
 620         it = (struct Item *)itemlist->data;
 621         it->canvas_item = gnome_canvas_item_new(redo->layer->group,
 622              gnome_canvas_line_get_type(), "points", it->path,
 623              "cap-style", GDK_CAP_ROUND, "join-style", GDK_JOIN_ROUND,
 624              "fill-color-rgba", it->brush.color_rgba,
 625              "width-units", it->brush.thickness, NULL);
 626         redo->layer->items = g_list_insert_before(redo->layer->items, target, it);
 627         redo->layer->nitems++;
 628         lower_canvas_item_to(redo->layer->group, it->canvas_item, erasure->item->canvas_item);
 629       }
 630       // re-delete the deleted one
 631       gtk_object_destroy(GTK_OBJECT(erasure->item->canvas_item));
 632       erasure->item->canvas_item = NULL;
 633       redo->layer->items = g_list_delete_link(redo->layer->items, target);
 634       redo->layer->nitems--;
 635     }
 636   }
 637   else if (redo->type == ITEM_NEW_BG_ONE || redo->type == ITEM_NEW_BG_RESIZE
 638            || redo->type == ITEM_PAPER_RESIZE) {
 639     if (redo->type != ITEM_PAPER_RESIZE) {
 640       // swap the two bg's
 641       tmp_bg = redo->page->bg;
 642       redo->page->bg = redo->bg;
 643       redo->bg = tmp_bg;
 644       redo->page->bg->canvas_item = redo->bg->canvas_item;
 645       redo->bg->canvas_item = NULL;
 646     }
 647     if (redo->type != ITEM_NEW_BG_ONE) {
 648       tmp_x = redo->page->width;
 649       tmp_y = redo->page->height;
 650       redo->page->width = redo->val_x;
 651       redo->page->height = redo->val_y;
 652       redo->val_x = tmp_x;
 653       redo->val_y = tmp_y;
 654       make_page_clipbox(redo->page);
 655     }
 656     update_canvas_bg(redo->page);
 657     do_switch_page(g_list_index(journal.pages, redo->page), TRUE);
 658   }
 659   else if (redo->type == ITEM_NEW_DEFAULT_BG) {
 660     tmp_bg = ui.default_page.bg;
 661     ui.default_page.bg = redo->bg;
 662     redo->bg = tmp_bg;
 663     tmp_x = ui.default_page.width;
 664     tmp_y = ui.default_page.height;
 665     ui.default_page.width = redo->val_x;
 666     ui.default_page.height = redo->val_y;
 667     redo->val_x = tmp_x;
 668     redo->val_y = tmp_y;
 669   }
 670   else if (redo->type == ITEM_NEW_PAGE) {
 671     // remap the page
 672     redo->page->bg->canvas_item = NULL;
 673     redo->page->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
 674       gnome_canvas_root(canvas), gnome_canvas_clipgroup_get_type(), NULL);
 675     make_page_clipbox(redo->page);
 676     update_canvas_bg(redo->page);
 677     l = (struct Layer *)redo->page->layers->data;
 678     l->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
 679       redo->page->group, gnome_canvas_group_get_type(), NULL);
 680
 681     journal.pages = g_list_insert(journal.pages, redo->page, redo->val);
 682     journal.npages++;
 683     do_switch_page(redo->val, TRUE);
 684   }
 685   else if (redo->type == ITEM_DELETE_PAGE) {
 686     // unmap all the canvas items
 687     gtk_object_destroy(GTK_OBJECT(redo->page->group));
 688     redo->page->group = NULL;
 689     redo->page->bg->canvas_item = NULL;
 690     for (list = redo->page->layers; list!=NULL; list = list->next) {
 691       l = (struct Layer *)list->data;
 692       for (itemlist = l->items; itemlist!=NULL; itemlist = itemlist->next)
 693         ((struct Item *)itemlist->data)->canvas_item = NULL;
 694       l->group = NULL;
 695     }
 696     journal.pages = g_list_remove(journal.pages, redo->page);
 697     journal.npages--;
 698     if (ui.pageno > undo->val || ui.pageno == journal.npages) ui.pageno--;
 699     ui.cur_page = NULL;
 700       // so do_switch_page() won't try to remap the layers of the defunct page
 701     do_switch_page(ui.pageno, TRUE);
 702   }
 703   else if (redo->type == ITEM_MOVESEL) {
 704     for (itemlist = redo->itemlist; itemlist != NULL; itemlist = itemlist->next) {
 705       it = (struct Item *)itemlist->data;
 706       if (it->canvas_item != NULL)
 707         gnome_canvas_item_move(it->canvas_item, redo->val_x, redo->val_y);
 708     }
 709     move_journal_items_by(redo->itemlist, redo->val_x, redo->val_y);
 710   }
 711   else if (redo->type == ITEM_PASTE) {
 712     for (itemlist = redo->itemlist; itemlist != NULL; itemlist = itemlist->next) {
 713       it = (struct Item *)itemlist->data;
 714       it->canvas_item = gnome_canvas_item_new(redo->layer->group,
 715            gnome_canvas_line_get_type(), "points", it->path,
 716            "cap-style", GDK_CAP_ROUND, "join-style", GDK_JOIN_ROUND,
 717            "fill-color-rgba", it->brush.color_rgba,
 718            "width-units", it->brush.thickness, NULL);
 719       redo->layer->items = g_list_append(redo->layer->items, it);
 720       redo->layer->nitems++;
 721     }
 722   }
 723   else if (redo->type == ITEM_NEW_LAYER) {
 724     redo->layer->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
 725         redo->page->group, gnome_canvas_group_get_type(), NULL);
 726     lower_canvas_item_to(redo->page->group, GNOME_CANVAS_ITEM(redo->layer->group),
 727       (redo->val >= 1) ? GNOME_CANVAS_ITEM(((struct Layer *)
 728             g_list_nth_data(redo->page->layers, redo->val-1))->group) :
 729             redo->page->bg->canvas_item);
 730     redo->page->layers = g_list_insert(redo->page->layers, redo->layer, redo->val);
 731     redo->page->nlayers++;
 732     do_switch_page(ui.pageno, FALSE);
 733   }
 734   else if (redo->type == ITEM_DELETE_LAYER) {
 735     gtk_object_destroy(GTK_OBJECT(redo->layer->group));
 736     redo->layer->group = NULL;
 737     for (list=redo->layer->items; list!=NULL; list=list->next)
 738       ((struct Item *)list->data)->canvas_item = NULL;
 739     redo->page->layers = g_list_remove(redo->page->layers, redo->layer);
 740     redo->page->nlayers--;
 741     if (redo->val == -1) {
 742       redo->layer2->group = (GnomeCanvasGroup *)gnome_canvas_item_new(
 743         redo->page->group, gnome_canvas_group_get_type(), NULL);
 744       redo->page->layers = g_list_append(redo->page->layers, redo->layer2);
 745       redo->page->nlayers++;
 746     }
 747     do_switch_page(ui.pageno, FALSE);
 748   }
 749
 750   // move item from redo to undo stack
 751   u = redo;
 752   redo = redo->next;
 753   u->next = undo;
 754   undo = u;
 755   ui.saved = FALSE;
 756   update_undo_redo_enabled();
 757   if (u->multiop & MULTIOP_CONT_REDO) on_editRedo_activate(NULL,NULL); // loop
 758 }
 759
 760
 761 void
 762 on_editCut_activate                    (GtkMenuItem     *menuitem,
 763                                         gpointer         user_data)
 764 {
 765   selection_to_clip();
 766   selection_delete();
 767 }
 768
 769
 770 void
 771 on_editCopy_activate                   (GtkMenuItem     *menuitem,
 772                                         gpointer         user_data)
 773 {
 774   selection_to_clip();
 775 }
 776
 777
 778 void
 779 on_editPaste_activate                  (GtkMenuItem     *menuitem,
 780                                         gpointer         user_data)
 781 {
 782   clipboard_paste();
 783 }
 784
 785
 786 void
 787 on_editDelete_activate                 (GtkMenuItem     *menuitem,
 788                                         gpointer         user_data)
 789 {
 790   selection_delete();
 791 }
 792
 793
 794 void
 795 on_viewContinuous_activate             (GtkMenuItem     *menuitem,
 796                                         gpointer         user_data)
 797 {
 798   GtkAdjustment *v_adj;
 799   double yscroll;
 800
 801   if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
 802   if (ui.view_continuous) return;
 803   ui.view_continuous = TRUE;
 804   v_adj = gtk_layout_get_vadjustment(GTK_LAYOUT(canvas));
 805   yscroll = gtk_adjustment_get_value(v_adj) - ui.cur_page->voffset*ui.zoom;
 806   update_page_stuff();
 807   gtk_adjustment_set_value(v_adj, yscroll + ui.cur_page->voffset*ui.zoom);
 808   // force a refresh
 809   gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
 810 }
 811
 812
 813 void
 814 on_viewOnePage_activate                (GtkMenuItem     *menuitem,
 815                                         gpointer         user_data)
 816 {
 817   GtkAdjustment *v_adj;
 818   double yscroll;
 819
 820   if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
 821   if (!ui.view_continuous) return;
 822   ui.view_continuous = FALSE;
 823   v_adj = gtk_layout_get_vadjustment(GTK_LAYOUT(canvas));
 824   yscroll = gtk_adjustment_get_value(v_adj) - ui.cur_page->voffset*ui.zoom;
 825   update_page_stuff();
 826   gtk_adjustment_set_value(v_adj, yscroll + ui.cur_page->voffset*ui.zoom);
 827   // force a refresh
 828   gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
 829 }
 830
 831
 832 void
 833 on_viewZoomIn_activate                 (GtkMenuItem     *menuitem,
 834                                         gpointer         user_data)
 835 {
 836   if (ui.zoom > MAX_ZOOM) return;
 837   ui.zoom *= 1.5;
 838   gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
 839   rescale_bg_pixmaps();
 840 }
 841
 842
 843 void
 844 on_viewZoomOut_activate                (GtkMenuItem     *menuitem,
 845                                         gpointer         user_data)
 846 {
 847   if (ui.zoom < MIN_ZOOM) return;
 848   ui.zoom /= 1.5;
 849   gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
 850   rescale_bg_pixmaps();
 851 }
 852
 853
 854 void
 855 on_viewNormalSize_activate             (GtkMenuItem     *menuitem,
 856                                         gpointer         user_data)
 857 {
 858   ui.zoom = DEFAULT_ZOOM;
 859   gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
 860   rescale_bg_pixmaps();
 861 }
 862
 863
 864 void
 865 on_viewPageWidth_activate              (GtkMenuItem     *menuitem,
 866                                         gpointer         user_data)
 867 {
 868   ui.zoom = (GTK_WIDGET(canvas))->allocation.width/ui.cur_page->width;
 869   gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
 870   rescale_bg_pixmaps();
 871 }
 872
 873
 874 void
 875 on_viewFirstPage_activate              (GtkMenuItem     *menuitem,
 876                                         gpointer         user_data)
 877 {
 878   do_switch_page(0, TRUE);
 879 }
 880
 881
 882 void
 883 on_viewPreviousPage_activate           (GtkMenuItem     *menuitem,
 884                                         gpointer         user_data)
 885 {
 886   if (ui.pageno == 0) return;
 887   do_switch_page(ui.pageno-1, TRUE);
 888 }
 889
 890
 891 void
 892 on_viewNextPage_activate               (GtkMenuItem     *menuitem,
 893                                         gpointer         user_data)
 894 {
 895   if (ui.pageno == journal.npages-1) { // create a page at end
 896     if (page_ops_forbidden()) return;
 897     on_journalNewPageEnd_activate(menuitem, user_data);
 898     return;
 899   }
 900   do_switch_page(ui.pageno+1, TRUE);
 901 }
 902
 903
 904 void
 905 on_viewLastPage_activate               (GtkMenuItem     *menuitem,
 906                                         gpointer         user_data)
 907 {
 908   do_switch_page(journal.npages-1, TRUE);
 909 }
 910
 911
 912 void
 913 on_viewShowLayer_activate              (GtkMenuItem     *menuitem,
 914                                         gpointer         user_data)
 915 {
 916   if (ui.layerno == ui.cur_page->nlayers-1) return;
 917   reset_selection();
 918   ui.layerno++;
 919   ui.cur_layer = g_list_nth_data(ui.cur_page->layers, ui.layerno);
 920   gnome_canvas_item_show(GNOME_CANVAS_ITEM(ui.cur_layer->group));
 921   update_page_stuff();
 922 }
 923
 924
 925 void
 926 on_viewHideLayer_activate              (GtkMenuItem     *menuitem,
 927                                         gpointer         user_data)
 928 {
 929   if (ui.layerno == -1) return;
 930   reset_selection();
 931   gnome_canvas_item_hide(GNOME_CANVAS_ITEM(ui.cur_layer->group));
 932   ui.layerno--;
 933   if (ui.layerno<0) ui.cur_layer = NULL;
 934   else ui.cur_layer = g_list_nth_data(ui.cur_page->layers, ui.layerno);
 935   update_page_stuff();
 936 }
 937
 938
 939 void
 940 on_journalNewPageBefore_activate       (GtkMenuItem     *menuitem,
 941                                         gpointer         user_data)
 942 {
 943   struct Page *pg;
 944
 945   if (page_ops_forbidden()) return;
 946   reset_selection();
 947   pg = new_page(ui.cur_page);
 948   journal.pages = g_list_insert(journal.pages, pg, ui.pageno);
 949   journal.npages++;
 950   do_switch_page(ui.pageno, TRUE);
 951
 952   prepare_new_undo();
 953   undo->type = ITEM_NEW_PAGE;
 954   undo->val = ui.pageno;
 955   undo->page = pg;
 956 }
 957
 958
 959 void
 960 on_journalNewPageAfter_activate        (GtkMenuItem     *menuitem,
 961                                         gpointer         user_data)
 962 {
 963   struct Page *pg;
 964
 965   if (page_ops_forbidden()) return;
 966   reset_selection();
 967   pg = new_page(ui.cur_page);
 968   journal.pages = g_list_insert(journal.pages, pg, ui.pageno+1);
 969   journal.npages++;
 970   do_switch_page(ui.pageno+1, TRUE);
 971
 972   prepare_new_undo();
 973   undo->type = ITEM_NEW_PAGE;
 974   undo->val = ui.pageno;
 975   undo->page = pg;
 976 }
 977
 978
 979 void
 980 on_journalNewPageEnd_activate          (GtkMenuItem     *menuitem,
 981                                         gpointer         user_data)
 982 {
 983   struct Page *pg;
 984
 985   if (page_ops_forbidden()) return;
 986   reset_selection();
 987   pg = new_page((struct Page *)g_list_last(journal.pages)->data);
 988   journal.pages = g_list_append(journal.pages, pg);
 989   journal.npages++;
 990   do_switch_page(journal.npages-1, TRUE);
 991
 992   prepare_new_undo();
 993   undo->type = ITEM_NEW_PAGE;
 994   undo->val = ui.pageno;
 995   undo->page = pg;
 996 }
 997
 998
 999 void
1000 on_journalDeletePage_activate          (GtkMenuItem     *menuitem,
1001                                         gpointer         user_data)
1002 {
1003   GList *layerlist, *itemlist;
1004   struct Layer *l;
1005
1006   if (page_ops_forbidden()) return;
1007   if (journal.npages == 1) return;
1008   reset_selection();
1009   prepare_new_undo();
1010   undo->type = ITEM_DELETE_PAGE;
1011   undo->val = ui.pageno;
1012   undo->page = ui.cur_page;
1013
1014   // unmap all the canvas items
1015   gtk_object_destroy(GTK_OBJECT(ui.cur_page->group));
1016   ui.cur_page->group = NULL;
1017   ui.cur_page->bg->canvas_item = NULL;
1018   for (layerlist = ui.cur_page->layers; layerlist!=NULL; layerlist = layerlist->next) {
1019     l = (struct Layer *)layerlist->data;
1020     for (itemlist = l->items; itemlist!=NULL; itemlist = itemlist->next)
1021       ((struct Item *)itemlist->data)->canvas_item = NULL;
1022     l->group = NULL;
1023   }
1024
1025   journal.pages = g_list_remove(journal.pages, ui.cur_page);
1026   journal.npages--;
1027   if (ui.pageno == journal.npages) ui.pageno--;
1028   ui.cur_page = NULL;
1029      // so do_switch_page() won't try to remap the layers of the defunct page
1030   do_switch_page(ui.pageno, TRUE);
1031 }
1032
1033
1034 void
1035 on_journalNewLayer_activate            (GtkMenuItem     *menuitem,
1036                                         gpointer         user_data)
1037 {
1038   struct Layer *l;
1039
1040   reset_selection();
1041   l = g_new(struct Layer, 1);
1042   l->items = NULL;
1043   l->nitems = 0;
1044   l->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
1045     ui.cur_page->group, gnome_canvas_group_get_type(), NULL);
1046   lower_canvas_item_to(ui.cur_page->group, GNOME_CANVAS_ITEM(l->group),
1047     (ui.cur_layer!=NULL)?(GNOME_CANVAS_ITEM(ui.cur_layer->group)):(ui.cur_page->bg->canvas_item));
1048   ui.cur_page->layers = g_list_insert(ui.cur_page->layers, l, ui.layerno+1);
1049   ui.cur_layer = l;
1050   ui.layerno++;
1051   ui.cur_page->nlayers++;
1052   update_page_stuff();
1053
1054   prepare_new_undo();
1055   undo->type = ITEM_NEW_LAYER;
1056   undo->val = ui.layerno;
1057   undo->layer = l;
1058   undo->page = ui.cur_page;
1059 }
1060
1061
1062 void
1063 on_journalDeleteLayer_activate         (GtkMenuItem     *menuitem,
1064                                         gpointer         user_data)
1065 {
1066   GList *list;
1067
1068   if (ui.cur_layer == NULL) return;
1069   reset_selection();
1070   prepare_new_undo();
1071   undo->type = ITEM_DELETE_LAYER;
1072   undo->val = ui.layerno;
1073   undo->layer = ui.cur_layer;
1074   undo->layer2 = NULL;
1075   undo->page = ui.cur_page;
1076   // delete all the canvas items
1077   gtk_object_destroy(GTK_OBJECT(ui.cur_layer->group));
1078   ui.cur_layer->group = NULL;
1079   for (list=ui.cur_layer->items; list!=NULL; list=list->next)
1080     ((struct Item *)list->data)->canvas_item = NULL;
1081
1082   ui.cur_page->layers = g_list_remove(ui.cur_page->layers, ui.cur_layer);
1083
1084   if (ui.cur_page->nlayers>=2) {
1085     ui.cur_page->nlayers--;
1086     ui.layerno--;
1087     if (ui.layerno<0) ui.cur_layer = NULL;
1088     else ui.cur_layer = (struct Layer *)g_list_nth_data(ui.cur_page->layers, ui.layerno);
1089   }
1090   else { // special case: can't remove the last layer
1091     ui.cur_layer = g_new(struct Layer, 1);
1092     ui.cur_layer->items = NULL;
1093     ui.cur_layer->nitems = 0;
1094     ui.cur_layer->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
1095       ui.cur_page->group, gnome_canvas_group_get_type(), NULL);
1096     ui.cur_page->layers = g_list_append(NULL, ui.cur_layer);
1097     undo->val = -1;
1098     undo->layer2 = ui.cur_layer;
1099   }
1100
1101   update_page_stuff();
1102 }
1103
1104
1105 void
1106 on_journalFlatten_activate             (GtkMenuItem     *menuitem,
1107                                         gpointer         user_data)
1108 {
1109
1110 }
1111
1112
1113 // the paper sizes dialog
1114
1115 GtkWidget *papersize_dialog;
1116 int papersize_std, papersize_unit;
1117 double papersize_width, papersize_height;
1118 gboolean papersize_need_init, papersize_width_valid, papersize_height_valid;
1119
1120 #define STD_SIZE_A4 0
1121 #define STD_SIZE_A4R 1
1122 #define STD_SIZE_LETTER 2
1123 #define STD_SIZE_LETTER_R 3
1124 #define STD_SIZE_CUSTOM 4
1125
1126 #define UNIT_CM 0
1127 #define UNIT_IN 1
1128 #define UNIT_PX 2
1129 #define UNIT_PT 3
1130
1131 double unit_sizes[4] = {28.346, 72., 1/DEFAULT_ZOOM, 1.};
1132 double std_widths[STD_SIZE_CUSTOM] =  {595.27, 841.89, 612., 792.};
1133 double std_heights[STD_SIZE_CUSTOM] = {841.89, 595.27, 792., 612.};
1134 double std_units[STD_SIZE_CUSTOM] = {UNIT_CM, UNIT_CM, UNIT_IN, UNIT_IN};
1135
1136 void
1137 on_journalPaperSize_activate           (GtkMenuItem     *menuitem,
1138                                         gpointer         user_data)
1139 {
1140   int i, response;
1141
1142   papersize_dialog = create_papersizeDialog();
1143   papersize_width = ui.cur_page->width;
1144   papersize_height = ui.cur_page->height;
1145   papersize_unit = UNIT_CM;
1146 //  if (ui.cur_page->bg->type == BG_PIXMAP) papersize_unit = UNIT_PX;
1147   papersize_std = STD_SIZE_CUSTOM;
1148   for (i=0;i<STD_SIZE_CUSTOM;i++)
1149     if (fabs(papersize_width - std_widths[i])<0.1 &&
1150         fabs(papersize_height - std_heights[i])<0.1)
1151       { papersize_std = i; papersize_unit = std_units[i]; }
1152   papersize_need_init = TRUE;
1153   papersize_width_valid = papersize_height_valid = TRUE;
1154
1155   gtk_widget_show(papersize_dialog);
1156   on_comboStdSizes_changed(GTK_COMBO_BOX(g_object_get_data(
1157        G_OBJECT(papersize_dialog), "comboStdSizes")), NULL);
1158   gtk_dialog_set_default_response(GTK_DIALOG(papersize_dialog), GTK_RESPONSE_OK);
1159
1160   response = gtk_dialog_run(GTK_DIALOG(papersize_dialog));
1161   gtk_widget_destroy(papersize_dialog);
1162   if (response != GTK_RESPONSE_OK) return;
1163
1164   prepare_new_undo();
1165   undo->type = ITEM_PAPER_RESIZE;
1166   undo->page = ui.cur_page;
1167   undo->val_x = ui.cur_page->width;
1168   undo->val_y = ui.cur_page->height;
1169
1170   if (papersize_width_valid) ui.cur_page->width = papersize_width;
1171   if (papersize_height_valid) ui.cur_page->height = papersize_height;
1172
1173   make_page_clipbox(ui.cur_page);
1174   update_canvas_bg(ui.cur_page);
1175   do_switch_page(ui.pageno, TRUE);
1176 }
1177
1178
1179 void
1180 on_papercolorWhite_activate            (GtkMenuItem     *menuitem,
1181                                         gpointer         user_data)
1182 {
1183   process_papercolor_activate(menuitem, COLOR_WHITE);
1184 }
1185
1186
1187 void
1188 on_papercolorYellow_activate           (GtkMenuItem     *menuitem,
1189                                         gpointer         user_data)
1190 {
1191   process_papercolor_activate(menuitem, COLOR_YELLOW);
1192 }
1193
1194
1195 void
1196 on_papercolorPink_activate             (GtkMenuItem     *menuitem,
1197                                         gpointer         user_data)
1198 {
1199   process_papercolor_activate(menuitem, COLOR_RED);
1200 }
1201
1202
1203 void
1204 on_papercolorOrange_activate           (GtkMenuItem     *menuitem,
1205                                         gpointer         user_data)
1206 {
1207   process_papercolor_activate(menuitem, COLOR_ORANGE);
1208 }
1209
1210
1211 void
1212 on_papercolorBlue_activate             (GtkMenuItem     *menuitem,
1213                                         gpointer         user_data)
1214 {
1215   process_papercolor_activate(menuitem, COLOR_BLUE);
1216 }
1217
1218
1219 void
1220 on_papercolorGreen_activate            (GtkMenuItem     *menuitem,
1221                                         gpointer         user_data)
1222 {
1223   process_papercolor_activate(menuitem, COLOR_GREEN);
1224 }
1225
1226
1227 void
1228 on_papercolorOther_activate            (GtkMenuItem     *menuitem,
1229                                         gpointer         user_data)
1230 {
1231
1232 }
1233
1234
1235 void
1236 on_paperstylePlain_activate            (GtkMenuItem     *menuitem,
1237                                         gpointer         user_data)
1238 {
1239   process_paperstyle_activate(menuitem, RULING_NONE);
1240 }
1241
1242
1243 void
1244 on_paperstyleLined_activate            (GtkMenuItem     *menuitem,
1245                                         gpointer         user_data)
1246 {
1247   process_paperstyle_activate(menuitem, RULING_LINED);
1248 }
1249
1250
1251 void
1252 on_paperstyleRuled_activate            (GtkMenuItem     *menuitem,
1253                                         gpointer         user_data)
1254 {
1255   process_paperstyle_activate(menuitem, RULING_RULED);
1256 }
1257
1258
1259 void
1260 on_paperstyleGraph_activate            (GtkMenuItem     *menuitem,
1261                                         gpointer         user_data)
1262 {
1263   process_paperstyle_activate(menuitem, RULING_GRAPH);
1264 }
1265
1266
1267 void
1268 on_journalLoadBackground_activate      (GtkMenuItem     *menuitem,
1269                                         gpointer         user_data)
1270 {
1271   GtkWidget *dialog, *attach_opt;
1272   struct Background *bg;
1273   struct Page *pg;
1274   int pageno;
1275   GList *bglist, *bglistiter;
1276   GtkFileFilter *filt_all, *filt_pix, *filt_pspdf;
1277   char *filename;
1278   gboolean attach;
1279
1280   dialog = gtk_file_chooser_dialog_new("Open Background", GTK_WINDOW (winMain),
1281      GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1282      GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);
1283
1284   filt_all = gtk_file_filter_new();
1285   gtk_file_filter_set_name(filt_all, "All files");
1286   gtk_file_filter_add_pattern(filt_all, "*");
1287   gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_all);
1288
1289 #if GTK_CHECK_VERSION(2,6,0)
1290
1291   if (!gtk_check_version(2, 6, 0)) {
1292     filt_pix = gtk_file_filter_new();
1293     gtk_file_filter_set_name(filt_pix, "Bitmap files");
1294     gtk_file_filter_add_pixbuf_formats(filt_pix);
1295     gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_pix);
1296   }
1297
1298 #endif
1299
1300   filt_pspdf = gtk_file_filter_new();
1301   gtk_file_filter_set_name(filt_pspdf, "PS/PDF files (as bitmaps)");
1302   gtk_file_filter_add_pattern(filt_pspdf, "*.ps");
1303   gtk_file_filter_add_pattern(filt_pspdf, "*.pdf");
1304   gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_pspdf);
1305
1306   attach_opt = gtk_check_button_new_with_label("Attach file to the journal");
1307   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(attach_opt), FALSE);
1308   gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER (dialog), attach_opt);
1309
1310   if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
1311     gtk_widget_destroy(dialog);
1312     return;
1313   }
1314   filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
1315   attach = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(attach_opt));
1316   gtk_widget_destroy(dialog);
1317
1318   set_cursor_busy(TRUE);
1319   bg = attempt_load_pix_bg(filename, attach);
1320   if (bg != NULL) bglist = g_list_append(NULL, bg);
1321   else bglist = attempt_load_gv_bg(filename);
1322   set_cursor_busy(FALSE);
1323
1324   if (bglist == NULL) {
1325     dialog = gtk_message_dialog_new(GTK_WINDOW(winMain), GTK_DIALOG_MODAL,
1326       GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
1327       "Error opening background '%s'", filename);
1328     gtk_dialog_run(GTK_DIALOG(dialog));
1329     gtk_widget_destroy(dialog);
1330     g_free(filename);
1331     return;
1332   }
1333
1334   g_free(filename);
1335   reset_selection();
1336   pageno = ui.pageno;
1337
1338   for (bglistiter = bglist, pageno = ui.pageno;
1339            bglistiter!=NULL; bglistiter = bglistiter->next, pageno++) {
1340     prepare_new_undo();
1341     if (bglistiter->next!=NULL) undo->multiop |= MULTIOP_CONT_REDO;
1342     if (bglistiter->prev!=NULL) undo->multiop |= MULTIOP_CONT_UNDO;
1343
1344     bg = (struct Background *)bglistiter->data;
1345
1346     if (pageno == journal.npages) {
1347       undo->type = ITEM_NEW_PAGE;
1348       pg = new_page_with_bg(bg,
1349               gdk_pixbuf_get_width(bg->pixbuf)/bg->pixbuf_scale,
1350               gdk_pixbuf_get_height(bg->pixbuf)/bg->pixbuf_scale);
1351       journal.pages = g_list_append(journal.pages, pg);
1352       journal.npages++;
1353       undo->val = pageno;
1354       undo->page = pg;
1355     } else
1356     {
1357       pg = g_list_nth_data(journal.pages, pageno);
1358       undo->type = ITEM_NEW_BG_RESIZE;
1359       undo->page = pg;
1360       undo->bg = pg->bg;
1361       bg->canvas_item = undo->bg->canvas_item;
1362       undo->bg->canvas_item = NULL;
1363       undo->val_x = pg->width;
1364       undo->val_y = pg->height;
1365       pg->bg = bg;
1366       pg->width = gdk_pixbuf_get_width(bg->pixbuf)/bg->pixbuf_scale;
1367       pg->height = gdk_pixbuf_get_height(bg->pixbuf)/bg->pixbuf_scale;
1368       make_page_clipbox(pg);
1369       update_canvas_bg(pg);
1370     }
1371   }
1372
1373   g_list_free(bglist);
1374   if (ui.zoom != DEFAULT_ZOOM) {
1375     ui.zoom = DEFAULT_ZOOM;
1376     gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
1377     rescale_bg_pixmaps();
1378   }
1379   do_switch_page(ui.pageno, TRUE);
1380 }
1381
1382 void
1383 on_journalScreenshot_activate          (GtkMenuItem     *menuitem,
1384                                         gpointer         user_data)
1385 {
1386   struct Background *bg;
1387
1388   reset_selection();
1389   gtk_window_iconify(GTK_WINDOW(winMain)); // hide ourselves
1390   gdk_display_sync(gdk_display_get_default());
1391
1392   if (ui.cursor!=NULL)
1393     gdk_cursor_unref(ui.cursor);
1394   ui.cursor = gdk_cursor_new(GDK_TCROSS);
1395
1396   bg = attempt_screenshot_bg();
1397
1398   gtk_window_deiconify(GTK_WINDOW(winMain));
1399   update_cursor();
1400   if (bg==NULL) return;
1401
1402   prepare_new_undo();
1403   undo->type = ITEM_NEW_BG_RESIZE;
1404   undo->page = ui.cur_page;
1405   undo->bg = ui.cur_page->bg;
1406   bg->canvas_item = undo->bg->canvas_item;
1407   undo->bg->canvas_item = NULL;
1408   undo->val_x = ui.cur_page->width;
1409   undo->val_y = ui.cur_page->height;
1410
1411   ui.cur_page->bg = bg;
1412   ui.cur_page->width = gdk_pixbuf_get_width(bg->pixbuf)/bg->pixbuf_scale;
1413   ui.cur_page->height = gdk_pixbuf_get_height(bg->pixbuf)/bg->pixbuf_scale;
1414
1415   make_page_clipbox(ui.cur_page);
1416   update_canvas_bg(ui.cur_page);
1417
1418   if (ui.zoom != DEFAULT_ZOOM) {
1419     ui.zoom = DEFAULT_ZOOM;
1420     gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
1421     rescale_bg_pixmaps();
1422   }
1423   do_switch_page(ui.pageno, TRUE);
1424 }
1425
1426
1427 void
1428 on_journalApplyAllPages_activate       (GtkMenuItem     *menuitem,
1429                                         gpointer         user_data)
1430 {
1431
1432 }
1433
1434
1435 void
1436 on_toolsPen_activate                   (GtkMenuItem     *menuitem,
1437                                         gpointer         user_data)
1438 {
1439   if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1440     if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1441       return;
1442   } else {
1443     if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1444       return;
1445   }
1446
1447   if (ui.toolno == TOOL_PEN) return;
1448
1449   reset_selection();
1450   ui.toolno = TOOL_PEN;
1451   ui.ruler = FALSE;
1452   ui.cur_brush = ui.brushes+TOOL_PEN;
1453   update_tool_buttons();
1454   update_tool_menu();
1455   update_color_menu();
1456   update_cursor();
1457 }
1458
1459
1460 void
1461 on_toolsEraser_activate                (GtkMenuItem     *menuitem,
1462                                         gpointer         user_data)
1463 {
1464   if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1465     if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1466       return;
1467   } else {
1468     if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1469       return;
1470   }
1471
1472   if (ui.toolno == TOOL_ERASER) return;
1473
1474   reset_selection();
1475   ui.toolno = TOOL_ERASER;
1476   ui.ruler = FALSE;
1477   ui.cur_brush = ui.brushes+TOOL_ERASER;
1478   update_tool_buttons();
1479   update_tool_menu();
1480   update_color_menu();
1481   update_cursor();
1482 }
1483
1484
1485 void
1486 on_toolsHighlighter_activate           (GtkMenuItem     *menuitem,
1487                                         gpointer         user_data)
1488 {
1489   if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1490     if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1491       return;
1492   } else {
1493     if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1494       return;
1495   }
1496
1497   if (ui.toolno == TOOL_HIGHLIGHTER) return;
1498
1499   reset_selection();
1500   ui.toolno = TOOL_HIGHLIGHTER;
1501   ui.ruler = FALSE;
1502   ui.cur_brush = ui.brushes+TOOL_HIGHLIGHTER;
1503   update_tool_buttons();
1504   update_tool_menu();
1505   update_color_menu();
1506   update_cursor();
1507 }
1508
1509
1510 void
1511 on_toolsText_activate                  (GtkMenuItem     *menuitem,
1512                                         gpointer         user_data)
1513 {
1514
1515 }
1516
1517
1518 void
1519 on_toolsSelectRegion_activate          (GtkMenuItem     *menuitem,
1520                                         gpointer         user_data)
1521 {
1522
1523 }
1524
1525
1526 void
1527 on_toolsSelectRectangle_activate       (GtkMenuItem     *menuitem,
1528                                         gpointer         user_data)
1529 {
1530   if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1531     if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1532       return;
1533   } else {
1534     if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1535       return;
1536   }
1537
1538   if (ui.toolno == TOOL_SELECTRECT) return;
1539
1540   ui.toolno = TOOL_SELECTRECT;
1541   ui.ruler = FALSE;
1542   update_tool_buttons();
1543   update_tool_menu();
1544   update_color_menu();
1545   update_cursor();
1546 }
1547
1548
1549 void
1550 on_toolsVerticalSpace_activate         (GtkMenuItem     *menuitem,
1551                                         gpointer         user_data)
1552 {
1553   if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1554     if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1555       return;
1556   } else {
1557     if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1558       return;
1559   }
1560
1561   if (ui.toolno == TOOL_VERTSPACE) return;
1562
1563   reset_selection();
1564   ui.toolno = TOOL_VERTSPACE;
1565   ui.ruler = FALSE;
1566   update_tool_buttons();
1567   update_tool_menu();
1568   update_color_menu();
1569   update_cursor();
1570 }
1571
1572
1573 void
1574 on_colorBlack_activate                 (GtkMenuItem     *menuitem,
1575                                         gpointer         user_data)
1576 {
1577   process_color_activate(menuitem, COLOR_BLACK);
1578 }
1579
1580
1581 void
1582 on_colorBlue_activate                  (GtkMenuItem     *menuitem,
1583                                         gpointer         user_data)
1584 {
1585   process_color_activate(menuitem, COLOR_BLUE);
1586
1587 }
1588
1589
1590 void
1591 on_colorRed_activate                   (GtkMenuItem     *menuitem,
1592                                         gpointer         user_data)
1593 {
1594   process_color_activate(menuitem, COLOR_RED);
1595 }
1596
1597
1598 void
1599 on_colorGreen_activate                 (GtkMenuItem     *menuitem,
1600                                         gpointer         user_data)
1601 {
1602   process_color_activate(menuitem, COLOR_GREEN);
1603 }
1604
1605
1606 void
1607 on_colorGray_activate                  (GtkMenuItem     *menuitem,
1608                                         gpointer         user_data)
1609 {
1610   process_color_activate(menuitem, COLOR_GRAY);
1611 }
1612
1613
1614 void
1615 on_colorLightBlue_activate             (GtkMenuItem     *menuitem,
1616                                         gpointer         user_data)
1617 {
1618   process_color_activate(menuitem, COLOR_LIGHTBLUE);
1619 }
1620
1621
1622 void
1623 on_colorLightGreen_activate            (GtkMenuItem     *menuitem,
1624                                         gpointer         user_data)
1625 {
1626   process_color_activate(menuitem, COLOR_LIGHTGREEN);
1627 }
1628
1629
1630 void
1631 on_colorMagenta_activate               (GtkMenuItem     *menuitem,
1632                                         gpointer         user_data)
1633 {
1634   process_color_activate(menuitem, COLOR_MAGENTA);
1635 }
1636
1637
1638 void
1639 on_colorOrange_activate                (GtkMenuItem     *menuitem,
1640                                         gpointer         user_data)
1641 {
1642   process_color_activate(menuitem, COLOR_ORANGE);
1643 }
1644
1645
1646 void
1647 on_colorYellow_activate                (GtkMenuItem     *menuitem,
1648                                         gpointer         user_data)
1649 {
1650   process_color_activate(menuitem, COLOR_YELLOW);
1651 }
1652
1653
1654 void
1655 on_colorWhite_activate                 (GtkMenuItem     *menuitem,
1656                                         gpointer         user_data)
1657 {
1658   process_color_activate(menuitem, COLOR_WHITE);
1659 }
1660
1661
1662 void
1663 on_colorOther_activate                 (GtkMenuItem     *menuitem,
1664                                         gpointer         user_data)
1665 {
1666
1667 }
1668
1669
1670 void
1671 on_penthicknessVeryFine_activate       (GtkMenuItem     *menuitem,
1672                                         gpointer         user_data)
1673 {
1674   process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_VERYFINE);
1675 }
1676
1677
1678 void
1679 on_penthicknessFine_activate           (GtkMenuItem     *menuitem,
1680                                         gpointer         user_data)
1681 {
1682   process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_FINE);
1683 }
1684
1685
1686 void
1687 on_penthicknessMedium_activate         (GtkMenuItem     *menuitem,
1688                                         gpointer         user_data)
1689 {
1690   process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_MEDIUM);
1691 }
1692
1693
1694 void
1695 on_penthicknessThick_activate          (GtkMenuItem     *menuitem,
1696                                         gpointer         user_data)
1697 {
1698   process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_THICK);
1699 }
1700
1701
1702 void
1703 on_penthicknessVeryThick_activate      (GtkMenuItem     *menuitem,
1704                                         gpointer         user_data)
1705 {
1706   process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_VERYTHICK);
1707 }
1708
1709
1710 void
1711 on_eraserFine_activate                 (GtkMenuItem     *menuitem,
1712                                         gpointer         user_data)
1713 {
1714   process_thickness_activate(menuitem, TOOL_ERASER, THICKNESS_FINE);
1715 }
1716
1717
1718 void
1719 on_eraserMedium_activate               (GtkMenuItem     *menuitem,
1720                                         gpointer         user_data)
1721 {
1722   process_thickness_activate(menuitem, TOOL_ERASER, THICKNESS_MEDIUM);
1723 }
1724
1725
1726 void
1727 on_eraserThick_activate                (GtkMenuItem     *menuitem,
1728                                         gpointer         user_data)
1729 {
1730   process_thickness_activate(menuitem, TOOL_ERASER, THICKNESS_THICK);
1731 }
1732
1733
1734 void
1735 on_eraserStandard_activate             (GtkMenuItem     *menuitem,
1736                                         gpointer         user_data)
1737 {
1738   if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
1739   ui.brushes[TOOL_ERASER].tool_options = TOOLOPT_ERASER_STANDARD;
1740 }
1741
1742
1743 void
1744 on_eraserWhiteout_activate             (GtkMenuItem     *menuitem,
1745                                         gpointer         user_data)
1746 {
1747   if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
1748   ui.brushes[TOOL_ERASER].tool_options = TOOLOPT_ERASER_WHITEOUT;
1749 }
1750
1751
1752 void
1753 on_eraserDeleteStrokes_activate        (GtkMenuItem     *menuitem,
1754                                         gpointer         user_data)
1755 {
1756   if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
1757   ui.brushes[TOOL_ERASER].tool_options = TOOLOPT_ERASER_STROKES;
1758 }
1759
1760
1761 void
1762 on_highlighterFine_activate            (GtkMenuItem     *menuitem,
1763                                         gpointer         user_data)
1764 {
1765   process_thickness_activate(menuitem, TOOL_HIGHLIGHTER, THICKNESS_FINE);
1766 }
1767
1768
1769 void
1770 on_highlighterMedium_activate          (GtkMenuItem     *menuitem,
1771                                         gpointer         user_data)
1772 {
1773   process_thickness_activate(menuitem, TOOL_HIGHLIGHTER, THICKNESS_MEDIUM);
1774 }
1775
1776
1777 void
1778 on_highlighterThick_activate           (GtkMenuItem     *menuitem,
1779                                         gpointer         user_data)
1780 {
1781   process_thickness_activate(menuitem, TOOL_HIGHLIGHTER, THICKNESS_THICK);
1782 }
1783
1784
1785 void
1786 on_toolsTextFont_activate              (GtkMenuItem     *menuitem,
1787                                         gpointer         user_data)
1788 {
1789
1790 }
1791
1792
1793 void
1794 on_toolsDefaultPen_activate            (GtkMenuItem     *menuitem,
1795                                         gpointer         user_data)
1796 {
1797   reset_selection();
1798   g_memmove(ui.brushes+TOOL_PEN, ui.default_brushes+TOOL_PEN, sizeof(struct Brush));
1799   ui.toolno = TOOL_PEN;
1800   ui.cur_brush = ui.brushes+TOOL_PEN;
1801   update_tool_buttons();
1802   update_tool_menu();
1803   update_pen_props_menu();
1804   update_color_menu();
1805   update_cursor();
1806 }
1807
1808
1809 void
1810 on_toolsDefaultEraser_activate         (GtkMenuItem     *menuitem,
1811                                         gpointer         user_data)
1812 {
1813   reset_selection();
1814   g_memmove(ui.brushes+TOOL_ERASER, ui.default_brushes+TOOL_ERASER, sizeof(struct Brush));
1815   ui.toolno = TOOL_ERASER;
1816   ui.cur_brush = ui.brushes+TOOL_ERASER;
1817   update_tool_buttons();
1818   update_tool_menu();
1819   update_eraser_props_menu();
1820   update_color_menu();
1821   update_cursor();
1822 }
1823
1824
1825 void
1826 on_toolsDefaultHighlighter_activate    (GtkMenuItem     *menuitem,
1827                                         gpointer         user_data)
1828 {
1829   reset_selection();
1830   g_memmove(ui.brushes+TOOL_HIGHLIGHTER, ui.default_brushes+TOOL_HIGHLIGHTER, sizeof(struct Brush));
1831   ui.toolno = TOOL_HIGHLIGHTER;
1832   ui.cur_brush = ui.brushes+TOOL_HIGHLIGHTER;
1833   update_tool_buttons();
1834   update_tool_menu();
1835   update_highlighter_props_menu();
1836   update_color_menu();
1837   update_cursor();
1838 }
1839
1840 void
1841 on_toolsDefaultText_activate           (GtkMenuItem     *menuitem,
1842                                         gpointer         user_data)
1843 {
1844
1845 }
1846
1847
1848 void
1849 on_toolsSetAsDefault_activate          (GtkMenuItem     *menuitem,
1850                                         gpointer         user_data)
1851 {
1852   if (ui.toolno < NUM_STROKE_TOOLS)
1853     g_memmove(ui.default_brushes+ui.toolno, ui.brushes+ui.toolno, sizeof(struct Brush));
1854 }
1855
1856
1857 void
1858 on_toolsRuler_activate                 (GtkMenuItem     *menuitem,
1859                                         gpointer         user_data)
1860 {
1861   gboolean active;
1862
1863   if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_CHECK_MENU_ITEM)
1864     active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
1865   else
1866     active = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem));
1867
1868   if (active == ui.ruler) return;
1869
1870   if (active && (ui.toolno!=TOOL_PEN && ui.toolno!=TOOL_HIGHLIGHTER)) {
1871     reset_selection();
1872     ui.toolno = TOOL_PEN;
1873     ui.cur_brush = ui.brushes+TOOL_PEN;
1874     update_color_menu();
1875     update_tool_buttons();
1876     update_tool_menu();
1877     update_cursor();
1878   }
1879
1880   ui.ruler = active;
1881   update_ruler_indicator();
1882 }
1883
1884
1885 void
1886 on_optionsSavePreferences_activate     (GtkMenuItem     *menuitem,
1887                                         gpointer         user_data)
1888 {
1889
1890 }
1891
1892
1893 void
1894 on_helpIndex_activate                  (GtkMenuItem     *menuitem,
1895                                         gpointer         user_data)
1896 {
1897
1898 }
1899
1900
1901 void
1902 on_helpAbout_activate                  (GtkMenuItem     *menuitem,
1903                                         gpointer         user_data)
1904 {
1905   GtkWidget *aboutDialog;
1906   GtkLabel *labelTitle;
1907
1908   aboutDialog = create_aboutDialog ();
1909   labelTitle = GTK_LABEL(g_object_get_data(G_OBJECT(aboutDialog), "labelTitle"));
1910   gtk_label_set_markup(labelTitle,
1911     "<span size=\"xx-large\" weight=\"bold\">Xournal " VERSION "</span>");
1912   gtk_dialog_run (GTK_DIALOG(aboutDialog));
1913   gtk_widget_destroy(aboutDialog);
1914 }
1915
1916
1917 void
1918 on_buttonToolDefault_clicked           (GtkToolButton   *toolbutton,
1919                                         gpointer         user_data)
1920 {
1921   if (ui.toolno < NUM_STROKE_TOOLS) {
1922     g_memmove(ui.brushes+ui.toolno, ui.default_brushes+ui.toolno, sizeof(struct Brush));
1923     update_thickness_buttons();
1924     update_color_buttons();
1925     update_color_menu();
1926     if (ui.toolno == TOOL_PEN) update_pen_props_menu();
1927     if (ui.toolno == TOOL_ERASER) update_eraser_props_menu();
1928     if (ui.toolno == TOOL_HIGHLIGHTER) update_highlighter_props_menu();
1929     update_cursor();
1930   }
1931 }
1932
1933
1934 void
1935 on_buttonFine_clicked                  (GtkToolButton   *toolbutton,
1936                                         gpointer         user_data)
1937 {
1938   process_thickness_activate((GtkMenuItem*)toolbutton, ui.toolno, THICKNESS_FINE);
1939 }
1940
1941
1942 void
1943 on_buttonMedium_clicked                (GtkToolButton   *toolbutton,
1944                                         gpointer         user_data)
1945 {
1946   process_thickness_activate((GtkMenuItem*)toolbutton, ui.toolno, THICKNESS_MEDIUM);
1947 }
1948
1949
1950 void
1951 on_buttonThick_clicked                 (GtkToolButton   *toolbutton,
1952                                         gpointer         user_data)
1953 {
1954   process_thickness_activate((GtkMenuItem*)toolbutton, ui.toolno, THICKNESS_THICK);
1955 }
1956
1957
1958 gboolean
1959 on_canvas_button_press_event           (GtkWidget       *widget,
1960                                         GdkEventButton  *event,
1961                                         gpointer         user_data)
1962 {
1963   double pt[2];
1964   gboolean page_change;
1965   struct Page *tmppage;
1966   GtkWidget *dialog;
1967
1968   if (ui.cur_item_type != ITEM_NONE) return FALSE; // we're already doing something
1969   if (event->button > 3) return FALSE; // no painting with the mouse wheel!
1970
1971   if (ui.use_xinput) {
1972     if (event->device->source == GDK_SOURCE_MOUSE) return FALSE;
1973     // re-get the axis values since Synaptics sends bogus ones
1974     gdk_device_get_state(event->device, event->window, event->axes, NULL);
1975     fix_xinput_coords((GdkEvent *)event);
1976   }
1977   else if (event->device->source != GDK_SOURCE_MOUSE) return FALSE;
1978
1979   if ((ui.use_xinput && event->device->source == GDK_SOURCE_ERASER) ||
1980       (ui.emulate_eraser && event->button >= 2)) {
1981     ui.saved_toolno = ui.toolno;
1982     ui.saved_ruler = ui.ruler;
1983     reset_selection();
1984     ui.toolno = TOOL_ERASER;
1985     ui.ruler = FALSE;
1986     ui.cur_brush = ui.brushes + TOOL_ERASER;
1987     update_tool_buttons();
1988     update_tool_menu();
1989     update_color_menu();
1990     update_cursor();
1991   }
1992
1993   // check whether we're in a page
1994   page_change = FALSE;
1995   tmppage = ui.cur_page;
1996   get_pointer_coords((GdkEvent *)event, pt);
1997   while (ui.view_continuous && (pt[1] < - VIEW_CONTINUOUS_SKIP)) {
1998     if (ui.pageno == 0) break;
1999     page_change = TRUE;
2000     ui.pageno--;
2001     tmppage = g_list_nth_data(journal.pages, ui.pageno);
2002     pt[1] += tmppage->height + VIEW_CONTINUOUS_SKIP;
2003   }
2004   while (ui.view_continuous && (pt[1] > tmppage->height + VIEW_CONTINUOUS_SKIP)) {
2005     if (ui.pageno == journal.npages-1) break;
2006     pt[1] -= tmppage->height + VIEW_CONTINUOUS_SKIP;
2007     page_change = TRUE;
2008     ui.pageno++;
2009     tmppage = g_list_nth_data(journal.pages, ui.pageno);
2010   }
2011   if (page_change) do_switch_page(ui.pageno, FALSE);
2012
2013   // can't paint on the background...
2014
2015   if (ui.cur_layer == NULL) {
2016     if (ui.saved_toolno >=0) {
2017       ui.toolno = ui.saved_toolno;
2018       ui.ruler = ui.saved_ruler;
2019       ui.saved_toolno = -1;
2020       if (ui.toolno < NUM_STROKE_TOOLS) ui.cur_brush = ui.brushes + ui.toolno;
2021       update_tool_buttons();
2022       update_tool_menu();
2023       update_color_menu();
2024       update_cursor();
2025     }
2026     /* warn */
2027     dialog = gtk_message_dialog_new(GTK_WINDOW(winMain), GTK_DIALOG_MODAL,
2028       GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, "Drawing is not allowed on the "
2029       "background layer.\n Switching to Layer 1.");
2030     gtk_dialog_run(GTK_DIALOG(dialog));
2031     gtk_widget_destroy(dialog);
2032     on_viewShowLayer_activate(NULL, NULL);
2033     return;
2034   }
2035
2036   // process the event
2037   ui.which_mouse_button = event->button;
2038
2039   if (ui.toolno == TOOL_PEN || ui.toolno == TOOL_HIGHLIGHTER ||
2040      (ui.toolno == TOOL_ERASER && ui.cur_brush->tool_options == TOOLOPT_ERASER_WHITEOUT)) {
2041     create_new_stroke((GdkEvent *)event);
2042   }
2043   else if (ui.toolno == TOOL_ERASER) {
2044     ui.cur_item_type = ITEM_ERASURE;
2045     do_eraser((GdkEvent *)event, ui.cur_brush->thickness/2,
2046                ui.cur_brush->tool_options == TOOLOPT_ERASER_STROKES);
2047   }
2048   else if (ui.toolno == TOOL_SELECTRECT) {
2049     if (!start_movesel((GdkEvent *)event))
2050       start_selectrect((GdkEvent *)event);
2051   }
2052   else if (ui.toolno == TOOL_VERTSPACE) {
2053     start_vertspace((GdkEvent *)event);
2054   }
2055   return FALSE;
2056 }
2057
2058
2059 gboolean
2060 on_canvas_button_release_event         (GtkWidget       *widget,
2061                                         GdkEventButton  *event,
2062                                         gpointer         user_data)
2063 {
2064   if (ui.cur_item_type == ITEM_NONE) return FALSE; // not doing anything
2065
2066   if (event->button != ui.which_mouse_button) return FALSE; // ignore
2067
2068   if (ui.use_xinput) {
2069     if (event->device->source == GDK_SOURCE_MOUSE) return FALSE;
2070     fix_xinput_coords((GdkEvent *)event);
2071   }
2072   else if (event->device->source != GDK_SOURCE_MOUSE) return FALSE;
2073
2074   if (ui.saved_toolno >= 0) {
2075     ui.toolno = ui.saved_toolno;
2076     ui.ruler = ui.saved_ruler;
2077     ui.saved_toolno = -1;
2078     if (ui.toolno < NUM_STROKE_TOOLS) ui.cur_brush = ui.brushes + ui.toolno;
2079     update_tool_buttons();
2080     update_tool_menu();
2081     update_color_menu();
2082     update_cursor();
2083   }
2084
2085   if (ui.cur_item_type == ITEM_STROKE) {
2086     finalize_stroke();
2087   }
2088   else if (ui.cur_item_type == ITEM_ERASURE) {
2089     finalize_erasure();
2090   }
2091   else if (ui.cur_item_type == ITEM_SELECTRECT) {
2092     finalize_selectrect();
2093   }
2094   else if (ui.cur_item_type == ITEM_MOVESEL) {
2095     finalize_movesel();
2096   }
2097
2098   return FALSE;
2099 }
2100
2101
2102 gboolean
2103 on_canvas_enter_notify_event           (GtkWidget       *widget,
2104                                         GdkEventCrossing *event,
2105                                         gpointer         user_data)
2106 {
2107
2108   return FALSE;
2109 }
2110
2111
2112 gboolean
2113 on_canvas_expose_event                 (GtkWidget       *widget,
2114                                         GdkEventExpose  *event,
2115                                         gpointer         user_data)
2116 {
2117
2118   return FALSE;
2119 }
2120
2121
2122 gboolean
2123 on_canvas_key_press_event              (GtkWidget       *widget,
2124                                         GdkEventKey     *event,
2125                                         gpointer         user_data)
2126 {
2127
2128   return FALSE;
2129 }
2130
2131
2132 gboolean
2133 on_canvas_motion_notify_event          (GtkWidget       *widget,
2134                                         GdkEventMotion  *event,
2135                                         gpointer         user_data)
2136 {
2137   gboolean looks_wrong;
2138   double pt[2];
2139
2140   if (ui.cur_item_type == ITEM_NONE) return FALSE; // we don't care
2141
2142   if (ui.use_xinput) {
2143     if (event->device->source == GDK_SOURCE_MOUSE) return FALSE;
2144     fix_xinput_coords((GdkEvent *)event);
2145   }
2146   else if (event->device->source != GDK_SOURCE_MOUSE) return FALSE;
2147
2148   looks_wrong = !(event->state & (1<<(7+ui.which_mouse_button)));
2149
2150   if (looks_wrong) { /* mouse button shouldn't be up... give up */
2151     if (ui.cur_item_type == ITEM_STROKE) {
2152       finalize_stroke();
2153     }
2154     else if (ui.cur_item_type == ITEM_ERASURE) {
2155       finalize_erasure();
2156     }
2157     else if (ui.cur_item_type == ITEM_SELECTRECT) {
2158       finalize_selectrect();
2159     }
2160     else if (ui.cur_item_type == ITEM_MOVESEL) {
2161       finalize_movesel();
2162     }
2163     return FALSE;
2164   }
2165
2166   if (ui.cur_item_type == ITEM_STROKE) {
2167     continue_stroke((GdkEvent *)event);
2168   }
2169   else if (ui.cur_item_type == ITEM_ERASURE) {
2170     do_eraser((GdkEvent *)event, ui.cur_brush->thickness/2,
2171                ui.cur_brush->tool_options == TOOLOPT_ERASER_STROKES);
2172   }
2173   else if (ui.cur_item_type == ITEM_SELECTRECT) {
2174     get_pointer_coords((GdkEvent *)event, pt);
2175     ui.selection->bbox.right = pt[0];
2176     ui.selection->bbox.bottom = pt[1];
2177     gnome_canvas_item_set(ui.selection->canvas_item,
2178                                "x2", pt[0], "y2", pt[1], NULL);
2179   }
2180   else if (ui.cur_item_type == ITEM_MOVESEL) {
2181     continue_movesel((GdkEvent *)event);
2182   }
2183
2184   return FALSE;
2185 }
2186
2187
2188 void
2189 on_comboLayer_changed                  (GtkComboBox     *combobox,
2190                                         gpointer         user_data)
2191 {
2192   int val;
2193
2194   if (ui.in_update_page_stuff) return; // avoid a bad retroaction
2195
2196   gtk_widget_grab_focus(GTK_WIDGET(canvas)); // stop focus on us
2197
2198   val = gtk_combo_box_get_active(combobox);
2199   if (val == -1) return;
2200   val = ui.cur_page->nlayers-1-val;
2201   if (val == ui.layerno) return;
2202
2203   reset_selection();
2204   while (val>ui.layerno) {
2205     ui.layerno++;
2206     ui.cur_layer = g_list_nth_data(ui.cur_page->layers, ui.layerno);
2207     gnome_canvas_item_show(GNOME_CANVAS_ITEM(ui.cur_layer->group));
2208   }
2209   while (val<ui.layerno) {
2210     gnome_canvas_item_hide(GNOME_CANVAS_ITEM(ui.cur_layer->group));
2211     ui.layerno--;
2212     if (ui.layerno<0) ui.cur_layer = NULL;
2213     else ui.cur_layer = g_list_nth_data(ui.cur_page->layers, ui.layerno);
2214   }
2215   update_page_stuff();
2216 }
2217
2218
2219 gboolean
2220 on_winMain_delete_event                (GtkWidget       *widget,
2221                                         GdkEvent        *event,
2222                                         gpointer         user_data)
2223 {
2224   if (ok_to_close()) gtk_main_quit();
2225   return TRUE;
2226 }
2227
2228
2229 void
2230 on_optionsUseXInput_activate           (GtkMenuItem     *menuitem,
2231                                         gpointer         user_data)
2232 {
2233   ui.allow_xinput = ui.use_xinput =
2234     gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
2235 }
2236
2237 void
2238 on_vscroll_changed                     (GtkAdjustment   *adjustment,
2239                                         gpointer         user_data)
2240 {
2241   gboolean need_update;
2242   double viewport_top, viewport_bottom;
2243   struct Page *tmppage;
2244
2245   if (!ui.view_continuous) return;
2246
2247   if (ui.progressive_bg) rescale_bg_pixmaps();
2248   need_update = FALSE;
2249   viewport_top = adjustment->value / ui.zoom;
2250   viewport_bottom = (adjustment->value + adjustment->page_size) / ui.zoom;
2251   tmppage = ui.cur_page;
2252   while (viewport_top > tmppage->voffset + tmppage->height) {
2253     if (ui.pageno == journal.npages-1) break;
2254     need_update = TRUE;
2255     ui.pageno++;
2256     tmppage = g_list_nth_data(journal.pages, ui.pageno);
2257   }
2258   while (viewport_bottom < tmppage->voffset) {
2259     if (ui.pageno == 0) break;
2260     need_update = TRUE;
2261     ui.pageno--;
2262     tmppage = g_list_nth_data(journal.pages, ui.pageno);
2263   }
2264   if (need_update) do_switch_page(ui.pageno, FALSE);
2265   return;
2266 }
2267
2268 void
2269 on_spinPageNo_value_changed            (GtkSpinButton   *spinbutton,
2270                                         gpointer         user_data)
2271 {
2272   int val;
2273
2274   if (ui.in_update_page_stuff) return; // avoid a bad retroaction
2275
2276   gtk_widget_grab_focus(GTK_WIDGET(canvas)); // stop blink-blink text cursor
2277
2278   val = gtk_spin_button_get_value_as_int(spinbutton) - 1;
2279
2280   if (val == journal.npages) { // create a page at end
2281     if (page_ops_forbidden()) return;
2282     on_journalNewPageEnd_activate(NULL, NULL);
2283     return;
2284   }
2285
2286   if (val == ui.pageno) return;
2287   if (val < 0) val = 0;
2288   if (val > journal.npages-1) val = journal.npages-1;
2289   do_switch_page(val, TRUE);
2290 }
2291
2292
2293 void
2294 on_journalDefaultBackground_activate   (GtkMenuItem     *menuitem,
2295                                         gpointer         user_data)
2296 {
2297   reset_selection();
2298   prepare_new_undo();
2299   undo->type = ITEM_NEW_BG_RESIZE;
2300   undo->page = ui.cur_page;
2301   undo->bg = ui.cur_page->bg;
2302   undo->val_x = ui.cur_page->width;
2303   undo->val_y = ui.cur_page->height;
2304
2305   ui.cur_page->bg = (struct Background *)g_memdup(ui.default_page.bg, sizeof(struct Background));
2306   ui.cur_page->width = ui.default_page.width;
2307   ui.cur_page->height = ui.default_page.height;
2308   ui.cur_page->bg->canvas_item = undo->bg->canvas_item;
2309   undo->bg->canvas_item = NULL;
2310
2311   make_page_clipbox(ui.cur_page);
2312   update_canvas_bg(ui.cur_page);
2313   do_switch_page(ui.pageno, TRUE);
2314 }
2315
2316
2317 void
2318 on_journalSetAsDefault_activate        (GtkMenuItem     *menuitem,
2319                                         gpointer         user_data)
2320 {
2321   if (ui.cur_page->bg->type != BG_SOLID) return;
2322
2323   prepare_new_undo();
2324   undo->type = ITEM_NEW_DEFAULT_BG;
2325   undo->val_x = ui.default_page.width;
2326   undo->val_y = ui.default_page.height;
2327   undo->bg = ui.default_page.bg;
2328
2329   ui.default_page.width = ui.cur_page->width;
2330   ui.default_page.height = ui.cur_page->height;
2331   ui.default_page.bg = (struct Background *)g_memdup(ui.cur_page->bg, sizeof(struct Background));
2332   ui.default_page.bg->canvas_item = NULL;
2333 }
2334
2335
2336 void
2337 on_comboStdSizes_changed               (GtkComboBox     *combobox,
2338                                         gpointer         user_data)
2339 {
2340   GtkEntry *entry;
2341   GtkComboBox *comboUnit;
2342   int val;
2343   gchar text[20];
2344
2345   if (papersize_need_init) {
2346     gtk_combo_box_set_active(combobox, papersize_std);
2347     papersize_need_init = FALSE;
2348   } else {
2349     val = gtk_combo_box_get_active(combobox);
2350     if (val == -1 || val == papersize_std) return;
2351     papersize_std = val;
2352     if (val == STD_SIZE_CUSTOM) return;
2353     papersize_unit = std_units[val];
2354     papersize_width = std_widths[val];
2355     papersize_height = std_heights[val];
2356   }
2357   comboUnit = GTK_COMBO_BOX(g_object_get_data(G_OBJECT(papersize_dialog), "comboUnit"));
2358   gtk_combo_box_set_active(comboUnit, papersize_unit);
2359   entry = GTK_ENTRY(g_object_get_data(G_OBJECT(papersize_dialog), "entryWidth"));
2360   g_snprintf(text, 20, "%.2f", papersize_width/unit_sizes[papersize_unit]);
2361   if (g_str_has_suffix(text, ".00"))
2362     g_snprintf(text, 20, "%d", (int) (papersize_width/unit_sizes[papersize_unit]));
2363   gtk_entry_set_text(entry, text);
2364   entry = GTK_ENTRY(g_object_get_data(G_OBJECT(papersize_dialog), "entryHeight"));
2365   g_snprintf(text, 20, "%.2f", papersize_height/unit_sizes[papersize_unit]);
2366   if (g_str_has_suffix(text, ".00"))
2367     g_snprintf(text, 20, "%d", (int) (papersize_height/unit_sizes[papersize_unit]));
2368   gtk_entry_set_text(entry, text);
2369 }
2370
2371
2372 void
2373 on_entryWidth_changed                  (GtkEditable     *editable,
2374                                         gpointer         user_data)
2375 {
2376   double val;
2377   const gchar *text;
2378   gchar *ptr;
2379   GtkComboBox *comboStdSizes;
2380
2381   text = gtk_entry_get_text(GTK_ENTRY(editable));
2382   val = strtod(text, &ptr);
2383   papersize_width_valid = (*ptr == 0 && val > 0.);
2384   if (!papersize_width_valid) return; // invalid entry
2385   val *= unit_sizes[papersize_unit];
2386   if (fabs(val - papersize_width) < 0.1) return; // no change
2387   papersize_std = STD_SIZE_CUSTOM;
2388   papersize_width = val;
2389   comboStdSizes = GTK_COMBO_BOX(g_object_get_data(G_OBJECT(papersize_dialog), "comboStdSizes"));
2390   gtk_combo_box_set_active(comboStdSizes, papersize_std);
2391 }
2392
2393
2394 void
2395 on_entryHeight_changed                 (GtkEditable     *editable,
2396                                         gpointer         user_data)
2397 {
2398   double val;
2399   const gchar *text;
2400   gchar *ptr;
2401   GtkComboBox *comboStdSizes;
2402
2403   text = gtk_entry_get_text(GTK_ENTRY(editable));
2404   val = strtod(text, &ptr);
2405   papersize_height_valid = (*ptr == 0 && val > 0.);
2406   if (!papersize_height_valid) return; // invalid entry
2407   val *= unit_sizes[papersize_unit];
2408   if (fabs(val - papersize_height) < 0.1) return; // no change
2409   papersize_std = STD_SIZE_CUSTOM;
2410   papersize_height = val;
2411   comboStdSizes = GTK_COMBO_BOX(g_object_get_data(G_OBJECT(papersize_dialog), "comboStdSizes"));
2412   gtk_combo_box_set_active(comboStdSizes, papersize_std);
2413 }
2414
2415
2416 void
2417 on_comboUnit_changed                   (GtkComboBox     *combobox,
2418                                         gpointer         user_data)
2419 {
2420   GtkEntry *entry;
2421   int val;
2422   gchar text[20];
2423
2424   val = gtk_combo_box_get_active(combobox);
2425   if (val == -1 || val == papersize_unit) return;
2426   papersize_unit = val;
2427   entry = GTK_ENTRY(g_object_get_data(G_OBJECT(papersize_dialog), "entryWidth"));
2428   if (papersize_width_valid) {
2429     g_snprintf(text, 20, "%.2f", papersize_width/unit_sizes[papersize_unit]);
2430     if (g_str_has_suffix(text, ".00"))
2431       g_snprintf(text, 20, "%d", (int) (papersize_width/unit_sizes[papersize_unit]));
2432   } else *text = 0;
2433   gtk_entry_set_text(entry, text);
2434   if (papersize_height_valid) {
2435     entry = GTK_ENTRY(g_object_get_data(G_OBJECT(papersize_dialog), "entryHeight"));
2436     g_snprintf(text, 20, "%.2f", papersize_height/unit_sizes[papersize_unit]);
2437     if (g_str_has_suffix(text, ".00"))
2438       g_snprintf(text, 20, "%d", (int) (papersize_height/unit_sizes[papersize_unit]));
2439   } else *text = 0;
2440   gtk_entry_set_text(entry, text);
2441 }
2442
2443
2444 void
2445 on_viewFullscreen_activate             (GtkMenuItem     *menuitem,
2446                                         gpointer         user_data)
2447 {
2448   gboolean active;
2449
2450   if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_CHECK_MENU_ITEM)
2451     active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
2452   else
2453     active = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem));
2454
2455   if (active == ui.fullscreen) return;
2456   ui.fullscreen = active;
2457
2458   if (ui.fullscreen) {
2459     gtk_window_fullscreen(GTK_WINDOW(winMain));
2460     gtk_widget_hide(GET_COMPONENT("menubar"));
2461     gtk_widget_hide(GET_COMPONENT("hbox1"));
2462   }
2463   else {
2464     gtk_window_unfullscreen(GTK_WINDOW(winMain));
2465     gtk_widget_show(GET_COMPONENT("menubar"));
2466     gtk_widget_show(GET_COMPONENT("hbox1"));
2467   }
2468 }
2469
2470
2471 void
2472 on_optionsEmulateEraser_activate       (GtkMenuItem     *menuitem,
2473                                         gpointer         user_data)
2474 {
2475   ui.emulate_eraser =
2476     gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
2477 }
2478
2479
2480 void
2481 on_optionsAntialiasBG_activate         (GtkMenuItem     *menuitem,
2482                                         gpointer         user_data)
2483 {
2484   gboolean active;
2485
2486   active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
2487   if (ui.antialias_bg == active) return;
2488   ui.antialias_bg = active;
2489   rescale_bg_pixmaps();
2490 }
2491
2492
2493 void
2494 on_optionsProgressiveBG_activate       (GtkMenuItem     *menuitem,
2495                                         gpointer         user_data)
2496 {
2497   gboolean active;
2498
2499   active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
2500   if (ui.progressive_bg == active) return;
2501   ui.progressive_bg = active;
2502   if (!ui.progressive_bg) rescale_bg_pixmaps();
2503 }
2504