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 = DEFAULT_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 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);
65 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
66 gtk_widget_destroy(dialog);
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;
74 gtk_widget_destroy(dialog);
76 set_cursor_busy(TRUE);
77 ui.saved = TRUE; // force close_journal to work
79 while (bgpdf.status != STATUS_NOT_INIT) {
80 // waiting for pdf processes to finish dying
84 ui.zoom = DEFAULT_ZOOM;
85 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
87 success = init_bgpdf(filename, TRUE, file_domain);
88 set_cursor_busy(FALSE);
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);
104 on_fileOpen_activate (GtkMenuItem *menuitem,
108 GtkFileFilter *filt_all, *filt_xoj;
112 if (!ok_to_close()) return; // user aborted on save confirmation
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_OK, NULL);
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);
127 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
128 gtk_widget_destroy(dialog);
131 filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
132 gtk_widget_destroy(dialog);
134 set_cursor_busy(TRUE);
135 success = open_journal(filename);
136 set_cursor_busy(FALSE);
137 if (success) { g_free(filename); return; }
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);
150 on_fileSave_activate (GtkMenuItem *menuitem,
155 if (ui.filename == NULL) {
156 on_fileSaveAs_activate(menuitem, user_data);
159 set_cursor_busy(TRUE);
160 if (save_journal(ui.filename)) { // success
161 set_cursor_busy(FALSE);
165 set_cursor_busy(FALSE);
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);
175 on_fileSaveAs_activate (GtkMenuItem *menuitem,
178 GtkWidget *dialog, *warning_dialog;
179 GtkFileFilter *filt_all, *filt_xoj;
184 struct stat stat_buf;
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_OK, NULL);
190 if (ui.filename!=NULL) {
191 gtk_file_chooser_set_filename(GTK_FILE_CHOOSER (dialog), ui.filename);
192 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), g_basename(ui.filename));
195 if (bgpdf.status!=STATUS_NOT_INIT && bgpdf.file_domain == DOMAIN_ABSOLUTE
196 && bgpdf.filename != NULL) {
197 filename = g_strdup_printf("%s.xoj", bgpdf.filename->s);
198 gtk_file_chooser_set_filename(GTK_FILE_CHOOSER (dialog), filename);
199 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), g_basename(filename));
203 curtime = time(NULL);
204 strftime(stime, 30, "%F-Note-%H-%M.xoj", localtime(&curtime));
205 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), stime);
208 filt_all = gtk_file_filter_new();
209 gtk_file_filter_set_name(filt_all, "All files");
210 gtk_file_filter_add_pattern(filt_all, "*");
211 filt_xoj = gtk_file_filter_new();
212 gtk_file_filter_set_name(filt_xoj, "Xournal files");
213 gtk_file_filter_add_pattern(filt_xoj, "*.xoj");
214 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_xoj);
215 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_all);
217 // somehow this doesn't seem to be set by default
218 gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
221 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
222 gtk_widget_destroy(dialog);
225 filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
226 warn = g_file_test (filename, G_FILE_TEST_EXISTS);
227 if (warn) { // ok to overwrite an empty file
228 if (!g_stat(filename, &stat_buf))
229 if (stat_buf.st_size == 0) warn=FALSE;
231 if (warn && ui.filename!=NULL) { // ok to overwrite oneself
232 if (ui.filename[0]=='/' && !strcmp(ui.filename, filename)) warn=FALSE;
233 if (ui.filename[0]!='/' && g_str_has_suffix(filename, ui.filename)) warn=FALSE;
236 warning_dialog = gtk_message_dialog_new(GTK_WINDOW(winMain),
237 GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO,
238 "Should the file %s be overwritten?", filename);
239 if (gtk_dialog_run(GTK_DIALOG(warning_dialog)) == GTK_RESPONSE_YES)
241 gtk_widget_destroy(warning_dialog);
245 gtk_widget_destroy(dialog);
247 set_cursor_busy(TRUE);
248 if (save_journal(filename)) { // success
250 set_cursor_busy(FALSE);
251 update_file_name(filename);
254 set_cursor_busy(FALSE);
256 dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
257 GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Error saving file '%s'", filename);
258 gtk_dialog_run(GTK_DIALOG(dialog));
259 gtk_widget_destroy(dialog);
265 on_filePrintOptions_activate (GtkMenuItem *menuitem,
273 on_filePrint_activate (GtkMenuItem *menuitem,
276 GtkWidget *printDialog, *preview;
278 int fromPage, toPage;
282 GnomePrintConfig *config = gnome_print_config_default();
284 if (ui.filename!=NULL) {
285 if (g_str_has_suffix(ui.filename, ".xoj")) {
286 in_fn = g_strdup(ui.filename);
287 g_strlcpy(g_strrstr(in_fn, "xoj"), "pdf", 4);
290 in_fn = g_strdup_printf("%s.pdf", ui.filename);
291 gnome_print_config_set(config, (guchar *)"Printer", (guchar *)"PDF");
292 gnome_print_config_set(config, (guchar *)GNOME_PRINT_KEY_OUTPUT_FILENAME, (guchar *)in_fn);
293 gnome_print_config_set(config, (guchar *)"Settings.Transport.Backend.FileName", (guchar *)in_fn);
294 g_strlcpy(g_strrstr(in_fn, "pdf"), "ps", 3);
295 gnome_print_config_set(config, (guchar *)"Printer", (guchar *)"GENERIC");
296 gnome_print_config_set (config, (guchar *)GNOME_PRINT_KEY_OUTPUT_FILENAME, (guchar *)in_fn);
297 s = gnome_print_config_get(config, (guchar *)"Settings.Transport.Backend.FileName");
300 gnome_print_config_set(config, (guchar *)"Settings.Transport.Backend.FileName", (guchar *)in_fn);
305 gpj = gnome_print_job_new(config); /* was NULL */
306 gnome_print_config_unref(config);
308 printDialog = gnome_print_dialog_new(gpj, (guchar *)"Print", GNOME_PRINT_DIALOG_RANGE);
309 gnome_print_dialog_construct_range_page(GNOME_PRINT_DIALOG(printDialog),
310 GNOME_PRINT_RANGE_ALL | GNOME_PRINT_RANGE_RANGE,
311 1, journal.npages, (guchar *)"Current page", (guchar *)"Pages");
312 /* don't have "Current page" as option, else it becomes the default!! */
314 gtk_dialog_set_response_sensitive(GTK_DIALOG(printDialog),
315 GNOME_PRINT_DIALOG_RESPONSE_PREVIEW, FALSE);
316 /* the print-job-preview "feature" is completely, hopelessly broken */
318 response = gtk_dialog_run(GTK_DIALOG(printDialog));
320 gtk_widget_destroy(printDialog);
325 if (response == GNOME_PRINT_DIALOG_RESPONSE_PREVIEW) {
326 print_job_render(gpj, 0, journal.npages-1);
327 gtk_widget_destroy(printDialog);
328 preview = gnome_print_job_preview_new(gpj, (guchar *)"Preview");
329 try_fix_print_preview_ui(preview);
330 gtk_window_set_modal(GTK_WINDOW(preview), TRUE);
331 gtk_widget_show_all(preview);
335 if (response == GNOME_PRINT_DIALOG_RESPONSE_PRINT) {
336 switch(gnome_print_dialog_get_range(GNOME_PRINT_DIALOG(printDialog))) {
337 case GNOME_PRINT_RANGE_RANGE:
338 gnome_print_dialog_get_range_page(GNOME_PRINT_DIALOG(printDialog), &fromPage, &toPage);
344 toPage = journal.npages-1;
347 gtk_widget_destroy(printDialog);
348 print_job_render(gpj, fromPage, toPage);
354 on_filePrintPDF_activate (GtkMenuItem *menuitem,
358 GtkWidget *dialog, *warning_dialog;
359 GtkFileFilter *filt_all, *filt_pdf;
360 char *filename, *in_fn;
366 dialog = gtk_file_chooser_dialog_new("Export to PDF", GTK_WINDOW (winMain),
367 GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
368 GTK_STOCK_SAVE, GTK_RESPONSE_OK, NULL);
370 if (ui.filename!=NULL) {
371 if (g_str_has_suffix(ui.filename, ".xoj")) {
372 in_fn = g_strdup(ui.filename);
373 g_strlcpy(g_strrstr(in_fn, "xoj"), "pdf", 4);
376 in_fn = g_strdup_printf("%s.pdf", ui.filename);
377 gtk_file_chooser_set_filename(GTK_FILE_CHOOSER (dialog), in_fn);
378 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), g_basename(in_fn));
380 curtime = time(NULL);
381 strftime(stime, 30, "%F-Note-%H-%M.pdf", localtime(&curtime));
382 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), stime);
386 filt_all = gtk_file_filter_new();
387 gtk_file_filter_set_name(filt_all, "All files");
388 gtk_file_filter_add_pattern(filt_all, "*");
389 filt_pdf = gtk_file_filter_new();
390 gtk_file_filter_set_name(filt_pdf, "PDF files");
391 gtk_file_filter_add_pattern(filt_pdf, "*.pdf");
392 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_pdf);
393 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_all);
394 gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
398 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
399 gtk_widget_destroy(dialog);
402 filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
403 warn = g_file_test(filename, G_FILE_TEST_EXISTS);
405 warning_dialog = gtk_message_dialog_new(GTK_WINDOW(winMain),
406 GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO,
407 "Should the file %s be overwritten?", filename);
408 if (gtk_dialog_run(GTK_DIALOG(warning_dialog)) == GTK_RESPONSE_YES)
410 gtk_widget_destroy(warning_dialog);
414 gtk_widget_destroy(dialog);
416 set_cursor_busy(TRUE);
417 if (!print_to_pdf(filename)) {
418 set_cursor_busy(FALSE);
419 dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
420 GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Error creating file '%s'", filename);
421 gtk_dialog_run(GTK_DIALOG(dialog));
422 gtk_widget_destroy(dialog);
424 set_cursor_busy(FALSE);
430 on_fileQuit_activate (GtkMenuItem *menuitem,
433 if (ok_to_close()) gtk_main_quit ();
438 on_editUndo_activate (GtkMenuItem *menuitem,
442 GList *list, *itemlist;
443 struct UndoErasureData *erasure;
445 struct Brush tmp_brush;
446 struct Background *tmp_bg;
449 if (undo == NULL) return; // nothing to undo!
450 reset_selection(); // safer
451 if (undo->type == ITEM_STROKE) {
452 // we're keeping the stroke info, but deleting the canvas item
453 gtk_object_destroy(GTK_OBJECT(undo->item->canvas_item));
454 undo->item->canvas_item = NULL;
455 // we also remove the object from its layer!
456 undo->layer->items = g_list_remove(undo->layer->items, undo->item);
457 undo->layer->nitems--;
459 else if (undo->type == ITEM_ERASURE) {
460 for (list = undo->erasurelist; list!=NULL; list = list->next) {
461 erasure = (struct UndoErasureData *)list->data;
462 // delete all the created items
463 for (itemlist = erasure->replacement_items; itemlist!=NULL; itemlist = itemlist->next) {
464 it = (struct Item *)itemlist->data;
465 gtk_object_destroy(GTK_OBJECT(it->canvas_item));
466 it->canvas_item = NULL;
467 undo->layer->items = g_list_remove(undo->layer->items, it);
468 undo->layer->nitems--;
470 // recreate the deleted one
471 erasure->item->canvas_item = gnome_canvas_item_new(undo->layer->group,
472 gnome_canvas_line_get_type(), "points", erasure->item->path,
473 "cap-style", GDK_CAP_ROUND, "join-style", GDK_JOIN_ROUND,
474 "fill-color-rgba", erasure->item->brush.color_rgba,
475 "width-units", erasure->item->brush.thickness, NULL);
476 undo->layer->items = g_list_insert(undo->layer->items, erasure->item,
478 if (erasure->npos == 0)
479 lower_canvas_item_to(undo->layer->group, erasure->item->canvas_item, NULL);
481 lower_canvas_item_to(undo->layer->group, erasure->item->canvas_item,
482 ((struct Item *)g_list_nth_data(undo->layer->items, erasure->npos-1))->canvas_item);
483 undo->layer->nitems++;
486 else if (undo->type == ITEM_NEW_BG_ONE || undo->type == ITEM_NEW_BG_RESIZE
487 || undo->type == ITEM_PAPER_RESIZE) {
488 if (undo->type != ITEM_PAPER_RESIZE) {
490 tmp_bg = undo->page->bg;
491 undo->page->bg = undo->bg;
493 undo->page->bg->canvas_item = undo->bg->canvas_item;
494 undo->bg->canvas_item = NULL;
496 if (undo->type != ITEM_NEW_BG_ONE) {
497 tmp_x = undo->page->width;
498 tmp_y = undo->page->height;
499 undo->page->width = undo->val_x;
500 undo->page->height = undo->val_y;
503 make_page_clipbox(undo->page);
505 update_canvas_bg(undo->page);
506 do_switch_page(g_list_index(journal.pages, undo->page), TRUE, TRUE);
508 else if (undo->type == ITEM_NEW_DEFAULT_BG) {
509 tmp_bg = ui.default_page.bg;
510 ui.default_page.bg = undo->bg;
512 tmp_x = ui.default_page.width;
513 tmp_y = ui.default_page.height;
514 ui.default_page.width = undo->val_x;
515 ui.default_page.height = undo->val_y;
519 else if (undo->type == ITEM_NEW_PAGE) {
520 // unmap the page; keep the page & its empty layer in memory
521 if (undo->page->group!=NULL) gtk_object_destroy(GTK_OBJECT(undo->page->group));
522 // also destroys the background and layer's canvas items
523 undo->page->group = NULL;
524 undo->page->bg->canvas_item = NULL;
525 journal.pages = g_list_remove(journal.pages, undo->page);
527 if (ui.cur_page == undo->page) ui.cur_page = NULL;
528 // so do_switch_page() won't try to remap the layers of the defunct page
529 if (ui.pageno >= undo->val) ui.pageno--;
530 if (ui.pageno < 0) ui.pageno = 0;
531 do_switch_page(ui.pageno, TRUE, TRUE);
533 else if (undo->type == ITEM_DELETE_PAGE) {
534 journal.pages = g_list_insert(journal.pages, undo->page, undo->val);
536 make_canvas_items(); // re-create the canvas items
537 do_switch_page(undo->val, TRUE, TRUE);
539 else if (undo->type == ITEM_MOVESEL) {
540 for (itemlist = undo->itemlist; itemlist != NULL; itemlist = itemlist->next) {
541 it = (struct Item *)itemlist->data;
542 if (it->canvas_item != NULL) {
543 if (undo->layer != undo->layer2)
544 gnome_canvas_item_reparent(it->canvas_item, undo->layer->group);
545 gnome_canvas_item_move(it->canvas_item, -undo->val_x, -undo->val_y);
548 move_journal_items_by(undo->itemlist, -undo->val_x, -undo->val_y,
549 undo->layer2, undo->layer, undo->auxlist);
551 else if (undo->type == ITEM_PASTE) {
552 for (itemlist = undo->itemlist; itemlist != NULL; itemlist = itemlist->next) {
553 it = (struct Item *)itemlist->data;
554 gtk_object_destroy(GTK_OBJECT(it->canvas_item));
555 it->canvas_item = NULL;
556 undo->layer->items = g_list_remove(undo->layer->items, it);
557 undo->layer->nitems--;
560 else if (undo->type == ITEM_NEW_LAYER) {
561 // unmap the layer; keep the empty layer in memory
562 if (undo->layer->group!=NULL) gtk_object_destroy(GTK_OBJECT(undo->layer->group));
563 undo->layer->group = NULL;
564 undo->page->layers = g_list_remove(undo->page->layers, undo->layer);
565 undo->page->nlayers--;
566 do_switch_page(ui.pageno, FALSE, FALSE); // don't stay with bad cur_layer info
568 else if (undo->type == ITEM_DELETE_LAYER) {
569 // special case of -1: deleted the last layer, created a new one
570 if (undo->val == -1) {
571 if (undo->layer2->group!=NULL) gtk_object_destroy(GTK_OBJECT(undo->layer2->group));
572 undo->layer2->group = NULL;
573 undo->page->layers = g_list_remove(undo->page->layers, undo->layer2);
574 undo->page->nlayers--;
577 undo->layer->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
578 undo->page->group, gnome_canvas_group_get_type(), NULL);
579 lower_canvas_item_to(undo->page->group, GNOME_CANVAS_ITEM(undo->layer->group),
580 (undo->val >= 1) ? GNOME_CANVAS_ITEM(((struct Layer *)
581 g_list_nth_data(undo->page->layers, undo->val-1))->group) :
582 undo->page->bg->canvas_item);
583 undo->page->layers = g_list_insert(undo->page->layers, undo->layer,
584 (undo->val >= 0) ? undo->val:0);
585 undo->page->nlayers++;
587 for (itemlist = undo->layer->items; itemlist!=NULL; itemlist = itemlist->next) {
588 it = (struct Item *)itemlist->data;
589 if (it->type == ITEM_STROKE) {
590 it->canvas_item = gnome_canvas_item_new(undo->layer->group,
591 gnome_canvas_line_get_type(), "points", it->path,
592 "cap-style", GDK_CAP_ROUND, "join-style", GDK_JOIN_ROUND,
593 "fill-color-rgba", it->brush.color_rgba,
594 "width-units", it->brush.thickness, NULL);
597 do_switch_page(ui.pageno, FALSE, FALSE); // show the restored layer & others...
599 else if (undo->type == ITEM_REPAINTSEL) {
600 for (itemlist = undo->itemlist, list = undo->auxlist; itemlist!=NULL;
601 itemlist = itemlist->next, list = list->next) {
602 it = (struct Item *)itemlist->data;
603 g_memmove(&tmp_brush, &(it->brush), sizeof(struct Brush));
604 g_memmove(&(it->brush), list->data, sizeof(struct Brush));
605 g_memmove(list->data, &tmp_brush, sizeof(struct Brush));
606 if (it->type == ITEM_STROKE && it->canvas_item != NULL)
607 gnome_canvas_item_set(it->canvas_item,
608 "fill-color-rgba", it->brush.color_rgba,
609 "width-units", it->brush.thickness, NULL);
613 // move item from undo to redo stack
619 update_undo_redo_enabled();
620 if (u->multiop & MULTIOP_CONT_UNDO) on_editUndo_activate(NULL,NULL); // loop
625 on_editRedo_activate (GtkMenuItem *menuitem,
629 GList *list, *itemlist, *target;
630 struct UndoErasureData *erasure;
632 struct Brush tmp_brush;
633 struct Background *tmp_bg;
637 if (redo == NULL) return; // nothing to redo!
638 reset_selection(); // safer
639 if (redo->type == ITEM_STROKE) {
640 // re-create the canvas_item
641 redo->item->canvas_item = gnome_canvas_item_new(redo->layer->group,
642 gnome_canvas_line_get_type(), "points", redo->item->path,
643 "cap-style", GDK_CAP_ROUND, "join-style", GDK_JOIN_ROUND,
644 "fill-color-rgba", redo->item->brush.color_rgba,
645 "width-units", redo->item->brush.thickness, NULL);
646 // reinsert the item on its layer
647 redo->layer->items = g_list_append(redo->layer->items, redo->item);
648 redo->layer->nitems++;
650 else if (redo->type == ITEM_ERASURE) {
651 for (list = redo->erasurelist; list!=NULL; list = list->next) {
652 erasure = (struct UndoErasureData *)list->data;
653 target = g_list_find(redo->layer->items, erasure->item);
654 // re-create all the created items
655 for (itemlist = erasure->replacement_items; itemlist!=NULL; itemlist = itemlist->next) {
656 it = (struct Item *)itemlist->data;
657 it->canvas_item = gnome_canvas_item_new(redo->layer->group,
658 gnome_canvas_line_get_type(), "points", it->path,
659 "cap-style", GDK_CAP_ROUND, "join-style", GDK_JOIN_ROUND,
660 "fill-color-rgba", it->brush.color_rgba,
661 "width-units", it->brush.thickness, NULL);
662 redo->layer->items = g_list_insert_before(redo->layer->items, target, it);
663 redo->layer->nitems++;
664 lower_canvas_item_to(redo->layer->group, it->canvas_item, erasure->item->canvas_item);
666 // re-delete the deleted one
667 gtk_object_destroy(GTK_OBJECT(erasure->item->canvas_item));
668 erasure->item->canvas_item = NULL;
669 redo->layer->items = g_list_delete_link(redo->layer->items, target);
670 redo->layer->nitems--;
673 else if (redo->type == ITEM_NEW_BG_ONE || redo->type == ITEM_NEW_BG_RESIZE
674 || redo->type == ITEM_PAPER_RESIZE) {
675 if (redo->type != ITEM_PAPER_RESIZE) {
677 tmp_bg = redo->page->bg;
678 redo->page->bg = redo->bg;
680 redo->page->bg->canvas_item = redo->bg->canvas_item;
681 redo->bg->canvas_item = NULL;
683 if (redo->type != ITEM_NEW_BG_ONE) {
684 tmp_x = redo->page->width;
685 tmp_y = redo->page->height;
686 redo->page->width = redo->val_x;
687 redo->page->height = redo->val_y;
690 make_page_clipbox(redo->page);
692 update_canvas_bg(redo->page);
693 do_switch_page(g_list_index(journal.pages, redo->page), TRUE, TRUE);
695 else if (redo->type == ITEM_NEW_DEFAULT_BG) {
696 tmp_bg = ui.default_page.bg;
697 ui.default_page.bg = redo->bg;
699 tmp_x = ui.default_page.width;
700 tmp_y = ui.default_page.height;
701 ui.default_page.width = redo->val_x;
702 ui.default_page.height = redo->val_y;
706 else if (redo->type == ITEM_NEW_PAGE) {
708 redo->page->bg->canvas_item = NULL;
709 redo->page->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
710 gnome_canvas_root(canvas), gnome_canvas_clipgroup_get_type(), NULL);
711 make_page_clipbox(redo->page);
712 update_canvas_bg(redo->page);
713 l = (struct Layer *)redo->page->layers->data;
714 l->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
715 redo->page->group, gnome_canvas_group_get_type(), NULL);
717 journal.pages = g_list_insert(journal.pages, redo->page, redo->val);
719 do_switch_page(redo->val, TRUE, TRUE);
721 else if (redo->type == ITEM_DELETE_PAGE) {
722 // unmap all the canvas items
723 gtk_object_destroy(GTK_OBJECT(redo->page->group));
724 redo->page->group = NULL;
725 redo->page->bg->canvas_item = NULL;
726 for (list = redo->page->layers; list!=NULL; list = list->next) {
727 l = (struct Layer *)list->data;
728 for (itemlist = l->items; itemlist!=NULL; itemlist = itemlist->next)
729 ((struct Item *)itemlist->data)->canvas_item = NULL;
732 journal.pages = g_list_remove(journal.pages, redo->page);
734 if (ui.pageno > undo->val || ui.pageno == journal.npages) ui.pageno--;
736 // so do_switch_page() won't try to remap the layers of the defunct page
737 do_switch_page(ui.pageno, TRUE, TRUE);
739 else if (redo->type == ITEM_MOVESEL) {
740 for (itemlist = redo->itemlist; itemlist != NULL; itemlist = itemlist->next) {
741 it = (struct Item *)itemlist->data;
742 if (it->canvas_item != NULL) {
743 if (redo->layer != redo->layer2)
744 gnome_canvas_item_reparent(it->canvas_item, redo->layer2->group);
745 gnome_canvas_item_move(it->canvas_item, redo->val_x, redo->val_y);
748 move_journal_items_by(redo->itemlist, redo->val_x, redo->val_y,
749 redo->layer, redo->layer2, NULL);
751 else if (redo->type == ITEM_PASTE) {
752 for (itemlist = redo->itemlist; itemlist != NULL; itemlist = itemlist->next) {
753 it = (struct Item *)itemlist->data;
754 it->canvas_item = gnome_canvas_item_new(redo->layer->group,
755 gnome_canvas_line_get_type(), "points", it->path,
756 "cap-style", GDK_CAP_ROUND, "join-style", GDK_JOIN_ROUND,
757 "fill-color-rgba", it->brush.color_rgba,
758 "width-units", it->brush.thickness, NULL);
759 redo->layer->items = g_list_append(redo->layer->items, it);
760 redo->layer->nitems++;
763 else if (redo->type == ITEM_NEW_LAYER) {
764 redo->layer->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
765 redo->page->group, gnome_canvas_group_get_type(), NULL);
766 lower_canvas_item_to(redo->page->group, GNOME_CANVAS_ITEM(redo->layer->group),
767 (redo->val >= 1) ? GNOME_CANVAS_ITEM(((struct Layer *)
768 g_list_nth_data(redo->page->layers, redo->val-1))->group) :
769 redo->page->bg->canvas_item);
770 redo->page->layers = g_list_insert(redo->page->layers, redo->layer, redo->val);
771 redo->page->nlayers++;
772 do_switch_page(ui.pageno, FALSE, FALSE);
774 else if (redo->type == ITEM_DELETE_LAYER) {
775 gtk_object_destroy(GTK_OBJECT(redo->layer->group));
776 redo->layer->group = NULL;
777 for (list=redo->layer->items; list!=NULL; list=list->next)
778 ((struct Item *)list->data)->canvas_item = NULL;
779 redo->page->layers = g_list_remove(redo->page->layers, redo->layer);
780 redo->page->nlayers--;
781 if (redo->val == -1) {
782 redo->layer2->group = (GnomeCanvasGroup *)gnome_canvas_item_new(
783 redo->page->group, gnome_canvas_group_get_type(), NULL);
784 redo->page->layers = g_list_append(redo->page->layers, redo->layer2);
785 redo->page->nlayers++;
787 do_switch_page(ui.pageno, FALSE, FALSE);
789 else if (redo->type == ITEM_REPAINTSEL) {
790 for (itemlist = redo->itemlist, list = redo->auxlist; itemlist!=NULL;
791 itemlist = itemlist->next, list = list->next) {
792 it = (struct Item *)itemlist->data;
793 g_memmove(&tmp_brush, &(it->brush), sizeof(struct Brush));
794 g_memmove(&(it->brush), list->data, sizeof(struct Brush));
795 g_memmove(list->data, &tmp_brush, sizeof(struct Brush));
796 if (it->type == ITEM_STROKE && it->canvas_item != NULL)
797 gnome_canvas_item_set(it->canvas_item,
798 "fill-color-rgba", it->brush.color_rgba,
799 "width-units", it->brush.thickness, NULL);
803 // move item from redo to undo stack
809 update_undo_redo_enabled();
810 if (u->multiop & MULTIOP_CONT_REDO) on_editRedo_activate(NULL,NULL); // loop
815 on_editCut_activate (GtkMenuItem *menuitem,
824 on_editCopy_activate (GtkMenuItem *menuitem,
832 on_editPaste_activate (GtkMenuItem *menuitem,
840 on_editDelete_activate (GtkMenuItem *menuitem,
848 on_viewContinuous_activate (GtkMenuItem *menuitem,
851 GtkAdjustment *v_adj;
855 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
856 if (ui.view_continuous) return;
857 ui.view_continuous = TRUE;
858 v_adj = gtk_layout_get_vadjustment(GTK_LAYOUT(canvas));
860 yscroll = gtk_adjustment_get_value(v_adj) - pg->voffset*ui.zoom;
862 gtk_adjustment_set_value(v_adj, yscroll + pg->voffset*ui.zoom);
864 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
869 on_viewOnePage_activate (GtkMenuItem *menuitem,
872 GtkAdjustment *v_adj;
875 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
876 if (!ui.view_continuous) return;
877 ui.view_continuous = FALSE;
878 v_adj = gtk_layout_get_vadjustment(GTK_LAYOUT(canvas));
879 yscroll = gtk_adjustment_get_value(v_adj) - ui.cur_page->voffset*ui.zoom;
881 gtk_adjustment_set_value(v_adj, yscroll + ui.cur_page->voffset*ui.zoom);
883 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
888 on_viewZoomIn_activate (GtkMenuItem *menuitem,
891 if (ui.zoom > MAX_ZOOM) return;
892 ui.zoom *= ui.zoom_step_factor;
893 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
894 rescale_bg_pixmaps();
899 on_viewZoomOut_activate (GtkMenuItem *menuitem,
902 if (ui.zoom < MIN_ZOOM) return;
903 ui.zoom /= ui.zoom_step_factor;
904 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
905 rescale_bg_pixmaps();
910 on_viewNormalSize_activate (GtkMenuItem *menuitem,
913 ui.zoom = DEFAULT_ZOOM;
914 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
915 rescale_bg_pixmaps();
920 on_viewPageWidth_activate (GtkMenuItem *menuitem,
923 ui.zoom = (GTK_WIDGET(canvas))->allocation.width/ui.cur_page->width;
924 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
925 rescale_bg_pixmaps();
930 on_viewFirstPage_activate (GtkMenuItem *menuitem,
933 do_switch_page(0, TRUE, FALSE);
938 on_viewPreviousPage_activate (GtkMenuItem *menuitem,
941 if (ui.pageno == 0) return;
942 do_switch_page(ui.pageno-1, TRUE, FALSE);
947 on_viewNextPage_activate (GtkMenuItem *menuitem,
950 if (ui.pageno == journal.npages-1) { // create a page at end
951 if (page_ops_forbidden()) return;
952 on_journalNewPageEnd_activate(menuitem, user_data);
955 do_switch_page(ui.pageno+1, TRUE, FALSE);
960 on_viewLastPage_activate (GtkMenuItem *menuitem,
963 do_switch_page(journal.npages-1, TRUE, FALSE);
968 on_viewShowLayer_activate (GtkMenuItem *menuitem,
971 if (ui.layerno == ui.cur_page->nlayers-1) return;
974 ui.cur_layer = g_list_nth_data(ui.cur_page->layers, ui.layerno);
975 gnome_canvas_item_show(GNOME_CANVAS_ITEM(ui.cur_layer->group));
981 on_viewHideLayer_activate (GtkMenuItem *menuitem,
984 if (ui.layerno == -1) return;
986 gnome_canvas_item_hide(GNOME_CANVAS_ITEM(ui.cur_layer->group));
988 if (ui.layerno<0) ui.cur_layer = NULL;
989 else ui.cur_layer = g_list_nth_data(ui.cur_page->layers, ui.layerno);
995 on_journalNewPageBefore_activate (GtkMenuItem *menuitem,
1000 if (page_ops_forbidden()) return;
1002 pg = new_page(ui.cur_page);
1003 journal.pages = g_list_insert(journal.pages, pg, ui.pageno);
1005 do_switch_page(ui.pageno, TRUE, TRUE);
1008 undo->type = ITEM_NEW_PAGE;
1009 undo->val = ui.pageno;
1015 on_journalNewPageAfter_activate (GtkMenuItem *menuitem,
1020 if (page_ops_forbidden()) return;
1022 pg = new_page(ui.cur_page);
1023 journal.pages = g_list_insert(journal.pages, pg, ui.pageno+1);
1025 do_switch_page(ui.pageno+1, TRUE, TRUE);
1028 undo->type = ITEM_NEW_PAGE;
1029 undo->val = ui.pageno;
1035 on_journalNewPageEnd_activate (GtkMenuItem *menuitem,
1040 if (page_ops_forbidden()) return;
1042 pg = new_page((struct Page *)g_list_last(journal.pages)->data);
1043 journal.pages = g_list_append(journal.pages, pg);
1045 do_switch_page(journal.npages-1, TRUE, TRUE);
1048 undo->type = ITEM_NEW_PAGE;
1049 undo->val = ui.pageno;
1055 on_journalDeletePage_activate (GtkMenuItem *menuitem,
1058 GList *layerlist, *itemlist;
1061 if (page_ops_forbidden()) return;
1062 if (journal.npages == 1) return;
1065 undo->type = ITEM_DELETE_PAGE;
1066 undo->val = ui.pageno;
1067 undo->page = ui.cur_page;
1069 // unmap all the canvas items
1070 gtk_object_destroy(GTK_OBJECT(ui.cur_page->group));
1071 ui.cur_page->group = NULL;
1072 ui.cur_page->bg->canvas_item = NULL;
1073 for (layerlist = ui.cur_page->layers; layerlist!=NULL; layerlist = layerlist->next) {
1074 l = (struct Layer *)layerlist->data;
1075 for (itemlist = l->items; itemlist!=NULL; itemlist = itemlist->next)
1076 ((struct Item *)itemlist->data)->canvas_item = NULL;
1080 journal.pages = g_list_remove(journal.pages, ui.cur_page);
1082 if (ui.pageno == journal.npages) ui.pageno--;
1084 // so do_switch_page() won't try to remap the layers of the defunct page
1085 do_switch_page(ui.pageno, TRUE, TRUE);
1090 on_journalNewLayer_activate (GtkMenuItem *menuitem,
1096 l = g_new(struct Layer, 1);
1099 l->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
1100 ui.cur_page->group, gnome_canvas_group_get_type(), NULL);
1101 lower_canvas_item_to(ui.cur_page->group, GNOME_CANVAS_ITEM(l->group),
1102 (ui.cur_layer!=NULL)?(GNOME_CANVAS_ITEM(ui.cur_layer->group)):(ui.cur_page->bg->canvas_item));
1103 ui.cur_page->layers = g_list_insert(ui.cur_page->layers, l, ui.layerno+1);
1106 ui.cur_page->nlayers++;
1107 update_page_stuff();
1110 undo->type = ITEM_NEW_LAYER;
1111 undo->val = ui.layerno;
1113 undo->page = ui.cur_page;
1118 on_journalDeleteLayer_activate (GtkMenuItem *menuitem,
1123 if (ui.cur_layer == NULL) return;
1126 undo->type = ITEM_DELETE_LAYER;
1127 undo->val = ui.layerno;
1128 undo->layer = ui.cur_layer;
1129 undo->layer2 = NULL;
1130 undo->page = ui.cur_page;
1131 // delete all the canvas items
1132 gtk_object_destroy(GTK_OBJECT(ui.cur_layer->group));
1133 ui.cur_layer->group = NULL;
1134 for (list=ui.cur_layer->items; list!=NULL; list=list->next)
1135 ((struct Item *)list->data)->canvas_item = NULL;
1137 ui.cur_page->layers = g_list_remove(ui.cur_page->layers, ui.cur_layer);
1139 if (ui.cur_page->nlayers>=2) {
1140 ui.cur_page->nlayers--;
1142 if (ui.layerno<0) ui.cur_layer = NULL;
1143 else ui.cur_layer = (struct Layer *)g_list_nth_data(ui.cur_page->layers, ui.layerno);
1145 else { // special case: can't remove the last layer
1146 ui.cur_layer = g_new(struct Layer, 1);
1147 ui.cur_layer->items = NULL;
1148 ui.cur_layer->nitems = 0;
1149 ui.cur_layer->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
1150 ui.cur_page->group, gnome_canvas_group_get_type(), NULL);
1151 ui.cur_page->layers = g_list_append(NULL, ui.cur_layer);
1153 undo->layer2 = ui.cur_layer;
1156 update_page_stuff();
1161 on_journalFlatten_activate (GtkMenuItem *menuitem,
1168 // the paper sizes dialog
1170 GtkWidget *papersize_dialog;
1171 int papersize_std, papersize_unit;
1172 double papersize_width, papersize_height;
1173 gboolean papersize_need_init, papersize_width_valid, papersize_height_valid;
1175 #define STD_SIZE_A4 0
1176 #define STD_SIZE_A4R 1
1177 #define STD_SIZE_LETTER 2
1178 #define STD_SIZE_LETTER_R 3
1179 #define STD_SIZE_CUSTOM 4
1181 double unit_sizes[4] = {28.346, 72., 72./DISPLAY_DPI_DEFAULT, 1.};
1182 double std_widths[STD_SIZE_CUSTOM] = {595.27, 841.89, 612., 792.};
1183 double std_heights[STD_SIZE_CUSTOM] = {841.89, 595.27, 792., 612.};
1184 double std_units[STD_SIZE_CUSTOM] = {UNIT_CM, UNIT_CM, UNIT_IN, UNIT_IN};
1187 on_journalPaperSize_activate (GtkMenuItem *menuitem,
1194 papersize_dialog = create_papersizeDialog();
1195 papersize_width = ui.cur_page->width;
1196 papersize_height = ui.cur_page->height;
1197 papersize_unit = ui.default_unit;
1198 unit_sizes[UNIT_PX] = 1./DEFAULT_ZOOM;
1199 // if (ui.cur_page->bg->type == BG_PIXMAP) papersize_unit = UNIT_PX;
1200 papersize_std = STD_SIZE_CUSTOM;
1201 for (i=0;i<STD_SIZE_CUSTOM;i++)
1202 if (fabs(papersize_width - std_widths[i])<0.1 &&
1203 fabs(papersize_height - std_heights[i])<0.1)
1204 { papersize_std = i; papersize_unit = std_units[i]; }
1205 papersize_need_init = TRUE;
1206 papersize_width_valid = papersize_height_valid = TRUE;
1208 gtk_widget_show(papersize_dialog);
1209 on_comboStdSizes_changed(GTK_COMBO_BOX(g_object_get_data(
1210 G_OBJECT(papersize_dialog), "comboStdSizes")), NULL);
1211 gtk_dialog_set_default_response(GTK_DIALOG(papersize_dialog), GTK_RESPONSE_OK);
1213 response = gtk_dialog_run(GTK_DIALOG(papersize_dialog));
1214 gtk_widget_destroy(papersize_dialog);
1215 if (response != GTK_RESPONSE_OK) return;
1218 for (pglist = journal.pages; pglist!=NULL; pglist = pglist->next) {
1219 if (ui.bg_apply_all_pages) pg = (struct Page *)pglist->data;
1221 if (ui.bg_apply_all_pages) {
1222 if (pglist->next!=NULL) undo->multiop |= MULTIOP_CONT_REDO;
1223 if (pglist->prev!=NULL) undo->multiop |= MULTIOP_CONT_UNDO;
1225 undo->type = ITEM_PAPER_RESIZE;
1227 undo->val_x = pg->width;
1228 undo->val_y = pg->height;
1229 if (papersize_width_valid) pg->width = papersize_width;
1230 if (papersize_height_valid) pg->height = papersize_height;
1231 make_page_clipbox(pg);
1232 update_canvas_bg(pg);
1233 if (!ui.bg_apply_all_pages) break;
1235 do_switch_page(ui.pageno, TRUE, TRUE);
1240 on_papercolorWhite_activate (GtkMenuItem *menuitem,
1243 process_papercolor_activate(menuitem, COLOR_WHITE);
1248 on_papercolorYellow_activate (GtkMenuItem *menuitem,
1251 process_papercolor_activate(menuitem, COLOR_YELLOW);
1256 on_papercolorPink_activate (GtkMenuItem *menuitem,
1259 process_papercolor_activate(menuitem, COLOR_RED);
1264 on_papercolorOrange_activate (GtkMenuItem *menuitem,
1267 process_papercolor_activate(menuitem, COLOR_ORANGE);
1272 on_papercolorBlue_activate (GtkMenuItem *menuitem,
1275 process_papercolor_activate(menuitem, COLOR_BLUE);
1280 on_papercolorGreen_activate (GtkMenuItem *menuitem,
1283 process_papercolor_activate(menuitem, COLOR_GREEN);
1288 on_papercolorOther_activate (GtkMenuItem *menuitem,
1296 on_paperstylePlain_activate (GtkMenuItem *menuitem,
1299 process_paperstyle_activate(menuitem, RULING_NONE);
1304 on_paperstyleLined_activate (GtkMenuItem *menuitem,
1307 process_paperstyle_activate(menuitem, RULING_LINED);
1312 on_paperstyleRuled_activate (GtkMenuItem *menuitem,
1315 process_paperstyle_activate(menuitem, RULING_RULED);
1320 on_paperstyleGraph_activate (GtkMenuItem *menuitem,
1323 process_paperstyle_activate(menuitem, RULING_GRAPH);
1328 on_journalLoadBackground_activate (GtkMenuItem *menuitem,
1331 GtkWidget *dialog, *attach_opt;
1332 struct Background *bg;
1335 GList *bglist, *bglistiter;
1336 GtkFileFilter *filt_all, *filt_pix, *filt_pspdf;
1340 dialog = gtk_file_chooser_dialog_new("Open Background", GTK_WINDOW (winMain),
1341 GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1342 GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL);
1344 filt_all = gtk_file_filter_new();
1345 gtk_file_filter_set_name(filt_all, "All files");
1346 gtk_file_filter_add_pattern(filt_all, "*");
1347 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_all);
1349 #if GTK_CHECK_VERSION(2,6,0)
1351 if (!gtk_check_version(2, 6, 0)) {
1352 filt_pix = gtk_file_filter_new();
1353 gtk_file_filter_set_name(filt_pix, "Bitmap files");
1354 gtk_file_filter_add_pixbuf_formats(filt_pix);
1355 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_pix);
1360 filt_pspdf = gtk_file_filter_new();
1361 gtk_file_filter_set_name(filt_pspdf, "PS/PDF files (as bitmaps)");
1362 gtk_file_filter_add_pattern(filt_pspdf, "*.ps");
1363 gtk_file_filter_add_pattern(filt_pspdf, "*.pdf");
1364 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_pspdf);
1366 attach_opt = gtk_check_button_new_with_label("Attach file to the journal");
1367 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(attach_opt), FALSE);
1368 gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER (dialog), attach_opt);
1370 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
1371 gtk_widget_destroy(dialog);
1374 filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
1375 attach = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(attach_opt));
1376 gtk_widget_destroy(dialog);
1378 set_cursor_busy(TRUE);
1379 bg = attempt_load_pix_bg(filename, attach);
1380 if (bg != NULL) bglist = g_list_append(NULL, bg);
1381 else bglist = attempt_load_gv_bg(filename);
1382 set_cursor_busy(FALSE);
1384 if (bglist == NULL) {
1385 dialog = gtk_message_dialog_new(GTK_WINDOW(winMain), GTK_DIALOG_MODAL,
1386 GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
1387 "Error opening background '%s'", filename);
1388 gtk_dialog_run(GTK_DIALOG(dialog));
1389 gtk_widget_destroy(dialog);
1398 for (bglistiter = bglist, pageno = ui.pageno;
1399 bglistiter!=NULL; bglistiter = bglistiter->next, pageno++) {
1401 if (bglistiter->next!=NULL) undo->multiop |= MULTIOP_CONT_REDO;
1402 if (bglistiter->prev!=NULL) undo->multiop |= MULTIOP_CONT_UNDO;
1404 bg = (struct Background *)bglistiter->data;
1406 if (pageno == journal.npages) {
1407 undo->type = ITEM_NEW_PAGE;
1408 pg = new_page_with_bg(bg,
1409 gdk_pixbuf_get_width(bg->pixbuf)/bg->pixbuf_scale,
1410 gdk_pixbuf_get_height(bg->pixbuf)/bg->pixbuf_scale);
1411 journal.pages = g_list_append(journal.pages, pg);
1417 pg = g_list_nth_data(journal.pages, pageno);
1418 undo->type = ITEM_NEW_BG_RESIZE;
1421 bg->canvas_item = undo->bg->canvas_item;
1422 undo->bg->canvas_item = NULL;
1423 undo->val_x = pg->width;
1424 undo->val_y = pg->height;
1426 pg->width = gdk_pixbuf_get_width(bg->pixbuf)/bg->pixbuf_scale;
1427 pg->height = gdk_pixbuf_get_height(bg->pixbuf)/bg->pixbuf_scale;
1428 make_page_clipbox(pg);
1429 update_canvas_bg(pg);
1433 g_list_free(bglist);
1434 if (ui.zoom != DEFAULT_ZOOM) {
1435 ui.zoom = DEFAULT_ZOOM;
1436 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
1437 rescale_bg_pixmaps();
1439 do_switch_page(ui.pageno, TRUE, TRUE);
1443 on_journalScreenshot_activate (GtkMenuItem *menuitem,
1446 struct Background *bg;
1449 gtk_window_iconify(GTK_WINDOW(winMain)); // hide ourselves
1450 gdk_display_sync(gdk_display_get_default());
1452 if (ui.cursor!=NULL)
1453 gdk_cursor_unref(ui.cursor);
1454 ui.cursor = gdk_cursor_new(GDK_TCROSS);
1456 bg = attempt_screenshot_bg();
1458 gtk_window_deiconify(GTK_WINDOW(winMain));
1460 if (bg==NULL) return;
1463 undo->type = ITEM_NEW_BG_RESIZE;
1464 undo->page = ui.cur_page;
1465 undo->bg = ui.cur_page->bg;
1466 bg->canvas_item = undo->bg->canvas_item;
1467 undo->bg->canvas_item = NULL;
1468 undo->val_x = ui.cur_page->width;
1469 undo->val_y = ui.cur_page->height;
1471 ui.cur_page->bg = bg;
1472 ui.cur_page->width = gdk_pixbuf_get_width(bg->pixbuf)/bg->pixbuf_scale;
1473 ui.cur_page->height = gdk_pixbuf_get_height(bg->pixbuf)/bg->pixbuf_scale;
1475 make_page_clipbox(ui.cur_page);
1476 update_canvas_bg(ui.cur_page);
1478 if (ui.zoom != DEFAULT_ZOOM) {
1479 ui.zoom = DEFAULT_ZOOM;
1480 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
1481 rescale_bg_pixmaps();
1483 do_switch_page(ui.pageno, TRUE, TRUE);
1488 on_journalApplyAllPages_activate (GtkMenuItem *menuitem,
1493 active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
1494 if (active == ui.bg_apply_all_pages) return;
1495 ui.bg_apply_all_pages = active;
1496 update_page_stuff();
1498 /* THIS IS THE OLD VERSION OF THE FEATURE -- APPLIED CURRENT BG TO ALL
1502 if (ui.cur_page->bg->type != BG_SOLID) return;
1504 for (pglist = journal.pages; pglist!=NULL; pglist = pglist->next) {
1505 page = (struct Page *)pglist->data;
1507 undo->type = ITEM_NEW_BG_RESIZE;
1509 undo->bg = page->bg;
1510 undo->val_x = page->width;
1511 undo->val_y = page->height;
1512 if (pglist->next!=NULL) undo->multiop |= MULTIOP_CONT_REDO;
1513 if (pglist->prev!=NULL) undo->multiop |= MULTIOP_CONT_UNDO;
1514 page->bg = (struct Background *)g_memdup(ui.cur_page->bg, sizeof(struct Background));
1515 page->width = ui.cur_page->width;
1516 page->height = ui.cur_page->height;
1517 page->bg->canvas_item = undo->bg->canvas_item;
1518 undo->bg->canvas_item = NULL;
1520 make_page_clipbox(page);
1521 update_canvas_bg(page);
1523 do_switch_page(ui.pageno, TRUE, TRUE);
1530 on_toolsPen_activate (GtkMenuItem *menuitem,
1533 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1534 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1537 if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1541 if (ui.cur_mapping != 0) return;
1542 if (ui.toolno[0] == TOOL_PEN) return;
1545 ui.toolno[0] = TOOL_PEN;
1546 ui.ruler[0] = FALSE;
1547 ui.cur_brush = &(ui.brushes[0][TOOL_PEN]);
1548 update_mapping_linkings(TOOL_PEN);
1549 update_tool_buttons();
1551 update_color_menu();
1557 on_toolsEraser_activate (GtkMenuItem *menuitem,
1560 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1561 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1564 if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1568 if (ui.cur_mapping != 0) return;
1569 if (ui.toolno[0] == TOOL_ERASER) return;
1572 ui.toolno[0] = TOOL_ERASER;
1573 ui.ruler[0] = FALSE;
1574 ui.cur_brush = &(ui.brushes[0][TOOL_ERASER]);
1575 update_mapping_linkings(TOOL_ERASER);
1576 update_tool_buttons();
1578 update_color_menu();
1584 on_toolsHighlighter_activate (GtkMenuItem *menuitem,
1587 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1588 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1591 if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1595 if (ui.cur_mapping != 0) return; // not user-generated
1596 if (ui.toolno[0] == TOOL_HIGHLIGHTER) return;
1599 ui.toolno[0] = TOOL_HIGHLIGHTER;
1600 ui.ruler[0] = FALSE;
1601 ui.cur_brush = &(ui.brushes[0][TOOL_HIGHLIGHTER]);
1602 update_mapping_linkings(TOOL_HIGHLIGHTER);
1603 update_tool_buttons();
1605 update_color_menu();
1611 on_toolsText_activate (GtkMenuItem *menuitem,
1619 on_toolsSelectRegion_activate (GtkMenuItem *menuitem,
1627 on_toolsSelectRectangle_activate (GtkMenuItem *menuitem,
1630 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1631 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1634 if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1638 if (ui.cur_mapping != 0) return; // not user-generated
1639 if (ui.toolno[0] == TOOL_SELECTRECT) return;
1641 ui.toolno[0] = TOOL_SELECTRECT;
1642 ui.ruler[0] = FALSE;
1643 update_mapping_linkings(-1);
1644 update_tool_buttons();
1646 update_color_menu();
1652 on_toolsVerticalSpace_activate (GtkMenuItem *menuitem,
1655 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1656 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1659 if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1663 if (ui.cur_mapping != 0) return; // not user-generated
1664 if (ui.toolno[0] == TOOL_VERTSPACE) return;
1667 ui.toolno[0] = TOOL_VERTSPACE;
1668 ui.ruler[0] = FALSE;
1669 update_mapping_linkings(-1);
1670 update_tool_buttons();
1672 update_color_menu();
1678 on_colorBlack_activate (GtkMenuItem *menuitem,
1681 process_color_activate(menuitem, COLOR_BLACK);
1686 on_colorBlue_activate (GtkMenuItem *menuitem,
1689 process_color_activate(menuitem, COLOR_BLUE);
1695 on_colorRed_activate (GtkMenuItem *menuitem,
1698 process_color_activate(menuitem, COLOR_RED);
1703 on_colorGreen_activate (GtkMenuItem *menuitem,
1706 process_color_activate(menuitem, COLOR_GREEN);
1711 on_colorGray_activate (GtkMenuItem *menuitem,
1714 process_color_activate(menuitem, COLOR_GRAY);
1719 on_colorLightBlue_activate (GtkMenuItem *menuitem,
1722 process_color_activate(menuitem, COLOR_LIGHTBLUE);
1727 on_colorLightGreen_activate (GtkMenuItem *menuitem,
1730 process_color_activate(menuitem, COLOR_LIGHTGREEN);
1735 on_colorMagenta_activate (GtkMenuItem *menuitem,
1738 process_color_activate(menuitem, COLOR_MAGENTA);
1743 on_colorOrange_activate (GtkMenuItem *menuitem,
1746 process_color_activate(menuitem, COLOR_ORANGE);
1751 on_colorYellow_activate (GtkMenuItem *menuitem,
1754 process_color_activate(menuitem, COLOR_YELLOW);
1759 on_colorWhite_activate (GtkMenuItem *menuitem,
1762 process_color_activate(menuitem, COLOR_WHITE);
1767 on_colorOther_activate (GtkMenuItem *menuitem,
1775 on_penthicknessVeryFine_activate (GtkMenuItem *menuitem,
1778 process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_VERYFINE);
1783 on_penthicknessFine_activate (GtkMenuItem *menuitem,
1786 process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_FINE);
1791 on_penthicknessMedium_activate (GtkMenuItem *menuitem,
1794 process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_MEDIUM);
1799 on_penthicknessThick_activate (GtkMenuItem *menuitem,
1802 process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_THICK);
1807 on_penthicknessVeryThick_activate (GtkMenuItem *menuitem,
1810 process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_VERYTHICK);
1815 on_eraserFine_activate (GtkMenuItem *menuitem,
1818 process_thickness_activate(menuitem, TOOL_ERASER, THICKNESS_FINE);
1823 on_eraserMedium_activate (GtkMenuItem *menuitem,
1826 process_thickness_activate(menuitem, TOOL_ERASER, THICKNESS_MEDIUM);
1831 on_eraserThick_activate (GtkMenuItem *menuitem,
1834 process_thickness_activate(menuitem, TOOL_ERASER, THICKNESS_THICK);
1839 on_eraserStandard_activate (GtkMenuItem *menuitem,
1842 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
1843 ui.brushes[0][TOOL_ERASER].tool_options = TOOLOPT_ERASER_STANDARD;
1844 update_mapping_linkings(TOOL_ERASER);
1849 on_eraserWhiteout_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_WHITEOUT;
1854 update_mapping_linkings(TOOL_ERASER);
1859 on_eraserDeleteStrokes_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_STROKES;
1864 update_mapping_linkings(TOOL_ERASER);
1869 on_highlighterFine_activate (GtkMenuItem *menuitem,
1872 process_thickness_activate(menuitem, TOOL_HIGHLIGHTER, THICKNESS_FINE);
1877 on_highlighterMedium_activate (GtkMenuItem *menuitem,
1880 process_thickness_activate(menuitem, TOOL_HIGHLIGHTER, THICKNESS_MEDIUM);
1885 on_highlighterThick_activate (GtkMenuItem *menuitem,
1888 process_thickness_activate(menuitem, TOOL_HIGHLIGHTER, THICKNESS_THICK);
1893 on_toolsTextFont_activate (GtkMenuItem *menuitem,
1901 on_toolsDefaultPen_activate (GtkMenuItem *menuitem,
1906 g_memmove(&(ui.brushes[0][TOOL_PEN]), ui.default_brushes+TOOL_PEN, sizeof(struct Brush));
1907 ui.toolno[0] = TOOL_PEN;
1908 ui.cur_brush = &(ui.brushes[0][TOOL_PEN]);
1909 ui.ruler[0] = FALSE;
1910 update_mapping_linkings(TOOL_PEN);
1911 update_tool_buttons();
1913 update_pen_props_menu();
1914 update_color_menu();
1920 on_toolsDefaultEraser_activate (GtkMenuItem *menuitem,
1925 g_memmove(&(ui.brushes[0][TOOL_ERASER]), ui.default_brushes+TOOL_ERASER, sizeof(struct Brush));
1926 ui.toolno[0] = TOOL_ERASER;
1927 ui.cur_brush = &(ui.brushes[0][TOOL_ERASER]);
1928 ui.ruler[0] = FALSE;
1929 update_mapping_linkings(TOOL_ERASER);
1930 update_tool_buttons();
1932 update_eraser_props_menu();
1933 update_color_menu();
1939 on_toolsDefaultHighlighter_activate (GtkMenuItem *menuitem,
1944 g_memmove(&(ui.brushes[0][TOOL_HIGHLIGHTER]), ui.default_brushes+TOOL_HIGHLIGHTER, sizeof(struct Brush));
1945 ui.toolno[0] = TOOL_HIGHLIGHTER;
1946 ui.cur_brush = &(ui.brushes[0][TOOL_HIGHLIGHTER]);
1947 ui.ruler[0] = FALSE;
1948 update_mapping_linkings(TOOL_HIGHLIGHTER);
1949 update_tool_buttons();
1951 update_highlighter_props_menu();
1952 update_color_menu();
1957 on_toolsDefaultText_activate (GtkMenuItem *menuitem,
1965 on_toolsSetAsDefault_activate (GtkMenuItem *menuitem,
1968 if (ui.cur_mapping!=0) return;
1969 if (ui.toolno[0] < NUM_STROKE_TOOLS)
1970 g_memmove(ui.default_brushes+ui.toolno[0], &(ui.brushes[0][ui.toolno[0]]), sizeof(struct Brush));
1975 on_toolsRuler_activate (GtkMenuItem *menuitem,
1980 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_CHECK_MENU_ITEM)
1981 active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
1983 active = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem));
1985 if (ui.cur_mapping != 0) return;
1986 if (active == ui.ruler[0]) return;
1988 if (active && (ui.toolno[0]!=TOOL_PEN && ui.toolno[0]!=TOOL_HIGHLIGHTER)) {
1990 ui.toolno[0] = TOOL_PEN;
1991 ui.cur_brush = &(ui.brushes[0][TOOL_PEN]);
1992 update_color_menu();
1993 update_tool_buttons();
1998 ui.ruler[0] = active;
1999 update_mapping_linkings(ui.toolno[0]);
2000 update_ruler_indicator();
2005 on_optionsSavePreferences_activate (GtkMenuItem *menuitem,
2008 save_config_to_file();
2013 on_helpIndex_activate (GtkMenuItem *menuitem,
2021 on_helpAbout_activate (GtkMenuItem *menuitem,
2024 GtkWidget *aboutDialog;
2025 GtkLabel *labelTitle;
2027 aboutDialog = create_aboutDialog ();
2028 labelTitle = GTK_LABEL(g_object_get_data(G_OBJECT(aboutDialog), "labelTitle"));
2029 gtk_label_set_markup(labelTitle,
2030 "<span size=\"xx-large\" weight=\"bold\">Xournal " VERSION "</span>");
2031 gtk_dialog_run (GTK_DIALOG(aboutDialog));
2032 gtk_widget_destroy(aboutDialog);
2037 on_buttonToolDefault_clicked (GtkToolButton *toolbutton,
2041 if (ui.toolno[0] < NUM_STROKE_TOOLS) {
2042 g_memmove(&(ui.brushes[0][ui.toolno[0]]), ui.default_brushes+ui.toolno[0], sizeof(struct Brush));
2043 ui.ruler[0] = FALSE;
2044 update_mapping_linkings(ui.toolno[0]);
2045 update_thickness_buttons();
2046 update_color_buttons();
2047 update_color_menu();
2048 if (ui.toolno[0] == TOOL_PEN) update_pen_props_menu();
2049 if (ui.toolno[0] == TOOL_ERASER) update_eraser_props_menu();
2050 if (ui.toolno[0] == TOOL_HIGHLIGHTER) update_highlighter_props_menu();
2057 on_buttonFine_clicked (GtkToolButton *toolbutton,
2060 if (ui.cur_mapping != 0) return;
2061 process_thickness_activate((GtkMenuItem*)toolbutton, ui.toolno[0], THICKNESS_FINE);
2066 on_buttonMedium_clicked (GtkToolButton *toolbutton,
2069 if (ui.cur_mapping != 0) return;
2070 process_thickness_activate((GtkMenuItem*)toolbutton, ui.toolno[0], THICKNESS_MEDIUM);
2075 on_buttonThick_clicked (GtkToolButton *toolbutton,
2078 if (ui.cur_mapping != 0) return;
2079 process_thickness_activate((GtkMenuItem*)toolbutton, ui.toolno[0], THICKNESS_THICK);
2084 on_canvas_button_press_event (GtkWidget *widget,
2085 GdkEventButton *event,
2089 gboolean page_change;
2090 struct Page *tmppage;
2094 if (ui.cur_item_type != ITEM_NONE) return FALSE; // we're already doing something
2095 if (event->button > 3) return FALSE; // no painting with the mouse wheel!
2097 if (ui.use_xinput) {
2098 if (event->device->source == GDK_SOURCE_MOUSE) return FALSE;
2099 // re-get the axis values since Synaptics sends bogus ones
2100 gdk_device_get_state(event->device, event->window, event->axes, NULL);
2101 fix_xinput_coords((GdkEvent *)event);
2103 else if (event->device->source != GDK_SOURCE_MOUSE) return FALSE;
2105 if (ui.use_erasertip && event->device->source == GDK_SOURCE_ERASER)
2106 mapping = NUM_BUTTONS;
2107 else mapping = event->button-1;
2109 // check whether we're in a page
2110 page_change = FALSE;
2111 tmppage = ui.cur_page;
2112 get_pointer_coords((GdkEvent *)event, pt);
2113 while (ui.view_continuous && (pt[1] < - VIEW_CONTINUOUS_SKIP)) {
2114 if (ui.pageno == 0) break;
2117 tmppage = g_list_nth_data(journal.pages, ui.pageno);
2118 pt[1] += tmppage->height + VIEW_CONTINUOUS_SKIP;
2120 while (ui.view_continuous && (pt[1] > tmppage->height + VIEW_CONTINUOUS_SKIP)) {
2121 if (ui.pageno == journal.npages-1) break;
2122 pt[1] -= tmppage->height + VIEW_CONTINUOUS_SKIP;
2125 tmppage = g_list_nth_data(journal.pages, ui.pageno);
2127 if (page_change) do_switch_page(ui.pageno, FALSE, FALSE);
2129 // can't paint on the background...
2131 if (ui.cur_layer == NULL) {
2133 dialog = gtk_message_dialog_new(GTK_WINDOW(winMain), GTK_DIALOG_MODAL,
2134 GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, "Drawing is not allowed on the "
2135 "background layer.\n Switching to Layer 1.");
2136 gtk_dialog_run(GTK_DIALOG(dialog));
2137 gtk_widget_destroy(dialog);
2138 on_viewShowLayer_activate(NULL, NULL);
2142 // switch mappings if needed
2144 ui.which_mouse_button = event->button;
2145 switch_mapping(mapping);
2147 // if this can be a selection move, then it takes precedence over anything else
2148 if (start_movesel((GdkEvent *)event)) return FALSE;
2150 if (ui.toolno[mapping] != TOOL_SELECTREGION && ui.toolno[mapping] != TOOL_SELECTRECT)
2153 // process the event
2155 if (ui.toolno[mapping] == TOOL_HAND) {
2156 ui.cur_item_type = ITEM_HAND;
2157 get_pointer_coords((GdkEvent *)event, ui.hand_refpt);
2159 else if (ui.toolno[mapping] == TOOL_PEN || ui.toolno[mapping] == TOOL_HIGHLIGHTER ||
2160 (ui.toolno[mapping] == TOOL_ERASER && ui.cur_brush->tool_options == TOOLOPT_ERASER_WHITEOUT)) {
2161 create_new_stroke((GdkEvent *)event);
2163 else if (ui.toolno[mapping] == TOOL_ERASER) {
2164 ui.cur_item_type = ITEM_ERASURE;
2165 do_eraser((GdkEvent *)event, ui.cur_brush->thickness/2,
2166 ui.cur_brush->tool_options == TOOLOPT_ERASER_STROKES);
2168 else if (ui.toolno[mapping] == TOOL_SELECTRECT) {
2169 start_selectrect((GdkEvent *)event);
2171 else if (ui.toolno[mapping] == TOOL_VERTSPACE) {
2172 start_vertspace((GdkEvent *)event);
2179 on_canvas_button_release_event (GtkWidget *widget,
2180 GdkEventButton *event,
2183 if (ui.cur_item_type == ITEM_NONE) return FALSE; // not doing anything
2185 if (event->button != ui.which_mouse_button) return FALSE; // ignore
2187 if (ui.use_xinput) {
2188 if (event->device->source == GDK_SOURCE_MOUSE) return FALSE;
2189 fix_xinput_coords((GdkEvent *)event);
2191 else if (event->device->source != GDK_SOURCE_MOUSE) return FALSE;
2193 if (ui.cur_item_type == ITEM_STROKE) {
2196 else if (ui.cur_item_type == ITEM_ERASURE) {
2199 else if (ui.cur_item_type == ITEM_SELECTRECT) {
2200 finalize_selectrect();
2202 else if (ui.cur_item_type == ITEM_MOVESEL || ui.cur_item_type == ITEM_MOVESEL_VERT) {
2205 else if (ui.cur_item_type == ITEM_HAND) {
2206 ui.cur_item_type = ITEM_NONE;
2215 on_canvas_enter_notify_event (GtkWidget *widget,
2216 GdkEventCrossing *event,
2225 on_canvas_expose_event (GtkWidget *widget,
2226 GdkEventExpose *event,
2229 if (ui.view_continuous && ui.progressive_bg) rescale_bg_pixmaps();
2235 on_canvas_key_press_event (GtkWidget *widget,
2245 on_canvas_motion_notify_event (GtkWidget *widget,
2246 GdkEventMotion *event,
2249 gboolean looks_wrong;
2252 if (ui.cur_item_type == ITEM_NONE) return FALSE; // we don't care
2254 if (ui.use_xinput) {
2255 if (event->device->source == GDK_SOURCE_MOUSE) return FALSE;
2256 fix_xinput_coords((GdkEvent *)event);
2258 else if (event->device->source != GDK_SOURCE_MOUSE) return FALSE;
2260 looks_wrong = !(event->state & (1<<(7+ui.which_mouse_button)));
2262 if (looks_wrong) { /* mouse button shouldn't be up... give up */
2263 if (ui.cur_item_type == ITEM_STROKE) {
2266 else if (ui.cur_item_type == ITEM_ERASURE) {
2269 else if (ui.cur_item_type == ITEM_SELECTRECT) {
2270 finalize_selectrect();
2272 else if (ui.cur_item_type == ITEM_MOVESEL || ui.cur_item_type == ITEM_MOVESEL_VERT) {
2279 if (ui.cur_item_type == ITEM_STROKE) {
2280 continue_stroke((GdkEvent *)event);
2282 else if (ui.cur_item_type == ITEM_ERASURE) {
2283 do_eraser((GdkEvent *)event, ui.cur_brush->thickness/2,
2284 ui.cur_brush->tool_options == TOOLOPT_ERASER_STROKES);
2286 else if (ui.cur_item_type == ITEM_SELECTRECT) {
2287 get_pointer_coords((GdkEvent *)event, pt);
2288 ui.selection->bbox.right = pt[0];
2289 ui.selection->bbox.bottom = pt[1];
2290 gnome_canvas_item_set(ui.selection->canvas_item,
2291 "x2", pt[0], "y2", pt[1], NULL);
2293 else if (ui.cur_item_type == ITEM_MOVESEL || ui.cur_item_type == ITEM_MOVESEL_VERT) {
2294 continue_movesel((GdkEvent *)event);
2296 else if (ui.cur_item_type == ITEM_HAND) {
2297 do_hand((GdkEvent *)event);
2304 on_comboLayer_changed (GtkComboBox *combobox,
2309 if (ui.in_update_page_stuff) return; // avoid a bad retroaction
2311 gtk_widget_grab_focus(GTK_WIDGET(canvas)); // stop focus on us
2313 val = gtk_combo_box_get_active(combobox);
2314 if (val == -1) return;
2315 val = ui.cur_page->nlayers-1-val;
2316 if (val == ui.layerno) return;
2319 while (val>ui.layerno) {
2321 ui.cur_layer = g_list_nth_data(ui.cur_page->layers, ui.layerno);
2322 gnome_canvas_item_show(GNOME_CANVAS_ITEM(ui.cur_layer->group));
2324 while (val<ui.layerno) {
2325 gnome_canvas_item_hide(GNOME_CANVAS_ITEM(ui.cur_layer->group));
2327 if (ui.layerno<0) ui.cur_layer = NULL;
2328 else ui.cur_layer = g_list_nth_data(ui.cur_page->layers, ui.layerno);
2330 update_page_stuff();
2335 on_winMain_delete_event (GtkWidget *widget,
2339 if (ok_to_close()) gtk_main_quit();
2345 on_optionsUseXInput_activate (GtkMenuItem *menuitem,
2348 ui.allow_xinput = ui.use_xinput =
2349 gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
2353 on_vscroll_changed (GtkAdjustment *adjustment,
2356 gboolean need_update;
2357 double viewport_top, viewport_bottom;
2358 struct Page *tmppage;
2360 if (!ui.view_continuous) return;
2362 if (ui.progressive_bg) rescale_bg_pixmaps();
2363 need_update = FALSE;
2364 viewport_top = adjustment->value / ui.zoom;
2365 viewport_bottom = (adjustment->value + adjustment->page_size) / ui.zoom;
2366 tmppage = ui.cur_page;
2367 while (viewport_top > tmppage->voffset + tmppage->height) {
2368 if (ui.pageno == journal.npages-1) break;
2371 tmppage = g_list_nth_data(journal.pages, ui.pageno);
2373 while (viewport_bottom < tmppage->voffset) {
2374 if (ui.pageno == 0) break;
2377 tmppage = g_list_nth_data(journal.pages, ui.pageno);
2379 if (need_update) do_switch_page(ui.pageno, FALSE, FALSE);
2384 on_spinPageNo_value_changed (GtkSpinButton *spinbutton,
2389 if (ui.in_update_page_stuff) return; // avoid a bad retroaction
2391 gtk_widget_grab_focus(GTK_WIDGET(canvas)); // stop blink-blink text cursor
2393 val = gtk_spin_button_get_value_as_int(spinbutton) - 1;
2395 if (val == journal.npages) { // create a page at end
2396 if (page_ops_forbidden()) return;
2397 on_journalNewPageEnd_activate(NULL, NULL);
2401 if (val == ui.pageno) return;
2402 if (val < 0) val = 0;
2403 if (val > journal.npages-1) val = journal.npages-1;
2404 do_switch_page(val, TRUE, FALSE);
2409 on_journalDefaultBackground_activate (GtkMenuItem *menuitem,
2418 for (pglist = journal.pages; pglist!=NULL; pglist = pglist->next) {
2419 if (ui.bg_apply_all_pages) pg = (struct Page *)pglist->data;
2421 if (ui.bg_apply_all_pages) {
2422 if (pglist->next!=NULL) undo->multiop |= MULTIOP_CONT_REDO;
2423 if (pglist->prev!=NULL) undo->multiop |= MULTIOP_CONT_UNDO;
2425 undo->type = ITEM_NEW_BG_RESIZE;
2428 undo->val_x = pg->width;
2429 undo->val_y = pg->height;
2430 pg->bg = (struct Background *)g_memdup(ui.default_page.bg, sizeof(struct Background));
2431 pg->width = ui.default_page.width;
2432 pg->height = ui.default_page.height;
2433 pg->bg->canvas_item = undo->bg->canvas_item;
2434 undo->bg->canvas_item = NULL;
2436 make_page_clipbox(pg);
2437 update_canvas_bg(pg);
2438 if (!ui.bg_apply_all_pages) break;
2440 do_switch_page(ui.pageno, TRUE, TRUE);
2445 on_journalSetAsDefault_activate (GtkMenuItem *menuitem,
2448 if (ui.cur_page->bg->type != BG_SOLID) return;
2451 undo->type = ITEM_NEW_DEFAULT_BG;
2452 undo->val_x = ui.default_page.width;
2453 undo->val_y = ui.default_page.height;
2454 undo->bg = ui.default_page.bg;
2456 ui.default_page.width = ui.cur_page->width;
2457 ui.default_page.height = ui.cur_page->height;
2458 ui.default_page.bg = (struct Background *)g_memdup(ui.cur_page->bg, sizeof(struct Background));
2459 ui.default_page.bg->canvas_item = NULL;
2464 on_comboStdSizes_changed (GtkComboBox *combobox,
2468 GtkComboBox *comboUnit;
2472 if (papersize_need_init) {
2473 gtk_combo_box_set_active(combobox, papersize_std);
2474 papersize_need_init = FALSE;
2476 val = gtk_combo_box_get_active(combobox);
2477 if (val == -1 || val == papersize_std) return;
2478 papersize_std = val;
2479 if (val == STD_SIZE_CUSTOM) return;
2480 papersize_unit = std_units[val];
2481 papersize_width = std_widths[val];
2482 papersize_height = std_heights[val];
2484 comboUnit = GTK_COMBO_BOX(g_object_get_data(G_OBJECT(papersize_dialog), "comboUnit"));
2485 gtk_combo_box_set_active(comboUnit, papersize_unit);
2486 entry = GTK_ENTRY(g_object_get_data(G_OBJECT(papersize_dialog), "entryWidth"));
2487 g_snprintf(text, 20, "%.2f", papersize_width/unit_sizes[papersize_unit]);
2488 if (g_str_has_suffix(text, ".00"))
2489 g_snprintf(text, 20, "%d", (int) (papersize_width/unit_sizes[papersize_unit]));
2490 gtk_entry_set_text(entry, text);
2491 entry = GTK_ENTRY(g_object_get_data(G_OBJECT(papersize_dialog), "entryHeight"));
2492 g_snprintf(text, 20, "%.2f", papersize_height/unit_sizes[papersize_unit]);
2493 if (g_str_has_suffix(text, ".00"))
2494 g_snprintf(text, 20, "%d", (int) (papersize_height/unit_sizes[papersize_unit]));
2495 gtk_entry_set_text(entry, text);
2500 on_entryWidth_changed (GtkEditable *editable,
2506 GtkComboBox *comboStdSizes;
2508 text = gtk_entry_get_text(GTK_ENTRY(editable));
2509 val = strtod(text, &ptr);
2510 papersize_width_valid = (*ptr == 0 && val > 0.);
2511 if (!papersize_width_valid) return; // invalid entry
2512 val *= unit_sizes[papersize_unit];
2513 if (fabs(val - papersize_width) < 0.1) return; // no change
2514 papersize_std = STD_SIZE_CUSTOM;
2515 papersize_width = val;
2516 comboStdSizes = GTK_COMBO_BOX(g_object_get_data(G_OBJECT(papersize_dialog), "comboStdSizes"));
2517 gtk_combo_box_set_active(comboStdSizes, papersize_std);
2522 on_entryHeight_changed (GtkEditable *editable,
2528 GtkComboBox *comboStdSizes;
2530 text = gtk_entry_get_text(GTK_ENTRY(editable));
2531 val = strtod(text, &ptr);
2532 papersize_height_valid = (*ptr == 0 && val > 0.);
2533 if (!papersize_height_valid) return; // invalid entry
2534 val *= unit_sizes[papersize_unit];
2535 if (fabs(val - papersize_height) < 0.1) return; // no change
2536 papersize_std = STD_SIZE_CUSTOM;
2537 papersize_height = val;
2538 comboStdSizes = GTK_COMBO_BOX(g_object_get_data(G_OBJECT(papersize_dialog), "comboStdSizes"));
2539 gtk_combo_box_set_active(comboStdSizes, papersize_std);
2544 on_comboUnit_changed (GtkComboBox *combobox,
2551 val = gtk_combo_box_get_active(combobox);
2552 if (val == -1 || val == papersize_unit) return;
2553 papersize_unit = val;
2554 entry = GTK_ENTRY(g_object_get_data(G_OBJECT(papersize_dialog), "entryWidth"));
2555 if (papersize_width_valid) {
2556 g_snprintf(text, 20, "%.2f", papersize_width/unit_sizes[papersize_unit]);
2557 if (g_str_has_suffix(text, ".00"))
2558 g_snprintf(text, 20, "%d", (int) (papersize_width/unit_sizes[papersize_unit]));
2560 gtk_entry_set_text(entry, text);
2561 if (papersize_height_valid) {
2562 entry = GTK_ENTRY(g_object_get_data(G_OBJECT(papersize_dialog), "entryHeight"));
2563 g_snprintf(text, 20, "%.2f", papersize_height/unit_sizes[papersize_unit]);
2564 if (g_str_has_suffix(text, ".00"))
2565 g_snprintf(text, 20, "%d", (int) (papersize_height/unit_sizes[papersize_unit]));
2567 gtk_entry_set_text(entry, text);
2572 on_viewFullscreen_activate (GtkMenuItem *menuitem,
2577 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_CHECK_MENU_ITEM)
2578 active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
2580 active = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem));
2582 if (active == ui.fullscreen) return;
2583 ui.fullscreen = active;
2584 gtk_check_menu_item_set_active(
2585 GTK_CHECK_MENU_ITEM(GET_COMPONENT("viewFullscreen")), ui.fullscreen);
2586 gtk_toggle_tool_button_set_active(
2587 GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonFullscreen")), ui.fullscreen);
2589 if (ui.fullscreen) {
2590 gtk_window_fullscreen(GTK_WINDOW(winMain));
2591 gtk_widget_hide(GET_COMPONENT("menubar"));
2592 gtk_widget_hide(GET_COMPONENT("hbox1"));
2595 gtk_window_unfullscreen(GTK_WINDOW(winMain));
2596 gtk_widget_show(GET_COMPONENT("menubar"));
2597 gtk_widget_show(GET_COMPONENT("hbox1"));
2603 on_optionsButtonMappings_activate (GtkMenuItem *menuitem,
2607 gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
2608 update_mappings_menu();
2613 on_optionsAntialiasBG_activate (GtkMenuItem *menuitem,
2618 active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
2619 if (ui.antialias_bg == active) return;
2620 ui.antialias_bg = active;
2621 rescale_bg_pixmaps();
2626 on_optionsProgressiveBG_activate (GtkMenuItem *menuitem,
2631 active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
2632 if (ui.progressive_bg == active) return;
2633 ui.progressive_bg = active;
2634 if (!ui.progressive_bg) rescale_bg_pixmaps();
2639 on_mru_activate (GtkMenuItem *menuitem,
2646 if (!ok_to_close()) return; // user aborted on save confirmation
2648 for (which = 0 ; which < MRU_SIZE; which++) {
2649 if (ui.mrumenu[which] == GTK_WIDGET(menuitem)) break;
2651 if (which == MRU_SIZE || ui.mru[which] == NULL) return; // not found...
2653 set_cursor_busy(TRUE);
2654 success = open_journal(ui.mru[which]);
2655 set_cursor_busy(FALSE);
2656 if (success) return;
2659 dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
2660 GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Error opening file '%s'", ui.mru[which]);
2661 gtk_dialog_run(GTK_DIALOG(dialog));
2662 gtk_widget_destroy(dialog);
2663 delete_mru_entry(which);
2668 on_button2Pen_activate (GtkMenuItem *menuitem,
2671 process_mapping_activate(menuitem, 1, TOOL_PEN);
2676 on_button2Eraser_activate (GtkMenuItem *menuitem,
2679 process_mapping_activate(menuitem, 1, TOOL_ERASER);
2684 on_button2Highlighter_activate (GtkMenuItem *menuitem,
2687 process_mapping_activate(menuitem, 1, TOOL_HIGHLIGHTER);
2692 on_button2Text_activate (GtkMenuItem *menuitem,
2700 on_button2SelectRegion_activate (GtkMenuItem *menuitem,
2703 process_mapping_activate(menuitem, 1, TOOL_SELECTREGION);
2708 on_button2SelectRectangle_activate (GtkMenuItem *menuitem,
2711 process_mapping_activate(menuitem, 1, TOOL_SELECTRECT);
2716 on_button2VerticalSpace_activate (GtkMenuItem *menuitem,
2719 process_mapping_activate(menuitem, 1, TOOL_VERTSPACE);
2724 on_button2LinkBrush_activate (GtkMenuItem *menuitem,
2729 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem))) return;
2730 ui.linked_brush[1] = BRUSH_LINKED;
2731 for (i=0;i<NUM_STROKE_TOOLS;i++) update_mapping_linkings(i);
2736 on_button2CopyBrush_activate (GtkMenuItem *menuitem,
2739 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem))) return;
2740 if (ui.toolno[1] >= NUM_STROKE_TOOLS) {
2741 ui.linked_brush[1] = BRUSH_STATIC;
2742 update_mappings_menu_linkings();
2745 ui.linked_brush[1] = BRUSH_COPIED;
2746 g_memmove(&(ui.brushes[1][ui.toolno[1]]), &(ui.brushes[0][ui.toolno[1]]), sizeof(struct Brush));
2747 ui.ruler[1] = ui.ruler[0];
2748 if (ui.toolno[1]!=TOOL_PEN && ui.toolno[1]!=TOOL_HIGHLIGHTER)
2749 ui.ruler[1] = FALSE;
2754 on_button3Pen_activate (GtkMenuItem *menuitem,
2757 process_mapping_activate(menuitem, 2, TOOL_PEN);
2762 on_button3Eraser_activate (GtkMenuItem *menuitem,
2765 process_mapping_activate(menuitem, 2, TOOL_ERASER);
2770 on_button3Highlighter_activate (GtkMenuItem *menuitem,
2773 process_mapping_activate(menuitem, 2, TOOL_HIGHLIGHTER);
2778 on_button3Text_activate (GtkMenuItem *menuitem,
2786 on_button3SelectRegion_activate (GtkMenuItem *menuitem,
2789 process_mapping_activate(menuitem, 2, TOOL_SELECTREGION);
2794 on_button3SelectRectangle_activate (GtkMenuItem *menuitem,
2797 process_mapping_activate(menuitem, 2, TOOL_SELECTRECT);
2802 on_button3VerticalSpace_activate (GtkMenuItem *menuitem,
2805 process_mapping_activate(menuitem, 2, TOOL_VERTSPACE);
2810 on_button3LinkBrush_activate (GtkMenuItem *menuitem,
2815 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem))) return;
2816 ui.linked_brush[2] = BRUSH_LINKED;
2817 for (i=0;i<NUM_STROKE_TOOLS;i++) update_mapping_linkings(i);
2822 on_button3CopyBrush_activate (GtkMenuItem *menuitem,
2825 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem))) return;
2826 if (ui.toolno[2] >= NUM_STROKE_TOOLS) {
2827 ui.linked_brush[2] = BRUSH_STATIC;
2828 update_mappings_menu_linkings();
2831 ui.linked_brush[2] = BRUSH_COPIED;
2832 g_memmove(&(ui.brushes[2][ui.toolno[2]]), &(ui.brushes[0][ui.toolno[2]]), sizeof(struct Brush));
2833 ui.ruler[2] = ui.ruler[0];
2834 if (ui.toolno[2]!=TOOL_PEN && ui.toolno[2]!=TOOL_HIGHLIGHTER)
2835 ui.ruler[2] = FALSE;
2838 // the set zoom dialog
2840 GtkWidget *zoom_dialog;
2841 double zoom_percent;
2844 on_viewSetZoom_activate (GtkMenuItem *menuitem,
2848 double test_w, test_h;
2849 GtkSpinButton *spinZoom;
2851 zoom_dialog = create_zoomDialog();
2852 zoom_percent = 100*ui.zoom / DEFAULT_ZOOM;
2853 spinZoom = GTK_SPIN_BUTTON(g_object_get_data(G_OBJECT(zoom_dialog), "spinZoom"));
2854 gtk_spin_button_set_increments(spinZoom, ui.zoom_step_increment, 5*ui.zoom_step_increment);
2855 gtk_spin_button_set_value(spinZoom, zoom_percent);
2856 test_w = 100*(GTK_WIDGET(canvas))->allocation.width/ui.cur_page->width/DEFAULT_ZOOM;
2857 test_h = 100*(GTK_WIDGET(canvas))->allocation.height/ui.cur_page->height/DEFAULT_ZOOM;
2858 if (zoom_percent > 99.9 && zoom_percent < 100.1)
2859 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_object_get_data(
2860 G_OBJECT(zoom_dialog), "radioZoom100")), TRUE);
2861 else if (zoom_percent > test_w-0.1 && zoom_percent < test_w+0.1)
2862 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_object_get_data(
2863 G_OBJECT(zoom_dialog), "radioZoomWidth")), TRUE);
2864 else if (zoom_percent > test_h-0.1 && zoom_percent < test_h+0.1)
2865 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_object_get_data(
2866 G_OBJECT(zoom_dialog), "radioZoomHeight")), TRUE);
2867 else gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_object_get_data(
2868 G_OBJECT(zoom_dialog), "radioZoom")), TRUE);
2869 gtk_widget_show(zoom_dialog);
2872 response = gtk_dialog_run(GTK_DIALOG(zoom_dialog));
2873 if (response == GTK_RESPONSE_OK || response == GTK_RESPONSE_APPLY) {
2874 ui.zoom = DEFAULT_ZOOM*zoom_percent/100;
2875 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
2876 rescale_bg_pixmaps();
2878 } while (response == GTK_RESPONSE_APPLY);
2880 gtk_widget_destroy(zoom_dialog);
2885 on_spinZoom_value_changed (GtkSpinButton *spinbutton,
2890 val = gtk_spin_button_get_value(GTK_SPIN_BUTTON(g_object_get_data(
2891 G_OBJECT(zoom_dialog), "spinZoom")));
2893 if (val<10) val=10.;
2894 if (val>1500) val=1500.;
2895 if (val<zoom_percent-1 || val>zoom_percent+1)
2896 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_object_get_data(
2897 G_OBJECT(zoom_dialog), "radioZoom")), TRUE);
2903 on_radioZoom_toggled (GtkToggleButton *togglebutton,
2911 on_radioZoom100_toggled (GtkToggleButton *togglebutton,
2914 if (!gtk_toggle_button_get_active(togglebutton)) return;
2915 zoom_percent = 100.;
2916 gtk_spin_button_set_value(GTK_SPIN_BUTTON(g_object_get_data(
2917 G_OBJECT(zoom_dialog), "spinZoom")), zoom_percent);
2922 on_radioZoomWidth_toggled (GtkToggleButton *togglebutton,
2925 if (!gtk_toggle_button_get_active(togglebutton)) return;
2926 zoom_percent = 100*(GTK_WIDGET(canvas))->allocation.width/ui.cur_page->width/DEFAULT_ZOOM;
2927 gtk_spin_button_set_value(GTK_SPIN_BUTTON(g_object_get_data(
2928 G_OBJECT(zoom_dialog), "spinZoom")), zoom_percent);
2933 on_radioZoomHeight_toggled (GtkToggleButton *togglebutton,
2936 if (!gtk_toggle_button_get_active(togglebutton)) return;
2937 zoom_percent = 100*(GTK_WIDGET(canvas))->allocation.height/ui.cur_page->height/DEFAULT_ZOOM;
2938 gtk_spin_button_set_value(GTK_SPIN_BUTTON(g_object_get_data(
2939 G_OBJECT(zoom_dialog), "spinZoom")), zoom_percent);
2944 on_toolsHand_activate (GtkMenuItem *menuitem,
2947 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
2948 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
2951 if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
2955 if (ui.cur_mapping != 0) return;
2956 if (ui.toolno[0] == TOOL_HAND) return;
2959 ui.toolno[0] = TOOL_HAND;
2960 ui.ruler[0] = FALSE;
2961 update_mapping_linkings(-1);
2962 update_tool_buttons();
2964 update_color_menu();
2970 on_button2Hand_activate (GtkMenuItem *menuitem,
2973 process_mapping_activate(menuitem, 1, TOOL_HAND);
2978 on_button3Hand_activate (GtkMenuItem *menuitem,
2981 process_mapping_activate(menuitem, 2, TOOL_HAND);
2986 on_optionsPrintRuling_activate (GtkMenuItem *menuitem,
2989 ui.print_ruling = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));