8 #include <libgnomecanvas/libgnomecanvas.h>
10 #include <libgnomeprintui/gnome-print-dialog.h>
11 #include <glib/gstdio.h>
14 #include "xo-callbacks.h"
15 #include "xo-interface.h"
16 #include "xo-support.h"
23 on_fileNew_activate (GtkMenuItem *menuitem,
26 if (close_journal()) {
28 ui.zoom = ui.startup_zoom;
30 gtk_adjustment_set_value(gtk_layout_get_vadjustment(GTK_LAYOUT(canvas)), 0);
31 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
37 on_fileNewBackground_activate (GtkMenuItem *menuitem,
40 GtkWidget *dialog, *attach_opt;
41 GtkFileFilter *filt_all, *filt_pdf;
46 if (!ok_to_close()) return; // user aborted on save confirmation
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_OK, NULL);
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);
61 if (ui.default_path!=NULL) gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (dialog), ui.default_path);
63 attach_opt = gtk_check_button_new_with_label("Attach file to the journal");
64 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(attach_opt), FALSE);
65 gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER (dialog), attach_opt);
67 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
68 gtk_widget_destroy(dialog);
71 filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
72 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(attach_opt)))
73 file_domain = DOMAIN_ATTACH;
74 else file_domain = DOMAIN_ABSOLUTE;
76 gtk_widget_destroy(dialog);
78 set_cursor_busy(TRUE);
79 ui.saved = TRUE; // force close_journal to work
81 while (bgpdf.status != STATUS_NOT_INIT) {
82 // waiting for pdf processes to finish dying
86 ui.zoom = ui.startup_zoom;
87 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
89 success = init_bgpdf(filename, TRUE, file_domain);
90 set_cursor_busy(FALSE);
97 dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
98 GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Error opening file '%s'", filename);
99 gtk_dialog_run(GTK_DIALOG(dialog));
100 gtk_widget_destroy(dialog);
106 on_fileOpen_activate (GtkMenuItem *menuitem,
110 GtkFileFilter *filt_all, *filt_xoj;
114 if (!ok_to_close()) return; // user aborted on save confirmation
116 dialog = gtk_file_chooser_dialog_new("Open Journal", GTK_WINDOW (winMain),
117 GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
118 GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL);
120 filt_all = gtk_file_filter_new();
121 gtk_file_filter_set_name(filt_all, "All files");
122 gtk_file_filter_add_pattern(filt_all, "*");
123 filt_xoj = gtk_file_filter_new();
124 gtk_file_filter_set_name(filt_xoj, "Xournal files");
125 gtk_file_filter_add_pattern(filt_xoj, "*.xoj");
126 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_xoj);
127 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_all);
129 if (ui.default_path!=NULL) gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (dialog), ui.default_path);
131 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
132 gtk_widget_destroy(dialog);
135 filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
136 gtk_widget_destroy(dialog);
138 set_cursor_busy(TRUE);
139 success = open_journal(filename);
140 set_cursor_busy(FALSE);
141 if (success) { g_free(filename); return; }
144 dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
145 GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Error opening file '%s'", filename);
146 gtk_dialog_run(GTK_DIALOG(dialog));
147 gtk_widget_destroy(dialog);
154 on_fileSave_activate (GtkMenuItem *menuitem,
159 if (ui.filename == NULL) {
160 on_fileSaveAs_activate(menuitem, user_data);
163 set_cursor_busy(TRUE);
164 if (save_journal(ui.filename)) { // success
165 set_cursor_busy(FALSE);
169 set_cursor_busy(FALSE);
171 dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
172 GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Error saving file '%s'", ui.filename);
173 gtk_dialog_run(GTK_DIALOG(dialog));
174 gtk_widget_destroy(dialog);
179 on_fileSaveAs_activate (GtkMenuItem *menuitem,
182 GtkWidget *dialog, *warning_dialog;
183 GtkFileFilter *filt_all, *filt_xoj;
188 struct stat stat_buf;
190 dialog = gtk_file_chooser_dialog_new("Save Journal", GTK_WINDOW (winMain),
191 GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
192 GTK_STOCK_SAVE, GTK_RESPONSE_OK, NULL);
194 if (ui.filename!=NULL) {
195 gtk_file_chooser_set_filename(GTK_FILE_CHOOSER (dialog), ui.filename);
196 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), g_basename(ui.filename));
199 if (bgpdf.status!=STATUS_NOT_INIT && bgpdf.file_domain == DOMAIN_ABSOLUTE
200 && bgpdf.filename != NULL) {
201 filename = g_strdup_printf("%s.xoj", bgpdf.filename->s);
202 gtk_file_chooser_set_filename(GTK_FILE_CHOOSER (dialog), filename);
203 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), g_basename(filename));
207 curtime = time(NULL);
208 strftime(stime, 30, "%F-Note-%H-%M.xoj", localtime(&curtime));
209 if (ui.default_path!=NULL)
210 gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (dialog), ui.default_path);
211 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), stime);
214 filt_all = gtk_file_filter_new();
215 gtk_file_filter_set_name(filt_all, "All files");
216 gtk_file_filter_add_pattern(filt_all, "*");
217 filt_xoj = gtk_file_filter_new();
218 gtk_file_filter_set_name(filt_xoj, "Xournal files");
219 gtk_file_filter_add_pattern(filt_xoj, "*.xoj");
220 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_xoj);
221 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_all);
223 // somehow this doesn't seem to be set by default
224 gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
227 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
228 gtk_widget_destroy(dialog);
231 filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
232 warn = g_file_test (filename, G_FILE_TEST_EXISTS);
233 if (warn) { // ok to overwrite an empty file
234 if (!g_stat(filename, &stat_buf))
235 if (stat_buf.st_size == 0) warn=FALSE;
237 if (warn && ui.filename!=NULL) { // ok to overwrite oneself
238 if (ui.filename[0]=='/' && !strcmp(ui.filename, filename)) warn=FALSE;
239 if (ui.filename[0]!='/' && g_str_has_suffix(filename, ui.filename)) warn=FALSE;
242 warning_dialog = gtk_message_dialog_new(GTK_WINDOW(winMain),
243 GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO,
244 "Should the file %s be overwritten?", filename);
245 if (gtk_dialog_run(GTK_DIALOG(warning_dialog)) == GTK_RESPONSE_YES)
247 gtk_widget_destroy(warning_dialog);
251 gtk_widget_destroy(dialog);
253 set_cursor_busy(TRUE);
254 if (save_journal(filename)) { // success
256 set_cursor_busy(FALSE);
257 update_file_name(filename);
260 set_cursor_busy(FALSE);
262 dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
263 GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Error saving file '%s'", filename);
264 gtk_dialog_run(GTK_DIALOG(dialog));
265 gtk_widget_destroy(dialog);
271 on_filePrintOptions_activate (GtkMenuItem *menuitem,
279 on_filePrint_activate (GtkMenuItem *menuitem,
282 GtkWidget *printDialog, *preview;
284 int fromPage, toPage;
288 GnomePrintConfig *config = gnome_print_config_default();
290 if (ui.filename!=NULL) {
291 if (g_str_has_suffix(ui.filename, ".xoj")) {
292 in_fn = g_strdup(ui.filename);
293 g_strlcpy(g_strrstr(in_fn, "xoj"), "pdf", 4);
296 in_fn = g_strdup_printf("%s.pdf", ui.filename);
297 gnome_print_config_set(config, (guchar *)"Printer", (guchar *)"PDF");
298 gnome_print_config_set(config, (guchar *)GNOME_PRINT_KEY_OUTPUT_FILENAME, (guchar *)in_fn);
299 gnome_print_config_set(config, (guchar *)"Settings.Transport.Backend.FileName", (guchar *)in_fn);
300 g_strlcpy(g_strrstr(in_fn, "pdf"), "ps", 3);
301 gnome_print_config_set(config, (guchar *)"Printer", (guchar *)"GENERIC");
302 gnome_print_config_set (config, (guchar *)GNOME_PRINT_KEY_OUTPUT_FILENAME, (guchar *)in_fn);
303 s = gnome_print_config_get(config, (guchar *)"Settings.Transport.Backend.FileName");
306 gnome_print_config_set(config, (guchar *)"Settings.Transport.Backend.FileName", (guchar *)in_fn);
311 gpj = gnome_print_job_new(config); /* was NULL */
312 gnome_print_config_unref(config);
314 printDialog = gnome_print_dialog_new(gpj, (guchar *)"Print", GNOME_PRINT_DIALOG_RANGE);
315 gnome_print_dialog_construct_range_page(GNOME_PRINT_DIALOG(printDialog),
316 GNOME_PRINT_RANGE_ALL | GNOME_PRINT_RANGE_RANGE,
317 1, journal.npages, (guchar *)"Current page", (guchar *)"Pages");
318 /* don't have "Current page" as option, else it becomes the default!! */
320 gtk_dialog_set_response_sensitive(GTK_DIALOG(printDialog),
321 GNOME_PRINT_DIALOG_RESPONSE_PREVIEW, FALSE);
322 /* the print-job-preview "feature" is completely, hopelessly broken */
324 response = gtk_dialog_run(GTK_DIALOG(printDialog));
326 gtk_widget_destroy(printDialog);
331 if (response == GNOME_PRINT_DIALOG_RESPONSE_PREVIEW) {
332 print_job_render(gpj, 0, journal.npages-1);
333 gtk_widget_destroy(printDialog);
334 preview = gnome_print_job_preview_new(gpj, (guchar *)"Preview");
335 try_fix_print_preview_ui(preview);
336 gtk_window_set_modal(GTK_WINDOW(preview), TRUE);
337 gtk_widget_show_all(preview);
341 if (response == GNOME_PRINT_DIALOG_RESPONSE_PRINT) {
342 switch(gnome_print_dialog_get_range(GNOME_PRINT_DIALOG(printDialog))) {
343 case GNOME_PRINT_RANGE_RANGE:
344 gnome_print_dialog_get_range_page(GNOME_PRINT_DIALOG(printDialog), &fromPage, &toPage);
350 toPage = journal.npages-1;
353 gtk_widget_destroy(printDialog);
354 print_job_render(gpj, fromPage, toPage);
360 on_filePrintPDF_activate (GtkMenuItem *menuitem,
364 GtkWidget *dialog, *warning_dialog;
365 GtkFileFilter *filt_all, *filt_pdf;
366 char *filename, *in_fn;
372 dialog = gtk_file_chooser_dialog_new("Export to PDF", GTK_WINDOW (winMain),
373 GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
374 GTK_STOCK_SAVE, GTK_RESPONSE_OK, NULL);
376 if (ui.filename!=NULL) {
377 if (g_str_has_suffix(ui.filename, ".xoj")) {
378 in_fn = g_strdup(ui.filename);
379 g_strlcpy(g_strrstr(in_fn, "xoj"), "pdf", 4);
382 in_fn = g_strdup_printf("%s.pdf", ui.filename);
383 gtk_file_chooser_set_filename(GTK_FILE_CHOOSER (dialog), in_fn);
384 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), g_basename(in_fn));
386 curtime = time(NULL);
387 strftime(stime, 30, "%F-Note-%H-%M.pdf", localtime(&curtime));
388 if (ui.default_path!=NULL)
389 gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (dialog), ui.default_path);
390 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), stime);
394 filt_all = gtk_file_filter_new();
395 gtk_file_filter_set_name(filt_all, "All files");
396 gtk_file_filter_add_pattern(filt_all, "*");
397 filt_pdf = gtk_file_filter_new();
398 gtk_file_filter_set_name(filt_pdf, "PDF files");
399 gtk_file_filter_add_pattern(filt_pdf, "*.pdf");
400 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_pdf);
401 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_all);
402 gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
406 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
407 gtk_widget_destroy(dialog);
410 filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
411 warn = g_file_test(filename, G_FILE_TEST_EXISTS);
413 warning_dialog = gtk_message_dialog_new(GTK_WINDOW(winMain),
414 GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO,
415 "Should the file %s be overwritten?", filename);
416 if (gtk_dialog_run(GTK_DIALOG(warning_dialog)) == GTK_RESPONSE_YES)
418 gtk_widget_destroy(warning_dialog);
422 gtk_widget_destroy(dialog);
424 set_cursor_busy(TRUE);
425 if (!print_to_pdf(filename)) {
426 set_cursor_busy(FALSE);
427 dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
428 GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Error creating file '%s'", filename);
429 gtk_dialog_run(GTK_DIALOG(dialog));
430 gtk_widget_destroy(dialog);
432 set_cursor_busy(FALSE);
438 on_fileQuit_activate (GtkMenuItem *menuitem,
441 if (ok_to_close()) gtk_main_quit ();
446 on_editUndo_activate (GtkMenuItem *menuitem,
450 GList *list, *itemlist;
451 struct UndoErasureData *erasure;
453 struct Brush tmp_brush;
454 struct Background *tmp_bg;
457 if (undo == NULL) return; // nothing to undo!
458 reset_selection(); // safer
459 if (undo->type == ITEM_STROKE) {
460 // we're keeping the stroke info, but deleting the canvas item
461 gtk_object_destroy(GTK_OBJECT(undo->item->canvas_item));
462 undo->item->canvas_item = NULL;
463 // we also remove the object from its layer!
464 undo->layer->items = g_list_remove(undo->layer->items, undo->item);
465 undo->layer->nitems--;
467 else if (undo->type == ITEM_ERASURE) {
468 for (list = undo->erasurelist; list!=NULL; list = list->next) {
469 erasure = (struct UndoErasureData *)list->data;
470 // delete all the created items
471 for (itemlist = erasure->replacement_items; itemlist!=NULL; itemlist = itemlist->next) {
472 it = (struct Item *)itemlist->data;
473 gtk_object_destroy(GTK_OBJECT(it->canvas_item));
474 it->canvas_item = NULL;
475 undo->layer->items = g_list_remove(undo->layer->items, it);
476 undo->layer->nitems--;
478 // recreate the deleted one
479 erasure->item->canvas_item = gnome_canvas_item_new(undo->layer->group,
480 gnome_canvas_line_get_type(), "points", erasure->item->path,
481 "cap-style", GDK_CAP_ROUND, "join-style", GDK_JOIN_ROUND,
482 "fill-color-rgba", erasure->item->brush.color_rgba,
483 "width-units", erasure->item->brush.thickness, NULL);
484 undo->layer->items = g_list_insert(undo->layer->items, erasure->item,
486 if (erasure->npos == 0)
487 lower_canvas_item_to(undo->layer->group, erasure->item->canvas_item, NULL);
489 lower_canvas_item_to(undo->layer->group, erasure->item->canvas_item,
490 ((struct Item *)g_list_nth_data(undo->layer->items, erasure->npos-1))->canvas_item);
491 undo->layer->nitems++;
494 else if (undo->type == ITEM_NEW_BG_ONE || undo->type == ITEM_NEW_BG_RESIZE
495 || undo->type == ITEM_PAPER_RESIZE) {
496 if (undo->type != ITEM_PAPER_RESIZE) {
498 tmp_bg = undo->page->bg;
499 undo->page->bg = undo->bg;
501 undo->page->bg->canvas_item = undo->bg->canvas_item;
502 undo->bg->canvas_item = NULL;
504 if (undo->type != ITEM_NEW_BG_ONE) {
505 tmp_x = undo->page->width;
506 tmp_y = undo->page->height;
507 undo->page->width = undo->val_x;
508 undo->page->height = undo->val_y;
511 make_page_clipbox(undo->page);
513 update_canvas_bg(undo->page);
514 do_switch_page(g_list_index(journal.pages, undo->page), TRUE, TRUE);
516 else if (undo->type == ITEM_NEW_DEFAULT_BG) {
517 tmp_bg = ui.default_page.bg;
518 ui.default_page.bg = undo->bg;
520 tmp_x = ui.default_page.width;
521 tmp_y = ui.default_page.height;
522 ui.default_page.width = undo->val_x;
523 ui.default_page.height = undo->val_y;
527 else if (undo->type == ITEM_NEW_PAGE) {
528 // unmap the page; keep the page & its empty layer in memory
529 if (undo->page->group!=NULL) gtk_object_destroy(GTK_OBJECT(undo->page->group));
530 // also destroys the background and layer's canvas items
531 undo->page->group = NULL;
532 undo->page->bg->canvas_item = NULL;
533 journal.pages = g_list_remove(journal.pages, undo->page);
535 if (ui.cur_page == undo->page) ui.cur_page = NULL;
536 // so do_switch_page() won't try to remap the layers of the defunct page
537 if (ui.pageno >= undo->val) ui.pageno--;
538 if (ui.pageno < 0) ui.pageno = 0;
539 do_switch_page(ui.pageno, TRUE, TRUE);
541 else if (undo->type == ITEM_DELETE_PAGE) {
542 journal.pages = g_list_insert(journal.pages, undo->page, undo->val);
544 make_canvas_items(); // re-create the canvas items
545 do_switch_page(undo->val, TRUE, TRUE);
547 else if (undo->type == ITEM_MOVESEL) {
548 for (itemlist = undo->itemlist; itemlist != NULL; itemlist = itemlist->next) {
549 it = (struct Item *)itemlist->data;
550 if (it->canvas_item != NULL) {
551 if (undo->layer != undo->layer2)
552 gnome_canvas_item_reparent(it->canvas_item, undo->layer->group);
553 gnome_canvas_item_move(it->canvas_item, -undo->val_x, -undo->val_y);
556 move_journal_items_by(undo->itemlist, -undo->val_x, -undo->val_y,
557 undo->layer2, undo->layer, undo->auxlist);
559 else if (undo->type == ITEM_PASTE) {
560 for (itemlist = undo->itemlist; itemlist != NULL; itemlist = itemlist->next) {
561 it = (struct Item *)itemlist->data;
562 gtk_object_destroy(GTK_OBJECT(it->canvas_item));
563 it->canvas_item = NULL;
564 undo->layer->items = g_list_remove(undo->layer->items, it);
565 undo->layer->nitems--;
568 else if (undo->type == ITEM_NEW_LAYER) {
569 // unmap the layer; keep the empty layer in memory
570 if (undo->layer->group!=NULL) gtk_object_destroy(GTK_OBJECT(undo->layer->group));
571 undo->layer->group = NULL;
572 undo->page->layers = g_list_remove(undo->page->layers, undo->layer);
573 undo->page->nlayers--;
574 do_switch_page(ui.pageno, FALSE, FALSE); // don't stay with bad cur_layer info
576 else if (undo->type == ITEM_DELETE_LAYER) {
577 // special case of -1: deleted the last layer, created a new one
578 if (undo->val == -1) {
579 if (undo->layer2->group!=NULL) gtk_object_destroy(GTK_OBJECT(undo->layer2->group));
580 undo->layer2->group = NULL;
581 undo->page->layers = g_list_remove(undo->page->layers, undo->layer2);
582 undo->page->nlayers--;
585 undo->layer->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
586 undo->page->group, gnome_canvas_group_get_type(), NULL);
587 lower_canvas_item_to(undo->page->group, GNOME_CANVAS_ITEM(undo->layer->group),
588 (undo->val >= 1) ? GNOME_CANVAS_ITEM(((struct Layer *)
589 g_list_nth_data(undo->page->layers, undo->val-1))->group) :
590 undo->page->bg->canvas_item);
591 undo->page->layers = g_list_insert(undo->page->layers, undo->layer,
592 (undo->val >= 0) ? undo->val:0);
593 undo->page->nlayers++;
595 for (itemlist = undo->layer->items; itemlist!=NULL; itemlist = itemlist->next) {
596 it = (struct Item *)itemlist->data;
597 if (it->type == ITEM_STROKE) {
598 it->canvas_item = gnome_canvas_item_new(undo->layer->group,
599 gnome_canvas_line_get_type(), "points", it->path,
600 "cap-style", GDK_CAP_ROUND, "join-style", GDK_JOIN_ROUND,
601 "fill-color-rgba", it->brush.color_rgba,
602 "width-units", it->brush.thickness, NULL);
605 do_switch_page(ui.pageno, FALSE, FALSE); // show the restored layer & others...
607 else if (undo->type == ITEM_REPAINTSEL) {
608 for (itemlist = undo->itemlist, list = undo->auxlist; itemlist!=NULL;
609 itemlist = itemlist->next, list = list->next) {
610 it = (struct Item *)itemlist->data;
611 g_memmove(&tmp_brush, &(it->brush), sizeof(struct Brush));
612 g_memmove(&(it->brush), list->data, sizeof(struct Brush));
613 g_memmove(list->data, &tmp_brush, sizeof(struct Brush));
614 if (it->type == ITEM_STROKE && it->canvas_item != NULL)
615 gnome_canvas_item_set(it->canvas_item,
616 "fill-color-rgba", it->brush.color_rgba,
617 "width-units", it->brush.thickness, NULL);
621 // move item from undo to redo stack
627 update_undo_redo_enabled();
628 if (u->multiop & MULTIOP_CONT_UNDO) on_editUndo_activate(NULL,NULL); // loop
633 on_editRedo_activate (GtkMenuItem *menuitem,
637 GList *list, *itemlist, *target;
638 struct UndoErasureData *erasure;
640 struct Brush tmp_brush;
641 struct Background *tmp_bg;
645 if (redo == NULL) return; // nothing to redo!
646 reset_selection(); // safer
647 if (redo->type == ITEM_STROKE) {
648 // re-create the canvas_item
649 redo->item->canvas_item = gnome_canvas_item_new(redo->layer->group,
650 gnome_canvas_line_get_type(), "points", redo->item->path,
651 "cap-style", GDK_CAP_ROUND, "join-style", GDK_JOIN_ROUND,
652 "fill-color-rgba", redo->item->brush.color_rgba,
653 "width-units", redo->item->brush.thickness, NULL);
654 // reinsert the item on its layer
655 redo->layer->items = g_list_append(redo->layer->items, redo->item);
656 redo->layer->nitems++;
658 else if (redo->type == ITEM_ERASURE) {
659 for (list = redo->erasurelist; list!=NULL; list = list->next) {
660 erasure = (struct UndoErasureData *)list->data;
661 target = g_list_find(redo->layer->items, erasure->item);
662 // re-create all the created items
663 for (itemlist = erasure->replacement_items; itemlist!=NULL; itemlist = itemlist->next) {
664 it = (struct Item *)itemlist->data;
665 it->canvas_item = gnome_canvas_item_new(redo->layer->group,
666 gnome_canvas_line_get_type(), "points", it->path,
667 "cap-style", GDK_CAP_ROUND, "join-style", GDK_JOIN_ROUND,
668 "fill-color-rgba", it->brush.color_rgba,
669 "width-units", it->brush.thickness, NULL);
670 redo->layer->items = g_list_insert_before(redo->layer->items, target, it);
671 redo->layer->nitems++;
672 lower_canvas_item_to(redo->layer->group, it->canvas_item, erasure->item->canvas_item);
674 // re-delete the deleted one
675 gtk_object_destroy(GTK_OBJECT(erasure->item->canvas_item));
676 erasure->item->canvas_item = NULL;
677 redo->layer->items = g_list_delete_link(redo->layer->items, target);
678 redo->layer->nitems--;
681 else if (redo->type == ITEM_NEW_BG_ONE || redo->type == ITEM_NEW_BG_RESIZE
682 || redo->type == ITEM_PAPER_RESIZE) {
683 if (redo->type != ITEM_PAPER_RESIZE) {
685 tmp_bg = redo->page->bg;
686 redo->page->bg = redo->bg;
688 redo->page->bg->canvas_item = redo->bg->canvas_item;
689 redo->bg->canvas_item = NULL;
691 if (redo->type != ITEM_NEW_BG_ONE) {
692 tmp_x = redo->page->width;
693 tmp_y = redo->page->height;
694 redo->page->width = redo->val_x;
695 redo->page->height = redo->val_y;
698 make_page_clipbox(redo->page);
700 update_canvas_bg(redo->page);
701 do_switch_page(g_list_index(journal.pages, redo->page), TRUE, TRUE);
703 else if (redo->type == ITEM_NEW_DEFAULT_BG) {
704 tmp_bg = ui.default_page.bg;
705 ui.default_page.bg = redo->bg;
707 tmp_x = ui.default_page.width;
708 tmp_y = ui.default_page.height;
709 ui.default_page.width = redo->val_x;
710 ui.default_page.height = redo->val_y;
714 else if (redo->type == ITEM_NEW_PAGE) {
716 redo->page->bg->canvas_item = NULL;
717 redo->page->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
718 gnome_canvas_root(canvas), gnome_canvas_clipgroup_get_type(), NULL);
719 make_page_clipbox(redo->page);
720 update_canvas_bg(redo->page);
721 l = (struct Layer *)redo->page->layers->data;
722 l->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
723 redo->page->group, gnome_canvas_group_get_type(), NULL);
725 journal.pages = g_list_insert(journal.pages, redo->page, redo->val);
727 do_switch_page(redo->val, TRUE, TRUE);
729 else if (redo->type == ITEM_DELETE_PAGE) {
730 // unmap all the canvas items
731 gtk_object_destroy(GTK_OBJECT(redo->page->group));
732 redo->page->group = NULL;
733 redo->page->bg->canvas_item = NULL;
734 for (list = redo->page->layers; list!=NULL; list = list->next) {
735 l = (struct Layer *)list->data;
736 for (itemlist = l->items; itemlist!=NULL; itemlist = itemlist->next)
737 ((struct Item *)itemlist->data)->canvas_item = NULL;
740 journal.pages = g_list_remove(journal.pages, redo->page);
742 if (ui.pageno > undo->val || ui.pageno == journal.npages) ui.pageno--;
744 // so do_switch_page() won't try to remap the layers of the defunct page
745 do_switch_page(ui.pageno, TRUE, TRUE);
747 else if (redo->type == ITEM_MOVESEL) {
748 for (itemlist = redo->itemlist; itemlist != NULL; itemlist = itemlist->next) {
749 it = (struct Item *)itemlist->data;
750 if (it->canvas_item != NULL) {
751 if (redo->layer != redo->layer2)
752 gnome_canvas_item_reparent(it->canvas_item, redo->layer2->group);
753 gnome_canvas_item_move(it->canvas_item, redo->val_x, redo->val_y);
756 move_journal_items_by(redo->itemlist, redo->val_x, redo->val_y,
757 redo->layer, redo->layer2, NULL);
759 else if (redo->type == ITEM_PASTE) {
760 for (itemlist = redo->itemlist; itemlist != NULL; itemlist = itemlist->next) {
761 it = (struct Item *)itemlist->data;
762 it->canvas_item = gnome_canvas_item_new(redo->layer->group,
763 gnome_canvas_line_get_type(), "points", it->path,
764 "cap-style", GDK_CAP_ROUND, "join-style", GDK_JOIN_ROUND,
765 "fill-color-rgba", it->brush.color_rgba,
766 "width-units", it->brush.thickness, NULL);
767 redo->layer->items = g_list_append(redo->layer->items, it);
768 redo->layer->nitems++;
771 else if (redo->type == ITEM_NEW_LAYER) {
772 redo->layer->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
773 redo->page->group, gnome_canvas_group_get_type(), NULL);
774 lower_canvas_item_to(redo->page->group, GNOME_CANVAS_ITEM(redo->layer->group),
775 (redo->val >= 1) ? GNOME_CANVAS_ITEM(((struct Layer *)
776 g_list_nth_data(redo->page->layers, redo->val-1))->group) :
777 redo->page->bg->canvas_item);
778 redo->page->layers = g_list_insert(redo->page->layers, redo->layer, redo->val);
779 redo->page->nlayers++;
780 do_switch_page(ui.pageno, FALSE, FALSE);
782 else if (redo->type == ITEM_DELETE_LAYER) {
783 gtk_object_destroy(GTK_OBJECT(redo->layer->group));
784 redo->layer->group = NULL;
785 for (list=redo->layer->items; list!=NULL; list=list->next)
786 ((struct Item *)list->data)->canvas_item = NULL;
787 redo->page->layers = g_list_remove(redo->page->layers, redo->layer);
788 redo->page->nlayers--;
789 if (redo->val == -1) {
790 redo->layer2->group = (GnomeCanvasGroup *)gnome_canvas_item_new(
791 redo->page->group, gnome_canvas_group_get_type(), NULL);
792 redo->page->layers = g_list_append(redo->page->layers, redo->layer2);
793 redo->page->nlayers++;
795 do_switch_page(ui.pageno, FALSE, FALSE);
797 else if (redo->type == ITEM_REPAINTSEL) {
798 for (itemlist = redo->itemlist, list = redo->auxlist; itemlist!=NULL;
799 itemlist = itemlist->next, list = list->next) {
800 it = (struct Item *)itemlist->data;
801 g_memmove(&tmp_brush, &(it->brush), sizeof(struct Brush));
802 g_memmove(&(it->brush), list->data, sizeof(struct Brush));
803 g_memmove(list->data, &tmp_brush, sizeof(struct Brush));
804 if (it->type == ITEM_STROKE && it->canvas_item != NULL)
805 gnome_canvas_item_set(it->canvas_item,
806 "fill-color-rgba", it->brush.color_rgba,
807 "width-units", it->brush.thickness, NULL);
811 // move item from redo to undo stack
817 update_undo_redo_enabled();
818 if (u->multiop & MULTIOP_CONT_REDO) on_editRedo_activate(NULL,NULL); // loop
823 on_editCut_activate (GtkMenuItem *menuitem,
832 on_editCopy_activate (GtkMenuItem *menuitem,
840 on_editPaste_activate (GtkMenuItem *menuitem,
848 on_editDelete_activate (GtkMenuItem *menuitem,
856 on_viewContinuous_activate (GtkMenuItem *menuitem,
859 GtkAdjustment *v_adj;
863 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
864 if (ui.view_continuous) return;
865 ui.view_continuous = TRUE;
866 v_adj = gtk_layout_get_vadjustment(GTK_LAYOUT(canvas));
868 yscroll = gtk_adjustment_get_value(v_adj) - pg->voffset*ui.zoom;
870 gtk_adjustment_set_value(v_adj, yscroll + pg->voffset*ui.zoom);
872 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
877 on_viewOnePage_activate (GtkMenuItem *menuitem,
880 GtkAdjustment *v_adj;
883 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
884 if (!ui.view_continuous) return;
885 ui.view_continuous = FALSE;
886 v_adj = gtk_layout_get_vadjustment(GTK_LAYOUT(canvas));
887 yscroll = gtk_adjustment_get_value(v_adj) - ui.cur_page->voffset*ui.zoom;
889 gtk_adjustment_set_value(v_adj, yscroll + ui.cur_page->voffset*ui.zoom);
891 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
896 on_viewZoomIn_activate (GtkMenuItem *menuitem,
899 if (ui.zoom > MAX_ZOOM) return;
900 ui.zoom *= ui.zoom_step_factor;
901 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
902 rescale_bg_pixmaps();
907 on_viewZoomOut_activate (GtkMenuItem *menuitem,
910 if (ui.zoom < MIN_ZOOM) return;
911 ui.zoom /= ui.zoom_step_factor;
912 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
913 rescale_bg_pixmaps();
918 on_viewNormalSize_activate (GtkMenuItem *menuitem,
921 ui.zoom = DEFAULT_ZOOM;
922 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
923 rescale_bg_pixmaps();
928 on_viewPageWidth_activate (GtkMenuItem *menuitem,
931 ui.zoom = (GTK_WIDGET(canvas))->allocation.width/ui.cur_page->width;
932 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
933 rescale_bg_pixmaps();
938 on_viewFirstPage_activate (GtkMenuItem *menuitem,
941 do_switch_page(0, TRUE, FALSE);
946 on_viewPreviousPage_activate (GtkMenuItem *menuitem,
949 if (ui.pageno == 0) return;
950 do_switch_page(ui.pageno-1, TRUE, FALSE);
955 on_viewNextPage_activate (GtkMenuItem *menuitem,
958 if (ui.pageno == journal.npages-1) { // create a page at end
959 if (page_ops_forbidden()) return;
960 on_journalNewPageEnd_activate(menuitem, user_data);
963 do_switch_page(ui.pageno+1, TRUE, FALSE);
968 on_viewLastPage_activate (GtkMenuItem *menuitem,
971 do_switch_page(journal.npages-1, TRUE, FALSE);
976 on_viewShowLayer_activate (GtkMenuItem *menuitem,
979 if (ui.layerno == ui.cur_page->nlayers-1) return;
982 ui.cur_layer = g_list_nth_data(ui.cur_page->layers, ui.layerno);
983 gnome_canvas_item_show(GNOME_CANVAS_ITEM(ui.cur_layer->group));
989 on_viewHideLayer_activate (GtkMenuItem *menuitem,
992 if (ui.layerno == -1) return;
994 gnome_canvas_item_hide(GNOME_CANVAS_ITEM(ui.cur_layer->group));
996 if (ui.layerno<0) ui.cur_layer = NULL;
997 else ui.cur_layer = g_list_nth_data(ui.cur_page->layers, ui.layerno);
1003 on_journalNewPageBefore_activate (GtkMenuItem *menuitem,
1008 if (page_ops_forbidden()) return;
1010 pg = new_page(ui.cur_page);
1011 journal.pages = g_list_insert(journal.pages, pg, ui.pageno);
1013 do_switch_page(ui.pageno, TRUE, TRUE);
1016 undo->type = ITEM_NEW_PAGE;
1017 undo->val = ui.pageno;
1023 on_journalNewPageAfter_activate (GtkMenuItem *menuitem,
1028 if (page_ops_forbidden()) return;
1030 pg = new_page(ui.cur_page);
1031 journal.pages = g_list_insert(journal.pages, pg, ui.pageno+1);
1033 do_switch_page(ui.pageno+1, TRUE, TRUE);
1036 undo->type = ITEM_NEW_PAGE;
1037 undo->val = ui.pageno;
1043 on_journalNewPageEnd_activate (GtkMenuItem *menuitem,
1048 if (page_ops_forbidden()) return;
1050 pg = new_page((struct Page *)g_list_last(journal.pages)->data);
1051 journal.pages = g_list_append(journal.pages, pg);
1053 do_switch_page(journal.npages-1, TRUE, TRUE);
1056 undo->type = ITEM_NEW_PAGE;
1057 undo->val = ui.pageno;
1063 on_journalDeletePage_activate (GtkMenuItem *menuitem,
1066 GList *layerlist, *itemlist;
1069 if (page_ops_forbidden()) return;
1070 if (journal.npages == 1) return;
1073 undo->type = ITEM_DELETE_PAGE;
1074 undo->val = ui.pageno;
1075 undo->page = ui.cur_page;
1077 // unmap all the canvas items
1078 gtk_object_destroy(GTK_OBJECT(ui.cur_page->group));
1079 ui.cur_page->group = NULL;
1080 ui.cur_page->bg->canvas_item = NULL;
1081 for (layerlist = ui.cur_page->layers; layerlist!=NULL; layerlist = layerlist->next) {
1082 l = (struct Layer *)layerlist->data;
1083 for (itemlist = l->items; itemlist!=NULL; itemlist = itemlist->next)
1084 ((struct Item *)itemlist->data)->canvas_item = NULL;
1088 journal.pages = g_list_remove(journal.pages, ui.cur_page);
1090 if (ui.pageno == journal.npages) ui.pageno--;
1092 // so do_switch_page() won't try to remap the layers of the defunct page
1093 do_switch_page(ui.pageno, TRUE, TRUE);
1098 on_journalNewLayer_activate (GtkMenuItem *menuitem,
1104 l = g_new(struct Layer, 1);
1107 l->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
1108 ui.cur_page->group, gnome_canvas_group_get_type(), NULL);
1109 lower_canvas_item_to(ui.cur_page->group, GNOME_CANVAS_ITEM(l->group),
1110 (ui.cur_layer!=NULL)?(GNOME_CANVAS_ITEM(ui.cur_layer->group)):(ui.cur_page->bg->canvas_item));
1111 ui.cur_page->layers = g_list_insert(ui.cur_page->layers, l, ui.layerno+1);
1114 ui.cur_page->nlayers++;
1115 update_page_stuff();
1118 undo->type = ITEM_NEW_LAYER;
1119 undo->val = ui.layerno;
1121 undo->page = ui.cur_page;
1126 on_journalDeleteLayer_activate (GtkMenuItem *menuitem,
1131 if (ui.cur_layer == NULL) return;
1134 undo->type = ITEM_DELETE_LAYER;
1135 undo->val = ui.layerno;
1136 undo->layer = ui.cur_layer;
1137 undo->layer2 = NULL;
1138 undo->page = ui.cur_page;
1139 // delete all the canvas items
1140 gtk_object_destroy(GTK_OBJECT(ui.cur_layer->group));
1141 ui.cur_layer->group = NULL;
1142 for (list=ui.cur_layer->items; list!=NULL; list=list->next)
1143 ((struct Item *)list->data)->canvas_item = NULL;
1145 ui.cur_page->layers = g_list_remove(ui.cur_page->layers, ui.cur_layer);
1147 if (ui.cur_page->nlayers>=2) {
1148 ui.cur_page->nlayers--;
1150 if (ui.layerno<0) ui.cur_layer = NULL;
1151 else ui.cur_layer = (struct Layer *)g_list_nth_data(ui.cur_page->layers, ui.layerno);
1153 else { // special case: can't remove the last layer
1154 ui.cur_layer = g_new(struct Layer, 1);
1155 ui.cur_layer->items = NULL;
1156 ui.cur_layer->nitems = 0;
1157 ui.cur_layer->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
1158 ui.cur_page->group, gnome_canvas_group_get_type(), NULL);
1159 ui.cur_page->layers = g_list_append(NULL, ui.cur_layer);
1161 undo->layer2 = ui.cur_layer;
1164 update_page_stuff();
1169 on_journalFlatten_activate (GtkMenuItem *menuitem,
1176 // the paper sizes dialog
1178 GtkWidget *papersize_dialog;
1179 int papersize_std, papersize_unit;
1180 double papersize_width, papersize_height;
1181 gboolean papersize_need_init, papersize_width_valid, papersize_height_valid;
1183 #define STD_SIZE_A4 0
1184 #define STD_SIZE_A4R 1
1185 #define STD_SIZE_LETTER 2
1186 #define STD_SIZE_LETTER_R 3
1187 #define STD_SIZE_CUSTOM 4
1189 double unit_sizes[4] = {28.346, 72., 72./DISPLAY_DPI_DEFAULT, 1.};
1190 double std_widths[STD_SIZE_CUSTOM] = {595.27, 841.89, 612., 792.};
1191 double std_heights[STD_SIZE_CUSTOM] = {841.89, 595.27, 792., 612.};
1192 double std_units[STD_SIZE_CUSTOM] = {UNIT_CM, UNIT_CM, UNIT_IN, UNIT_IN};
1195 on_journalPaperSize_activate (GtkMenuItem *menuitem,
1202 papersize_dialog = create_papersizeDialog();
1203 papersize_width = ui.cur_page->width;
1204 papersize_height = ui.cur_page->height;
1205 papersize_unit = ui.default_unit;
1206 unit_sizes[UNIT_PX] = 1./DEFAULT_ZOOM;
1207 // if (ui.cur_page->bg->type == BG_PIXMAP) papersize_unit = UNIT_PX;
1208 papersize_std = STD_SIZE_CUSTOM;
1209 for (i=0;i<STD_SIZE_CUSTOM;i++)
1210 if (fabs(papersize_width - std_widths[i])<0.1 &&
1211 fabs(papersize_height - std_heights[i])<0.1)
1212 { papersize_std = i; papersize_unit = std_units[i]; }
1213 papersize_need_init = TRUE;
1214 papersize_width_valid = papersize_height_valid = TRUE;
1216 gtk_widget_show(papersize_dialog);
1217 on_comboStdSizes_changed(GTK_COMBO_BOX(g_object_get_data(
1218 G_OBJECT(papersize_dialog), "comboStdSizes")), NULL);
1219 gtk_dialog_set_default_response(GTK_DIALOG(papersize_dialog), GTK_RESPONSE_OK);
1221 response = gtk_dialog_run(GTK_DIALOG(papersize_dialog));
1222 gtk_widget_destroy(papersize_dialog);
1223 if (response != GTK_RESPONSE_OK) return;
1226 for (pglist = journal.pages; pglist!=NULL; pglist = pglist->next) {
1227 if (ui.bg_apply_all_pages) pg = (struct Page *)pglist->data;
1229 if (ui.bg_apply_all_pages) {
1230 if (pglist->next!=NULL) undo->multiop |= MULTIOP_CONT_REDO;
1231 if (pglist->prev!=NULL) undo->multiop |= MULTIOP_CONT_UNDO;
1233 undo->type = ITEM_PAPER_RESIZE;
1235 undo->val_x = pg->width;
1236 undo->val_y = pg->height;
1237 if (papersize_width_valid) pg->width = papersize_width;
1238 if (papersize_height_valid) pg->height = papersize_height;
1239 make_page_clipbox(pg);
1240 update_canvas_bg(pg);
1241 if (!ui.bg_apply_all_pages) break;
1243 do_switch_page(ui.pageno, TRUE, TRUE);
1248 on_papercolorWhite_activate (GtkMenuItem *menuitem,
1251 process_papercolor_activate(menuitem, COLOR_WHITE);
1256 on_papercolorYellow_activate (GtkMenuItem *menuitem,
1259 process_papercolor_activate(menuitem, COLOR_YELLOW);
1264 on_papercolorPink_activate (GtkMenuItem *menuitem,
1267 process_papercolor_activate(menuitem, COLOR_RED);
1272 on_papercolorOrange_activate (GtkMenuItem *menuitem,
1275 process_papercolor_activate(menuitem, COLOR_ORANGE);
1280 on_papercolorBlue_activate (GtkMenuItem *menuitem,
1283 process_papercolor_activate(menuitem, COLOR_BLUE);
1288 on_papercolorGreen_activate (GtkMenuItem *menuitem,
1291 process_papercolor_activate(menuitem, COLOR_GREEN);
1296 on_papercolorOther_activate (GtkMenuItem *menuitem,
1304 on_paperstylePlain_activate (GtkMenuItem *menuitem,
1307 process_paperstyle_activate(menuitem, RULING_NONE);
1312 on_paperstyleLined_activate (GtkMenuItem *menuitem,
1315 process_paperstyle_activate(menuitem, RULING_LINED);
1320 on_paperstyleRuled_activate (GtkMenuItem *menuitem,
1323 process_paperstyle_activate(menuitem, RULING_RULED);
1328 on_paperstyleGraph_activate (GtkMenuItem *menuitem,
1331 process_paperstyle_activate(menuitem, RULING_GRAPH);
1336 on_journalLoadBackground_activate (GtkMenuItem *menuitem,
1339 GtkWidget *dialog, *attach_opt;
1340 struct Background *bg;
1343 GList *bglist, *bglistiter;
1344 GtkFileFilter *filt_all, *filt_pix, *filt_pspdf;
1348 dialog = gtk_file_chooser_dialog_new("Open Background", GTK_WINDOW (winMain),
1349 GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1350 GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL);
1352 filt_all = gtk_file_filter_new();
1353 gtk_file_filter_set_name(filt_all, "All files");
1354 gtk_file_filter_add_pattern(filt_all, "*");
1355 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_all);
1357 #if GTK_CHECK_VERSION(2,6,0)
1359 if (!gtk_check_version(2, 6, 0)) {
1360 filt_pix = gtk_file_filter_new();
1361 gtk_file_filter_set_name(filt_pix, "Bitmap files");
1362 gtk_file_filter_add_pixbuf_formats(filt_pix);
1363 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_pix);
1368 filt_pspdf = gtk_file_filter_new();
1369 gtk_file_filter_set_name(filt_pspdf, "PS/PDF files (as bitmaps)");
1370 gtk_file_filter_add_pattern(filt_pspdf, "*.ps");
1371 gtk_file_filter_add_pattern(filt_pspdf, "*.pdf");
1372 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_pspdf);
1374 attach_opt = gtk_check_button_new_with_label("Attach file to the journal");
1375 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(attach_opt), FALSE);
1376 gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER (dialog), attach_opt);
1378 if (ui.default_path!=NULL) gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (dialog), ui.default_path);
1380 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
1381 gtk_widget_destroy(dialog);
1384 filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
1385 attach = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(attach_opt));
1386 gtk_widget_destroy(dialog);
1388 set_cursor_busy(TRUE);
1389 bg = attempt_load_pix_bg(filename, attach);
1390 if (bg != NULL) bglist = g_list_append(NULL, bg);
1391 else bglist = attempt_load_gv_bg(filename);
1392 set_cursor_busy(FALSE);
1394 if (bglist == NULL) {
1395 dialog = gtk_message_dialog_new(GTK_WINDOW(winMain), GTK_DIALOG_MODAL,
1396 GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
1397 "Error opening background '%s'", filename);
1398 gtk_dialog_run(GTK_DIALOG(dialog));
1399 gtk_widget_destroy(dialog);
1408 for (bglistiter = bglist, pageno = ui.pageno;
1409 bglistiter!=NULL; bglistiter = bglistiter->next, pageno++) {
1411 if (bglistiter->next!=NULL) undo->multiop |= MULTIOP_CONT_REDO;
1412 if (bglistiter->prev!=NULL) undo->multiop |= MULTIOP_CONT_UNDO;
1414 bg = (struct Background *)bglistiter->data;
1416 if (pageno == journal.npages) {
1417 undo->type = ITEM_NEW_PAGE;
1418 pg = new_page_with_bg(bg,
1419 gdk_pixbuf_get_width(bg->pixbuf)/bg->pixbuf_scale,
1420 gdk_pixbuf_get_height(bg->pixbuf)/bg->pixbuf_scale);
1421 journal.pages = g_list_append(journal.pages, pg);
1427 pg = g_list_nth_data(journal.pages, pageno);
1428 undo->type = ITEM_NEW_BG_RESIZE;
1431 bg->canvas_item = undo->bg->canvas_item;
1432 undo->bg->canvas_item = NULL;
1433 undo->val_x = pg->width;
1434 undo->val_y = pg->height;
1436 pg->width = gdk_pixbuf_get_width(bg->pixbuf)/bg->pixbuf_scale;
1437 pg->height = gdk_pixbuf_get_height(bg->pixbuf)/bg->pixbuf_scale;
1438 make_page_clipbox(pg);
1439 update_canvas_bg(pg);
1443 g_list_free(bglist);
1444 if (ui.zoom != DEFAULT_ZOOM) {
1445 ui.zoom = DEFAULT_ZOOM;
1446 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
1447 rescale_bg_pixmaps();
1449 do_switch_page(ui.pageno, TRUE, TRUE);
1453 on_journalScreenshot_activate (GtkMenuItem *menuitem,
1456 struct Background *bg;
1459 gtk_window_iconify(GTK_WINDOW(winMain)); // hide ourselves
1460 gdk_display_sync(gdk_display_get_default());
1462 if (ui.cursor!=NULL)
1463 gdk_cursor_unref(ui.cursor);
1464 ui.cursor = gdk_cursor_new(GDK_TCROSS);
1466 bg = attempt_screenshot_bg();
1468 gtk_window_deiconify(GTK_WINDOW(winMain));
1470 if (bg==NULL) return;
1473 undo->type = ITEM_NEW_BG_RESIZE;
1474 undo->page = ui.cur_page;
1475 undo->bg = ui.cur_page->bg;
1476 bg->canvas_item = undo->bg->canvas_item;
1477 undo->bg->canvas_item = NULL;
1478 undo->val_x = ui.cur_page->width;
1479 undo->val_y = ui.cur_page->height;
1481 ui.cur_page->bg = bg;
1482 ui.cur_page->width = gdk_pixbuf_get_width(bg->pixbuf)/bg->pixbuf_scale;
1483 ui.cur_page->height = gdk_pixbuf_get_height(bg->pixbuf)/bg->pixbuf_scale;
1485 make_page_clipbox(ui.cur_page);
1486 update_canvas_bg(ui.cur_page);
1488 if (ui.zoom != DEFAULT_ZOOM) {
1489 ui.zoom = DEFAULT_ZOOM;
1490 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
1491 rescale_bg_pixmaps();
1493 do_switch_page(ui.pageno, TRUE, TRUE);
1498 on_journalApplyAllPages_activate (GtkMenuItem *menuitem,
1503 active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
1504 if (active == ui.bg_apply_all_pages) return;
1505 ui.bg_apply_all_pages = active;
1506 update_page_stuff();
1508 /* THIS IS THE OLD VERSION OF THE FEATURE -- APPLIED CURRENT BG TO ALL
1512 if (ui.cur_page->bg->type != BG_SOLID) return;
1514 for (pglist = journal.pages; pglist!=NULL; pglist = pglist->next) {
1515 page = (struct Page *)pglist->data;
1517 undo->type = ITEM_NEW_BG_RESIZE;
1519 undo->bg = page->bg;
1520 undo->val_x = page->width;
1521 undo->val_y = page->height;
1522 if (pglist->next!=NULL) undo->multiop |= MULTIOP_CONT_REDO;
1523 if (pglist->prev!=NULL) undo->multiop |= MULTIOP_CONT_UNDO;
1524 page->bg = (struct Background *)g_memdup(ui.cur_page->bg, sizeof(struct Background));
1525 page->width = ui.cur_page->width;
1526 page->height = ui.cur_page->height;
1527 page->bg->canvas_item = undo->bg->canvas_item;
1528 undo->bg->canvas_item = NULL;
1530 make_page_clipbox(page);
1531 update_canvas_bg(page);
1533 do_switch_page(ui.pageno, TRUE, TRUE);
1540 on_toolsPen_activate (GtkMenuItem *menuitem,
1543 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1544 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1547 if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1551 if (ui.cur_mapping != 0) return;
1552 if (ui.toolno[0] == TOOL_PEN) return;
1555 ui.toolno[0] = TOOL_PEN;
1556 ui.ruler[0] = FALSE;
1557 ui.cur_brush = &(ui.brushes[0][TOOL_PEN]);
1558 update_mapping_linkings(TOOL_PEN);
1559 update_tool_buttons();
1561 update_color_menu();
1567 on_toolsEraser_activate (GtkMenuItem *menuitem,
1570 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1571 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1574 if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1578 if (ui.cur_mapping != 0) return;
1579 if (ui.toolno[0] == TOOL_ERASER) return;
1582 ui.toolno[0] = TOOL_ERASER;
1583 ui.ruler[0] = FALSE;
1584 ui.cur_brush = &(ui.brushes[0][TOOL_ERASER]);
1585 update_mapping_linkings(TOOL_ERASER);
1586 update_tool_buttons();
1588 update_color_menu();
1594 on_toolsHighlighter_activate (GtkMenuItem *menuitem,
1597 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1598 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1601 if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1605 if (ui.cur_mapping != 0) return; // not user-generated
1606 if (ui.toolno[0] == TOOL_HIGHLIGHTER) return;
1609 ui.toolno[0] = TOOL_HIGHLIGHTER;
1610 ui.ruler[0] = FALSE;
1611 ui.cur_brush = &(ui.brushes[0][TOOL_HIGHLIGHTER]);
1612 update_mapping_linkings(TOOL_HIGHLIGHTER);
1613 update_tool_buttons();
1615 update_color_menu();
1621 on_toolsText_activate (GtkMenuItem *menuitem,
1629 on_toolsSelectRegion_activate (GtkMenuItem *menuitem,
1637 on_toolsSelectRectangle_activate (GtkMenuItem *menuitem,
1640 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1641 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1644 if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1648 if (ui.cur_mapping != 0) return; // not user-generated
1649 if (ui.toolno[0] == TOOL_SELECTRECT) return;
1651 ui.toolno[0] = TOOL_SELECTRECT;
1652 ui.ruler[0] = FALSE;
1653 update_mapping_linkings(-1);
1654 update_tool_buttons();
1656 update_color_menu();
1662 on_toolsVerticalSpace_activate (GtkMenuItem *menuitem,
1665 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1666 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1669 if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1673 if (ui.cur_mapping != 0) return; // not user-generated
1674 if (ui.toolno[0] == TOOL_VERTSPACE) return;
1677 ui.toolno[0] = TOOL_VERTSPACE;
1678 ui.ruler[0] = FALSE;
1679 update_mapping_linkings(-1);
1680 update_tool_buttons();
1682 update_color_menu();
1688 on_colorBlack_activate (GtkMenuItem *menuitem,
1691 process_color_activate(menuitem, COLOR_BLACK);
1696 on_colorBlue_activate (GtkMenuItem *menuitem,
1699 process_color_activate(menuitem, COLOR_BLUE);
1705 on_colorRed_activate (GtkMenuItem *menuitem,
1708 process_color_activate(menuitem, COLOR_RED);
1713 on_colorGreen_activate (GtkMenuItem *menuitem,
1716 process_color_activate(menuitem, COLOR_GREEN);
1721 on_colorGray_activate (GtkMenuItem *menuitem,
1724 process_color_activate(menuitem, COLOR_GRAY);
1729 on_colorLightBlue_activate (GtkMenuItem *menuitem,
1732 process_color_activate(menuitem, COLOR_LIGHTBLUE);
1737 on_colorLightGreen_activate (GtkMenuItem *menuitem,
1740 process_color_activate(menuitem, COLOR_LIGHTGREEN);
1745 on_colorMagenta_activate (GtkMenuItem *menuitem,
1748 process_color_activate(menuitem, COLOR_MAGENTA);
1753 on_colorOrange_activate (GtkMenuItem *menuitem,
1756 process_color_activate(menuitem, COLOR_ORANGE);
1761 on_colorYellow_activate (GtkMenuItem *menuitem,
1764 process_color_activate(menuitem, COLOR_YELLOW);
1769 on_colorWhite_activate (GtkMenuItem *menuitem,
1772 process_color_activate(menuitem, COLOR_WHITE);
1777 on_colorOther_activate (GtkMenuItem *menuitem,
1785 on_penthicknessVeryFine_activate (GtkMenuItem *menuitem,
1788 process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_VERYFINE);
1793 on_penthicknessFine_activate (GtkMenuItem *menuitem,
1796 process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_FINE);
1801 on_penthicknessMedium_activate (GtkMenuItem *menuitem,
1804 process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_MEDIUM);
1809 on_penthicknessThick_activate (GtkMenuItem *menuitem,
1812 process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_THICK);
1817 on_penthicknessVeryThick_activate (GtkMenuItem *menuitem,
1820 process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_VERYTHICK);
1825 on_eraserFine_activate (GtkMenuItem *menuitem,
1828 process_thickness_activate(menuitem, TOOL_ERASER, THICKNESS_FINE);
1833 on_eraserMedium_activate (GtkMenuItem *menuitem,
1836 process_thickness_activate(menuitem, TOOL_ERASER, THICKNESS_MEDIUM);
1841 on_eraserThick_activate (GtkMenuItem *menuitem,
1844 process_thickness_activate(menuitem, TOOL_ERASER, THICKNESS_THICK);
1849 on_eraserStandard_activate (GtkMenuItem *menuitem,
1852 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
1853 ui.brushes[0][TOOL_ERASER].tool_options = TOOLOPT_ERASER_STANDARD;
1854 update_mapping_linkings(TOOL_ERASER);
1859 on_eraserWhiteout_activate (GtkMenuItem *menuitem,
1862 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
1863 ui.brushes[0][TOOL_ERASER].tool_options = TOOLOPT_ERASER_WHITEOUT;
1864 update_mapping_linkings(TOOL_ERASER);
1869 on_eraserDeleteStrokes_activate (GtkMenuItem *menuitem,
1872 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
1873 ui.brushes[0][TOOL_ERASER].tool_options = TOOLOPT_ERASER_STROKES;
1874 update_mapping_linkings(TOOL_ERASER);
1879 on_highlighterFine_activate (GtkMenuItem *menuitem,
1882 process_thickness_activate(menuitem, TOOL_HIGHLIGHTER, THICKNESS_FINE);
1887 on_highlighterMedium_activate (GtkMenuItem *menuitem,
1890 process_thickness_activate(menuitem, TOOL_HIGHLIGHTER, THICKNESS_MEDIUM);
1895 on_highlighterThick_activate (GtkMenuItem *menuitem,
1898 process_thickness_activate(menuitem, TOOL_HIGHLIGHTER, THICKNESS_THICK);
1903 on_toolsTextFont_activate (GtkMenuItem *menuitem,
1911 on_toolsDefaultPen_activate (GtkMenuItem *menuitem,
1916 g_memmove(&(ui.brushes[0][TOOL_PEN]), ui.default_brushes+TOOL_PEN, sizeof(struct Brush));
1917 ui.toolno[0] = TOOL_PEN;
1918 ui.cur_brush = &(ui.brushes[0][TOOL_PEN]);
1919 ui.ruler[0] = FALSE;
1920 update_mapping_linkings(TOOL_PEN);
1921 update_tool_buttons();
1923 update_pen_props_menu();
1924 update_color_menu();
1930 on_toolsDefaultEraser_activate (GtkMenuItem *menuitem,
1935 g_memmove(&(ui.brushes[0][TOOL_ERASER]), ui.default_brushes+TOOL_ERASER, sizeof(struct Brush));
1936 ui.toolno[0] = TOOL_ERASER;
1937 ui.cur_brush = &(ui.brushes[0][TOOL_ERASER]);
1938 ui.ruler[0] = FALSE;
1939 update_mapping_linkings(TOOL_ERASER);
1940 update_tool_buttons();
1942 update_eraser_props_menu();
1943 update_color_menu();
1949 on_toolsDefaultHighlighter_activate (GtkMenuItem *menuitem,
1954 g_memmove(&(ui.brushes[0][TOOL_HIGHLIGHTER]), ui.default_brushes+TOOL_HIGHLIGHTER, sizeof(struct Brush));
1955 ui.toolno[0] = TOOL_HIGHLIGHTER;
1956 ui.cur_brush = &(ui.brushes[0][TOOL_HIGHLIGHTER]);
1957 ui.ruler[0] = FALSE;
1958 update_mapping_linkings(TOOL_HIGHLIGHTER);
1959 update_tool_buttons();
1961 update_highlighter_props_menu();
1962 update_color_menu();
1967 on_toolsDefaultText_activate (GtkMenuItem *menuitem,
1975 on_toolsSetAsDefault_activate (GtkMenuItem *menuitem,
1978 if (ui.cur_mapping!=0) return;
1979 if (ui.toolno[0] < NUM_STROKE_TOOLS)
1980 g_memmove(ui.default_brushes+ui.toolno[0], &(ui.brushes[0][ui.toolno[0]]), sizeof(struct Brush));
1985 on_toolsRuler_activate (GtkMenuItem *menuitem,
1990 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_CHECK_MENU_ITEM)
1991 active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
1993 active = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem));
1995 if (ui.cur_mapping != 0) return;
1996 if (active == ui.ruler[0]) return;
1998 if (active && (ui.toolno[0]!=TOOL_PEN && ui.toolno[0]!=TOOL_HIGHLIGHTER)) {
2000 ui.toolno[0] = TOOL_PEN;
2001 ui.cur_brush = &(ui.brushes[0][TOOL_PEN]);
2002 update_color_menu();
2003 update_tool_buttons();
2008 ui.ruler[0] = active;
2009 update_mapping_linkings(ui.toolno[0]);
2010 update_ruler_indicator();
2015 on_optionsSavePreferences_activate (GtkMenuItem *menuitem,
2018 save_config_to_file();
2023 on_helpIndex_activate (GtkMenuItem *menuitem,
2031 on_helpAbout_activate (GtkMenuItem *menuitem,
2034 GtkWidget *aboutDialog;
2035 GtkLabel *labelTitle;
2037 aboutDialog = create_aboutDialog ();
2038 labelTitle = GTK_LABEL(g_object_get_data(G_OBJECT(aboutDialog), "labelTitle"));
2039 gtk_label_set_markup(labelTitle,
2040 "<span size=\"xx-large\" weight=\"bold\">Xournal " VERSION "</span>");
2041 gtk_dialog_run (GTK_DIALOG(aboutDialog));
2042 gtk_widget_destroy(aboutDialog);
2047 on_buttonToolDefault_clicked (GtkToolButton *toolbutton,
2051 if (ui.toolno[0] < NUM_STROKE_TOOLS) {
2052 g_memmove(&(ui.brushes[0][ui.toolno[0]]), ui.default_brushes+ui.toolno[0], sizeof(struct Brush));
2053 ui.ruler[0] = FALSE;
2054 update_mapping_linkings(ui.toolno[0]);
2055 update_thickness_buttons();
2056 update_color_buttons();
2057 update_color_menu();
2058 if (ui.toolno[0] == TOOL_PEN) update_pen_props_menu();
2059 if (ui.toolno[0] == TOOL_ERASER) update_eraser_props_menu();
2060 if (ui.toolno[0] == TOOL_HIGHLIGHTER) update_highlighter_props_menu();
2067 on_buttonFine_clicked (GtkToolButton *toolbutton,
2070 if (ui.cur_mapping != 0) return;
2071 process_thickness_activate((GtkMenuItem*)toolbutton, ui.toolno[0], THICKNESS_FINE);
2076 on_buttonMedium_clicked (GtkToolButton *toolbutton,
2079 if (ui.cur_mapping != 0) return;
2080 process_thickness_activate((GtkMenuItem*)toolbutton, ui.toolno[0], THICKNESS_MEDIUM);
2085 on_buttonThick_clicked (GtkToolButton *toolbutton,
2088 if (ui.cur_mapping != 0) return;
2089 process_thickness_activate((GtkMenuItem*)toolbutton, ui.toolno[0], THICKNESS_THICK);
2094 on_canvas_button_press_event (GtkWidget *widget,
2095 GdkEventButton *event,
2099 gboolean page_change;
2100 struct Page *tmppage;
2105 if (ui.cur_item_type != ITEM_NONE) return FALSE; // we're already doing something
2106 if (event->button > 3) return FALSE; // no painting with the mouse wheel!
2108 is_core = (event->device == gdk_device_get_core_pointer());
2109 if (!ui.use_xinput && !is_core) return FALSE;
2110 if (ui.use_xinput && is_core && ui.discard_corepointer) return FALSE;
2112 // re-get the axis values since Synaptics sends bogus ones
2113 gdk_device_get_state(event->device, event->window, event->axes, NULL);
2114 fix_xinput_coords((GdkEvent *)event);
2116 ui.is_corestroke = is_core;
2118 if (ui.use_erasertip && event->device->source == GDK_SOURCE_ERASER)
2119 mapping = NUM_BUTTONS;
2120 else mapping = event->button-1;
2122 // check whether we're in a page
2123 page_change = FALSE;
2124 tmppage = ui.cur_page;
2125 get_pointer_coords((GdkEvent *)event, pt);
2126 while (ui.view_continuous && (pt[1] < - VIEW_CONTINUOUS_SKIP)) {
2127 if (ui.pageno == 0) break;
2130 tmppage = g_list_nth_data(journal.pages, ui.pageno);
2131 pt[1] += tmppage->height + VIEW_CONTINUOUS_SKIP;
2133 while (ui.view_continuous && (pt[1] > tmppage->height + VIEW_CONTINUOUS_SKIP)) {
2134 if (ui.pageno == journal.npages-1) break;
2135 pt[1] -= tmppage->height + VIEW_CONTINUOUS_SKIP;
2138 tmppage = g_list_nth_data(journal.pages, ui.pageno);
2140 if (page_change) do_switch_page(ui.pageno, FALSE, FALSE);
2142 // can't paint on the background...
2144 if (ui.cur_layer == NULL) {
2146 dialog = gtk_message_dialog_new(GTK_WINDOW(winMain), GTK_DIALOG_MODAL,
2147 GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, "Drawing is not allowed on the "
2148 "background layer.\n Switching to Layer 1.");
2149 gtk_dialog_run(GTK_DIALOG(dialog));
2150 gtk_widget_destroy(dialog);
2151 on_viewShowLayer_activate(NULL, NULL);
2155 // switch mappings if needed
2157 ui.which_mouse_button = event->button;
2158 switch_mapping(mapping);
2160 // if this can be a selection move, then it takes precedence over anything else
2161 if (start_movesel((GdkEvent *)event)) return FALSE;
2163 if (ui.toolno[mapping] != TOOL_SELECTREGION && ui.toolno[mapping] != TOOL_SELECTRECT)
2166 // process the event
2168 if (ui.toolno[mapping] == TOOL_HAND) {
2169 ui.cur_item_type = ITEM_HAND;
2170 get_pointer_coords((GdkEvent *)event, ui.hand_refpt);
2172 else if (ui.toolno[mapping] == TOOL_PEN || ui.toolno[mapping] == TOOL_HIGHLIGHTER ||
2173 (ui.toolno[mapping] == TOOL_ERASER && ui.cur_brush->tool_options == TOOLOPT_ERASER_WHITEOUT)) {
2174 create_new_stroke((GdkEvent *)event);
2176 else if (ui.toolno[mapping] == TOOL_ERASER) {
2177 ui.cur_item_type = ITEM_ERASURE;
2178 do_eraser((GdkEvent *)event, ui.cur_brush->thickness/2,
2179 ui.cur_brush->tool_options == TOOLOPT_ERASER_STROKES);
2181 else if (ui.toolno[mapping] == TOOL_SELECTRECT) {
2182 start_selectrect((GdkEvent *)event);
2184 else if (ui.toolno[mapping] == TOOL_VERTSPACE) {
2185 start_vertspace((GdkEvent *)event);
2192 on_canvas_button_release_event (GtkWidget *widget,
2193 GdkEventButton *event,
2198 if (ui.cur_item_type == ITEM_NONE) return FALSE; // not doing anything
2200 if (event->button != ui.which_mouse_button) return FALSE; // ignore
2202 is_core = (event->device == gdk_device_get_core_pointer());
2203 if (!ui.use_xinput && !is_core) return FALSE;
2204 if (ui.use_xinput && is_core && !ui.is_corestroke) return FALSE;
2205 if (!is_core) fix_xinput_coords((GdkEvent *)event);
2207 if (ui.cur_item_type == ITEM_STROKE) {
2210 else if (ui.cur_item_type == ITEM_ERASURE) {
2213 else if (ui.cur_item_type == ITEM_SELECTRECT) {
2214 finalize_selectrect();
2216 else if (ui.cur_item_type == ITEM_MOVESEL || ui.cur_item_type == ITEM_MOVESEL_VERT) {
2219 else if (ui.cur_item_type == ITEM_HAND) {
2220 ui.cur_item_type = ITEM_NONE;
2229 on_canvas_enter_notify_event (GtkWidget *widget,
2230 GdkEventCrossing *event,
2239 on_canvas_expose_event (GtkWidget *widget,
2240 GdkEventExpose *event,
2243 if (ui.view_continuous && ui.progressive_bg) rescale_bg_pixmaps();
2249 on_canvas_key_press_event (GtkWidget *widget,
2259 on_canvas_motion_notify_event (GtkWidget *widget,
2260 GdkEventMotion *event,
2263 gboolean looks_wrong, is_core;
2266 if (ui.cur_item_type == ITEM_NONE) return FALSE; // we don't care
2268 is_core = (event->device == gdk_device_get_core_pointer());
2269 if (!ui.use_xinput && !is_core) return FALSE;
2270 if (ui.use_xinput && is_core && !ui.is_corestroke) return FALSE;
2271 if (!is_core) fix_xinput_coords((GdkEvent *)event);
2273 looks_wrong = !(event->state & (1<<(7+ui.which_mouse_button)));
2275 if (looks_wrong) { /* mouse button shouldn't be up... give up */
2276 if (ui.cur_item_type == ITEM_STROKE) {
2279 else if (ui.cur_item_type == ITEM_ERASURE) {
2282 else if (ui.cur_item_type == ITEM_SELECTRECT) {
2283 finalize_selectrect();
2285 else if (ui.cur_item_type == ITEM_MOVESEL || ui.cur_item_type == ITEM_MOVESEL_VERT) {
2292 if (ui.cur_item_type == ITEM_STROKE) {
2293 continue_stroke((GdkEvent *)event);
2295 else if (ui.cur_item_type == ITEM_ERASURE) {
2296 do_eraser((GdkEvent *)event, ui.cur_brush->thickness/2,
2297 ui.cur_brush->tool_options == TOOLOPT_ERASER_STROKES);
2299 else if (ui.cur_item_type == ITEM_SELECTRECT) {
2300 get_pointer_coords((GdkEvent *)event, pt);
2301 ui.selection->bbox.right = pt[0];
2302 ui.selection->bbox.bottom = pt[1];
2303 gnome_canvas_item_set(ui.selection->canvas_item,
2304 "x2", pt[0], "y2", pt[1], NULL);
2306 else if (ui.cur_item_type == ITEM_MOVESEL || ui.cur_item_type == ITEM_MOVESEL_VERT) {
2307 continue_movesel((GdkEvent *)event);
2309 else if (ui.cur_item_type == ITEM_HAND) {
2310 do_hand((GdkEvent *)event);
2317 on_comboLayer_changed (GtkComboBox *combobox,
2322 if (ui.in_update_page_stuff) return; // avoid a bad retroaction
2324 gtk_widget_grab_focus(GTK_WIDGET(canvas)); // stop focus on us
2326 val = gtk_combo_box_get_active(combobox);
2327 if (val == -1) return;
2328 val = ui.cur_page->nlayers-1-val;
2329 if (val == ui.layerno) return;
2332 while (val>ui.layerno) {
2334 ui.cur_layer = g_list_nth_data(ui.cur_page->layers, ui.layerno);
2335 gnome_canvas_item_show(GNOME_CANVAS_ITEM(ui.cur_layer->group));
2337 while (val<ui.layerno) {
2338 gnome_canvas_item_hide(GNOME_CANVAS_ITEM(ui.cur_layer->group));
2340 if (ui.layerno<0) ui.cur_layer = NULL;
2341 else ui.cur_layer = g_list_nth_data(ui.cur_page->layers, ui.layerno);
2343 update_page_stuff();
2348 on_winMain_delete_event (GtkWidget *widget,
2352 if (ok_to_close()) gtk_main_quit();
2358 on_optionsUseXInput_activate (GtkMenuItem *menuitem,
2361 ui.allow_xinput = ui.use_xinput =
2362 gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
2363 update_mappings_menu();
2367 on_vscroll_changed (GtkAdjustment *adjustment,
2370 gboolean need_update;
2371 double viewport_top, viewport_bottom;
2372 struct Page *tmppage;
2374 if (!ui.view_continuous) return;
2376 if (ui.progressive_bg) rescale_bg_pixmaps();
2377 need_update = FALSE;
2378 viewport_top = adjustment->value / ui.zoom;
2379 viewport_bottom = (adjustment->value + adjustment->page_size) / ui.zoom;
2380 tmppage = ui.cur_page;
2381 while (viewport_top > tmppage->voffset + tmppage->height) {
2382 if (ui.pageno == journal.npages-1) break;
2385 tmppage = g_list_nth_data(journal.pages, ui.pageno);
2387 while (viewport_bottom < tmppage->voffset) {
2388 if (ui.pageno == 0) break;
2391 tmppage = g_list_nth_data(journal.pages, ui.pageno);
2393 if (need_update) do_switch_page(ui.pageno, FALSE, FALSE);
2398 on_spinPageNo_value_changed (GtkSpinButton *spinbutton,
2403 if (ui.in_update_page_stuff) return; // avoid a bad retroaction
2405 gtk_widget_grab_focus(GTK_WIDGET(canvas)); // stop blink-blink text cursor
2407 val = gtk_spin_button_get_value_as_int(spinbutton) - 1;
2409 if (val == journal.npages) { // create a page at end
2410 if (page_ops_forbidden()) return;
2411 on_journalNewPageEnd_activate(NULL, NULL);
2415 if (val == ui.pageno) return;
2416 if (val < 0) val = 0;
2417 if (val > journal.npages-1) val = journal.npages-1;
2418 do_switch_page(val, TRUE, FALSE);
2423 on_journalDefaultBackground_activate (GtkMenuItem *menuitem,
2432 for (pglist = journal.pages; pglist!=NULL; pglist = pglist->next) {
2433 if (ui.bg_apply_all_pages) pg = (struct Page *)pglist->data;
2435 if (ui.bg_apply_all_pages) {
2436 if (pglist->next!=NULL) undo->multiop |= MULTIOP_CONT_REDO;
2437 if (pglist->prev!=NULL) undo->multiop |= MULTIOP_CONT_UNDO;
2439 undo->type = ITEM_NEW_BG_RESIZE;
2442 undo->val_x = pg->width;
2443 undo->val_y = pg->height;
2444 pg->bg = (struct Background *)g_memdup(ui.default_page.bg, sizeof(struct Background));
2445 pg->width = ui.default_page.width;
2446 pg->height = ui.default_page.height;
2447 pg->bg->canvas_item = undo->bg->canvas_item;
2448 undo->bg->canvas_item = NULL;
2450 make_page_clipbox(pg);
2451 update_canvas_bg(pg);
2452 if (!ui.bg_apply_all_pages) break;
2454 do_switch_page(ui.pageno, TRUE, TRUE);
2459 on_journalSetAsDefault_activate (GtkMenuItem *menuitem,
2462 if (ui.cur_page->bg->type != BG_SOLID) return;
2465 undo->type = ITEM_NEW_DEFAULT_BG;
2466 undo->val_x = ui.default_page.width;
2467 undo->val_y = ui.default_page.height;
2468 undo->bg = ui.default_page.bg;
2470 ui.default_page.width = ui.cur_page->width;
2471 ui.default_page.height = ui.cur_page->height;
2472 ui.default_page.bg = (struct Background *)g_memdup(ui.cur_page->bg, sizeof(struct Background));
2473 ui.default_page.bg->canvas_item = NULL;
2478 on_comboStdSizes_changed (GtkComboBox *combobox,
2482 GtkComboBox *comboUnit;
2486 if (papersize_need_init) {
2487 gtk_combo_box_set_active(combobox, papersize_std);
2488 papersize_need_init = FALSE;
2490 val = gtk_combo_box_get_active(combobox);
2491 if (val == -1 || val == papersize_std) return;
2492 papersize_std = val;
2493 if (val == STD_SIZE_CUSTOM) return;
2494 papersize_unit = std_units[val];
2495 papersize_width = std_widths[val];
2496 papersize_height = std_heights[val];
2498 comboUnit = GTK_COMBO_BOX(g_object_get_data(G_OBJECT(papersize_dialog), "comboUnit"));
2499 gtk_combo_box_set_active(comboUnit, papersize_unit);
2500 entry = GTK_ENTRY(g_object_get_data(G_OBJECT(papersize_dialog), "entryWidth"));
2501 g_snprintf(text, 20, "%.2f", papersize_width/unit_sizes[papersize_unit]);
2502 if (g_str_has_suffix(text, ".00"))
2503 g_snprintf(text, 20, "%d", (int) (papersize_width/unit_sizes[papersize_unit]));
2504 gtk_entry_set_text(entry, text);
2505 entry = GTK_ENTRY(g_object_get_data(G_OBJECT(papersize_dialog), "entryHeight"));
2506 g_snprintf(text, 20, "%.2f", papersize_height/unit_sizes[papersize_unit]);
2507 if (g_str_has_suffix(text, ".00"))
2508 g_snprintf(text, 20, "%d", (int) (papersize_height/unit_sizes[papersize_unit]));
2509 gtk_entry_set_text(entry, text);
2514 on_entryWidth_changed (GtkEditable *editable,
2520 GtkComboBox *comboStdSizes;
2522 text = gtk_entry_get_text(GTK_ENTRY(editable));
2523 val = strtod(text, &ptr);
2524 papersize_width_valid = (*ptr == 0 && val > 0.);
2525 if (!papersize_width_valid) return; // invalid entry
2526 val *= unit_sizes[papersize_unit];
2527 if (fabs(val - papersize_width) < 0.1) return; // no change
2528 papersize_std = STD_SIZE_CUSTOM;
2529 papersize_width = val;
2530 comboStdSizes = GTK_COMBO_BOX(g_object_get_data(G_OBJECT(papersize_dialog), "comboStdSizes"));
2531 gtk_combo_box_set_active(comboStdSizes, papersize_std);
2536 on_entryHeight_changed (GtkEditable *editable,
2542 GtkComboBox *comboStdSizes;
2544 text = gtk_entry_get_text(GTK_ENTRY(editable));
2545 val = strtod(text, &ptr);
2546 papersize_height_valid = (*ptr == 0 && val > 0.);
2547 if (!papersize_height_valid) return; // invalid entry
2548 val *= unit_sizes[papersize_unit];
2549 if (fabs(val - papersize_height) < 0.1) return; // no change
2550 papersize_std = STD_SIZE_CUSTOM;
2551 papersize_height = val;
2552 comboStdSizes = GTK_COMBO_BOX(g_object_get_data(G_OBJECT(papersize_dialog), "comboStdSizes"));
2553 gtk_combo_box_set_active(comboStdSizes, papersize_std);
2558 on_comboUnit_changed (GtkComboBox *combobox,
2565 val = gtk_combo_box_get_active(combobox);
2566 if (val == -1 || val == papersize_unit) return;
2567 papersize_unit = val;
2568 entry = GTK_ENTRY(g_object_get_data(G_OBJECT(papersize_dialog), "entryWidth"));
2569 if (papersize_width_valid) {
2570 g_snprintf(text, 20, "%.2f", papersize_width/unit_sizes[papersize_unit]);
2571 if (g_str_has_suffix(text, ".00"))
2572 g_snprintf(text, 20, "%d", (int) (papersize_width/unit_sizes[papersize_unit]));
2574 gtk_entry_set_text(entry, text);
2575 if (papersize_height_valid) {
2576 entry = GTK_ENTRY(g_object_get_data(G_OBJECT(papersize_dialog), "entryHeight"));
2577 g_snprintf(text, 20, "%.2f", papersize_height/unit_sizes[papersize_unit]);
2578 if (g_str_has_suffix(text, ".00"))
2579 g_snprintf(text, 20, "%d", (int) (papersize_height/unit_sizes[papersize_unit]));
2581 gtk_entry_set_text(entry, text);
2586 on_viewFullscreen_activate (GtkMenuItem *menuitem,
2591 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_CHECK_MENU_ITEM)
2592 active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
2594 active = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem));
2596 if (active == ui.fullscreen) return;
2597 ui.fullscreen = active;
2598 gtk_check_menu_item_set_active(
2599 GTK_CHECK_MENU_ITEM(GET_COMPONENT("viewFullscreen")), ui.fullscreen);
2600 gtk_toggle_tool_button_set_active(
2601 GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonFullscreen")), ui.fullscreen);
2603 if (ui.fullscreen) gtk_window_fullscreen(GTK_WINDOW(winMain));
2604 else gtk_window_unfullscreen(GTK_WINDOW(winMain));
2606 update_vbox_order(ui.vertical_order[ui.fullscreen?1:0]);
2611 on_optionsButtonMappings_activate (GtkMenuItem *menuitem,
2615 gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
2616 update_mappings_menu();
2621 on_optionsAntialiasBG_activate (GtkMenuItem *menuitem,
2626 active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
2627 if (ui.antialias_bg == active) return;
2628 ui.antialias_bg = active;
2629 rescale_bg_pixmaps();
2634 on_optionsProgressiveBG_activate (GtkMenuItem *menuitem,
2639 active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
2640 if (ui.progressive_bg == active) return;
2641 ui.progressive_bg = active;
2642 if (!ui.progressive_bg) rescale_bg_pixmaps();
2647 on_mru_activate (GtkMenuItem *menuitem,
2654 if (!ok_to_close()) return; // user aborted on save confirmation
2656 for (which = 0 ; which < MRU_SIZE; which++) {
2657 if (ui.mrumenu[which] == GTK_WIDGET(menuitem)) break;
2659 if (which == MRU_SIZE || ui.mru[which] == NULL) return; // not found...
2661 set_cursor_busy(TRUE);
2662 success = open_journal(ui.mru[which]);
2663 set_cursor_busy(FALSE);
2664 if (success) return;
2667 dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
2668 GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Error opening file '%s'", ui.mru[which]);
2669 gtk_dialog_run(GTK_DIALOG(dialog));
2670 gtk_widget_destroy(dialog);
2671 delete_mru_entry(which);
2676 on_button2Pen_activate (GtkMenuItem *menuitem,
2679 process_mapping_activate(menuitem, 1, TOOL_PEN);
2684 on_button2Eraser_activate (GtkMenuItem *menuitem,
2687 process_mapping_activate(menuitem, 1, TOOL_ERASER);
2692 on_button2Highlighter_activate (GtkMenuItem *menuitem,
2695 process_mapping_activate(menuitem, 1, TOOL_HIGHLIGHTER);
2700 on_button2Text_activate (GtkMenuItem *menuitem,
2708 on_button2SelectRegion_activate (GtkMenuItem *menuitem,
2711 process_mapping_activate(menuitem, 1, TOOL_SELECTREGION);
2716 on_button2SelectRectangle_activate (GtkMenuItem *menuitem,
2719 process_mapping_activate(menuitem, 1, TOOL_SELECTRECT);
2724 on_button2VerticalSpace_activate (GtkMenuItem *menuitem,
2727 process_mapping_activate(menuitem, 1, TOOL_VERTSPACE);
2732 on_button2LinkBrush_activate (GtkMenuItem *menuitem,
2737 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem))) return;
2738 ui.linked_brush[1] = BRUSH_LINKED;
2739 for (i=0;i<NUM_STROKE_TOOLS;i++) update_mapping_linkings(i);
2744 on_button2CopyBrush_activate (GtkMenuItem *menuitem,
2747 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem))) return;
2748 if (ui.toolno[1] >= NUM_STROKE_TOOLS) {
2749 ui.linked_brush[1] = BRUSH_STATIC;
2750 update_mappings_menu_linkings();
2753 ui.linked_brush[1] = BRUSH_COPIED;
2754 g_memmove(&(ui.brushes[1][ui.toolno[1]]), &(ui.brushes[0][ui.toolno[1]]), sizeof(struct Brush));
2755 ui.ruler[1] = ui.ruler[0];
2756 if (ui.toolno[1]!=TOOL_PEN && ui.toolno[1]!=TOOL_HIGHLIGHTER)
2757 ui.ruler[1] = FALSE;
2762 on_button3Pen_activate (GtkMenuItem *menuitem,
2765 process_mapping_activate(menuitem, 2, TOOL_PEN);
2770 on_button3Eraser_activate (GtkMenuItem *menuitem,
2773 process_mapping_activate(menuitem, 2, TOOL_ERASER);
2778 on_button3Highlighter_activate (GtkMenuItem *menuitem,
2781 process_mapping_activate(menuitem, 2, TOOL_HIGHLIGHTER);
2786 on_button3Text_activate (GtkMenuItem *menuitem,
2794 on_button3SelectRegion_activate (GtkMenuItem *menuitem,
2797 process_mapping_activate(menuitem, 2, TOOL_SELECTREGION);
2802 on_button3SelectRectangle_activate (GtkMenuItem *menuitem,
2805 process_mapping_activate(menuitem, 2, TOOL_SELECTRECT);
2810 on_button3VerticalSpace_activate (GtkMenuItem *menuitem,
2813 process_mapping_activate(menuitem, 2, TOOL_VERTSPACE);
2818 on_button3LinkBrush_activate (GtkMenuItem *menuitem,
2823 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem))) return;
2824 ui.linked_brush[2] = BRUSH_LINKED;
2825 for (i=0;i<NUM_STROKE_TOOLS;i++) update_mapping_linkings(i);
2830 on_button3CopyBrush_activate (GtkMenuItem *menuitem,
2833 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem))) return;
2834 if (ui.toolno[2] >= NUM_STROKE_TOOLS) {
2835 ui.linked_brush[2] = BRUSH_STATIC;
2836 update_mappings_menu_linkings();
2839 ui.linked_brush[2] = BRUSH_COPIED;
2840 g_memmove(&(ui.brushes[2][ui.toolno[2]]), &(ui.brushes[0][ui.toolno[2]]), sizeof(struct Brush));
2841 ui.ruler[2] = ui.ruler[0];
2842 if (ui.toolno[2]!=TOOL_PEN && ui.toolno[2]!=TOOL_HIGHLIGHTER)
2843 ui.ruler[2] = FALSE;
2846 // the set zoom dialog
2848 GtkWidget *zoom_dialog;
2849 double zoom_percent;
2852 on_viewSetZoom_activate (GtkMenuItem *menuitem,
2856 double test_w, test_h;
2857 GtkSpinButton *spinZoom;
2859 zoom_dialog = create_zoomDialog();
2860 zoom_percent = 100*ui.zoom / DEFAULT_ZOOM;
2861 spinZoom = GTK_SPIN_BUTTON(g_object_get_data(G_OBJECT(zoom_dialog), "spinZoom"));
2862 gtk_spin_button_set_increments(spinZoom, ui.zoom_step_increment, 5*ui.zoom_step_increment);
2863 gtk_spin_button_set_value(spinZoom, zoom_percent);
2864 test_w = 100*(GTK_WIDGET(canvas))->allocation.width/ui.cur_page->width/DEFAULT_ZOOM;
2865 test_h = 100*(GTK_WIDGET(canvas))->allocation.height/ui.cur_page->height/DEFAULT_ZOOM;
2866 if (zoom_percent > 99.9 && zoom_percent < 100.1)
2867 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_object_get_data(
2868 G_OBJECT(zoom_dialog), "radioZoom100")), TRUE);
2869 else if (zoom_percent > test_w-0.1 && zoom_percent < test_w+0.1)
2870 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_object_get_data(
2871 G_OBJECT(zoom_dialog), "radioZoomWidth")), TRUE);
2872 else if (zoom_percent > test_h-0.1 && zoom_percent < test_h+0.1)
2873 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_object_get_data(
2874 G_OBJECT(zoom_dialog), "radioZoomHeight")), TRUE);
2875 else gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_object_get_data(
2876 G_OBJECT(zoom_dialog), "radioZoom")), TRUE);
2877 gtk_widget_show(zoom_dialog);
2880 response = gtk_dialog_run(GTK_DIALOG(zoom_dialog));
2881 if (response == GTK_RESPONSE_OK || response == GTK_RESPONSE_APPLY) {
2882 ui.zoom = DEFAULT_ZOOM*zoom_percent/100;
2883 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
2884 rescale_bg_pixmaps();
2886 } while (response == GTK_RESPONSE_APPLY);
2888 gtk_widget_destroy(zoom_dialog);
2893 on_spinZoom_value_changed (GtkSpinButton *spinbutton,
2898 val = gtk_spin_button_get_value(GTK_SPIN_BUTTON(g_object_get_data(
2899 G_OBJECT(zoom_dialog), "spinZoom")));
2901 if (val<10) val=10.;
2902 if (val>1500) val=1500.;
2903 if (val<zoom_percent-1 || val>zoom_percent+1)
2904 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_object_get_data(
2905 G_OBJECT(zoom_dialog), "radioZoom")), TRUE);
2911 on_radioZoom_toggled (GtkToggleButton *togglebutton,
2919 on_radioZoom100_toggled (GtkToggleButton *togglebutton,
2922 if (!gtk_toggle_button_get_active(togglebutton)) return;
2923 zoom_percent = 100.;
2924 gtk_spin_button_set_value(GTK_SPIN_BUTTON(g_object_get_data(
2925 G_OBJECT(zoom_dialog), "spinZoom")), zoom_percent);
2930 on_radioZoomWidth_toggled (GtkToggleButton *togglebutton,
2933 if (!gtk_toggle_button_get_active(togglebutton)) return;
2934 zoom_percent = 100*(GTK_WIDGET(canvas))->allocation.width/ui.cur_page->width/DEFAULT_ZOOM;
2935 gtk_spin_button_set_value(GTK_SPIN_BUTTON(g_object_get_data(
2936 G_OBJECT(zoom_dialog), "spinZoom")), zoom_percent);
2941 on_radioZoomHeight_toggled (GtkToggleButton *togglebutton,
2944 if (!gtk_toggle_button_get_active(togglebutton)) return;
2945 zoom_percent = 100*(GTK_WIDGET(canvas))->allocation.height/ui.cur_page->height/DEFAULT_ZOOM;
2946 gtk_spin_button_set_value(GTK_SPIN_BUTTON(g_object_get_data(
2947 G_OBJECT(zoom_dialog), "spinZoom")), zoom_percent);
2952 on_toolsHand_activate (GtkMenuItem *menuitem,
2955 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
2956 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
2959 if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
2963 if (ui.cur_mapping != 0) return;
2964 if (ui.toolno[0] == TOOL_HAND) return;
2967 ui.toolno[0] = TOOL_HAND;
2968 ui.ruler[0] = FALSE;
2969 update_mapping_linkings(-1);
2970 update_tool_buttons();
2972 update_color_menu();
2978 on_button2Hand_activate (GtkMenuItem *menuitem,
2981 process_mapping_activate(menuitem, 1, TOOL_HAND);
2986 on_button3Hand_activate (GtkMenuItem *menuitem,
2989 process_mapping_activate(menuitem, 2, TOOL_HAND);
2994 on_optionsPrintRuling_activate (GtkMenuItem *menuitem,
2997 ui.print_ruling = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
3001 on_optionsDiscardCore_activate (GtkMenuItem *menuitem,
3004 ui.discard_corepointer =
3005 gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
3006 update_mappings_menu();