8 #include <libgnomecanvas/libgnomecanvas.h>
10 #include <glib/gstdio.h>
11 #include <gdk/gdkkeysyms.h>
14 #include "xo-callbacks.h"
15 #include "xo-interface.h"
16 #include "xo-support.h"
21 #include "xo-shapes.h"
24 on_fileNew_activate (GtkMenuItem *menuitem,
29 if (close_journal()) {
31 ui.zoom = ui.startup_zoom;
33 gtk_adjustment_set_value(gtk_layout_get_vadjustment(GTK_LAYOUT(canvas)), 0);
34 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
40 on_fileNewBackground_activate (GtkMenuItem *menuitem,
43 GtkWidget *dialog, *attach_opt;
44 GtkFileFilter *filt_all, *filt_pdf;
51 if (!ok_to_close()) return; // user aborted on save confirmation
53 dialog = gtk_file_chooser_dialog_new(_("Open PDF"), GTK_WINDOW (winMain),
54 GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
55 GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL);
56 #ifdef FILE_DIALOG_SIZE_BUGFIX
57 gtk_window_set_default_size(GTK_WINDOW(dialog), 500, 400);
60 filt_all = gtk_file_filter_new();
61 gtk_file_filter_set_name(filt_all, _("All files"));
62 gtk_file_filter_add_pattern(filt_all, "*");
63 filt_pdf = gtk_file_filter_new();
64 gtk_file_filter_set_name(filt_pdf, _("PDF files"));
65 gtk_file_filter_add_pattern(filt_pdf, "*.pdf");
66 gtk_file_filter_add_pattern(filt_pdf, "*.PDF");
67 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_pdf);
68 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_all);
70 if (ui.default_path!=NULL) gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (dialog), ui.default_path);
72 attach_opt = gtk_check_button_new_with_label(_("Attach file to the journal"));
73 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(attach_opt), FALSE);
74 gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER (dialog), attach_opt);
76 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
77 gtk_widget_destroy(dialog);
80 filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
81 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(attach_opt)))
82 file_domain = DOMAIN_ATTACH;
83 else file_domain = DOMAIN_ABSOLUTE;
85 gtk_widget_destroy(dialog);
87 set_cursor_busy(TRUE);
88 ui.saved = TRUE; // force close_journal to work
90 while (bgpdf.status != STATUS_NOT_INIT) {
91 // waiting for pdf processes to finish dying
95 ui.zoom = ui.startup_zoom;
96 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
98 success = init_bgpdf(filename, TRUE, file_domain);
99 set_cursor_busy(FALSE);
106 dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
107 GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Error opening file '%s'"), filename);
108 gtk_dialog_run(GTK_DIALOG(dialog));
109 gtk_widget_destroy(dialog);
115 on_fileOpen_activate (GtkMenuItem *menuitem,
119 GtkFileFilter *filt_all, *filt_xoj;
125 if (!ok_to_close()) return; // user aborted on save confirmation
127 dialog = gtk_file_chooser_dialog_new(_("Open Journal"), GTK_WINDOW (winMain),
128 GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
129 GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL);
130 #ifdef FILE_DIALOG_SIZE_BUGFIX
131 gtk_window_set_default_size(GTK_WINDOW(dialog), 500, 400);
134 filt_all = gtk_file_filter_new();
135 gtk_file_filter_set_name(filt_all, _("All files"));
136 gtk_file_filter_add_pattern(filt_all, "*");
137 filt_xoj = gtk_file_filter_new();
138 gtk_file_filter_set_name(filt_xoj, _("Xournal files"));
139 gtk_file_filter_add_pattern(filt_xoj, "*.xoj");
140 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_xoj);
141 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_all);
143 if (ui.default_path!=NULL) gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (dialog), ui.default_path);
145 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
146 gtk_widget_destroy(dialog);
149 filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
150 gtk_widget_destroy(dialog);
152 set_cursor_busy(TRUE);
153 success = open_journal(filename);
154 set_cursor_busy(FALSE);
155 if (success) { g_free(filename); return; }
158 dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
159 GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Error opening file '%s'"), filename);
160 gtk_dialog_run(GTK_DIALOG(dialog));
161 gtk_widget_destroy(dialog);
168 on_fileSave_activate (GtkMenuItem *menuitem,
175 if (ui.filename == NULL) {
176 on_fileSaveAs_activate(menuitem, user_data);
179 set_cursor_busy(TRUE);
180 if (save_journal(ui.filename)) { // success
181 set_cursor_busy(FALSE);
185 set_cursor_busy(FALSE);
187 dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
188 GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Error saving file '%s'"), ui.filename);
189 gtk_dialog_run(GTK_DIALOG(dialog));
190 gtk_widget_destroy(dialog);
195 on_fileSaveAs_activate (GtkMenuItem *menuitem,
198 GtkWidget *dialog, *warning_dialog;
199 GtkFileFilter *filt_all, *filt_xoj;
204 struct stat stat_buf;
208 dialog = gtk_file_chooser_dialog_new(_("Save Journal"), GTK_WINDOW (winMain),
209 GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
210 GTK_STOCK_SAVE, GTK_RESPONSE_OK, NULL);
211 #ifdef FILE_DIALOG_SIZE_BUGFIX
212 gtk_window_set_default_size(GTK_WINDOW(dialog), 500, 400);
215 if (ui.filename!=NULL) {
216 gtk_file_chooser_set_filename(GTK_FILE_CHOOSER (dialog), ui.filename);
217 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), g_basename(ui.filename));
220 if (bgpdf.status!=STATUS_NOT_INIT && bgpdf.file_domain == DOMAIN_ABSOLUTE
221 && bgpdf.filename != NULL) {
222 filename = g_strdup_printf("%s.xoj", bgpdf.filename->s);
223 gtk_file_chooser_set_filename(GTK_FILE_CHOOSER (dialog), filename);
224 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), g_basename(filename));
228 curtime = time(NULL);
229 strftime(stime, 30, "%F-Note-%H-%M.xoj", localtime(&curtime));
230 if (ui.default_path!=NULL)
231 gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (dialog), ui.default_path);
232 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), stime);
235 filt_all = gtk_file_filter_new();
236 gtk_file_filter_set_name(filt_all, _("All files"));
237 gtk_file_filter_add_pattern(filt_all, "*");
238 filt_xoj = gtk_file_filter_new();
239 gtk_file_filter_set_name(filt_xoj, _("Xournal files"));
240 gtk_file_filter_add_pattern(filt_xoj, "*.xoj");
241 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_xoj);
242 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_all);
244 // somehow this doesn't seem to be set by default
245 gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
248 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
249 gtk_widget_destroy(dialog);
252 filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
253 warn = g_file_test (filename, G_FILE_TEST_EXISTS);
254 if (warn) { // ok to overwrite an empty file
255 if (!g_stat(filename, &stat_buf))
256 if (stat_buf.st_size == 0) warn=FALSE;
258 if (warn && ui.filename!=NULL) { // ok to overwrite oneself
259 if (ui.filename[0]=='/' && !strcmp(ui.filename, filename)) warn=FALSE;
260 if (ui.filename[0]!='/' && g_str_has_suffix(filename, ui.filename)) warn=FALSE;
263 warning_dialog = gtk_message_dialog_new(GTK_WINDOW(winMain),
264 GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO,
265 _("Should the file %s be overwritten?"), filename);
266 if (gtk_dialog_run(GTK_DIALOG(warning_dialog)) == GTK_RESPONSE_YES)
268 gtk_widget_destroy(warning_dialog);
272 gtk_widget_destroy(dialog);
274 set_cursor_busy(TRUE);
275 if (save_journal(filename)) { // success
277 set_cursor_busy(FALSE);
278 update_file_name(filename);
281 set_cursor_busy(FALSE);
283 dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
284 GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Error saving file '%s'"), filename);
285 gtk_dialog_run(GTK_DIALOG(dialog));
286 gtk_widget_destroy(dialog);
292 on_filePrintOptions_activate (GtkMenuItem *menuitem,
299 on_filePrint_activate (GtkMenuItem *menuitem,
302 #if GTK_CHECK_VERSION(2, 10, 0)
303 GtkPrintOperation *print;
304 GtkPrintOperationResult res;
306 int fromPage, toPage;
312 if (!gtk_check_version(2, 10, 0)) {
313 print = gtk_print_operation_new();
315 if (!ui.print_settings)
316 ui.print_settings = gtk_print_settings_new();
317 if (ui.filename!=NULL) {
318 if (g_str_has_suffix(ui.filename, ".xoj")) {
319 in_fn = g_strdup(ui.filename);
320 g_strlcpy(g_strrstr(in_fn, "xoj"), "pdf", 4);
322 else in_fn = g_strdup_printf("%s.pdf", ui.filename);
323 gtk_print_settings_set(ui.print_settings, GTK_PRINT_SETTINGS_OUTPUT_URI,
324 g_filename_to_uri(in_fn, NULL, NULL));
328 if (ui.print_settings!=NULL)
329 gtk_print_operation_set_print_settings (print, ui.print_settings);
330 gtk_print_operation_set_n_pages(print, journal.npages);
331 gtk_print_operation_set_current_page(print, ui.pageno);
332 gtk_print_operation_set_show_progress(print, TRUE);
333 if (ui.filename!=NULL) {
334 p = g_utf8_strrchr(ui.filename, -1, '/');
335 if (p==NULL) p = ui.filename;
337 gtk_print_operation_set_job_name(print, p);
339 g_signal_connect (print, "draw_page", G_CALLBACK (print_job_render_page), NULL);
340 res = gtk_print_operation_run(print, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG,
341 GTK_WINDOW(winMain), NULL);
342 if (res == GTK_PRINT_OPERATION_RESULT_APPLY) {
343 if (ui.print_settings!=NULL) g_object_unref(ui.print_settings);
344 ui.print_settings = g_object_ref(gtk_print_operation_get_print_settings(print));
346 g_object_unref(print);
353 on_filePrintPDF_activate (GtkMenuItem *menuitem,
357 GtkWidget *dialog, *warning_dialog;
358 GtkFileFilter *filt_all, *filt_pdf;
359 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);
369 #ifdef FILE_DIALOG_SIZE_BUGFIX
370 gtk_window_set_default_size(GTK_WINDOW(dialog), 500, 400);
373 if (ui.filename!=NULL) {
374 if (g_str_has_suffix(ui.filename, ".xoj")) {
375 in_fn = g_strdup(ui.filename);
376 g_strlcpy(g_strrstr(in_fn, "xoj"), "pdf", 4);
379 in_fn = g_strdup_printf("%s.pdf", ui.filename);
380 gtk_file_chooser_set_filename(GTK_FILE_CHOOSER (dialog), in_fn);
381 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), g_basename(in_fn));
383 curtime = time(NULL);
384 strftime(stime, 30, "%F-Note-%H-%M.pdf", localtime(&curtime));
385 if (ui.default_path!=NULL)
386 gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (dialog), ui.default_path);
387 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), stime);
391 filt_all = gtk_file_filter_new();
392 gtk_file_filter_set_name(filt_all, _("All files"));
393 gtk_file_filter_add_pattern(filt_all, "*");
394 filt_pdf = gtk_file_filter_new();
395 gtk_file_filter_set_name(filt_pdf, _("PDF files"));
396 gtk_file_filter_add_pattern(filt_pdf, "*.pdf");
397 gtk_file_filter_add_pattern(filt_pdf, "*.PDF");
398 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_pdf);
399 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_all);
400 gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
404 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
405 gtk_widget_destroy(dialog);
408 filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
409 warn = g_file_test(filename, G_FILE_TEST_EXISTS);
411 warning_dialog = gtk_message_dialog_new(GTK_WINDOW(winMain),
412 GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO,
413 _("Should the file %s be overwritten?"), filename);
414 if (gtk_dialog_run(GTK_DIALOG(warning_dialog)) == GTK_RESPONSE_YES)
416 gtk_widget_destroy(warning_dialog);
420 gtk_widget_destroy(dialog);
422 set_cursor_busy(TRUE);
423 if (!print_to_pdf(filename)) {
424 set_cursor_busy(FALSE);
425 dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
426 GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Error creating file '%s'"), filename);
427 gtk_dialog_run(GTK_DIALOG(dialog));
428 gtk_widget_destroy(dialog);
430 set_cursor_busy(FALSE);
436 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 GnomeCanvasGroup *group;
461 if (undo == NULL) return; // nothing to undo!
462 reset_selection(); // safer
463 if (undo->type == ITEM_STROKE || undo->type == ITEM_TEXT) {
464 // we're keeping the stroke info, but deleting the canvas item
465 gtk_object_destroy(GTK_OBJECT(undo->item->canvas_item));
466 undo->item->canvas_item = NULL;
467 // we also remove the object from its layer!
468 undo->layer->items = g_list_remove(undo->layer->items, undo->item);
469 undo->layer->nitems--;
471 else if (undo->type == ITEM_ERASURE || undo->type == ITEM_RECOGNIZER) {
472 for (list = undo->erasurelist; list!=NULL; list = list->next) {
473 erasure = (struct UndoErasureData *)list->data;
474 // delete all the created items
475 for (itemlist = erasure->replacement_items; itemlist!=NULL; itemlist = itemlist->next) {
476 it = (struct Item *)itemlist->data;
477 gtk_object_destroy(GTK_OBJECT(it->canvas_item));
478 it->canvas_item = NULL;
479 undo->layer->items = g_list_remove(undo->layer->items, it);
480 undo->layer->nitems--;
482 // recreate the deleted one
483 make_canvas_item_one(undo->layer->group, erasure->item);
485 undo->layer->items = g_list_insert(undo->layer->items, erasure->item,
487 if (erasure->npos == 0)
488 lower_canvas_item_to(undo->layer->group, erasure->item->canvas_item, NULL);
490 lower_canvas_item_to(undo->layer->group, erasure->item->canvas_item,
491 ((struct Item *)g_list_nth_data(undo->layer->items, erasure->npos-1))->canvas_item);
492 undo->layer->nitems++;
495 else if (undo->type == ITEM_NEW_BG_ONE || undo->type == ITEM_NEW_BG_RESIZE
496 || undo->type == ITEM_PAPER_RESIZE) {
497 if (undo->type != ITEM_PAPER_RESIZE) {
499 tmp_bg = undo->page->bg;
500 undo->page->bg = undo->bg;
502 undo->page->bg->canvas_item = undo->bg->canvas_item;
503 undo->bg->canvas_item = NULL;
505 if (undo->type != ITEM_NEW_BG_ONE) {
506 tmp_x = undo->page->width;
507 tmp_y = undo->page->height;
508 undo->page->width = undo->val_x;
509 undo->page->height = undo->val_y;
512 make_page_clipbox(undo->page);
514 update_canvas_bg(undo->page);
515 do_switch_page(g_list_index(journal.pages, undo->page), TRUE, TRUE);
517 else if (undo->type == ITEM_NEW_DEFAULT_BG) {
518 tmp_bg = ui.default_page.bg;
519 ui.default_page.bg = undo->bg;
521 tmp_x = ui.default_page.width;
522 tmp_y = ui.default_page.height;
523 ui.default_page.width = undo->val_x;
524 ui.default_page.height = undo->val_y;
528 else if (undo->type == ITEM_NEW_PAGE) {
529 // unmap the page; keep the page & its empty layer in memory
530 if (undo->page->group!=NULL) gtk_object_destroy(GTK_OBJECT(undo->page->group));
531 // also destroys the background and layer's canvas items
532 undo->page->group = NULL;
533 undo->page->bg->canvas_item = NULL;
534 journal.pages = g_list_remove(journal.pages, undo->page);
536 if (ui.cur_page == undo->page) ui.cur_page = NULL;
537 // so do_switch_page() won't try to remap the layers of the defunct page
538 if (ui.pageno >= undo->val) ui.pageno--;
539 if (ui.pageno < 0) ui.pageno = 0;
540 do_switch_page(ui.pageno, TRUE, TRUE);
542 else if (undo->type == ITEM_DELETE_PAGE) {
543 journal.pages = g_list_insert(journal.pages, undo->page, undo->val);
545 make_canvas_items(); // re-create the canvas items
546 do_switch_page(undo->val, TRUE, TRUE);
548 else if (undo->type == ITEM_MOVESEL) {
549 for (itemlist = undo->itemlist; itemlist != NULL; itemlist = itemlist->next) {
550 it = (struct Item *)itemlist->data;
551 if (it->canvas_item != NULL) {
552 if (undo->layer != undo->layer2)
553 gnome_canvas_item_reparent(it->canvas_item, undo->layer->group);
554 gnome_canvas_item_move(it->canvas_item, -undo->val_x, -undo->val_y);
557 move_journal_items_by(undo->itemlist, -undo->val_x, -undo->val_y,
558 undo->layer2, undo->layer, undo->auxlist);
560 else if (undo->type == ITEM_RESIZESEL) {
561 resize_journal_items_by(undo->itemlist,
562 1/undo->scaling_x, 1/undo->scaling_y,
563 -undo->val_x/undo->scaling_x, -undo->val_y/undo->scaling_y);
565 else if (undo->type == ITEM_PASTE) {
566 for (itemlist = undo->itemlist; itemlist != NULL; itemlist = itemlist->next) {
567 it = (struct Item *)itemlist->data;
568 gtk_object_destroy(GTK_OBJECT(it->canvas_item));
569 it->canvas_item = NULL;
570 undo->layer->items = g_list_remove(undo->layer->items, it);
571 undo->layer->nitems--;
574 else if (undo->type == ITEM_NEW_LAYER) {
575 // unmap the layer; keep the empty layer in memory
576 if (undo->layer->group!=NULL) gtk_object_destroy(GTK_OBJECT(undo->layer->group));
577 undo->layer->group = NULL;
578 undo->page->layers = g_list_remove(undo->page->layers, undo->layer);
579 undo->page->nlayers--;
580 do_switch_page(ui.pageno, FALSE, FALSE); // don't stay with bad cur_layer info
582 else if (undo->type == ITEM_DELETE_LAYER) {
583 // special case of -1: deleted the last layer, created a new one
584 if (undo->val == -1) {
585 if (undo->layer2->group!=NULL) gtk_object_destroy(GTK_OBJECT(undo->layer2->group));
586 undo->layer2->group = NULL;
587 undo->page->layers = g_list_remove(undo->page->layers, undo->layer2);
588 undo->page->nlayers--;
591 undo->layer->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
592 undo->page->group, gnome_canvas_group_get_type(), NULL);
593 lower_canvas_item_to(undo->page->group, GNOME_CANVAS_ITEM(undo->layer->group),
594 (undo->val >= 1) ? GNOME_CANVAS_ITEM(((struct Layer *)
595 g_list_nth_data(undo->page->layers, undo->val-1))->group) :
596 undo->page->bg->canvas_item);
597 undo->page->layers = g_list_insert(undo->page->layers, undo->layer,
598 (undo->val >= 0) ? undo->val:0);
599 undo->page->nlayers++;
601 for (itemlist = undo->layer->items; itemlist!=NULL; itemlist = itemlist->next)
602 make_canvas_item_one(undo->layer->group, (struct Item *)itemlist->data);
604 do_switch_page(ui.pageno, FALSE, FALSE); // show the restored layer & others...
606 else if (undo->type == ITEM_REPAINTSEL) {
607 for (itemlist = undo->itemlist, list = undo->auxlist; itemlist!=NULL;
608 itemlist = itemlist->next, list = list->next) {
609 it = (struct Item *)itemlist->data;
610 g_memmove(&tmp_brush, &(it->brush), sizeof(struct Brush));
611 g_memmove(&(it->brush), list->data, sizeof(struct Brush));
612 g_memmove(list->data, &tmp_brush, sizeof(struct Brush));
613 if (it->type == ITEM_STROKE && it->canvas_item != NULL) {
614 // remark: a variable-width item might have lost its variable-width
615 group = (GnomeCanvasGroup *) it->canvas_item->parent;
616 gtk_object_destroy(GTK_OBJECT(it->canvas_item));
617 make_canvas_item_one(group, it);
619 if (it->type == ITEM_TEXT && it->canvas_item != NULL)
620 gnome_canvas_item_set(it->canvas_item,
621 "fill-color-rgba", it->brush.color_rgba, NULL);
624 else if (undo->type == ITEM_TEXT_EDIT) {
626 undo->str = undo->item->text;
627 undo->item->text = tmpstr;
628 gnome_canvas_item_set(undo->item->canvas_item, "text", tmpstr, NULL);
629 update_item_bbox(undo->item);
631 else if (undo->type == ITEM_TEXT_ATTRIB) {
633 undo->str = undo->item->font_name;
634 undo->item->font_name = tmpstr;
636 undo->val_x = undo->item->font_size;
637 undo->item->font_size = tmp_x;
638 g_memmove(&tmp_brush, undo->brush, sizeof(struct Brush));
639 g_memmove(undo->brush, &(undo->item->brush), sizeof(struct Brush));
640 g_memmove(&(undo->item->brush), &tmp_brush, sizeof(struct Brush));
641 gnome_canvas_item_set(undo->item->canvas_item,
642 "fill-color-rgba", undo->item->brush.color_rgba, NULL);
643 update_text_item_displayfont(undo->item);
644 update_item_bbox(undo->item);
647 // move item from undo to redo stack
653 update_undo_redo_enabled();
654 if (u->multiop & MULTIOP_CONT_UNDO) on_editUndo_activate(NULL,NULL); // loop
659 on_editRedo_activate (GtkMenuItem *menuitem,
663 GList *list, *itemlist, *target;
664 struct UndoErasureData *erasure;
666 struct Brush tmp_brush;
667 struct Background *tmp_bg;
671 GnomeCanvasGroup *group;
675 if (redo == NULL) return; // nothing to redo!
676 reset_selection(); // safer
677 if (redo->type == ITEM_STROKE || redo->type == ITEM_TEXT) {
678 // re-create the canvas_item
679 make_canvas_item_one(redo->layer->group, redo->item);
680 // reinsert the item on its layer
681 redo->layer->items = g_list_append(redo->layer->items, redo->item);
682 redo->layer->nitems++;
684 else if (redo->type == ITEM_ERASURE || redo->type == ITEM_RECOGNIZER) {
685 for (list = redo->erasurelist; list!=NULL; list = list->next) {
686 erasure = (struct UndoErasureData *)list->data;
687 target = g_list_find(redo->layer->items, erasure->item);
688 // re-create all the created items
689 for (itemlist = erasure->replacement_items; itemlist!=NULL; itemlist = itemlist->next) {
690 it = (struct Item *)itemlist->data;
691 make_canvas_item_one(redo->layer->group, it);
692 redo->layer->items = g_list_insert_before(redo->layer->items, target, it);
693 redo->layer->nitems++;
694 lower_canvas_item_to(redo->layer->group, it->canvas_item, erasure->item->canvas_item);
696 // re-delete the deleted one
697 gtk_object_destroy(GTK_OBJECT(erasure->item->canvas_item));
698 erasure->item->canvas_item = NULL;
699 redo->layer->items = g_list_delete_link(redo->layer->items, target);
700 redo->layer->nitems--;
703 else if (redo->type == ITEM_NEW_BG_ONE || redo->type == ITEM_NEW_BG_RESIZE
704 || redo->type == ITEM_PAPER_RESIZE) {
705 if (redo->type != ITEM_PAPER_RESIZE) {
707 tmp_bg = redo->page->bg;
708 redo->page->bg = redo->bg;
710 redo->page->bg->canvas_item = redo->bg->canvas_item;
711 redo->bg->canvas_item = NULL;
713 if (redo->type != ITEM_NEW_BG_ONE) {
714 tmp_x = redo->page->width;
715 tmp_y = redo->page->height;
716 redo->page->width = redo->val_x;
717 redo->page->height = redo->val_y;
720 make_page_clipbox(redo->page);
722 update_canvas_bg(redo->page);
723 do_switch_page(g_list_index(journal.pages, redo->page), TRUE, TRUE);
725 else if (redo->type == ITEM_NEW_DEFAULT_BG) {
726 tmp_bg = ui.default_page.bg;
727 ui.default_page.bg = redo->bg;
729 tmp_x = ui.default_page.width;
730 tmp_y = ui.default_page.height;
731 ui.default_page.width = redo->val_x;
732 ui.default_page.height = redo->val_y;
736 else if (redo->type == ITEM_NEW_PAGE) {
738 redo->page->bg->canvas_item = NULL;
739 redo->page->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
740 gnome_canvas_root(canvas), gnome_canvas_clipgroup_get_type(), NULL);
741 make_page_clipbox(redo->page);
742 update_canvas_bg(redo->page);
743 l = (struct Layer *)redo->page->layers->data;
744 l->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
745 redo->page->group, gnome_canvas_group_get_type(), NULL);
747 journal.pages = g_list_insert(journal.pages, redo->page, redo->val);
749 do_switch_page(redo->val, TRUE, TRUE);
751 else if (redo->type == ITEM_DELETE_PAGE) {
752 // unmap all the canvas items
753 gtk_object_destroy(GTK_OBJECT(redo->page->group));
754 redo->page->group = NULL;
755 redo->page->bg->canvas_item = NULL;
756 for (list = redo->page->layers; list!=NULL; list = list->next) {
757 l = (struct Layer *)list->data;
758 for (itemlist = l->items; itemlist!=NULL; itemlist = itemlist->next)
759 ((struct Item *)itemlist->data)->canvas_item = NULL;
762 journal.pages = g_list_remove(journal.pages, redo->page);
764 if (ui.pageno > redo->val || ui.pageno == journal.npages) ui.pageno--;
766 // so do_switch_page() won't try to remap the layers of the defunct page
767 do_switch_page(ui.pageno, TRUE, TRUE);
769 else if (redo->type == ITEM_MOVESEL) {
770 for (itemlist = redo->itemlist; itemlist != NULL; itemlist = itemlist->next) {
771 it = (struct Item *)itemlist->data;
772 if (it->canvas_item != NULL) {
773 if (redo->layer != redo->layer2)
774 gnome_canvas_item_reparent(it->canvas_item, redo->layer2->group);
775 gnome_canvas_item_move(it->canvas_item, redo->val_x, redo->val_y);
778 move_journal_items_by(redo->itemlist, redo->val_x, redo->val_y,
779 redo->layer, redo->layer2, NULL);
781 else if (redo->type == ITEM_RESIZESEL) {
782 resize_journal_items_by(redo->itemlist,
783 redo->scaling_x, redo->scaling_y, redo->val_x, redo->val_y);
785 else if (redo->type == ITEM_PASTE) {
786 for (itemlist = redo->itemlist; itemlist != NULL; itemlist = itemlist->next) {
787 it = (struct Item *)itemlist->data;
788 make_canvas_item_one(redo->layer->group, it);
789 redo->layer->items = g_list_append(redo->layer->items, it);
790 redo->layer->nitems++;
793 else if (redo->type == ITEM_NEW_LAYER) {
794 redo->layer->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
795 redo->page->group, gnome_canvas_group_get_type(), NULL);
796 lower_canvas_item_to(redo->page->group, GNOME_CANVAS_ITEM(redo->layer->group),
797 (redo->val >= 1) ? GNOME_CANVAS_ITEM(((struct Layer *)
798 g_list_nth_data(redo->page->layers, redo->val-1))->group) :
799 redo->page->bg->canvas_item);
800 redo->page->layers = g_list_insert(redo->page->layers, redo->layer, redo->val);
801 redo->page->nlayers++;
802 do_switch_page(ui.pageno, FALSE, FALSE);
804 else if (redo->type == ITEM_DELETE_LAYER) {
805 gtk_object_destroy(GTK_OBJECT(redo->layer->group));
806 redo->layer->group = NULL;
807 for (list=redo->layer->items; list!=NULL; list=list->next)
808 ((struct Item *)list->data)->canvas_item = NULL;
809 redo->page->layers = g_list_remove(redo->page->layers, redo->layer);
810 redo->page->nlayers--;
811 if (redo->val == -1) {
812 redo->layer2->group = (GnomeCanvasGroup *)gnome_canvas_item_new(
813 redo->page->group, gnome_canvas_group_get_type(), NULL);
814 redo->page->layers = g_list_append(redo->page->layers, redo->layer2);
815 redo->page->nlayers++;
817 do_switch_page(ui.pageno, FALSE, FALSE);
819 else if (redo->type == ITEM_REPAINTSEL) {
820 for (itemlist = redo->itemlist, list = redo->auxlist; itemlist!=NULL;
821 itemlist = itemlist->next, list = list->next) {
822 it = (struct Item *)itemlist->data;
823 g_memmove(&tmp_brush, &(it->brush), sizeof(struct Brush));
824 g_memmove(&(it->brush), list->data, sizeof(struct Brush));
825 g_memmove(list->data, &tmp_brush, sizeof(struct Brush));
826 if (it->type == ITEM_STROKE && it->canvas_item != NULL) {
827 // remark: a variable-width item might have lost its variable-width
828 group = (GnomeCanvasGroup *) it->canvas_item->parent;
829 gtk_object_destroy(GTK_OBJECT(it->canvas_item));
830 make_canvas_item_one(group, it);
832 if (it->type == ITEM_TEXT && it->canvas_item != NULL)
833 gnome_canvas_item_set(it->canvas_item,
834 "fill-color-rgba", it->brush.color_rgba, NULL);
837 else if (redo->type == ITEM_TEXT_EDIT) {
839 redo->str = redo->item->text;
840 redo->item->text = tmpstr;
841 gnome_canvas_item_set(redo->item->canvas_item, "text", tmpstr, NULL);
842 update_item_bbox(redo->item);
844 else if (redo->type == ITEM_TEXT_ATTRIB) {
846 redo->str = redo->item->font_name;
847 redo->item->font_name = tmpstr;
849 redo->val_x = redo->item->font_size;
850 redo->item->font_size = tmp_x;
851 g_memmove(&tmp_brush, redo->brush, sizeof(struct Brush));
852 g_memmove(redo->brush, &(redo->item->brush), sizeof(struct Brush));
853 g_memmove(&(redo->item->brush), &tmp_brush, sizeof(struct Brush));
854 gnome_canvas_item_set(redo->item->canvas_item,
855 "fill-color-rgba", redo->item->brush.color_rgba, NULL);
856 update_text_item_displayfont(redo->item);
857 update_item_bbox(redo->item);
860 // move item from redo to undo stack
866 update_undo_redo_enabled();
867 if (u->multiop & MULTIOP_CONT_REDO) on_editRedo_activate(NULL,NULL); // loop
872 on_editCut_activate (GtkMenuItem *menuitem,
883 on_editCopy_activate (GtkMenuItem *menuitem,
893 on_editPaste_activate (GtkMenuItem *menuitem,
903 on_editDelete_activate (GtkMenuItem *menuitem,
913 on_viewContinuous_activate (GtkMenuItem *menuitem,
916 GtkAdjustment *v_adj;
921 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
922 if (ui.view_continuous) return;
923 ui.view_continuous = TRUE;
924 v_adj = gtk_layout_get_vadjustment(GTK_LAYOUT(canvas));
926 yscroll = gtk_adjustment_get_value(v_adj) - pg->voffset*ui.zoom;
928 gtk_adjustment_set_value(v_adj, yscroll + pg->voffset*ui.zoom);
930 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
935 on_viewOnePage_activate (GtkMenuItem *menuitem,
938 GtkAdjustment *v_adj;
942 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
943 if (!ui.view_continuous) return;
944 ui.view_continuous = FALSE;
945 v_adj = gtk_layout_get_vadjustment(GTK_LAYOUT(canvas));
946 yscroll = gtk_adjustment_get_value(v_adj) - ui.cur_page->voffset*ui.zoom;
948 gtk_adjustment_set_value(v_adj, yscroll + ui.cur_page->voffset*ui.zoom);
950 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
955 on_viewZoomIn_activate (GtkMenuItem *menuitem,
959 if (ui.zoom > MAX_ZOOM) return;
960 ui.zoom *= ui.zoom_step_factor;
961 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
962 rescale_text_items();
963 rescale_bg_pixmaps();
968 on_viewZoomOut_activate (GtkMenuItem *menuitem,
972 if (ui.zoom < MIN_ZOOM) return;
973 ui.zoom /= ui.zoom_step_factor;
974 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
975 rescale_text_items();
976 rescale_bg_pixmaps();
981 on_viewNormalSize_activate (GtkMenuItem *menuitem,
985 ui.zoom = DEFAULT_ZOOM;
986 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
987 rescale_text_items();
988 rescale_bg_pixmaps();
993 on_viewPageWidth_activate (GtkMenuItem *menuitem,
997 ui.zoom = (GTK_WIDGET(canvas))->allocation.width/ui.cur_page->width;
998 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
999 rescale_text_items();
1000 rescale_bg_pixmaps();
1005 on_viewFirstPage_activate (GtkMenuItem *menuitem,
1010 do_switch_page(0, TRUE, FALSE);
1015 on_viewPreviousPage_activate (GtkMenuItem *menuitem,
1020 if (ui.pageno == 0) return;
1021 do_switch_page(ui.pageno-1, TRUE, FALSE);
1026 on_viewNextPage_activate (GtkMenuItem *menuitem,
1031 if (ui.pageno == journal.npages-1) { // create a page at end
1032 on_journalNewPageEnd_activate(menuitem, user_data);
1035 do_switch_page(ui.pageno+1, TRUE, FALSE);
1040 on_viewLastPage_activate (GtkMenuItem *menuitem,
1045 do_switch_page(journal.npages-1, TRUE, FALSE);
1050 on_viewShowLayer_activate (GtkMenuItem *menuitem,
1055 if (ui.layerno == ui.cur_page->nlayers-1) return;
1058 ui.cur_layer = g_list_nth_data(ui.cur_page->layers, ui.layerno);
1059 gnome_canvas_item_show(GNOME_CANVAS_ITEM(ui.cur_layer->group));
1060 update_page_stuff();
1065 on_viewHideLayer_activate (GtkMenuItem *menuitem,
1070 if (ui.layerno == -1) return;
1072 gnome_canvas_item_hide(GNOME_CANVAS_ITEM(ui.cur_layer->group));
1074 if (ui.layerno<0) ui.cur_layer = NULL;
1075 else ui.cur_layer = g_list_nth_data(ui.cur_page->layers, ui.layerno);
1076 update_page_stuff();
1081 on_journalNewPageBefore_activate (GtkMenuItem *menuitem,
1089 pg = new_page(ui.cur_page);
1090 journal.pages = g_list_insert(journal.pages, pg, ui.pageno);
1092 do_switch_page(ui.pageno, TRUE, TRUE);
1095 undo->type = ITEM_NEW_PAGE;
1096 undo->val = ui.pageno;
1102 on_journalNewPageAfter_activate (GtkMenuItem *menuitem,
1110 pg = new_page(ui.cur_page);
1111 journal.pages = g_list_insert(journal.pages, pg, ui.pageno+1);
1113 do_switch_page(ui.pageno+1, TRUE, TRUE);
1116 undo->type = ITEM_NEW_PAGE;
1117 undo->val = ui.pageno;
1123 on_journalNewPageEnd_activate (GtkMenuItem *menuitem,
1131 pg = new_page((struct Page *)g_list_last(journal.pages)->data);
1132 journal.pages = g_list_append(journal.pages, pg);
1134 do_switch_page(journal.npages-1, TRUE, TRUE);
1137 undo->type = ITEM_NEW_PAGE;
1138 undo->val = ui.pageno;
1144 on_journalDeletePage_activate (GtkMenuItem *menuitem,
1147 GList *layerlist, *itemlist;
1152 if (journal.npages == 1) return;
1155 undo->type = ITEM_DELETE_PAGE;
1156 undo->val = ui.pageno;
1157 undo->page = ui.cur_page;
1159 // unmap all the canvas items
1160 gtk_object_destroy(GTK_OBJECT(ui.cur_page->group));
1161 ui.cur_page->group = NULL;
1162 ui.cur_page->bg->canvas_item = NULL;
1163 for (layerlist = ui.cur_page->layers; layerlist!=NULL; layerlist = layerlist->next) {
1164 l = (struct Layer *)layerlist->data;
1165 for (itemlist = l->items; itemlist!=NULL; itemlist = itemlist->next)
1166 ((struct Item *)itemlist->data)->canvas_item = NULL;
1170 journal.pages = g_list_remove(journal.pages, ui.cur_page);
1172 if (ui.pageno == journal.npages) ui.pageno--;
1174 // so do_switch_page() won't try to remap the layers of the defunct page
1175 do_switch_page(ui.pageno, TRUE, TRUE);
1180 on_journalNewLayer_activate (GtkMenuItem *menuitem,
1188 l = g_new(struct Layer, 1);
1191 l->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
1192 ui.cur_page->group, gnome_canvas_group_get_type(), NULL);
1193 lower_canvas_item_to(ui.cur_page->group, GNOME_CANVAS_ITEM(l->group),
1194 (ui.cur_layer!=NULL)?(GNOME_CANVAS_ITEM(ui.cur_layer->group)):(ui.cur_page->bg->canvas_item));
1195 ui.cur_page->layers = g_list_insert(ui.cur_page->layers, l, ui.layerno+1);
1198 ui.cur_page->nlayers++;
1199 update_page_stuff();
1202 undo->type = ITEM_NEW_LAYER;
1203 undo->val = ui.layerno;
1205 undo->page = ui.cur_page;
1210 on_journalDeleteLayer_activate (GtkMenuItem *menuitem,
1217 if (ui.cur_layer == NULL) return;
1220 undo->type = ITEM_DELETE_LAYER;
1221 undo->val = ui.layerno;
1222 undo->layer = ui.cur_layer;
1223 undo->layer2 = NULL;
1224 undo->page = ui.cur_page;
1225 // delete all the canvas items
1226 gtk_object_destroy(GTK_OBJECT(ui.cur_layer->group));
1227 ui.cur_layer->group = NULL;
1228 for (list=ui.cur_layer->items; list!=NULL; list=list->next)
1229 ((struct Item *)list->data)->canvas_item = NULL;
1231 ui.cur_page->layers = g_list_remove(ui.cur_page->layers, ui.cur_layer);
1233 if (ui.cur_page->nlayers>=2) {
1234 ui.cur_page->nlayers--;
1236 if (ui.layerno<0) ui.cur_layer = NULL;
1237 else ui.cur_layer = (struct Layer *)g_list_nth_data(ui.cur_page->layers, ui.layerno);
1239 else { // special case: can't remove the last layer
1240 ui.cur_layer = g_new(struct Layer, 1);
1241 ui.cur_layer->items = NULL;
1242 ui.cur_layer->nitems = 0;
1243 ui.cur_layer->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
1244 ui.cur_page->group, gnome_canvas_group_get_type(), NULL);
1245 ui.cur_page->layers = g_list_append(NULL, ui.cur_layer);
1247 undo->layer2 = ui.cur_layer;
1250 update_page_stuff();
1255 on_journalFlatten_activate (GtkMenuItem *menuitem,
1262 // the paper sizes dialog
1264 GtkWidget *papersize_dialog;
1265 int papersize_std, papersize_unit;
1266 double papersize_width, papersize_height;
1267 gboolean papersize_need_init, papersize_width_valid, papersize_height_valid;
1269 #define STD_SIZE_A4 0
1270 #define STD_SIZE_A4R 1
1271 #define STD_SIZE_LETTER 2
1272 #define STD_SIZE_LETTER_R 3
1273 #define STD_SIZE_CUSTOM 4
1275 double unit_sizes[4] = {28.346, 72., 72./DISPLAY_DPI_DEFAULT, 1.};
1276 double std_widths[STD_SIZE_CUSTOM] = {595.27, 841.89, 612., 792.};
1277 double std_heights[STD_SIZE_CUSTOM] = {841.89, 595.27, 792., 612.};
1278 double std_units[STD_SIZE_CUSTOM] = {UNIT_CM, UNIT_CM, UNIT_IN, UNIT_IN};
1281 on_journalPaperSize_activate (GtkMenuItem *menuitem,
1290 papersize_dialog = create_papersizeDialog();
1291 papersize_width = ui.cur_page->width;
1292 papersize_height = ui.cur_page->height;
1293 papersize_unit = ui.default_unit;
1294 unit_sizes[UNIT_PX] = 1./DEFAULT_ZOOM;
1295 // if (ui.cur_page->bg->type == BG_PIXMAP) papersize_unit = UNIT_PX;
1296 papersize_std = STD_SIZE_CUSTOM;
1297 for (i=0;i<STD_SIZE_CUSTOM;i++)
1298 if (fabs(papersize_width - std_widths[i])<0.1 &&
1299 fabs(papersize_height - std_heights[i])<0.1)
1300 { papersize_std = i; papersize_unit = std_units[i]; }
1301 papersize_need_init = TRUE;
1302 papersize_width_valid = papersize_height_valid = TRUE;
1304 gtk_widget_show(papersize_dialog);
1305 on_comboStdSizes_changed(GTK_COMBO_BOX(g_object_get_data(
1306 G_OBJECT(papersize_dialog), "comboStdSizes")), NULL);
1307 gtk_dialog_set_default_response(GTK_DIALOG(papersize_dialog), GTK_RESPONSE_OK);
1309 response = gtk_dialog_run(GTK_DIALOG(papersize_dialog));
1310 gtk_widget_destroy(papersize_dialog);
1311 if (response != GTK_RESPONSE_OK) return;
1314 for (pglist = journal.pages; pglist!=NULL; pglist = pglist->next) {
1315 if (ui.bg_apply_all_pages) pg = (struct Page *)pglist->data;
1317 if (ui.bg_apply_all_pages) {
1318 if (pglist->next!=NULL) undo->multiop |= MULTIOP_CONT_REDO;
1319 if (pglist->prev!=NULL) undo->multiop |= MULTIOP_CONT_UNDO;
1321 undo->type = ITEM_PAPER_RESIZE;
1323 undo->val_x = pg->width;
1324 undo->val_y = pg->height;
1325 if (papersize_width_valid) pg->width = papersize_width;
1326 if (papersize_height_valid) pg->height = papersize_height;
1327 make_page_clipbox(pg);
1328 update_canvas_bg(pg);
1329 if (!ui.bg_apply_all_pages) break;
1331 do_switch_page(ui.pageno, TRUE, TRUE);
1336 on_papercolorWhite_activate (GtkMenuItem *menuitem,
1341 process_papercolor_activate(menuitem, COLOR_WHITE);
1346 on_papercolorYellow_activate (GtkMenuItem *menuitem,
1351 process_papercolor_activate(menuitem, COLOR_YELLOW);
1356 on_papercolorPink_activate (GtkMenuItem *menuitem,
1361 process_papercolor_activate(menuitem, COLOR_RED);
1366 on_papercolorOrange_activate (GtkMenuItem *menuitem,
1371 process_papercolor_activate(menuitem, COLOR_ORANGE);
1376 on_papercolorBlue_activate (GtkMenuItem *menuitem,
1381 process_papercolor_activate(menuitem, COLOR_BLUE);
1386 on_papercolorGreen_activate (GtkMenuItem *menuitem,
1391 process_papercolor_activate(menuitem, COLOR_GREEN);
1396 on_papercolorOther_activate (GtkMenuItem *menuitem,
1404 on_paperstylePlain_activate (GtkMenuItem *menuitem,
1409 process_paperstyle_activate(menuitem, RULING_NONE);
1414 on_paperstyleLined_activate (GtkMenuItem *menuitem,
1419 process_paperstyle_activate(menuitem, RULING_LINED);
1424 on_paperstyleRuled_activate (GtkMenuItem *menuitem,
1429 process_paperstyle_activate(menuitem, RULING_RULED);
1434 on_paperstyleGraph_activate (GtkMenuItem *menuitem,
1439 process_paperstyle_activate(menuitem, RULING_GRAPH);
1444 on_journalLoadBackground_activate (GtkMenuItem *menuitem,
1447 GtkWidget *dialog, *attach_opt;
1448 struct Background *bg;
1451 GList *bglist, *bglistiter;
1452 GtkFileFilter *filt_all, *filt_pix, *filt_pspdf;
1458 dialog = gtk_file_chooser_dialog_new(_("Open Background"), GTK_WINDOW (winMain),
1459 GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1460 GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL);
1461 #ifdef FILE_DIALOG_SIZE_BUGFIX
1462 gtk_window_set_default_size(GTK_WINDOW(dialog), 500, 400);
1465 filt_all = gtk_file_filter_new();
1466 gtk_file_filter_set_name(filt_all, _("All files"));
1467 gtk_file_filter_add_pattern(filt_all, "*");
1468 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_all);
1470 #if GTK_CHECK_VERSION(2,6,0)
1472 if (!gtk_check_version(2, 6, 0)) {
1473 filt_pix = gtk_file_filter_new();
1474 gtk_file_filter_set_name(filt_pix, _("Bitmap files"));
1475 gtk_file_filter_add_pixbuf_formats(filt_pix);
1476 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_pix);
1481 filt_pspdf = gtk_file_filter_new();
1482 gtk_file_filter_set_name(filt_pspdf, _("PS/PDF files (as bitmaps)"));
1483 gtk_file_filter_add_pattern(filt_pspdf, "*.ps");
1484 gtk_file_filter_add_pattern(filt_pspdf, "*.PS");
1485 gtk_file_filter_add_pattern(filt_pspdf, "*.pdf");
1486 gtk_file_filter_add_pattern(filt_pspdf, "*.PDF");
1487 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_pspdf);
1489 attach_opt = gtk_check_button_new_with_label(_("Attach file to the journal"));
1490 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(attach_opt), FALSE);
1491 gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER (dialog), attach_opt);
1493 if (ui.default_path!=NULL) gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (dialog), ui.default_path);
1495 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
1496 gtk_widget_destroy(dialog);
1499 filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
1500 attach = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(attach_opt));
1501 gtk_widget_destroy(dialog);
1503 set_cursor_busy(TRUE);
1504 bg = attempt_load_pix_bg(filename, attach);
1505 if (bg != NULL) bglist = g_list_append(NULL, bg);
1506 else bglist = attempt_load_gv_bg(filename);
1507 set_cursor_busy(FALSE);
1509 if (bglist == NULL) {
1510 dialog = gtk_message_dialog_new(GTK_WINDOW(winMain), GTK_DIALOG_MODAL,
1511 GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
1512 _("Error opening background '%s'"), filename);
1513 gtk_dialog_run(GTK_DIALOG(dialog));
1514 gtk_widget_destroy(dialog);
1523 for (bglistiter = bglist, pageno = ui.pageno;
1524 bglistiter!=NULL; bglistiter = bglistiter->next, pageno++) {
1526 if (bglistiter->next!=NULL) undo->multiop |= MULTIOP_CONT_REDO;
1527 if (bglistiter->prev!=NULL) undo->multiop |= MULTIOP_CONT_UNDO;
1529 bg = (struct Background *)bglistiter->data;
1531 if (pageno == journal.npages) {
1532 undo->type = ITEM_NEW_PAGE;
1533 pg = new_page_with_bg(bg,
1534 gdk_pixbuf_get_width(bg->pixbuf)/bg->pixbuf_scale,
1535 gdk_pixbuf_get_height(bg->pixbuf)/bg->pixbuf_scale);
1536 journal.pages = g_list_append(journal.pages, pg);
1542 pg = g_list_nth_data(journal.pages, pageno);
1543 undo->type = ITEM_NEW_BG_RESIZE;
1546 bg->canvas_item = undo->bg->canvas_item;
1547 undo->bg->canvas_item = NULL;
1548 undo->val_x = pg->width;
1549 undo->val_y = pg->height;
1551 pg->width = gdk_pixbuf_get_width(bg->pixbuf)/bg->pixbuf_scale;
1552 pg->height = gdk_pixbuf_get_height(bg->pixbuf)/bg->pixbuf_scale;
1553 make_page_clipbox(pg);
1554 update_canvas_bg(pg);
1558 g_list_free(bglist);
1559 if (ui.zoom != DEFAULT_ZOOM) {
1560 ui.zoom = DEFAULT_ZOOM;
1561 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
1562 rescale_text_items();
1563 rescale_bg_pixmaps();
1565 do_switch_page(ui.pageno, TRUE, TRUE);
1569 on_journalScreenshot_activate (GtkMenuItem *menuitem,
1572 struct Background *bg;
1577 gtk_window_iconify(GTK_WINDOW(winMain)); // hide ourselves
1578 gdk_display_sync(gdk_display_get_default());
1580 if (ui.cursor!=NULL)
1581 gdk_cursor_unref(ui.cursor);
1582 ui.cursor = gdk_cursor_new(GDK_TCROSS);
1584 bg = attempt_screenshot_bg();
1586 gtk_window_deiconify(GTK_WINDOW(winMain));
1588 if (bg==NULL) return;
1591 undo->type = ITEM_NEW_BG_RESIZE;
1592 undo->page = ui.cur_page;
1593 undo->bg = ui.cur_page->bg;
1594 bg->canvas_item = undo->bg->canvas_item;
1595 undo->bg->canvas_item = NULL;
1596 undo->val_x = ui.cur_page->width;
1597 undo->val_y = ui.cur_page->height;
1599 ui.cur_page->bg = bg;
1600 ui.cur_page->width = gdk_pixbuf_get_width(bg->pixbuf)/bg->pixbuf_scale;
1601 ui.cur_page->height = gdk_pixbuf_get_height(bg->pixbuf)/bg->pixbuf_scale;
1603 make_page_clipbox(ui.cur_page);
1604 update_canvas_bg(ui.cur_page);
1606 if (ui.zoom != DEFAULT_ZOOM) {
1607 ui.zoom = DEFAULT_ZOOM;
1608 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
1609 rescale_text_items();
1610 rescale_bg_pixmaps();
1612 do_switch_page(ui.pageno, TRUE, TRUE);
1617 on_journalApplyAllPages_activate (GtkMenuItem *menuitem,
1624 active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
1625 if (active == ui.bg_apply_all_pages) return;
1626 ui.bg_apply_all_pages = active;
1627 update_page_stuff();
1629 /* THIS IS THE OLD VERSION OF THE FEATURE -- APPLIED CURRENT BG TO ALL
1633 if (ui.cur_page->bg->type != BG_SOLID) return;
1635 for (pglist = journal.pages; pglist!=NULL; pglist = pglist->next) {
1636 page = (struct Page *)pglist->data;
1638 undo->type = ITEM_NEW_BG_RESIZE;
1640 undo->bg = page->bg;
1641 undo->val_x = page->width;
1642 undo->val_y = page->height;
1643 if (pglist->next!=NULL) undo->multiop |= MULTIOP_CONT_REDO;
1644 if (pglist->prev!=NULL) undo->multiop |= MULTIOP_CONT_UNDO;
1645 page->bg = (struct Background *)g_memdup(ui.cur_page->bg, sizeof(struct Background));
1646 page->width = ui.cur_page->width;
1647 page->height = ui.cur_page->height;
1648 page->bg->canvas_item = undo->bg->canvas_item;
1649 undo->bg->canvas_item = NULL;
1651 make_page_clipbox(page);
1652 update_canvas_bg(page);
1654 do_switch_page(ui.pageno, TRUE, TRUE);
1661 on_toolsPen_activate (GtkMenuItem *menuitem,
1664 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1665 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1668 if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1672 if (ui.cur_mapping != 0 && !ui.button_switch_mapping) return; // not user-generated
1673 if (ui.toolno[ui.cur_mapping] == TOOL_PEN) return;
1675 ui.cur_mapping = 0; // don't use switch_mapping() (refreshes buttons too soon)
1679 ui.toolno[ui.cur_mapping] = TOOL_PEN;
1680 ui.cur_brush = &(ui.brushes[ui.cur_mapping][TOOL_PEN]);
1681 ui.cur_brush->ruler = ui.default_brushes[TOOL_PEN].ruler;
1682 ui.cur_brush->recognizer = ui.default_brushes[TOOL_PEN].recognizer;
1683 update_mapping_linkings(TOOL_PEN);
1684 update_tool_buttons();
1686 update_color_menu();
1692 on_toolsEraser_activate (GtkMenuItem *menuitem,
1695 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1696 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1699 if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1703 if (ui.cur_mapping != 0 && !ui.button_switch_mapping) return; // not user-generated
1704 if (ui.toolno[ui.cur_mapping] == TOOL_ERASER) return;
1706 ui.cur_mapping = 0; // don't use switch_mapping() (refreshes buttons too soon)
1710 ui.toolno[ui.cur_mapping] = TOOL_ERASER;
1711 ui.cur_brush = &(ui.brushes[ui.cur_mapping][TOOL_ERASER]);
1712 update_mapping_linkings(TOOL_ERASER);
1713 update_tool_buttons();
1715 update_color_menu();
1721 on_toolsHighlighter_activate (GtkMenuItem *menuitem,
1724 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1725 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1728 if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1732 if (ui.cur_mapping != 0 && !ui.button_switch_mapping) return; // not user-generated
1733 if (ui.toolno[ui.cur_mapping] == TOOL_HIGHLIGHTER) return;
1735 ui.cur_mapping = 0; // don't use switch_mapping() (refreshes buttons too soon)
1739 ui.toolno[ui.cur_mapping] = TOOL_HIGHLIGHTER;
1740 ui.cur_brush = &(ui.brushes[ui.cur_mapping][TOOL_HIGHLIGHTER]);
1741 ui.cur_brush->ruler = ui.default_brushes[TOOL_HIGHLIGHTER].ruler;
1742 ui.cur_brush->recognizer = ui.default_brushes[TOOL_HIGHLIGHTER].recognizer;
1743 update_mapping_linkings(TOOL_HIGHLIGHTER);
1744 update_tool_buttons();
1746 update_color_menu();
1752 on_toolsText_activate (GtkMenuItem *menuitem,
1755 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1756 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1759 if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1763 if (ui.cur_mapping != 0 && !ui.button_switch_mapping) return; // not user-generated
1764 if (ui.toolno[ui.cur_mapping] == TOOL_TEXT) return;
1766 ui.cur_mapping = 0; // don't use switch_mapping() (refreshes buttons too soon)
1769 ui.toolno[ui.cur_mapping] = TOOL_TEXT;
1770 ui.cur_brush = &(ui.brushes[ui.cur_mapping][TOOL_PEN]);
1771 update_mapping_linkings(-1);
1772 update_tool_buttons();
1774 update_color_menu();
1780 on_toolsSelectRegion_activate (GtkMenuItem *menuitem,
1788 on_toolsSelectRectangle_activate (GtkMenuItem *menuitem,
1791 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1792 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1795 if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1799 if (ui.cur_mapping != 0 && !ui.button_switch_mapping) return; // not user-generated
1800 if (ui.toolno[ui.cur_mapping] == TOOL_SELECTRECT) return;
1802 ui.cur_mapping = 0; // don't use switch_mapping() (refreshes buttons too soon)
1805 ui.toolno[ui.cur_mapping] = TOOL_SELECTRECT;
1806 update_mapping_linkings(-1);
1807 update_tool_buttons();
1809 update_color_menu();
1815 on_toolsVerticalSpace_activate (GtkMenuItem *menuitem,
1818 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1819 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1822 if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1826 if (ui.cur_mapping != 0 && !ui.button_switch_mapping) return; // not user-generated
1827 if (ui.toolno[ui.cur_mapping] == TOOL_VERTSPACE) return;
1829 ui.cur_mapping = 0; // don't use switch_mapping() (refreshes buttons too soon)
1833 ui.toolno[ui.cur_mapping] = TOOL_VERTSPACE;
1834 update_mapping_linkings(-1);
1835 update_tool_buttons();
1837 update_color_menu();
1843 on_colorBlack_activate (GtkMenuItem *menuitem,
1846 process_color_activate(menuitem, COLOR_BLACK, predef_colors_rgba[COLOR_BLACK]);
1851 on_colorBlue_activate (GtkMenuItem *menuitem,
1854 process_color_activate(menuitem, COLOR_BLUE, predef_colors_rgba[COLOR_BLUE]);
1859 on_colorRed_activate (GtkMenuItem *menuitem,
1862 process_color_activate(menuitem, COLOR_RED, predef_colors_rgba[COLOR_RED]);
1867 on_colorGreen_activate (GtkMenuItem *menuitem,
1870 process_color_activate(menuitem, COLOR_GREEN, predef_colors_rgba[COLOR_GREEN]);
1875 on_colorGray_activate (GtkMenuItem *menuitem,
1878 process_color_activate(menuitem, COLOR_GRAY, predef_colors_rgba[COLOR_GRAY]);
1883 on_colorLightBlue_activate (GtkMenuItem *menuitem,
1886 process_color_activate(menuitem, COLOR_LIGHTBLUE, predef_colors_rgba[COLOR_LIGHTBLUE]);
1891 on_colorLightGreen_activate (GtkMenuItem *menuitem,
1894 process_color_activate(menuitem, COLOR_LIGHTGREEN, predef_colors_rgba[COLOR_LIGHTGREEN]);
1899 on_colorMagenta_activate (GtkMenuItem *menuitem,
1902 process_color_activate(menuitem, COLOR_MAGENTA, predef_colors_rgba[COLOR_MAGENTA]);
1907 on_colorOrange_activate (GtkMenuItem *menuitem,
1910 process_color_activate(menuitem, COLOR_ORANGE, predef_colors_rgba[COLOR_ORANGE]);
1915 on_colorYellow_activate (GtkMenuItem *menuitem,
1918 process_color_activate(menuitem, COLOR_YELLOW, predef_colors_rgba[COLOR_YELLOW]);
1923 on_colorWhite_activate (GtkMenuItem *menuitem,
1926 process_color_activate(menuitem, COLOR_WHITE, predef_colors_rgba[COLOR_WHITE]);
1931 on_colorOther_activate (GtkMenuItem *menuitem,
1934 gtk_button_clicked(GTK_BUTTON(GET_COMPONENT("buttonColorChooser")));
1939 on_penthicknessVeryFine_activate (GtkMenuItem *menuitem,
1942 process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_VERYFINE);
1947 on_penthicknessFine_activate (GtkMenuItem *menuitem,
1950 process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_FINE);
1955 on_penthicknessMedium_activate (GtkMenuItem *menuitem,
1958 process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_MEDIUM);
1963 on_penthicknessThick_activate (GtkMenuItem *menuitem,
1966 process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_THICK);
1971 on_penthicknessVeryThick_activate (GtkMenuItem *menuitem,
1974 process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_VERYTHICK);
1979 on_eraserFine_activate (GtkMenuItem *menuitem,
1982 process_thickness_activate(menuitem, TOOL_ERASER, THICKNESS_FINE);
1987 on_eraserMedium_activate (GtkMenuItem *menuitem,
1990 process_thickness_activate(menuitem, TOOL_ERASER, THICKNESS_MEDIUM);
1995 on_eraserThick_activate (GtkMenuItem *menuitem,
1998 process_thickness_activate(menuitem, TOOL_ERASER, THICKNESS_THICK);
2003 on_eraserStandard_activate (GtkMenuItem *menuitem,
2006 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
2009 ui.brushes[0][TOOL_ERASER].tool_options = TOOLOPT_ERASER_STANDARD;
2010 update_mapping_linkings(TOOL_ERASER);
2015 on_eraserWhiteout_activate (GtkMenuItem *menuitem,
2018 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
2021 ui.brushes[0][TOOL_ERASER].tool_options = TOOLOPT_ERASER_WHITEOUT;
2022 update_mapping_linkings(TOOL_ERASER);
2027 on_eraserDeleteStrokes_activate (GtkMenuItem *menuitem,
2030 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
2033 ui.brushes[0][TOOL_ERASER].tool_options = TOOLOPT_ERASER_STROKES;
2034 update_mapping_linkings(TOOL_ERASER);
2039 on_highlighterFine_activate (GtkMenuItem *menuitem,
2042 process_thickness_activate(menuitem, TOOL_HIGHLIGHTER, THICKNESS_FINE);
2047 on_highlighterMedium_activate (GtkMenuItem *menuitem,
2050 process_thickness_activate(menuitem, TOOL_HIGHLIGHTER, THICKNESS_MEDIUM);
2055 on_highlighterThick_activate (GtkMenuItem *menuitem,
2058 process_thickness_activate(menuitem, TOOL_HIGHLIGHTER, THICKNESS_THICK);
2063 on_toolsTextFont_activate (GtkMenuItem *menuitem,
2069 dialog = gtk_font_selection_dialog_new(_("Select Font"));
2070 str = make_cur_font_name();
2071 gtk_font_selection_dialog_set_font_name(GTK_FONT_SELECTION_DIALOG(dialog), str);
2073 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
2074 gtk_widget_destroy(dialog);
2078 str = gtk_font_selection_dialog_get_font_name(GTK_FONT_SELECTION_DIALOG(dialog));
2079 gtk_widget_destroy(dialog);
2080 process_font_sel(str);
2084 on_toolsDefaultPen_activate (GtkMenuItem *menuitem,
2091 g_memmove(&(ui.brushes[0][TOOL_PEN]), ui.default_brushes+TOOL_PEN, sizeof(struct Brush));
2092 ui.toolno[0] = TOOL_PEN;
2093 ui.cur_brush = &(ui.brushes[0][TOOL_PEN]);
2094 update_mapping_linkings(TOOL_PEN);
2095 update_tool_buttons();
2097 update_pen_props_menu();
2098 update_color_menu();
2104 on_toolsDefaultEraser_activate (GtkMenuItem *menuitem,
2111 g_memmove(&(ui.brushes[0][TOOL_ERASER]), ui.default_brushes+TOOL_ERASER, sizeof(struct Brush));
2112 ui.toolno[0] = TOOL_ERASER;
2113 ui.cur_brush = &(ui.brushes[0][TOOL_ERASER]);
2114 update_mapping_linkings(TOOL_ERASER);
2115 update_tool_buttons();
2117 update_eraser_props_menu();
2118 update_color_menu();
2124 on_toolsDefaultHighlighter_activate (GtkMenuItem *menuitem,
2131 g_memmove(&(ui.brushes[0][TOOL_HIGHLIGHTER]), ui.default_brushes+TOOL_HIGHLIGHTER, sizeof(struct Brush));
2132 ui.toolno[0] = TOOL_HIGHLIGHTER;
2133 ui.cur_brush = &(ui.brushes[0][TOOL_HIGHLIGHTER]);
2134 update_mapping_linkings(TOOL_HIGHLIGHTER);
2135 update_tool_buttons();
2137 update_highlighter_props_menu();
2138 update_color_menu();
2143 on_toolsDefaultText_activate (GtkMenuItem *menuitem,
2147 if (ui.toolno[0]!=TOOL_TEXT) end_text();
2150 ui.toolno[0] = TOOL_TEXT;
2151 ui.cur_brush = &(ui.brushes[0][TOOL_PEN]);
2152 ui.cur_brush->color_no = ui.default_brushes[TOOL_PEN].color_no;
2153 ui.cur_brush->color_rgba = ui.default_brushes[TOOL_PEN].color_rgba;
2154 g_free(ui.font_name);
2155 ui.font_name = g_strdup(ui.default_font_name);
2156 ui.font_size = ui.default_font_size;
2157 if (ui.cur_item_type == ITEM_TEXT) {
2158 refont_text_item(ui.cur_item, ui.font_name, ui.font_size);
2160 update_font_button();
2161 update_mapping_linkings(-1);
2162 update_tool_buttons();
2164 update_color_menu();
2170 on_toolsSetAsDefault_activate (GtkMenuItem *menuitem,
2175 if (ui.cur_mapping!=0 && !ui.button_switch_mapping) return;
2176 if (ui.toolno[ui.cur_mapping] < NUM_STROKE_TOOLS)
2177 g_memmove(ui.default_brushes+ui.toolno[ui.cur_mapping],
2178 &(ui.brushes[ui.cur_mapping][ui.toolno[ui.cur_mapping]]), sizeof(struct Brush));
2179 if (ui.toolno[ui.cur_mapping] == TOOL_TEXT) {
2180 if (ui.cur_item_type == ITEM_TEXT) {
2181 g_free(ui.font_name);
2182 ui.font_name = g_strdup(ui.cur_item->font_name);
2183 ui.font_size = ui.cur_item->font_size;
2185 else if (ui.selection!=NULL && ui.selection->items!=NULL &&
2186 ui.selection->items->next==NULL &&
2187 (it=(struct Item*)ui.selection->items->data)->type == ITEM_TEXT) {
2188 g_free(ui.font_name);
2189 ui.font_name = g_strdup(it->font_name);
2190 ui.font_size = it->font_size;
2192 g_free(ui.default_font_name);
2193 ui.default_font_name = g_strdup(ui.font_name);
2194 ui.default_font_size = ui.font_size;
2202 on_toolsRuler_activate (GtkMenuItem *menuitem,
2205 gboolean active, current;
2207 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_CHECK_MENU_ITEM)
2208 active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
2210 active = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem));
2212 if (ui.cur_mapping != 0 && !ui.button_switch_mapping) return;
2213 current = (ui.toolno[ui.cur_mapping] == TOOL_PEN || ui.toolno[ui.cur_mapping] == TOOL_HIGHLIGHTER) && ui.cur_brush->ruler;
2214 if (active == current) return;
2219 if (ui.toolno[ui.cur_mapping]!=TOOL_PEN && ui.toolno[ui.cur_mapping]!=TOOL_HIGHLIGHTER) {
2221 ui.toolno[ui.cur_mapping] = TOOL_PEN;
2222 ui.cur_brush = &(ui.brushes[ui.cur_mapping][TOOL_PEN]);
2223 update_color_menu();
2224 update_tool_buttons();
2229 ui.cur_brush->ruler = active;
2230 if (active) ui.cur_brush->recognizer = FALSE;
2231 update_mapping_linkings(ui.toolno[ui.cur_mapping]);
2232 update_ruler_indicator();
2237 on_toolsReco_activate (GtkMenuItem *menuitem,
2240 gboolean active, current;
2242 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_CHECK_MENU_ITEM)
2243 active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
2245 active = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem));
2247 if (ui.cur_mapping != 0 && !ui.button_switch_mapping) return;
2248 current = (ui.toolno[ui.cur_mapping] == TOOL_PEN || ui.toolno[ui.cur_mapping] == TOOL_HIGHLIGHTER) && ui.cur_brush->recognizer;
2249 if (active == current) return;
2254 if (ui.toolno[ui.cur_mapping]!=TOOL_PEN && ui.toolno[ui.cur_mapping]!=TOOL_HIGHLIGHTER) {
2256 ui.toolno[ui.cur_mapping] = TOOL_PEN;
2257 ui.cur_brush = &(ui.brushes[ui.cur_mapping][TOOL_PEN]);
2258 update_color_menu();
2259 update_tool_buttons();
2264 ui.cur_brush->recognizer = active;
2266 ui.cur_brush->ruler = FALSE;
2269 update_mapping_linkings(ui.toolno[ui.cur_mapping]);
2270 update_ruler_indicator();
2275 on_optionsSavePreferences_activate (GtkMenuItem *menuitem,
2280 save_config_to_file();
2285 on_helpIndex_activate (GtkMenuItem *menuitem,
2293 on_helpAbout_activate (GtkMenuItem *menuitem,
2296 GtkWidget *aboutDialog;
2297 GtkLabel *labelTitle;
2301 aboutDialog = create_aboutDialog ();
2302 labelTitle = GTK_LABEL(g_object_get_data(G_OBJECT(aboutDialog), "labelTitle"));
2303 gtk_label_set_markup(labelTitle,
2304 "<span size=\"xx-large\" weight=\"bold\">Xournal " VERSION "</span>");
2305 gtk_dialog_run (GTK_DIALOG(aboutDialog));
2306 gtk_widget_destroy(aboutDialog);
2311 on_buttonToolDefault_clicked (GtkToolButton *toolbutton,
2314 if (ui.toolno[0]==TOOL_TEXT) {
2315 on_toolsDefaultText_activate(NULL, NULL);
2321 if (ui.toolno[0] < NUM_STROKE_TOOLS) {
2322 g_memmove(&(ui.brushes[0][ui.toolno[0]]), ui.default_brushes+ui.toolno[0], sizeof(struct Brush));
2323 update_mapping_linkings(ui.toolno[0]);
2324 update_thickness_buttons();
2325 update_color_buttons();
2326 update_color_menu();
2327 if (ui.toolno[0] == TOOL_PEN) update_pen_props_menu();
2328 if (ui.toolno[0] == TOOL_ERASER) update_eraser_props_menu();
2329 if (ui.toolno[0] == TOOL_HIGHLIGHTER) update_highlighter_props_menu();
2336 on_buttonFine_clicked (GtkToolButton *toolbutton,
2339 if (ui.cur_mapping != 0 && !ui.button_switch_mapping) return;
2340 process_thickness_activate((GtkMenuItem*)toolbutton, ui.toolno[ui.cur_mapping], THICKNESS_FINE);
2345 on_buttonMedium_clicked (GtkToolButton *toolbutton,
2348 if (ui.cur_mapping != 0 && !ui.button_switch_mapping) return;
2349 process_thickness_activate((GtkMenuItem*)toolbutton, ui.toolno[ui.cur_mapping], THICKNESS_MEDIUM);
2354 on_buttonThick_clicked (GtkToolButton *toolbutton,
2357 if (ui.cur_mapping != 0 && !ui.button_switch_mapping) return;
2358 process_thickness_activate((GtkMenuItem*)toolbutton, ui.toolno[ui.cur_mapping], THICKNESS_THICK);
2363 on_canvas_button_press_event (GtkWidget *widget,
2364 GdkEventButton *event,
2368 gboolean page_change;
2369 struct Page *tmppage;
2374 GdkEvent scroll_event;
2377 printf("DEBUG: ButtonPress (%s) (x,y)=(%.2f,%.2f), button %d, modifier %x\n",
2378 event->device->name, event->x, event->y, event->button, event->state);
2381 if (ui.cur_item_type != ITEM_TEXT) // remove focus from other elements
2382 gtk_widget_grab_focus(GTK_WIDGET(canvas));
2384 is_core = (event->device == gdk_device_get_core_pointer());
2385 if (!ui.use_xinput && !is_core) return FALSE;
2386 if (ui.use_xinput && is_core && ui.discard_corepointer) return FALSE;
2387 if (event->type != GDK_BUTTON_PRESS) return FALSE;
2388 // double-clicks may have broken axes member (free'd) due to a bug in GDK
2390 if (event->button > 3) { // scroll wheel events! don't paint...
2391 if (ui.use_xinput && !gtk_check_version(2, 17, 0) && event->button <= 7) {
2392 /* with GTK+ 2.17 and later, the entire widget hierarchy is xinput-aware,
2393 so the core button event gets discarded and the scroll event never
2394 gets processed by the main window. This is arguably a GTK+ bug.
2395 We work around it. */
2396 scroll_event.scroll.type = GDK_SCROLL;
2397 scroll_event.scroll.window = event->window;
2398 scroll_event.scroll.send_event = event->send_event;
2399 scroll_event.scroll.time = event->time;
2400 scroll_event.scroll.x = event->x;
2401 scroll_event.scroll.y = event->y;
2402 scroll_event.scroll.state = event->state;
2403 scroll_event.scroll.device = event->device;
2404 scroll_event.scroll.x_root = event->x_root;
2405 scroll_event.scroll.y_root = event->y_root;
2406 if (event->button == 4) scroll_event.scroll.direction = GDK_SCROLL_UP;
2407 else if (event->button == 5) scroll_event.scroll.direction = GDK_SCROLL_DOWN;
2408 else if (event->button == 6) scroll_event.scroll.direction = GDK_SCROLL_LEFT;
2409 else scroll_event.scroll.direction = GDK_SCROLL_RIGHT;
2410 printf("sending...\n");
2411 gtk_widget_event(GET_COMPONENT("scrolledwindowMain"), &scroll_event);
2415 if ((event->state & (GDK_CONTROL_MASK|GDK_MOD1_MASK)) != 0) return FALSE;
2416 // no control-clicking or alt-clicking
2418 fix_xinput_coords((GdkEvent *)event);
2420 if (!finite(event->x) || !finite(event->y)) return FALSE; // Xorg 7.3 bug
2422 if (ui.cur_item_type == ITEM_TEXT) {
2423 if (!is_event_within_textview(event)) end_text();
2426 if (ui.cur_item_type == ITEM_STROKE && ui.is_corestroke && !is_core &&
2427 ui.cur_path.num_points == 1) {
2428 // Xorg 7.3+ sent core event before XInput event: fix initial point
2429 ui.is_corestroke = FALSE;
2430 get_pointer_coords((GdkEvent *)event, ui.cur_path.coords);
2432 if (ui.cur_item_type != ITEM_NONE) return FALSE; // we're already doing something
2434 // if button_switch_mapping enabled, button 2 or 3 clicks only switch mapping
2435 if (ui.button_switch_mapping && event->button > 1) {
2436 ui.which_unswitch_button = event->button;
2437 switch_mapping(event->button-1);
2441 ui.is_corestroke = is_core;
2442 ui.stroke_device = event->device;
2444 if (ui.use_erasertip && event->device->source == GDK_SOURCE_ERASER)
2445 mapping = NUM_BUTTONS;
2446 else if (ui.button_switch_mapping) {
2447 mapping = ui.cur_mapping;
2448 if (!mapping && (event->state & GDK_BUTTON2_MASK)) mapping = 1;
2449 if (!mapping && (event->state & GDK_BUTTON3_MASK)) mapping = 2;
2451 else mapping = event->button-1;
2453 // check whether we're in a page
2454 page_change = FALSE;
2455 tmppage = ui.cur_page;
2456 get_pointer_coords((GdkEvent *)event, pt);
2457 while (ui.view_continuous && (pt[1] < - VIEW_CONTINUOUS_SKIP)) {
2458 if (ui.pageno == 0) break;
2461 tmppage = g_list_nth_data(journal.pages, ui.pageno);
2462 pt[1] += tmppage->height + VIEW_CONTINUOUS_SKIP;
2464 while (ui.view_continuous && (pt[1] > tmppage->height + VIEW_CONTINUOUS_SKIP)) {
2465 if (ui.pageno == journal.npages-1) break;
2466 pt[1] -= tmppage->height + VIEW_CONTINUOUS_SKIP;
2469 tmppage = g_list_nth_data(journal.pages, ui.pageno);
2471 if (page_change) do_switch_page(ui.pageno, FALSE, FALSE);
2473 // can't paint on the background...
2475 if (ui.cur_layer == NULL) {
2477 dialog = gtk_message_dialog_new(GTK_WINDOW(winMain), GTK_DIALOG_MODAL,
2478 GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, _("Drawing is not allowed on the "
2479 "background layer.\n Switching to Layer 1."));
2480 gtk_dialog_run(GTK_DIALOG(dialog));
2481 gtk_widget_destroy(dialog);
2482 on_viewShowLayer_activate(NULL, NULL);
2486 // switch mappings if needed
2488 ui.which_mouse_button = event->button;
2489 switch_mapping(mapping);
2491 // in text tool, clicking in a text area edits it
2492 if (ui.toolno[mapping] == TOOL_TEXT) {
2493 item = click_is_in_text(ui.cur_layer, pt[0], pt[1]);
2496 start_text((GdkEvent *)event, item);
2501 // if this can be a selection move or resize, then it takes precedence over anything else
2502 if (start_resizesel((GdkEvent *)event)) return FALSE;
2503 if (start_movesel((GdkEvent *)event)) return FALSE;
2505 if (ui.toolno[mapping] != TOOL_SELECTREGION && ui.toolno[mapping] != TOOL_SELECTRECT)
2508 // process the event
2510 if (ui.toolno[mapping] == TOOL_HAND) {
2511 ui.cur_item_type = ITEM_HAND;
2512 get_pointer_coords((GdkEvent *)event, ui.hand_refpt);
2513 ui.hand_refpt[0] += ui.cur_page->hoffset;
2514 ui.hand_refpt[1] += ui.cur_page->voffset;
2516 else if (ui.toolno[mapping] == TOOL_PEN || ui.toolno[mapping] == TOOL_HIGHLIGHTER ||
2517 (ui.toolno[mapping] == TOOL_ERASER && ui.cur_brush->tool_options == TOOLOPT_ERASER_WHITEOUT)) {
2518 create_new_stroke((GdkEvent *)event);
2520 else if (ui.toolno[mapping] == TOOL_ERASER) {
2521 ui.cur_item_type = ITEM_ERASURE;
2522 do_eraser((GdkEvent *)event, ui.cur_brush->thickness/2,
2523 ui.cur_brush->tool_options == TOOLOPT_ERASER_STROKES);
2525 else if (ui.toolno[mapping] == TOOL_SELECTRECT) {
2526 start_selectrect((GdkEvent *)event);
2528 else if (ui.toolno[mapping] == TOOL_VERTSPACE) {
2529 start_vertspace((GdkEvent *)event);
2531 else if (ui.toolno[mapping] == TOOL_TEXT) {
2532 start_text((GdkEvent *)event, NULL);
2539 on_canvas_button_release_event (GtkWidget *widget,
2540 GdkEventButton *event,
2546 printf("DEBUG: ButtonRelease (%s) (x,y)=(%.2f,%.2f), button %d, modifier %x\n",
2547 event->device->name, event->x, event->y, event->button, event->state);
2550 is_core = (event->device == gdk_device_get_core_pointer());
2551 if (!ui.use_xinput && !is_core) return FALSE;
2552 if (ui.use_xinput && is_core && !ui.is_corestroke) return FALSE;
2553 if (!is_core) fix_xinput_coords((GdkEvent *)event);
2555 if (event->button != ui.which_mouse_button &&
2556 event->button != ui.which_unswitch_button)
2559 if (ui.cur_item_type == ITEM_STROKE) {
2561 if (ui.cur_brush->recognizer) recognize_patterns();
2563 else if (ui.cur_item_type == ITEM_ERASURE) {
2566 else if (ui.cur_item_type == ITEM_SELECTRECT) {
2567 finalize_selectrect();
2569 else if (ui.cur_item_type == ITEM_MOVESEL || ui.cur_item_type == ITEM_MOVESEL_VERT) {
2572 else if (ui.cur_item_type == ITEM_RESIZESEL) {
2573 finalize_resizesel();
2575 else if (ui.cur_item_type == ITEM_HAND) {
2576 ui.cur_item_type = ITEM_NONE;
2579 if (!ui.which_unswitch_button || event->button == ui.which_unswitch_button)
2580 switch_mapping(0); // will reset ui.which_unswitch_button
2587 on_canvas_enter_notify_event (GtkWidget *widget,
2588 GdkEventCrossing *event,
2596 on_canvas_leave_notify_event (GtkWidget *widget,
2597 GdkEventCrossing *event,
2601 printf("DEBUG: leave notify\n");
2603 if (ui.need_emergency_disable_xinput) {
2604 gtk_widget_set_extension_events(GTK_WIDGET (canvas), GDK_EXTENSION_EVENTS_NONE);
2605 ui.need_emergency_disable_xinput = FALSE;
2612 on_canvas_expose_event (GtkWidget *widget,
2613 GdkEventExpose *event,
2616 if (ui.view_continuous && ui.progressive_bg) rescale_bg_pixmaps();
2622 on_canvas_key_press_event (GtkWidget *widget,
2629 // Esc leaves text edition, or leaves fullscreen mode
2630 if (event->keyval == GDK_Escape) {
2631 if (ui.cur_item_type == ITEM_TEXT) {
2636 else if (ui.fullscreen) {
2637 do_fullscreen(FALSE);
2643 /* In single page mode, switch pages with PgUp/PgDn (or Up/Dn)
2644 when there's nowhere else to go. */
2645 pgheight = GTK_WIDGET(canvas)->allocation.height;
2646 adj = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(GET_COMPONENT("scrolledwindowMain")));
2648 if (event->keyval == GDK_Page_Down || event->keyval == GDK_Down) {
2649 if (!ui.view_continuous &&
2650 (0.96 * ui.zoom * ui.cur_page->height < pgheight ||
2651 adj->value == adj->upper-pgheight))
2654 if (ui.pageno < journal.npages-1)
2655 do_switch_page(ui.pageno+1, TRUE, FALSE);
2658 if (adj->value == adj->upper-pgheight) return TRUE; // don't send focus away
2661 if (event->keyval == GDK_Page_Up || event->keyval == GDK_Up) {
2662 if (!ui.view_continuous &&
2663 (0.96 * ui.zoom * ui.cur_page->height < pgheight ||
2664 adj->value == adj->lower))
2667 if (ui.pageno != 0) {
2668 do_switch_page(ui.pageno-1, TRUE, FALSE);
2669 gtk_adjustment_set_value(adj, adj->upper-pgheight);
2673 if (adj->value == adj->lower) return TRUE; // don't send focus away
2681 on_canvas_motion_notify_event (GtkWidget *widget,
2682 GdkEventMotion *event,
2685 gboolean looks_wrong, is_core;
2687 GdkModifierType mask;
2689 /* we don't care about this event unless some operation is in progress;
2690 or if there's a selection (then we might want to change the mouse
2691 cursor to indicate the possibility of resizing) */
2692 if (ui.cur_item_type == ITEM_NONE && ui.selection==NULL) return FALSE;
2693 if (ui.cur_item_type == ITEM_TEXT) return FALSE;
2695 is_core = (event->device == gdk_device_get_core_pointer());
2696 if (!ui.use_xinput && !is_core) return FALSE;
2697 if (!is_core) fix_xinput_coords((GdkEvent *)event);
2698 if (!finite(event->x) || !finite(event->y)) return FALSE; // Xorg 7.3 bug
2700 if (ui.selection!=NULL && ui.cur_item_type == ITEM_NONE) {
2701 get_pointer_coords((GdkEvent *)event, pt);
2702 update_cursor_for_resize(pt);
2706 if (ui.use_xinput && is_core && !ui.is_corestroke) return FALSE;
2707 if (!is_core) ui.is_corestroke = FALSE;
2710 printf("DEBUG: MotionNotify (%s) (x,y)=(%.2f,%.2f), modifier %x\n",
2711 is_core?"core":"xinput", event->x, event->y, event->state);
2714 looks_wrong = !(event->state & (1<<(7+ui.which_mouse_button)));
2716 gdk_device_get_state(ui.stroke_device, event->window, NULL, &mask);
2717 looks_wrong = !(mask & (1<<(7+ui.which_mouse_button)));
2720 if (looks_wrong) { /* mouse button shouldn't be up... give up */
2721 if (ui.cur_item_type == ITEM_STROKE) {
2723 if (ui.cur_brush->recognizer) recognize_patterns();
2725 else if (ui.cur_item_type == ITEM_ERASURE) {
2728 else if (ui.cur_item_type == ITEM_SELECTRECT) {
2729 finalize_selectrect();
2731 else if (ui.cur_item_type == ITEM_MOVESEL || ui.cur_item_type == ITEM_MOVESEL_VERT) {
2734 else if (ui.cur_item_type == ITEM_RESIZESEL) {
2735 finalize_resizesel();
2741 if (ui.cur_item_type == ITEM_STROKE) {
2742 continue_stroke((GdkEvent *)event);
2744 else if (ui.cur_item_type == ITEM_ERASURE) {
2745 do_eraser((GdkEvent *)event, ui.cur_brush->thickness/2,
2746 ui.cur_brush->tool_options == TOOLOPT_ERASER_STROKES);
2748 else if (ui.cur_item_type == ITEM_SELECTRECT) {
2749 get_pointer_coords((GdkEvent *)event, pt);
2750 ui.selection->bbox.right = pt[0];
2751 ui.selection->bbox.bottom = pt[1];
2752 gnome_canvas_item_set(ui.selection->canvas_item,
2753 "x2", pt[0], "y2", pt[1], NULL);
2755 else if (ui.cur_item_type == ITEM_MOVESEL || ui.cur_item_type == ITEM_MOVESEL_VERT) {
2756 continue_movesel((GdkEvent *)event);
2758 else if (ui.cur_item_type == ITEM_RESIZESEL) {
2759 continue_resizesel((GdkEvent *)event);
2761 else if (ui.cur_item_type == ITEM_HAND) {
2762 do_hand((GdkEvent *)event);
2769 on_comboLayer_changed (GtkComboBox *combobox,
2774 if (ui.in_update_page_stuff) return; // avoid a bad retroaction
2779 val = gtk_combo_box_get_active(combobox);
2780 if (val == -1) return;
2781 val = ui.cur_page->nlayers-1-val;
2782 if (val == ui.layerno) return;
2785 while (val>ui.layerno) {
2787 ui.cur_layer = g_list_nth_data(ui.cur_page->layers, ui.layerno);
2788 gnome_canvas_item_show(GNOME_CANVAS_ITEM(ui.cur_layer->group));
2790 while (val<ui.layerno) {
2791 gnome_canvas_item_hide(GNOME_CANVAS_ITEM(ui.cur_layer->group));
2793 if (ui.layerno<0) ui.cur_layer = NULL;
2794 else ui.cur_layer = g_list_nth_data(ui.cur_page->layers, ui.layerno);
2796 update_page_stuff();
2801 on_winMain_delete_event (GtkWidget *widget,
2807 if (ok_to_close()) gtk_main_quit();
2813 on_optionsUseXInput_activate (GtkMenuItem *menuitem,
2818 ui.allow_xinput = ui.use_xinput =
2819 gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
2821 /* HOW THINGS USED TO BE:
2823 We'd like on_canvas_... to get BOTH core and xinput events. Up to
2824 GTK+ 2.16 this is achieved by making only the canvas's parent
2825 GdkWindow xinput-aware, rather than the entire hierarchy.
2826 Otherwise, the proximity detection code in GDK is broken and
2827 we'll lose core events.
2829 Up to GTK+ 2.10, gtk_widget_set_extension_events() only sets
2830 extension events for the widget's main window itself; in GTK+ 2.11
2831 also traverses GDK child windows that belong to the widget
2832 and sets their extension events too. We want to avoid that.
2833 So we use gdk_input_set_extension_events() directly on the canvas.
2835 As much as possible, we'd like to keep doing this, though GTK+ 2.17
2836 is making our life harder (crasher bugs require us to disable XInput
2837 while editing text or using the layers combo box, but disabling
2838 XInput while in a XInput-aware window causes the interface to become
2842 if (!gtk_check_version(2, 17, 0)) {
2843 /* GTK+ 2.17 and later: everybody shares a single native window,
2844 so we'll never get any core events, and we might as well set
2845 extension events the way we're supposed to. Doing so helps solve
2846 crasher bugs in 2.17, and prevents us from losing two-button
2848 gtk_widget_set_extension_events(GTK_WIDGET (canvas),
2849 ui.use_xinput?GDK_EXTENSION_EVENTS_ALL:GDK_EXTENSION_EVENTS_NONE);
2851 /* GTK+ 2.16 and earlier: we only activate extension events on the
2852 canvas's parent GdkWindow. This allows us to keep receiving core
2854 gdk_input_set_extension_events(GTK_WIDGET(canvas)->window,
2855 GDK_POINTER_MOTION_MASK | GDK_BUTTON_MOTION_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK,
2856 ui.use_xinput?GDK_EXTENSION_EVENTS_ALL:GDK_EXTENSION_EVENTS_NONE);
2859 update_mappings_menu();
2863 on_vscroll_changed (GtkAdjustment *adjustment,
2866 gboolean need_update;
2867 double viewport_top, viewport_bottom;
2868 struct Page *tmppage;
2870 if (!ui.view_continuous) return;
2872 if (ui.progressive_bg) rescale_bg_pixmaps();
2873 need_update = FALSE;
2874 viewport_top = adjustment->value / ui.zoom;
2875 viewport_bottom = (adjustment->value + adjustment->page_size) / ui.zoom;
2876 tmppage = ui.cur_page;
2877 while (viewport_top > tmppage->voffset + tmppage->height) {
2878 if (ui.pageno == journal.npages-1) break;
2881 tmppage = g_list_nth_data(journal.pages, ui.pageno);
2883 while (viewport_bottom < tmppage->voffset) {
2884 if (ui.pageno == 0) break;
2887 tmppage = g_list_nth_data(journal.pages, ui.pageno);
2891 do_switch_page(ui.pageno, FALSE, FALSE);
2898 on_spinPageNo_value_changed (GtkSpinButton *spinbutton,
2903 if (ui.in_update_page_stuff) return; // avoid a bad retroaction
2908 val = gtk_spin_button_get_value_as_int(spinbutton) - 1;
2910 if (val == journal.npages) { // create a page at end
2911 on_journalNewPageEnd_activate(NULL, NULL);
2915 if (val == ui.pageno) return;
2916 if (val < 0) val = 0;
2917 if (val > journal.npages-1) val = journal.npages-1;
2918 do_switch_page(val, TRUE, FALSE);
2923 on_journalDefaultBackground_activate (GtkMenuItem *menuitem,
2934 for (pglist = journal.pages; pglist!=NULL; pglist = pglist->next) {
2935 if (ui.bg_apply_all_pages) pg = (struct Page *)pglist->data;
2937 if (ui.bg_apply_all_pages) {
2938 if (pglist->next!=NULL) undo->multiop |= MULTIOP_CONT_REDO;
2939 if (pglist->prev!=NULL) undo->multiop |= MULTIOP_CONT_UNDO;
2941 undo->type = ITEM_NEW_BG_RESIZE;
2944 undo->val_x = pg->width;
2945 undo->val_y = pg->height;
2946 pg->bg = (struct Background *)g_memdup(ui.default_page.bg, sizeof(struct Background));
2947 pg->width = ui.default_page.width;
2948 pg->height = ui.default_page.height;
2949 pg->bg->canvas_item = undo->bg->canvas_item;
2950 undo->bg->canvas_item = NULL;
2952 make_page_clipbox(pg);
2953 update_canvas_bg(pg);
2954 if (!ui.bg_apply_all_pages) break;
2956 do_switch_page(ui.pageno, TRUE, TRUE);
2961 on_journalSetAsDefault_activate (GtkMenuItem *menuitem,
2964 if (ui.cur_page->bg->type != BG_SOLID) return;
2969 undo->type = ITEM_NEW_DEFAULT_BG;
2970 undo->val_x = ui.default_page.width;
2971 undo->val_y = ui.default_page.height;
2972 undo->bg = ui.default_page.bg;
2974 ui.default_page.width = ui.cur_page->width;
2975 ui.default_page.height = ui.cur_page->height;
2976 ui.default_page.bg = (struct Background *)g_memdup(ui.cur_page->bg, sizeof(struct Background));
2977 ui.default_page.bg->canvas_item = NULL;
2982 on_comboStdSizes_changed (GtkComboBox *combobox,
2986 GtkComboBox *comboUnit;
2990 if (papersize_need_init) {
2991 gtk_combo_box_set_active(combobox, papersize_std);
2992 papersize_need_init = FALSE;
2994 val = gtk_combo_box_get_active(combobox);
2995 if (val == -1 || val == papersize_std) return;
2996 papersize_std = val;
2997 if (val == STD_SIZE_CUSTOM) return;
2998 papersize_unit = std_units[val];
2999 papersize_width = std_widths[val];
3000 papersize_height = std_heights[val];
3002 comboUnit = GTK_COMBO_BOX(g_object_get_data(G_OBJECT(papersize_dialog), "comboUnit"));
3003 gtk_combo_box_set_active(comboUnit, papersize_unit);
3004 entry = GTK_ENTRY(g_object_get_data(G_OBJECT(papersize_dialog), "entryWidth"));
3005 g_snprintf(text, 20, "%.2f", papersize_width/unit_sizes[papersize_unit]);
3006 if (g_str_has_suffix(text, ".00"))
3007 g_snprintf(text, 20, "%d", (int) (papersize_width/unit_sizes[papersize_unit]));
3008 gtk_entry_set_text(entry, text);
3009 entry = GTK_ENTRY(g_object_get_data(G_OBJECT(papersize_dialog), "entryHeight"));
3010 g_snprintf(text, 20, "%.2f", papersize_height/unit_sizes[papersize_unit]);
3011 if (g_str_has_suffix(text, ".00"))
3012 g_snprintf(text, 20, "%d", (int) (papersize_height/unit_sizes[papersize_unit]));
3013 gtk_entry_set_text(entry, text);
3018 on_entryWidth_changed (GtkEditable *editable,
3024 GtkComboBox *comboStdSizes;
3026 text = gtk_entry_get_text(GTK_ENTRY(editable));
3027 val = strtod(text, &ptr);
3028 papersize_width_valid = (*ptr == 0 && val > 0.);
3029 if (!papersize_width_valid) return; // invalid entry
3030 val *= unit_sizes[papersize_unit];
3031 if (fabs(val - papersize_width) < 0.1) return; // no change
3032 papersize_std = STD_SIZE_CUSTOM;
3033 papersize_width = val;
3034 comboStdSizes = GTK_COMBO_BOX(g_object_get_data(G_OBJECT(papersize_dialog), "comboStdSizes"));
3035 gtk_combo_box_set_active(comboStdSizes, papersize_std);
3040 on_entryHeight_changed (GtkEditable *editable,
3046 GtkComboBox *comboStdSizes;
3048 text = gtk_entry_get_text(GTK_ENTRY(editable));
3049 val = strtod(text, &ptr);
3050 papersize_height_valid = (*ptr == 0 && val > 0.);
3051 if (!papersize_height_valid) return; // invalid entry
3052 val *= unit_sizes[papersize_unit];
3053 if (fabs(val - papersize_height) < 0.1) return; // no change
3054 papersize_std = STD_SIZE_CUSTOM;
3055 papersize_height = val;
3056 comboStdSizes = GTK_COMBO_BOX(g_object_get_data(G_OBJECT(papersize_dialog), "comboStdSizes"));
3057 gtk_combo_box_set_active(comboStdSizes, papersize_std);
3062 on_comboUnit_changed (GtkComboBox *combobox,
3069 val = gtk_combo_box_get_active(combobox);
3070 if (val == -1 || val == papersize_unit) return;
3071 papersize_unit = val;
3072 entry = GTK_ENTRY(g_object_get_data(G_OBJECT(papersize_dialog), "entryWidth"));
3073 if (papersize_width_valid) {
3074 g_snprintf(text, 20, "%.2f", papersize_width/unit_sizes[papersize_unit]);
3075 if (g_str_has_suffix(text, ".00"))
3076 g_snprintf(text, 20, "%d", (int) (papersize_width/unit_sizes[papersize_unit]));
3078 gtk_entry_set_text(entry, text);
3079 if (papersize_height_valid) {
3080 entry = GTK_ENTRY(g_object_get_data(G_OBJECT(papersize_dialog), "entryHeight"));
3081 g_snprintf(text, 20, "%.2f", papersize_height/unit_sizes[papersize_unit]);
3082 if (g_str_has_suffix(text, ".00"))
3083 g_snprintf(text, 20, "%d", (int) (papersize_height/unit_sizes[papersize_unit]));
3085 gtk_entry_set_text(entry, text);
3090 on_viewFullscreen_activate (GtkMenuItem *menuitem,
3095 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_CHECK_MENU_ITEM)
3096 active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
3098 active = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem));
3100 if (active == ui.fullscreen) return;
3101 do_fullscreen(active);
3106 on_optionsButtonMappings_activate (GtkMenuItem *menuitem,
3112 gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
3113 update_mappings_menu();
3118 on_optionsProgressiveBG_activate (GtkMenuItem *menuitem,
3123 active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
3124 if (ui.progressive_bg == active) return;
3127 ui.progressive_bg = active;
3128 if (!ui.progressive_bg) rescale_bg_pixmaps();
3133 on_mru_activate (GtkMenuItem *menuitem,
3142 if (!ok_to_close()) return; // user aborted on save confirmation
3144 for (which = 0 ; which < MRU_SIZE; which++) {
3145 if (ui.mrumenu[which] == GTK_WIDGET(menuitem)) break;
3147 if (which == MRU_SIZE || ui.mru[which] == NULL) return; // not found...
3149 set_cursor_busy(TRUE);
3150 success = open_journal(ui.mru[which]);
3151 set_cursor_busy(FALSE);
3152 if (success) return;
3155 dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
3156 GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Error opening file '%s'"), ui.mru[which]);
3157 gtk_dialog_run(GTK_DIALOG(dialog));
3158 gtk_widget_destroy(dialog);
3159 delete_mru_entry(which);
3164 on_button2Pen_activate (GtkMenuItem *menuitem,
3167 process_mapping_activate(menuitem, 1, TOOL_PEN);
3172 on_button2Eraser_activate (GtkMenuItem *menuitem,
3175 process_mapping_activate(menuitem, 1, TOOL_ERASER);
3180 on_button2Highlighter_activate (GtkMenuItem *menuitem,
3183 process_mapping_activate(menuitem, 1, TOOL_HIGHLIGHTER);
3188 on_button2Text_activate (GtkMenuItem *menuitem,
3191 process_mapping_activate(menuitem, 1, TOOL_TEXT);
3196 on_button2SelectRegion_activate (GtkMenuItem *menuitem,
3199 process_mapping_activate(menuitem, 1, TOOL_SELECTREGION);
3204 on_button2SelectRectangle_activate (GtkMenuItem *menuitem,
3207 process_mapping_activate(menuitem, 1, TOOL_SELECTRECT);
3212 on_button2VerticalSpace_activate (GtkMenuItem *menuitem,
3215 process_mapping_activate(menuitem, 1, TOOL_VERTSPACE);
3220 on_button2LinkBrush_activate (GtkMenuItem *menuitem,
3225 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem))) return;
3228 ui.linked_brush[1] = BRUSH_LINKED;
3229 for (i=0;i<NUM_STROKE_TOOLS;i++) update_mapping_linkings(i);
3234 on_button2CopyBrush_activate (GtkMenuItem *menuitem,
3237 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem))) return;
3240 if (ui.toolno[1] >= NUM_STROKE_TOOLS) {
3241 ui.linked_brush[1] = BRUSH_STATIC;
3242 update_mappings_menu_linkings();
3245 ui.linked_brush[1] = BRUSH_COPIED;
3246 g_memmove(&(ui.brushes[1][ui.toolno[1]]), &(ui.brushes[0][ui.toolno[1]]), sizeof(struct Brush));
3251 on_button3Pen_activate (GtkMenuItem *menuitem,
3254 process_mapping_activate(menuitem, 2, TOOL_PEN);
3259 on_button3Eraser_activate (GtkMenuItem *menuitem,
3262 process_mapping_activate(menuitem, 2, TOOL_ERASER);
3267 on_button3Highlighter_activate (GtkMenuItem *menuitem,
3270 process_mapping_activate(menuitem, 2, TOOL_HIGHLIGHTER);
3275 on_button3Text_activate (GtkMenuItem *menuitem,
3278 process_mapping_activate(menuitem, 2, TOOL_TEXT);
3283 on_button3SelectRegion_activate (GtkMenuItem *menuitem,
3286 process_mapping_activate(menuitem, 2, TOOL_SELECTREGION);
3291 on_button3SelectRectangle_activate (GtkMenuItem *menuitem,
3294 process_mapping_activate(menuitem, 2, TOOL_SELECTRECT);
3299 on_button3VerticalSpace_activate (GtkMenuItem *menuitem,
3302 process_mapping_activate(menuitem, 2, TOOL_VERTSPACE);
3307 on_button3LinkBrush_activate (GtkMenuItem *menuitem,
3312 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem))) return;
3315 ui.linked_brush[2] = BRUSH_LINKED;
3316 for (i=0;i<NUM_STROKE_TOOLS;i++) update_mapping_linkings(i);
3321 on_button3CopyBrush_activate (GtkMenuItem *menuitem,
3324 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem))) return;
3327 if (ui.toolno[2] >= NUM_STROKE_TOOLS) {
3328 ui.linked_brush[2] = BRUSH_STATIC;
3329 update_mappings_menu_linkings();
3332 ui.linked_brush[2] = BRUSH_COPIED;
3333 g_memmove(&(ui.brushes[2][ui.toolno[2]]), &(ui.brushes[0][ui.toolno[2]]), sizeof(struct Brush));
3336 // the set zoom dialog
3338 GtkWidget *zoom_dialog;
3339 double zoom_percent;
3342 on_viewSetZoom_activate (GtkMenuItem *menuitem,
3346 double test_w, test_h;
3347 GtkSpinButton *spinZoom;
3351 zoom_dialog = create_zoomDialog();
3352 zoom_percent = 100*ui.zoom / DEFAULT_ZOOM;
3353 spinZoom = GTK_SPIN_BUTTON(g_object_get_data(G_OBJECT(zoom_dialog), "spinZoom"));
3354 gtk_spin_button_set_increments(spinZoom, ui.zoom_step_increment, 5*ui.zoom_step_increment);
3355 gtk_spin_button_set_value(spinZoom, zoom_percent);
3356 test_w = 100*(GTK_WIDGET(canvas))->allocation.width/ui.cur_page->width/DEFAULT_ZOOM;
3357 test_h = 100*(GTK_WIDGET(canvas))->allocation.height/ui.cur_page->height/DEFAULT_ZOOM;
3358 if (zoom_percent > 99.9 && zoom_percent < 100.1)
3359 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_object_get_data(
3360 G_OBJECT(zoom_dialog), "radioZoom100")), TRUE);
3361 else if (zoom_percent > test_w-0.1 && zoom_percent < test_w+0.1)
3362 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_object_get_data(
3363 G_OBJECT(zoom_dialog), "radioZoomWidth")), TRUE);
3364 else if (zoom_percent > test_h-0.1 && zoom_percent < test_h+0.1)
3365 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_object_get_data(
3366 G_OBJECT(zoom_dialog), "radioZoomHeight")), TRUE);
3367 else gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_object_get_data(
3368 G_OBJECT(zoom_dialog), "radioZoom")), TRUE);
3369 gtk_widget_show(zoom_dialog);
3372 response = gtk_dialog_run(GTK_DIALOG(zoom_dialog));
3373 if (response == GTK_RESPONSE_OK || response == GTK_RESPONSE_APPLY) {
3374 ui.zoom = DEFAULT_ZOOM*zoom_percent/100;
3375 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
3376 rescale_text_items();
3377 rescale_bg_pixmaps();
3379 } while (response == GTK_RESPONSE_APPLY);
3381 gtk_widget_destroy(zoom_dialog);
3386 on_spinZoom_value_changed (GtkSpinButton *spinbutton,
3391 val = gtk_spin_button_get_value(GTK_SPIN_BUTTON(g_object_get_data(
3392 G_OBJECT(zoom_dialog), "spinZoom")));
3394 if (val<10) val=10.;
3395 if (val>1500) val=1500.;
3396 if (val<zoom_percent-1 || val>zoom_percent+1)
3397 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_object_get_data(
3398 G_OBJECT(zoom_dialog), "radioZoom")), TRUE);
3404 on_radioZoom_toggled (GtkToggleButton *togglebutton,
3412 on_radioZoom100_toggled (GtkToggleButton *togglebutton,
3415 if (!gtk_toggle_button_get_active(togglebutton)) return;
3416 zoom_percent = 100.;
3417 gtk_spin_button_set_value(GTK_SPIN_BUTTON(g_object_get_data(
3418 G_OBJECT(zoom_dialog), "spinZoom")), zoom_percent);
3423 on_radioZoomWidth_toggled (GtkToggleButton *togglebutton,
3426 if (!gtk_toggle_button_get_active(togglebutton)) return;
3427 zoom_percent = 100*(GTK_WIDGET(canvas))->allocation.width/ui.cur_page->width/DEFAULT_ZOOM;
3428 gtk_spin_button_set_value(GTK_SPIN_BUTTON(g_object_get_data(
3429 G_OBJECT(zoom_dialog), "spinZoom")), zoom_percent);
3434 on_radioZoomHeight_toggled (GtkToggleButton *togglebutton,
3437 if (!gtk_toggle_button_get_active(togglebutton)) return;
3438 zoom_percent = 100*(GTK_WIDGET(canvas))->allocation.height/ui.cur_page->height/DEFAULT_ZOOM;
3439 gtk_spin_button_set_value(GTK_SPIN_BUTTON(g_object_get_data(
3440 G_OBJECT(zoom_dialog), "spinZoom")), zoom_percent);
3445 on_toolsHand_activate (GtkMenuItem *menuitem,
3448 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
3449 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
3452 if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
3456 if (ui.cur_mapping != 0 && !ui.button_switch_mapping) return;
3457 if (ui.toolno[ui.cur_mapping] == TOOL_HAND) return;
3463 ui.toolno[ui.cur_mapping] = TOOL_HAND;
3464 update_mapping_linkings(-1);
3465 update_tool_buttons();
3467 update_color_menu();
3473 on_button2Hand_activate (GtkMenuItem *menuitem,
3476 process_mapping_activate(menuitem, 1, TOOL_HAND);
3481 on_button3Hand_activate (GtkMenuItem *menuitem,
3484 process_mapping_activate(menuitem, 2, TOOL_HAND);
3489 on_optionsPrintRuling_activate (GtkMenuItem *menuitem,
3494 ui.print_ruling = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
3498 on_optionsDiscardCore_activate (GtkMenuItem *menuitem,
3503 ui.discard_corepointer =
3504 gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
3505 update_mappings_menu();
3509 on_fontButton_font_set (GtkFontButton *fontbutton,
3514 str = g_strdup(gtk_font_button_get_font_name(fontbutton));
3515 process_font_sel(str);
3519 on_optionsLeftHanded_activate (GtkMenuItem *menuitem,
3524 ui.left_handed = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
3525 gtk_scrolled_window_set_placement(GTK_SCROLLED_WINDOW(GET_COMPONENT("scrolledwindowMain")),
3526 ui.left_handed?GTK_CORNER_TOP_RIGHT:GTK_CORNER_TOP_LEFT);
3530 on_optionsShortenMenus_activate (GtkMenuItem *menuitem,
3533 gchar *item, *nextptr;
3538 ui.shorten_menus = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
3540 /* go over the item list */
3541 item = ui.shorten_menu_items;
3542 while (*item==' ') item++;
3544 nextptr = strchr(item, ' ');
3545 if (nextptr!=NULL) *nextptr = 0;
3546 // hide or show the item
3547 w = GET_COMPONENT(item);
3549 if (ui.shorten_menus) gtk_widget_hide(w);
3550 else gtk_widget_show(w);
3553 if (nextptr==NULL) break;
3556 while (*item==' ') item++;
3559 // just in case someone tried to unhide stuff they shouldn't be seeing
3560 hide_unimplemented();
3561 // maybe we should also make sure the drawing area stays visible ?
3565 on_optionsAutoSavePrefs_activate (GtkMenuItem *menuitem,
3570 ui.auto_save_prefs = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
3574 on_optionsPressureSensitive_activate (GtkMenuItem *menuitem,
3580 ui.pressure_sensitivity =
3581 gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
3582 for (i=0; i<=NUM_BUTTONS; i++)
3583 ui.brushes[i][TOOL_PEN].variable_width = ui.pressure_sensitivity;
3584 update_mappings_menu();
3589 on_buttonColorChooser_set (GtkColorButton *colorbutton,
3595 gtk_color_button_get_color(colorbutton, &gdkcolor);
3596 alpha = gtk_color_button_get_alpha(colorbutton);
3597 process_color_activate((GtkMenuItem*)colorbutton, COLOR_OTHER, gdkcolor_to_rgba(gdkcolor, alpha));
3602 on_optionsButtonsSwitchMappings_activate(GtkMenuItem *menuitem,
3608 ui.button_switch_mapping = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));