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_ACCEPT, 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_ACCEPT) {
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_ACCEPT, 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_ACCEPT) {
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_ACCEPT, NULL);
190 if (ui.filename!=NULL) {
191 if (ui.filename[0] == '/')
192 gtk_file_chooser_set_filename(GTK_FILE_CHOOSER (dialog), ui.filename);
194 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), ui.filename);
196 curtime = time(NULL);
197 strftime(stime, 30, "%F-Note-%H-%M.xoj", localtime(&curtime));
198 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), stime);
201 filt_all = gtk_file_filter_new();
202 gtk_file_filter_set_name(filt_all, "All files");
203 gtk_file_filter_add_pattern(filt_all, "*");
204 filt_xoj = gtk_file_filter_new();
205 gtk_file_filter_set_name(filt_xoj, "Xournal files");
206 gtk_file_filter_add_pattern(filt_xoj, "*.xoj");
207 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_xoj);
208 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_all);
210 // somehow this doesn't seem to be set by default
211 gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
214 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
215 gtk_widget_destroy(dialog);
218 filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
219 warn = g_file_test (filename, G_FILE_TEST_EXISTS);
220 if (warn) { // ok to overwrite an empty file
221 if (!g_stat(filename, &stat_buf))
222 if (stat_buf.st_size == 0) warn=FALSE;
224 if (warn && ui.filename!=NULL) { // ok to overwrite oneself
225 if (ui.filename[0]=='/' && !strcmp(ui.filename, filename)) warn=FALSE;
226 if (ui.filename[0]!='/' && g_str_has_suffix(filename, ui.filename)) warn=FALSE;
229 warning_dialog = gtk_message_dialog_new(GTK_WINDOW(winMain),
230 GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO,
231 "Should the file %s be overwritten?", filename);
232 if (gtk_dialog_run(GTK_DIALOG(warning_dialog)) == GTK_RESPONSE_YES)
234 gtk_widget_destroy(warning_dialog);
238 gtk_widget_destroy(dialog);
240 set_cursor_busy(TRUE);
241 if (save_journal(filename)) { // success
243 set_cursor_busy(FALSE);
244 update_file_name(filename);
247 set_cursor_busy(FALSE);
249 dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
250 GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Error saving file '%s'", filename);
251 gtk_dialog_run(GTK_DIALOG(dialog));
252 gtk_widget_destroy(dialog);
258 on_filePrintOptions_activate (GtkMenuItem *menuitem,
266 on_filePrint_activate (GtkMenuItem *menuitem,
269 GtkWidget *printDialog, *preview;
271 int fromPage, toPage;
275 GnomePrintConfig *config = gnome_print_config_default();
277 if (ui.filename!=NULL) {
278 if (g_str_has_suffix(ui.filename, ".xoj")) {
279 in_fn = g_strdup(ui.filename);
280 g_strlcpy(g_strrstr(in_fn, "xoj"), "pdf", 4);
283 in_fn = g_strdup_printf("%s.pdf", ui.filename);
284 gnome_print_config_set(config, (guchar *)"Printer", (guchar *)"PDF");
285 gnome_print_config_set(config, (guchar *)GNOME_PRINT_KEY_OUTPUT_FILENAME, (guchar *)in_fn);
286 gnome_print_config_set(config, (guchar *)"Settings.Transport.Backend.FileName", (guchar *)in_fn);
287 g_strlcpy(g_strrstr(in_fn, "pdf"), "ps", 3);
288 gnome_print_config_set(config, (guchar *)"Printer", (guchar *)"GENERIC");
289 gnome_print_config_set (config, (guchar *)GNOME_PRINT_KEY_OUTPUT_FILENAME, (guchar *)in_fn);
290 s = gnome_print_config_get(config, (guchar *)"Settings.Transport.Backend.FileName");
293 gnome_print_config_set(config, (guchar *)"Settings.Transport.Backend.FileName", (guchar *)in_fn);
298 gpj = gnome_print_job_new(config); /* was NULL */
299 gnome_print_config_unref(config);
301 printDialog = gnome_print_dialog_new(gpj, (guchar *)"Print", GNOME_PRINT_DIALOG_RANGE);
302 gnome_print_dialog_construct_range_page(GNOME_PRINT_DIALOG(printDialog),
303 GNOME_PRINT_RANGE_ALL | GNOME_PRINT_RANGE_RANGE,
304 1, journal.npages, (guchar *)"Current page", (guchar *)"Pages");
305 /* don't have "Current page" as option, else it becomes the default!! */
307 gtk_dialog_set_response_sensitive(GTK_DIALOG(printDialog),
308 GNOME_PRINT_DIALOG_RESPONSE_PREVIEW, FALSE);
309 /* the print-job-preview "feature" is completely, hopelessly broken */
311 response = gtk_dialog_run(GTK_DIALOG(printDialog));
313 gtk_widget_destroy(printDialog);
318 if (response == GNOME_PRINT_DIALOG_RESPONSE_PREVIEW) {
319 print_job_render(gpj, 0, journal.npages-1);
320 gtk_widget_destroy(printDialog);
321 preview = gnome_print_job_preview_new(gpj, (guchar *)"Preview");
322 try_fix_print_preview_ui(preview);
323 gtk_window_set_modal(GTK_WINDOW(preview), TRUE);
324 gtk_widget_show_all(preview);
328 if (response == GNOME_PRINT_DIALOG_RESPONSE_PRINT) {
329 switch(gnome_print_dialog_get_range(GNOME_PRINT_DIALOG(printDialog))) {
330 case GNOME_PRINT_RANGE_RANGE:
331 gnome_print_dialog_get_range_page(GNOME_PRINT_DIALOG(printDialog), &fromPage, &toPage);
335 toPage = journal.npages-1;
338 gtk_widget_destroy(printDialog);
339 print_job_render(gpj, fromPage, toPage);
345 on_filePrintPDF_activate (GtkMenuItem *menuitem,
350 GtkFileFilter *filt_all, *filt_pdf;
351 char *filename, *in_fn;
355 GnomePrintConfig *config;
358 dialog = gtk_file_chooser_dialog_new("Print to PDF", GTK_WINDOW (winMain),
359 GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
360 GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL);
362 if (ui.filename!=NULL) {
363 if (g_str_has_suffix(ui.filename, ".xoj")) {
364 in_fn = g_strdup(ui.filename);
365 g_strlcpy(g_strrstr(in_fn, "xoj"), "pdf", 4);
368 in_fn = g_strdup_printf("%s.pdf", ui.filename);
370 gtk_file_chooser_set_filename(GTK_FILE_CHOOSER (dialog), in_fn);
371 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), in_fn);
373 curtime = time(NULL);
374 strftime(stime, 30, "%F-Note-%H-%M.pdf", localtime(&curtime));
375 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), stime);
379 filt_all = gtk_file_filter_new();
380 gtk_file_filter_set_name(filt_all, "All files");
381 gtk_file_filter_add_pattern(filt_all, "*");
382 filt_pdf = gtk_file_filter_new();
383 gtk_file_filter_set_name(filt_pdf, "PDF files");
384 gtk_file_filter_add_pattern(filt_pdf, "*.pdf");
385 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_pdf);
386 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_all);
388 // somehow this doesn't seem to be set by default
389 gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
391 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
393 gtk_widget_destroy(dialog);
396 filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
398 gtk_widget_destroy(dialog);
400 config = gnome_print_config_default();
401 gnome_print_config_set(config, (guchar *)"Printer", (guchar *)"PDF");
402 gpj = gnome_print_job_new(config);
403 gnome_print_job_print_to_file(gpj, filename);
405 print_job_render(gpj, 0, journal.npages-1);
406 gnome_print_config_unref(config);
413 on_fileQuit_activate (GtkMenuItem *menuitem,
416 if (ok_to_close()) gtk_main_quit ();
421 on_editUndo_activate (GtkMenuItem *menuitem,
425 GList *list, *itemlist;
426 struct UndoErasureData *erasure;
428 struct Background *tmp_bg;
431 if (undo == NULL) return; // nothing to undo!
432 reset_selection(); // safer
433 if (undo->type == ITEM_STROKE) {
434 // we're keeping the stroke info, but deleting the canvas item
435 gtk_object_destroy(GTK_OBJECT(undo->item->canvas_item));
436 undo->item->canvas_item = NULL;
437 // we also remove the object from its layer!
438 undo->layer->items = g_list_remove(undo->layer->items, undo->item);
439 undo->layer->nitems--;
441 else if (undo->type == ITEM_ERASURE) {
442 for (list = undo->erasurelist; list!=NULL; list = list->next) {
443 erasure = (struct UndoErasureData *)list->data;
444 // delete all the created items
445 for (itemlist = erasure->replacement_items; itemlist!=NULL; itemlist = itemlist->next) {
446 it = (struct Item *)itemlist->data;
447 gtk_object_destroy(GTK_OBJECT(it->canvas_item));
448 it->canvas_item = NULL;
449 undo->layer->items = g_list_remove(undo->layer->items, it);
450 undo->layer->nitems--;
452 // recreate the deleted one
453 erasure->item->canvas_item = gnome_canvas_item_new(undo->layer->group,
454 gnome_canvas_line_get_type(), "points", erasure->item->path,
455 "cap-style", GDK_CAP_ROUND, "join-style", GDK_JOIN_ROUND,
456 "fill-color-rgba", erasure->item->brush.color_rgba,
457 "width-units", erasure->item->brush.thickness, NULL);
458 undo->layer->items = g_list_insert(undo->layer->items, erasure->item,
460 if (erasure->npos == 0)
461 lower_canvas_item_to(undo->layer->group, erasure->item->canvas_item, NULL);
463 lower_canvas_item_to(undo->layer->group, erasure->item->canvas_item,
464 ((struct Item *)g_list_nth_data(undo->layer->items, erasure->npos-1))->canvas_item);
465 undo->layer->nitems++;
468 else if (undo->type == ITEM_NEW_BG_ONE || undo->type == ITEM_NEW_BG_RESIZE
469 || undo->type == ITEM_PAPER_RESIZE) {
470 if (undo->type != ITEM_PAPER_RESIZE) {
472 tmp_bg = undo->page->bg;
473 undo->page->bg = undo->bg;
475 undo->page->bg->canvas_item = undo->bg->canvas_item;
476 undo->bg->canvas_item = NULL;
478 if (undo->type != ITEM_NEW_BG_ONE) {
479 tmp_x = undo->page->width;
480 tmp_y = undo->page->height;
481 undo->page->width = undo->val_x;
482 undo->page->height = undo->val_y;
485 make_page_clipbox(undo->page);
487 update_canvas_bg(undo->page);
488 do_switch_page(g_list_index(journal.pages, undo->page), TRUE);
490 else if (undo->type == ITEM_NEW_DEFAULT_BG) {
491 tmp_bg = ui.default_page.bg;
492 ui.default_page.bg = undo->bg;
494 tmp_x = ui.default_page.width;
495 tmp_y = ui.default_page.height;
496 ui.default_page.width = undo->val_x;
497 ui.default_page.height = undo->val_y;
501 else if (undo->type == ITEM_NEW_PAGE) {
502 // unmap the page; keep the page & its empty layer in memory
503 if (undo->page->group!=NULL) gtk_object_destroy(GTK_OBJECT(undo->page->group));
504 // also destroys the background and layer's canvas items
505 undo->page->group = NULL;
506 undo->page->bg->canvas_item = NULL;
507 journal.pages = g_list_remove(journal.pages, undo->page);
509 if (ui.cur_page == undo->page) ui.cur_page = NULL;
510 // so do_switch_page() won't try to remap the layers of the defunct page
511 if (ui.pageno >= undo->val) ui.pageno--;
512 if (ui.pageno < 0) ui.pageno = 0;
513 do_switch_page(ui.pageno, TRUE);
515 else if (undo->type == ITEM_DELETE_PAGE) {
516 journal.pages = g_list_insert(journal.pages, undo->page, undo->val);
518 make_canvas_items(); // re-create the canvas items
519 do_switch_page(undo->val, TRUE);
521 else if (undo->type == ITEM_MOVESEL) {
522 for (itemlist = undo->itemlist; itemlist != NULL; itemlist = itemlist->next) {
523 it = (struct Item *)itemlist->data;
524 if (it->canvas_item != NULL)
525 gnome_canvas_item_move(it->canvas_item, -undo->val_x, -undo->val_y);
527 move_journal_items_by(undo->itemlist, -undo->val_x, -undo->val_y);
529 else if (undo->type == ITEM_PASTE) {
530 for (itemlist = undo->itemlist; itemlist != NULL; itemlist = itemlist->next) {
531 it = (struct Item *)itemlist->data;
532 gtk_object_destroy(GTK_OBJECT(it->canvas_item));
533 it->canvas_item = NULL;
534 undo->layer->items = g_list_remove(undo->layer->items, it);
535 undo->layer->nitems--;
538 else if (undo->type == ITEM_NEW_LAYER) {
539 // unmap the layer; keep the empty layer in memory
540 if (undo->layer->group!=NULL) gtk_object_destroy(GTK_OBJECT(undo->layer->group));
541 undo->layer->group = NULL;
542 undo->page->layers = g_list_remove(undo->page->layers, undo->layer);
543 undo->page->nlayers--;
544 do_switch_page(ui.pageno, FALSE); // don't stay with bad cur_layer info
546 else if (undo->type == ITEM_DELETE_LAYER) {
547 // special case of -1: deleted the last layer, created a new one
548 if (undo->val == -1) {
549 if (undo->layer2->group!=NULL) gtk_object_destroy(GTK_OBJECT(undo->layer2->group));
550 undo->layer2->group = NULL;
551 undo->page->layers = g_list_remove(undo->page->layers, undo->layer2);
552 undo->page->nlayers--;
555 undo->layer->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
556 undo->page->group, gnome_canvas_group_get_type(), NULL);
557 lower_canvas_item_to(undo->page->group, GNOME_CANVAS_ITEM(undo->layer->group),
558 (undo->val >= 1) ? GNOME_CANVAS_ITEM(((struct Layer *)
559 g_list_nth_data(undo->page->layers, undo->val-1))->group) :
560 undo->page->bg->canvas_item);
561 undo->page->layers = g_list_insert(undo->page->layers, undo->layer,
562 (undo->val >= 0) ? undo->val:0);
563 undo->page->nlayers++;
565 for (itemlist = undo->layer->items; itemlist!=NULL; itemlist = itemlist->next) {
566 it = (struct Item *)itemlist->data;
567 if (it->type == ITEM_STROKE) {
568 it->canvas_item = gnome_canvas_item_new(undo->layer->group,
569 gnome_canvas_line_get_type(), "points", it->path,
570 "cap-style", GDK_CAP_ROUND, "join-style", GDK_JOIN_ROUND,
571 "fill-color-rgba", it->brush.color_rgba,
572 "width-units", it->brush.thickness, NULL);
575 do_switch_page(ui.pageno, FALSE); // show the restored layer & others...
578 // move item from undo to redo stack
584 update_undo_redo_enabled();
585 if (u->multiop & MULTIOP_CONT_UNDO) on_editUndo_activate(NULL,NULL); // loop
590 on_editRedo_activate (GtkMenuItem *menuitem,
594 GList *list, *itemlist, *target;
595 struct UndoErasureData *erasure;
597 struct Background *tmp_bg;
601 if (redo == NULL) return; // nothing to redo!
602 reset_selection(); // safer
603 if (redo->type == ITEM_STROKE) {
604 // re-create the canvas_item
605 redo->item->canvas_item = gnome_canvas_item_new(redo->layer->group,
606 gnome_canvas_line_get_type(), "points", redo->item->path,
607 "cap-style", GDK_CAP_ROUND, "join-style", GDK_JOIN_ROUND,
608 "fill-color-rgba", redo->item->brush.color_rgba,
609 "width-units", redo->item->brush.thickness, NULL);
610 // reinsert the item on its layer
611 redo->layer->items = g_list_append(redo->layer->items, redo->item);
612 redo->layer->nitems++;
614 else if (redo->type == ITEM_ERASURE) {
615 for (list = redo->erasurelist; list!=NULL; list = list->next) {
616 erasure = (struct UndoErasureData *)list->data;
617 target = g_list_find(redo->layer->items, erasure->item);
618 // re-create all the created items
619 for (itemlist = erasure->replacement_items; itemlist!=NULL; itemlist = itemlist->next) {
620 it = (struct Item *)itemlist->data;
621 it->canvas_item = gnome_canvas_item_new(redo->layer->group,
622 gnome_canvas_line_get_type(), "points", it->path,
623 "cap-style", GDK_CAP_ROUND, "join-style", GDK_JOIN_ROUND,
624 "fill-color-rgba", it->brush.color_rgba,
625 "width-units", it->brush.thickness, NULL);
626 redo->layer->items = g_list_insert_before(redo->layer->items, target, it);
627 redo->layer->nitems++;
628 lower_canvas_item_to(redo->layer->group, it->canvas_item, erasure->item->canvas_item);
630 // re-delete the deleted one
631 gtk_object_destroy(GTK_OBJECT(erasure->item->canvas_item));
632 erasure->item->canvas_item = NULL;
633 redo->layer->items = g_list_delete_link(redo->layer->items, target);
634 redo->layer->nitems--;
637 else if (redo->type == ITEM_NEW_BG_ONE || redo->type == ITEM_NEW_BG_RESIZE
638 || redo->type == ITEM_PAPER_RESIZE) {
639 if (redo->type != ITEM_PAPER_RESIZE) {
641 tmp_bg = redo->page->bg;
642 redo->page->bg = redo->bg;
644 redo->page->bg->canvas_item = redo->bg->canvas_item;
645 redo->bg->canvas_item = NULL;
647 if (redo->type != ITEM_NEW_BG_ONE) {
648 tmp_x = redo->page->width;
649 tmp_y = redo->page->height;
650 redo->page->width = redo->val_x;
651 redo->page->height = redo->val_y;
654 make_page_clipbox(redo->page);
656 update_canvas_bg(redo->page);
657 do_switch_page(g_list_index(journal.pages, redo->page), TRUE);
659 else if (redo->type == ITEM_NEW_DEFAULT_BG) {
660 tmp_bg = ui.default_page.bg;
661 ui.default_page.bg = redo->bg;
663 tmp_x = ui.default_page.width;
664 tmp_y = ui.default_page.height;
665 ui.default_page.width = redo->val_x;
666 ui.default_page.height = redo->val_y;
670 else if (redo->type == ITEM_NEW_PAGE) {
672 redo->page->bg->canvas_item = NULL;
673 redo->page->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
674 gnome_canvas_root(canvas), gnome_canvas_clipgroup_get_type(), NULL);
675 make_page_clipbox(redo->page);
676 update_canvas_bg(redo->page);
677 l = (struct Layer *)redo->page->layers->data;
678 l->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
679 redo->page->group, gnome_canvas_group_get_type(), NULL);
681 journal.pages = g_list_insert(journal.pages, redo->page, redo->val);
683 do_switch_page(redo->val, TRUE);
685 else if (redo->type == ITEM_DELETE_PAGE) {
686 // unmap all the canvas items
687 gtk_object_destroy(GTK_OBJECT(redo->page->group));
688 redo->page->group = NULL;
689 redo->page->bg->canvas_item = NULL;
690 for (list = redo->page->layers; list!=NULL; list = list->next) {
691 l = (struct Layer *)list->data;
692 for (itemlist = l->items; itemlist!=NULL; itemlist = itemlist->next)
693 ((struct Item *)itemlist->data)->canvas_item = NULL;
696 journal.pages = g_list_remove(journal.pages, redo->page);
698 if (ui.pageno > undo->val || ui.pageno == journal.npages) ui.pageno--;
700 // so do_switch_page() won't try to remap the layers of the defunct page
701 do_switch_page(ui.pageno, TRUE);
703 else if (redo->type == ITEM_MOVESEL) {
704 for (itemlist = redo->itemlist; itemlist != NULL; itemlist = itemlist->next) {
705 it = (struct Item *)itemlist->data;
706 if (it->canvas_item != NULL)
707 gnome_canvas_item_move(it->canvas_item, redo->val_x, redo->val_y);
709 move_journal_items_by(redo->itemlist, redo->val_x, redo->val_y);
711 else if (redo->type == ITEM_PASTE) {
712 for (itemlist = redo->itemlist; itemlist != NULL; itemlist = itemlist->next) {
713 it = (struct Item *)itemlist->data;
714 it->canvas_item = gnome_canvas_item_new(redo->layer->group,
715 gnome_canvas_line_get_type(), "points", it->path,
716 "cap-style", GDK_CAP_ROUND, "join-style", GDK_JOIN_ROUND,
717 "fill-color-rgba", it->brush.color_rgba,
718 "width-units", it->brush.thickness, NULL);
719 redo->layer->items = g_list_append(redo->layer->items, it);
720 redo->layer->nitems++;
723 else if (redo->type == ITEM_NEW_LAYER) {
724 redo->layer->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
725 redo->page->group, gnome_canvas_group_get_type(), NULL);
726 lower_canvas_item_to(redo->page->group, GNOME_CANVAS_ITEM(redo->layer->group),
727 (redo->val >= 1) ? GNOME_CANVAS_ITEM(((struct Layer *)
728 g_list_nth_data(redo->page->layers, redo->val-1))->group) :
729 redo->page->bg->canvas_item);
730 redo->page->layers = g_list_insert(redo->page->layers, redo->layer, redo->val);
731 redo->page->nlayers++;
732 do_switch_page(ui.pageno, FALSE);
734 else if (redo->type == ITEM_DELETE_LAYER) {
735 gtk_object_destroy(GTK_OBJECT(redo->layer->group));
736 redo->layer->group = NULL;
737 for (list=redo->layer->items; list!=NULL; list=list->next)
738 ((struct Item *)list->data)->canvas_item = NULL;
739 redo->page->layers = g_list_remove(redo->page->layers, redo->layer);
740 redo->page->nlayers--;
741 if (redo->val == -1) {
742 redo->layer2->group = (GnomeCanvasGroup *)gnome_canvas_item_new(
743 redo->page->group, gnome_canvas_group_get_type(), NULL);
744 redo->page->layers = g_list_append(redo->page->layers, redo->layer2);
745 redo->page->nlayers++;
747 do_switch_page(ui.pageno, FALSE);
750 // move item from redo to undo stack
756 update_undo_redo_enabled();
757 if (u->multiop & MULTIOP_CONT_REDO) on_editRedo_activate(NULL,NULL); // loop
762 on_editCut_activate (GtkMenuItem *menuitem,
771 on_editCopy_activate (GtkMenuItem *menuitem,
779 on_editPaste_activate (GtkMenuItem *menuitem,
787 on_editDelete_activate (GtkMenuItem *menuitem,
795 on_viewContinuous_activate (GtkMenuItem *menuitem,
798 GtkAdjustment *v_adj;
801 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
802 if (ui.view_continuous) return;
803 ui.view_continuous = TRUE;
804 v_adj = gtk_layout_get_vadjustment(GTK_LAYOUT(canvas));
805 yscroll = gtk_adjustment_get_value(v_adj) - ui.cur_page->voffset*ui.zoom;
807 gtk_adjustment_set_value(v_adj, yscroll + ui.cur_page->voffset*ui.zoom);
809 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
814 on_viewOnePage_activate (GtkMenuItem *menuitem,
817 GtkAdjustment *v_adj;
820 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
821 if (!ui.view_continuous) return;
822 ui.view_continuous = FALSE;
823 v_adj = gtk_layout_get_vadjustment(GTK_LAYOUT(canvas));
824 yscroll = gtk_adjustment_get_value(v_adj) - ui.cur_page->voffset*ui.zoom;
826 gtk_adjustment_set_value(v_adj, yscroll + ui.cur_page->voffset*ui.zoom);
828 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
833 on_viewZoomIn_activate (GtkMenuItem *menuitem,
836 if (ui.zoom > MAX_ZOOM) return;
838 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
839 rescale_bg_pixmaps();
844 on_viewZoomOut_activate (GtkMenuItem *menuitem,
847 if (ui.zoom < MIN_ZOOM) return;
849 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
850 rescale_bg_pixmaps();
855 on_viewNormalSize_activate (GtkMenuItem *menuitem,
858 ui.zoom = DEFAULT_ZOOM;
859 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
860 rescale_bg_pixmaps();
865 on_viewPageWidth_activate (GtkMenuItem *menuitem,
868 ui.zoom = (GTK_WIDGET(canvas))->allocation.width/ui.cur_page->width;
869 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
870 rescale_bg_pixmaps();
875 on_viewFirstPage_activate (GtkMenuItem *menuitem,
878 do_switch_page(0, TRUE);
883 on_viewPreviousPage_activate (GtkMenuItem *menuitem,
886 if (ui.pageno == 0) return;
887 do_switch_page(ui.pageno-1, TRUE);
892 on_viewNextPage_activate (GtkMenuItem *menuitem,
895 if (ui.pageno == journal.npages-1) { // create a page at end
896 if (page_ops_forbidden()) return;
897 on_journalNewPageEnd_activate(menuitem, user_data);
900 do_switch_page(ui.pageno+1, TRUE);
905 on_viewLastPage_activate (GtkMenuItem *menuitem,
908 do_switch_page(journal.npages-1, TRUE);
913 on_viewShowLayer_activate (GtkMenuItem *menuitem,
916 if (ui.layerno == ui.cur_page->nlayers-1) return;
919 ui.cur_layer = g_list_nth_data(ui.cur_page->layers, ui.layerno);
920 gnome_canvas_item_show(GNOME_CANVAS_ITEM(ui.cur_layer->group));
926 on_viewHideLayer_activate (GtkMenuItem *menuitem,
929 if (ui.layerno == -1) return;
931 gnome_canvas_item_hide(GNOME_CANVAS_ITEM(ui.cur_layer->group));
933 if (ui.layerno<0) ui.cur_layer = NULL;
934 else ui.cur_layer = g_list_nth_data(ui.cur_page->layers, ui.layerno);
940 on_journalNewPageBefore_activate (GtkMenuItem *menuitem,
945 if (page_ops_forbidden()) return;
947 pg = new_page(ui.cur_page);
948 journal.pages = g_list_insert(journal.pages, pg, ui.pageno);
950 do_switch_page(ui.pageno, TRUE);
953 undo->type = ITEM_NEW_PAGE;
954 undo->val = ui.pageno;
960 on_journalNewPageAfter_activate (GtkMenuItem *menuitem,
965 if (page_ops_forbidden()) return;
967 pg = new_page(ui.cur_page);
968 journal.pages = g_list_insert(journal.pages, pg, ui.pageno+1);
970 do_switch_page(ui.pageno+1, TRUE);
973 undo->type = ITEM_NEW_PAGE;
974 undo->val = ui.pageno;
980 on_journalNewPageEnd_activate (GtkMenuItem *menuitem,
985 if (page_ops_forbidden()) return;
987 pg = new_page((struct Page *)g_list_last(journal.pages)->data);
988 journal.pages = g_list_append(journal.pages, pg);
990 do_switch_page(journal.npages-1, TRUE);
993 undo->type = ITEM_NEW_PAGE;
994 undo->val = ui.pageno;
1000 on_journalDeletePage_activate (GtkMenuItem *menuitem,
1003 GList *layerlist, *itemlist;
1006 if (page_ops_forbidden()) return;
1007 if (journal.npages == 1) return;
1010 undo->type = ITEM_DELETE_PAGE;
1011 undo->val = ui.pageno;
1012 undo->page = ui.cur_page;
1014 // unmap all the canvas items
1015 gtk_object_destroy(GTK_OBJECT(ui.cur_page->group));
1016 ui.cur_page->group = NULL;
1017 ui.cur_page->bg->canvas_item = NULL;
1018 for (layerlist = ui.cur_page->layers; layerlist!=NULL; layerlist = layerlist->next) {
1019 l = (struct Layer *)layerlist->data;
1020 for (itemlist = l->items; itemlist!=NULL; itemlist = itemlist->next)
1021 ((struct Item *)itemlist->data)->canvas_item = NULL;
1025 journal.pages = g_list_remove(journal.pages, ui.cur_page);
1027 if (ui.pageno == journal.npages) ui.pageno--;
1029 // so do_switch_page() won't try to remap the layers of the defunct page
1030 do_switch_page(ui.pageno, TRUE);
1035 on_journalNewLayer_activate (GtkMenuItem *menuitem,
1041 l = g_new(struct Layer, 1);
1044 l->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
1045 ui.cur_page->group, gnome_canvas_group_get_type(), NULL);
1046 lower_canvas_item_to(ui.cur_page->group, GNOME_CANVAS_ITEM(l->group),
1047 (ui.cur_layer!=NULL)?(GNOME_CANVAS_ITEM(ui.cur_layer->group)):(ui.cur_page->bg->canvas_item));
1048 ui.cur_page->layers = g_list_insert(ui.cur_page->layers, l, ui.layerno+1);
1051 ui.cur_page->nlayers++;
1052 update_page_stuff();
1055 undo->type = ITEM_NEW_LAYER;
1056 undo->val = ui.layerno;
1058 undo->page = ui.cur_page;
1063 on_journalDeleteLayer_activate (GtkMenuItem *menuitem,
1068 if (ui.cur_layer == NULL) return;
1071 undo->type = ITEM_DELETE_LAYER;
1072 undo->val = ui.layerno;
1073 undo->layer = ui.cur_layer;
1074 undo->layer2 = NULL;
1075 undo->page = ui.cur_page;
1076 // delete all the canvas items
1077 gtk_object_destroy(GTK_OBJECT(ui.cur_layer->group));
1078 ui.cur_layer->group = NULL;
1079 for (list=ui.cur_layer->items; list!=NULL; list=list->next)
1080 ((struct Item *)list->data)->canvas_item = NULL;
1082 ui.cur_page->layers = g_list_remove(ui.cur_page->layers, ui.cur_layer);
1084 if (ui.cur_page->nlayers>=2) {
1085 ui.cur_page->nlayers--;
1087 if (ui.layerno<0) ui.cur_layer = NULL;
1088 else ui.cur_layer = (struct Layer *)g_list_nth_data(ui.cur_page->layers, ui.layerno);
1090 else { // special case: can't remove the last layer
1091 ui.cur_layer = g_new(struct Layer, 1);
1092 ui.cur_layer->items = NULL;
1093 ui.cur_layer->nitems = 0;
1094 ui.cur_layer->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
1095 ui.cur_page->group, gnome_canvas_group_get_type(), NULL);
1096 ui.cur_page->layers = g_list_append(NULL, ui.cur_layer);
1098 undo->layer2 = ui.cur_layer;
1101 update_page_stuff();
1106 on_journalFlatten_activate (GtkMenuItem *menuitem,
1113 // the paper sizes dialog
1115 GtkWidget *papersize_dialog;
1116 int papersize_std, papersize_unit;
1117 double papersize_width, papersize_height;
1118 gboolean papersize_need_init, papersize_width_valid, papersize_height_valid;
1120 #define STD_SIZE_A4 0
1121 #define STD_SIZE_A4R 1
1122 #define STD_SIZE_LETTER 2
1123 #define STD_SIZE_LETTER_R 3
1124 #define STD_SIZE_CUSTOM 4
1131 double unit_sizes[4] = {28.346, 72., 1/DEFAULT_ZOOM, 1.};
1132 double std_widths[STD_SIZE_CUSTOM] = {595.27, 841.89, 612., 792.};
1133 double std_heights[STD_SIZE_CUSTOM] = {841.89, 595.27, 792., 612.};
1134 double std_units[STD_SIZE_CUSTOM] = {UNIT_CM, UNIT_CM, UNIT_IN, UNIT_IN};
1137 on_journalPaperSize_activate (GtkMenuItem *menuitem,
1142 papersize_dialog = create_papersizeDialog();
1143 papersize_width = ui.cur_page->width;
1144 papersize_height = ui.cur_page->height;
1145 papersize_unit = UNIT_CM;
1146 // if (ui.cur_page->bg->type == BG_PIXMAP) papersize_unit = UNIT_PX;
1147 papersize_std = STD_SIZE_CUSTOM;
1148 for (i=0;i<STD_SIZE_CUSTOM;i++)
1149 if (fabs(papersize_width - std_widths[i])<0.1 &&
1150 fabs(papersize_height - std_heights[i])<0.1)
1151 { papersize_std = i; papersize_unit = std_units[i]; }
1152 papersize_need_init = TRUE;
1153 papersize_width_valid = papersize_height_valid = TRUE;
1155 gtk_widget_show(papersize_dialog);
1156 on_comboStdSizes_changed(GTK_COMBO_BOX(g_object_get_data(
1157 G_OBJECT(papersize_dialog), "comboStdSizes")), NULL);
1158 gtk_dialog_set_default_response(GTK_DIALOG(papersize_dialog), GTK_RESPONSE_OK);
1160 response = gtk_dialog_run(GTK_DIALOG(papersize_dialog));
1161 gtk_widget_destroy(papersize_dialog);
1162 if (response != GTK_RESPONSE_OK) return;
1165 undo->type = ITEM_PAPER_RESIZE;
1166 undo->page = ui.cur_page;
1167 undo->val_x = ui.cur_page->width;
1168 undo->val_y = ui.cur_page->height;
1170 if (papersize_width_valid) ui.cur_page->width = papersize_width;
1171 if (papersize_height_valid) ui.cur_page->height = papersize_height;
1173 make_page_clipbox(ui.cur_page);
1174 update_canvas_bg(ui.cur_page);
1175 do_switch_page(ui.pageno, TRUE);
1180 on_papercolorWhite_activate (GtkMenuItem *menuitem,
1183 process_papercolor_activate(menuitem, COLOR_WHITE);
1188 on_papercolorYellow_activate (GtkMenuItem *menuitem,
1191 process_papercolor_activate(menuitem, COLOR_YELLOW);
1196 on_papercolorPink_activate (GtkMenuItem *menuitem,
1199 process_papercolor_activate(menuitem, COLOR_RED);
1204 on_papercolorOrange_activate (GtkMenuItem *menuitem,
1207 process_papercolor_activate(menuitem, COLOR_ORANGE);
1212 on_papercolorBlue_activate (GtkMenuItem *menuitem,
1215 process_papercolor_activate(menuitem, COLOR_BLUE);
1220 on_papercolorGreen_activate (GtkMenuItem *menuitem,
1223 process_papercolor_activate(menuitem, COLOR_GREEN);
1228 on_papercolorOther_activate (GtkMenuItem *menuitem,
1236 on_paperstylePlain_activate (GtkMenuItem *menuitem,
1239 process_paperstyle_activate(menuitem, RULING_NONE);
1244 on_paperstyleLined_activate (GtkMenuItem *menuitem,
1247 process_paperstyle_activate(menuitem, RULING_LINED);
1252 on_paperstyleRuled_activate (GtkMenuItem *menuitem,
1255 process_paperstyle_activate(menuitem, RULING_RULED);
1260 on_paperstyleGraph_activate (GtkMenuItem *menuitem,
1263 process_paperstyle_activate(menuitem, RULING_GRAPH);
1268 on_journalLoadBackground_activate (GtkMenuItem *menuitem,
1271 GtkWidget *dialog, *attach_opt;
1272 struct Background *bg;
1275 GList *bglist, *bglistiter;
1276 GtkFileFilter *filt_all, *filt_pix, *filt_pspdf;
1280 dialog = gtk_file_chooser_dialog_new("Open Background", GTK_WINDOW (winMain),
1281 GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1282 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);
1284 filt_all = gtk_file_filter_new();
1285 gtk_file_filter_set_name(filt_all, "All files");
1286 gtk_file_filter_add_pattern(filt_all, "*");
1287 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_all);
1289 #if GTK_CHECK_VERSION(2,6,0)
1291 if (!gtk_check_version(2, 6, 0)) {
1292 filt_pix = gtk_file_filter_new();
1293 gtk_file_filter_set_name(filt_pix, "Bitmap files");
1294 gtk_file_filter_add_pixbuf_formats(filt_pix);
1295 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_pix);
1300 filt_pspdf = gtk_file_filter_new();
1301 gtk_file_filter_set_name(filt_pspdf, "PS/PDF files (as bitmaps)");
1302 gtk_file_filter_add_pattern(filt_pspdf, "*.ps");
1303 gtk_file_filter_add_pattern(filt_pspdf, "*.pdf");
1304 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_pspdf);
1306 attach_opt = gtk_check_button_new_with_label("Attach file to the journal");
1307 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(attach_opt), FALSE);
1308 gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER (dialog), attach_opt);
1310 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
1311 gtk_widget_destroy(dialog);
1314 filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
1315 attach = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(attach_opt));
1316 gtk_widget_destroy(dialog);
1318 set_cursor_busy(TRUE);
1319 bg = attempt_load_pix_bg(filename, attach);
1320 if (bg != NULL) bglist = g_list_append(NULL, bg);
1321 else bglist = attempt_load_gv_bg(filename);
1322 set_cursor_busy(FALSE);
1324 if (bglist == NULL) {
1325 dialog = gtk_message_dialog_new(GTK_WINDOW(winMain), GTK_DIALOG_MODAL,
1326 GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
1327 "Error opening background '%s'", filename);
1328 gtk_dialog_run(GTK_DIALOG(dialog));
1329 gtk_widget_destroy(dialog);
1338 for (bglistiter = bglist, pageno = ui.pageno;
1339 bglistiter!=NULL; bglistiter = bglistiter->next, pageno++) {
1341 if (bglistiter->next!=NULL) undo->multiop |= MULTIOP_CONT_REDO;
1342 if (bglistiter->prev!=NULL) undo->multiop |= MULTIOP_CONT_UNDO;
1344 bg = (struct Background *)bglistiter->data;
1346 if (pageno == journal.npages) {
1347 undo->type = ITEM_NEW_PAGE;
1348 pg = new_page_with_bg(bg,
1349 gdk_pixbuf_get_width(bg->pixbuf)/bg->pixbuf_scale,
1350 gdk_pixbuf_get_height(bg->pixbuf)/bg->pixbuf_scale);
1351 journal.pages = g_list_append(journal.pages, pg);
1357 pg = g_list_nth_data(journal.pages, pageno);
1358 undo->type = ITEM_NEW_BG_RESIZE;
1361 bg->canvas_item = undo->bg->canvas_item;
1362 undo->bg->canvas_item = NULL;
1363 undo->val_x = pg->width;
1364 undo->val_y = pg->height;
1366 pg->width = gdk_pixbuf_get_width(bg->pixbuf)/bg->pixbuf_scale;
1367 pg->height = gdk_pixbuf_get_height(bg->pixbuf)/bg->pixbuf_scale;
1368 make_page_clipbox(pg);
1369 update_canvas_bg(pg);
1373 g_list_free(bglist);
1374 if (ui.zoom != DEFAULT_ZOOM) {
1375 ui.zoom = DEFAULT_ZOOM;
1376 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
1377 rescale_bg_pixmaps();
1379 do_switch_page(ui.pageno, TRUE);
1383 on_journalScreenshot_activate (GtkMenuItem *menuitem,
1386 struct Background *bg;
1389 gtk_window_iconify(GTK_WINDOW(winMain)); // hide ourselves
1390 gdk_display_sync(gdk_display_get_default());
1392 if (ui.cursor!=NULL)
1393 gdk_cursor_unref(ui.cursor);
1394 ui.cursor = gdk_cursor_new(GDK_TCROSS);
1396 bg = attempt_screenshot_bg();
1398 gtk_window_deiconify(GTK_WINDOW(winMain));
1400 if (bg==NULL) return;
1403 undo->type = ITEM_NEW_BG_RESIZE;
1404 undo->page = ui.cur_page;
1405 undo->bg = ui.cur_page->bg;
1406 bg->canvas_item = undo->bg->canvas_item;
1407 undo->bg->canvas_item = NULL;
1408 undo->val_x = ui.cur_page->width;
1409 undo->val_y = ui.cur_page->height;
1411 ui.cur_page->bg = bg;
1412 ui.cur_page->width = gdk_pixbuf_get_width(bg->pixbuf)/bg->pixbuf_scale;
1413 ui.cur_page->height = gdk_pixbuf_get_height(bg->pixbuf)/bg->pixbuf_scale;
1415 make_page_clipbox(ui.cur_page);
1416 update_canvas_bg(ui.cur_page);
1418 if (ui.zoom != DEFAULT_ZOOM) {
1419 ui.zoom = DEFAULT_ZOOM;
1420 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
1421 rescale_bg_pixmaps();
1423 do_switch_page(ui.pageno, TRUE);
1428 on_journalApplyAllPages_activate (GtkMenuItem *menuitem,
1436 on_toolsPen_activate (GtkMenuItem *menuitem,
1439 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1440 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1443 if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1447 if (ui.toolno == TOOL_PEN) return;
1450 ui.toolno = TOOL_PEN;
1452 ui.cur_brush = ui.brushes+TOOL_PEN;
1453 update_tool_buttons();
1455 update_color_menu();
1461 on_toolsEraser_activate (GtkMenuItem *menuitem,
1464 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1465 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1468 if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1472 if (ui.toolno == TOOL_ERASER) return;
1475 ui.toolno = TOOL_ERASER;
1477 ui.cur_brush = ui.brushes+TOOL_ERASER;
1478 update_tool_buttons();
1480 update_color_menu();
1486 on_toolsHighlighter_activate (GtkMenuItem *menuitem,
1489 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1490 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1493 if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1497 if (ui.toolno == TOOL_HIGHLIGHTER) return;
1500 ui.toolno = TOOL_HIGHLIGHTER;
1502 ui.cur_brush = ui.brushes+TOOL_HIGHLIGHTER;
1503 update_tool_buttons();
1505 update_color_menu();
1511 on_toolsText_activate (GtkMenuItem *menuitem,
1519 on_toolsSelectRegion_activate (GtkMenuItem *menuitem,
1527 on_toolsSelectRectangle_activate (GtkMenuItem *menuitem,
1530 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1531 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1534 if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1538 if (ui.toolno == TOOL_SELECTRECT) return;
1540 ui.toolno = TOOL_SELECTRECT;
1542 update_tool_buttons();
1544 update_color_menu();
1550 on_toolsVerticalSpace_activate (GtkMenuItem *menuitem,
1553 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1554 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1557 if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1561 if (ui.toolno == TOOL_VERTSPACE) return;
1564 ui.toolno = TOOL_VERTSPACE;
1566 update_tool_buttons();
1568 update_color_menu();
1574 on_colorBlack_activate (GtkMenuItem *menuitem,
1577 process_color_activate(menuitem, COLOR_BLACK);
1582 on_colorBlue_activate (GtkMenuItem *menuitem,
1585 process_color_activate(menuitem, COLOR_BLUE);
1591 on_colorRed_activate (GtkMenuItem *menuitem,
1594 process_color_activate(menuitem, COLOR_RED);
1599 on_colorGreen_activate (GtkMenuItem *menuitem,
1602 process_color_activate(menuitem, COLOR_GREEN);
1607 on_colorGray_activate (GtkMenuItem *menuitem,
1610 process_color_activate(menuitem, COLOR_GRAY);
1615 on_colorLightBlue_activate (GtkMenuItem *menuitem,
1618 process_color_activate(menuitem, COLOR_LIGHTBLUE);
1623 on_colorLightGreen_activate (GtkMenuItem *menuitem,
1626 process_color_activate(menuitem, COLOR_LIGHTGREEN);
1631 on_colorMagenta_activate (GtkMenuItem *menuitem,
1634 process_color_activate(menuitem, COLOR_MAGENTA);
1639 on_colorOrange_activate (GtkMenuItem *menuitem,
1642 process_color_activate(menuitem, COLOR_ORANGE);
1647 on_colorYellow_activate (GtkMenuItem *menuitem,
1650 process_color_activate(menuitem, COLOR_YELLOW);
1655 on_colorWhite_activate (GtkMenuItem *menuitem,
1658 process_color_activate(menuitem, COLOR_WHITE);
1663 on_colorOther_activate (GtkMenuItem *menuitem,
1671 on_penthicknessVeryFine_activate (GtkMenuItem *menuitem,
1674 process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_VERYFINE);
1679 on_penthicknessFine_activate (GtkMenuItem *menuitem,
1682 process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_FINE);
1687 on_penthicknessMedium_activate (GtkMenuItem *menuitem,
1690 process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_MEDIUM);
1695 on_penthicknessThick_activate (GtkMenuItem *menuitem,
1698 process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_THICK);
1703 on_penthicknessVeryThick_activate (GtkMenuItem *menuitem,
1706 process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_VERYTHICK);
1711 on_eraserFine_activate (GtkMenuItem *menuitem,
1714 process_thickness_activate(menuitem, TOOL_ERASER, THICKNESS_FINE);
1719 on_eraserMedium_activate (GtkMenuItem *menuitem,
1722 process_thickness_activate(menuitem, TOOL_ERASER, THICKNESS_MEDIUM);
1727 on_eraserThick_activate (GtkMenuItem *menuitem,
1730 process_thickness_activate(menuitem, TOOL_ERASER, THICKNESS_THICK);
1735 on_eraserStandard_activate (GtkMenuItem *menuitem,
1738 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
1739 ui.brushes[TOOL_ERASER].tool_options = TOOLOPT_ERASER_STANDARD;
1744 on_eraserWhiteout_activate (GtkMenuItem *menuitem,
1747 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
1748 ui.brushes[TOOL_ERASER].tool_options = TOOLOPT_ERASER_WHITEOUT;
1753 on_eraserDeleteStrokes_activate (GtkMenuItem *menuitem,
1756 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
1757 ui.brushes[TOOL_ERASER].tool_options = TOOLOPT_ERASER_STROKES;
1762 on_highlighterFine_activate (GtkMenuItem *menuitem,
1765 process_thickness_activate(menuitem, TOOL_HIGHLIGHTER, THICKNESS_FINE);
1770 on_highlighterMedium_activate (GtkMenuItem *menuitem,
1773 process_thickness_activate(menuitem, TOOL_HIGHLIGHTER, THICKNESS_MEDIUM);
1778 on_highlighterThick_activate (GtkMenuItem *menuitem,
1781 process_thickness_activate(menuitem, TOOL_HIGHLIGHTER, THICKNESS_THICK);
1786 on_toolsTextFont_activate (GtkMenuItem *menuitem,
1794 on_toolsDefaultPen_activate (GtkMenuItem *menuitem,
1798 g_memmove(ui.brushes+TOOL_PEN, ui.default_brushes+TOOL_PEN, sizeof(struct Brush));
1799 ui.toolno = TOOL_PEN;
1800 ui.cur_brush = ui.brushes+TOOL_PEN;
1801 update_tool_buttons();
1803 update_pen_props_menu();
1804 update_color_menu();
1810 on_toolsDefaultEraser_activate (GtkMenuItem *menuitem,
1814 g_memmove(ui.brushes+TOOL_ERASER, ui.default_brushes+TOOL_ERASER, sizeof(struct Brush));
1815 ui.toolno = TOOL_ERASER;
1816 ui.cur_brush = ui.brushes+TOOL_ERASER;
1817 update_tool_buttons();
1819 update_eraser_props_menu();
1820 update_color_menu();
1826 on_toolsDefaultHighlighter_activate (GtkMenuItem *menuitem,
1830 g_memmove(ui.brushes+TOOL_HIGHLIGHTER, ui.default_brushes+TOOL_HIGHLIGHTER, sizeof(struct Brush));
1831 ui.toolno = TOOL_HIGHLIGHTER;
1832 ui.cur_brush = ui.brushes+TOOL_HIGHLIGHTER;
1833 update_tool_buttons();
1835 update_highlighter_props_menu();
1836 update_color_menu();
1841 on_toolsDefaultText_activate (GtkMenuItem *menuitem,
1849 on_toolsSetAsDefault_activate (GtkMenuItem *menuitem,
1852 if (ui.toolno < NUM_STROKE_TOOLS)
1853 g_memmove(ui.default_brushes+ui.toolno, ui.brushes+ui.toolno, sizeof(struct Brush));
1858 on_toolsRuler_activate (GtkMenuItem *menuitem,
1863 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_CHECK_MENU_ITEM)
1864 active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
1866 active = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem));
1868 if (active == ui.ruler) return;
1870 if (active && (ui.toolno!=TOOL_PEN && ui.toolno!=TOOL_HIGHLIGHTER)) {
1872 ui.toolno = TOOL_PEN;
1873 ui.cur_brush = ui.brushes+TOOL_PEN;
1874 update_color_menu();
1875 update_tool_buttons();
1881 update_ruler_indicator();
1886 on_optionsSavePreferences_activate (GtkMenuItem *menuitem,
1894 on_helpIndex_activate (GtkMenuItem *menuitem,
1902 on_helpAbout_activate (GtkMenuItem *menuitem,
1905 GtkWidget *aboutDialog;
1906 GtkLabel *labelTitle;
1908 aboutDialog = create_aboutDialog ();
1909 labelTitle = GTK_LABEL(g_object_get_data(G_OBJECT(aboutDialog), "labelTitle"));
1910 gtk_label_set_markup(labelTitle,
1911 "<span size=\"xx-large\" weight=\"bold\">Xournal " VERSION "</span>");
1912 gtk_dialog_run (GTK_DIALOG(aboutDialog));
1913 gtk_widget_destroy(aboutDialog);
1918 on_buttonToolDefault_clicked (GtkToolButton *toolbutton,
1921 if (ui.toolno < NUM_STROKE_TOOLS) {
1922 g_memmove(ui.brushes+ui.toolno, ui.default_brushes+ui.toolno, sizeof(struct Brush));
1923 update_thickness_buttons();
1924 update_color_buttons();
1925 update_color_menu();
1926 if (ui.toolno == TOOL_PEN) update_pen_props_menu();
1927 if (ui.toolno == TOOL_ERASER) update_eraser_props_menu();
1928 if (ui.toolno == TOOL_HIGHLIGHTER) update_highlighter_props_menu();
1935 on_buttonFine_clicked (GtkToolButton *toolbutton,
1938 process_thickness_activate((GtkMenuItem*)toolbutton, ui.toolno, THICKNESS_FINE);
1943 on_buttonMedium_clicked (GtkToolButton *toolbutton,
1946 process_thickness_activate((GtkMenuItem*)toolbutton, ui.toolno, THICKNESS_MEDIUM);
1951 on_buttonThick_clicked (GtkToolButton *toolbutton,
1954 process_thickness_activate((GtkMenuItem*)toolbutton, ui.toolno, THICKNESS_THICK);
1959 on_canvas_button_press_event (GtkWidget *widget,
1960 GdkEventButton *event,
1964 gboolean page_change;
1965 struct Page *tmppage;
1968 if (ui.cur_item_type != ITEM_NONE) return FALSE; // we're already doing something
1969 if (event->button > 3) return FALSE; // no painting with the mouse wheel!
1971 if (ui.use_xinput) {
1972 if (event->device->source == GDK_SOURCE_MOUSE) return FALSE;
1973 // re-get the axis values since Synaptics sends bogus ones
1974 gdk_device_get_state(event->device, event->window, event->axes, NULL);
1975 fix_xinput_coords((GdkEvent *)event);
1977 else if (event->device->source != GDK_SOURCE_MOUSE) return FALSE;
1979 if ((ui.use_xinput && event->device->source == GDK_SOURCE_ERASER) ||
1980 (ui.emulate_eraser && event->button >= 2)) {
1981 ui.saved_toolno = ui.toolno;
1982 ui.saved_ruler = ui.ruler;
1984 ui.toolno = TOOL_ERASER;
1986 ui.cur_brush = ui.brushes + TOOL_ERASER;
1987 update_tool_buttons();
1989 update_color_menu();
1993 // check whether we're in a page
1994 page_change = FALSE;
1995 tmppage = ui.cur_page;
1996 get_pointer_coords((GdkEvent *)event, pt);
1997 while (ui.view_continuous && (pt[1] < - VIEW_CONTINUOUS_SKIP)) {
1998 if (ui.pageno == 0) break;
2001 tmppage = g_list_nth_data(journal.pages, ui.pageno);
2002 pt[1] += tmppage->height + VIEW_CONTINUOUS_SKIP;
2004 while (ui.view_continuous && (pt[1] > tmppage->height + VIEW_CONTINUOUS_SKIP)) {
2005 if (ui.pageno == journal.npages-1) break;
2006 pt[1] -= tmppage->height + VIEW_CONTINUOUS_SKIP;
2009 tmppage = g_list_nth_data(journal.pages, ui.pageno);
2011 if (page_change) do_switch_page(ui.pageno, FALSE);
2013 // can't paint on the background...
2015 if (ui.cur_layer == NULL) {
2016 if (ui.saved_toolno >=0) {
2017 ui.toolno = ui.saved_toolno;
2018 ui.ruler = ui.saved_ruler;
2019 ui.saved_toolno = -1;
2020 if (ui.toolno < NUM_STROKE_TOOLS) ui.cur_brush = ui.brushes + ui.toolno;
2021 update_tool_buttons();
2023 update_color_menu();
2027 dialog = gtk_message_dialog_new(GTK_WINDOW(winMain), GTK_DIALOG_MODAL,
2028 GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, "Drawing is not allowed on the "
2029 "background layer.\n Switching to Layer 1.");
2030 gtk_dialog_run(GTK_DIALOG(dialog));
2031 gtk_widget_destroy(dialog);
2032 on_viewShowLayer_activate(NULL, NULL);
2036 // process the event
2037 ui.which_mouse_button = event->button;
2039 if (ui.toolno == TOOL_PEN || ui.toolno == TOOL_HIGHLIGHTER ||
2040 (ui.toolno == TOOL_ERASER && ui.cur_brush->tool_options == TOOLOPT_ERASER_WHITEOUT)) {
2041 create_new_stroke((GdkEvent *)event);
2043 else if (ui.toolno == TOOL_ERASER) {
2044 ui.cur_item_type = ITEM_ERASURE;
2045 do_eraser((GdkEvent *)event, ui.cur_brush->thickness/2,
2046 ui.cur_brush->tool_options == TOOLOPT_ERASER_STROKES);
2048 else if (ui.toolno == TOOL_SELECTRECT) {
2049 if (!start_movesel((GdkEvent *)event))
2050 start_selectrect((GdkEvent *)event);
2052 else if (ui.toolno == TOOL_VERTSPACE) {
2053 start_vertspace((GdkEvent *)event);
2060 on_canvas_button_release_event (GtkWidget *widget,
2061 GdkEventButton *event,
2064 if (ui.cur_item_type == ITEM_NONE) return FALSE; // not doing anything
2066 if (event->button != ui.which_mouse_button) return FALSE; // ignore
2068 if (ui.use_xinput) {
2069 if (event->device->source == GDK_SOURCE_MOUSE) return FALSE;
2070 fix_xinput_coords((GdkEvent *)event);
2072 else if (event->device->source != GDK_SOURCE_MOUSE) return FALSE;
2074 if (ui.saved_toolno >= 0) {
2075 ui.toolno = ui.saved_toolno;
2076 ui.ruler = ui.saved_ruler;
2077 ui.saved_toolno = -1;
2078 if (ui.toolno < NUM_STROKE_TOOLS) ui.cur_brush = ui.brushes + ui.toolno;
2079 update_tool_buttons();
2081 update_color_menu();
2085 if (ui.cur_item_type == ITEM_STROKE) {
2088 else if (ui.cur_item_type == ITEM_ERASURE) {
2091 else if (ui.cur_item_type == ITEM_SELECTRECT) {
2092 finalize_selectrect();
2094 else if (ui.cur_item_type == ITEM_MOVESEL) {
2103 on_canvas_enter_notify_event (GtkWidget *widget,
2104 GdkEventCrossing *event,
2113 on_canvas_expose_event (GtkWidget *widget,
2114 GdkEventExpose *event,
2123 on_canvas_key_press_event (GtkWidget *widget,
2133 on_canvas_motion_notify_event (GtkWidget *widget,
2134 GdkEventMotion *event,
2137 gboolean looks_wrong;
2140 if (ui.cur_item_type == ITEM_NONE) return FALSE; // we don't care
2142 if (ui.use_xinput) {
2143 if (event->device->source == GDK_SOURCE_MOUSE) return FALSE;
2144 fix_xinput_coords((GdkEvent *)event);
2146 else if (event->device->source != GDK_SOURCE_MOUSE) return FALSE;
2148 looks_wrong = !(event->state & (1<<(7+ui.which_mouse_button)));
2150 if (looks_wrong) { /* mouse button shouldn't be up... give up */
2151 if (ui.cur_item_type == ITEM_STROKE) {
2154 else if (ui.cur_item_type == ITEM_ERASURE) {
2157 else if (ui.cur_item_type == ITEM_SELECTRECT) {
2158 finalize_selectrect();
2160 else if (ui.cur_item_type == ITEM_MOVESEL) {
2166 if (ui.cur_item_type == ITEM_STROKE) {
2167 continue_stroke((GdkEvent *)event);
2169 else if (ui.cur_item_type == ITEM_ERASURE) {
2170 do_eraser((GdkEvent *)event, ui.cur_brush->thickness/2,
2171 ui.cur_brush->tool_options == TOOLOPT_ERASER_STROKES);
2173 else if (ui.cur_item_type == ITEM_SELECTRECT) {
2174 get_pointer_coords((GdkEvent *)event, pt);
2175 ui.selection->bbox.right = pt[0];
2176 ui.selection->bbox.bottom = pt[1];
2177 gnome_canvas_item_set(ui.selection->canvas_item,
2178 "x2", pt[0], "y2", pt[1], NULL);
2180 else if (ui.cur_item_type == ITEM_MOVESEL) {
2181 continue_movesel((GdkEvent *)event);
2189 on_comboLayer_changed (GtkComboBox *combobox,
2194 if (ui.in_update_page_stuff) return; // avoid a bad retroaction
2196 gtk_widget_grab_focus(GTK_WIDGET(canvas)); // stop focus on us
2198 val = gtk_combo_box_get_active(combobox);
2199 if (val == -1) return;
2200 val = ui.cur_page->nlayers-1-val;
2201 if (val == ui.layerno) return;
2204 while (val>ui.layerno) {
2206 ui.cur_layer = g_list_nth_data(ui.cur_page->layers, ui.layerno);
2207 gnome_canvas_item_show(GNOME_CANVAS_ITEM(ui.cur_layer->group));
2209 while (val<ui.layerno) {
2210 gnome_canvas_item_hide(GNOME_CANVAS_ITEM(ui.cur_layer->group));
2212 if (ui.layerno<0) ui.cur_layer = NULL;
2213 else ui.cur_layer = g_list_nth_data(ui.cur_page->layers, ui.layerno);
2215 update_page_stuff();
2220 on_winMain_delete_event (GtkWidget *widget,
2224 if (ok_to_close()) gtk_main_quit();
2230 on_optionsUseXInput_activate (GtkMenuItem *menuitem,
2233 ui.allow_xinput = ui.use_xinput =
2234 gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
2238 on_vscroll_changed (GtkAdjustment *adjustment,
2241 gboolean need_update;
2242 double viewport_top, viewport_bottom;
2243 struct Page *tmppage;
2245 if (!ui.view_continuous) return;
2247 if (ui.progressive_bg) rescale_bg_pixmaps();
2248 need_update = FALSE;
2249 viewport_top = adjustment->value / ui.zoom;
2250 viewport_bottom = (adjustment->value + adjustment->page_size) / ui.zoom;
2251 tmppage = ui.cur_page;
2252 while (viewport_top > tmppage->voffset + tmppage->height) {
2253 if (ui.pageno == journal.npages-1) break;
2256 tmppage = g_list_nth_data(journal.pages, ui.pageno);
2258 while (viewport_bottom < tmppage->voffset) {
2259 if (ui.pageno == 0) break;
2262 tmppage = g_list_nth_data(journal.pages, ui.pageno);
2264 if (need_update) do_switch_page(ui.pageno, FALSE);
2269 on_spinPageNo_value_changed (GtkSpinButton *spinbutton,
2274 if (ui.in_update_page_stuff) return; // avoid a bad retroaction
2276 gtk_widget_grab_focus(GTK_WIDGET(canvas)); // stop blink-blink text cursor
2278 val = gtk_spin_button_get_value_as_int(spinbutton) - 1;
2280 if (val == journal.npages) { // create a page at end
2281 if (page_ops_forbidden()) return;
2282 on_journalNewPageEnd_activate(NULL, NULL);
2286 if (val == ui.pageno) return;
2287 if (val < 0) val = 0;
2288 if (val > journal.npages-1) val = journal.npages-1;
2289 do_switch_page(val, TRUE);
2294 on_journalDefaultBackground_activate (GtkMenuItem *menuitem,
2299 undo->type = ITEM_NEW_BG_RESIZE;
2300 undo->page = ui.cur_page;
2301 undo->bg = ui.cur_page->bg;
2302 undo->val_x = ui.cur_page->width;
2303 undo->val_y = ui.cur_page->height;
2305 ui.cur_page->bg = (struct Background *)g_memdup(ui.default_page.bg, sizeof(struct Background));
2306 ui.cur_page->width = ui.default_page.width;
2307 ui.cur_page->height = ui.default_page.height;
2308 ui.cur_page->bg->canvas_item = undo->bg->canvas_item;
2309 undo->bg->canvas_item = NULL;
2311 make_page_clipbox(ui.cur_page);
2312 update_canvas_bg(ui.cur_page);
2313 do_switch_page(ui.pageno, TRUE);
2318 on_journalSetAsDefault_activate (GtkMenuItem *menuitem,
2321 if (ui.cur_page->bg->type != BG_SOLID) return;
2324 undo->type = ITEM_NEW_DEFAULT_BG;
2325 undo->val_x = ui.default_page.width;
2326 undo->val_y = ui.default_page.height;
2327 undo->bg = ui.default_page.bg;
2329 ui.default_page.width = ui.cur_page->width;
2330 ui.default_page.height = ui.cur_page->height;
2331 ui.default_page.bg = (struct Background *)g_memdup(ui.cur_page->bg, sizeof(struct Background));
2332 ui.default_page.bg->canvas_item = NULL;
2337 on_comboStdSizes_changed (GtkComboBox *combobox,
2341 GtkComboBox *comboUnit;
2345 if (papersize_need_init) {
2346 gtk_combo_box_set_active(combobox, papersize_std);
2347 papersize_need_init = FALSE;
2349 val = gtk_combo_box_get_active(combobox);
2350 if (val == -1 || val == papersize_std) return;
2351 papersize_std = val;
2352 if (val == STD_SIZE_CUSTOM) return;
2353 papersize_unit = std_units[val];
2354 papersize_width = std_widths[val];
2355 papersize_height = std_heights[val];
2357 comboUnit = GTK_COMBO_BOX(g_object_get_data(G_OBJECT(papersize_dialog), "comboUnit"));
2358 gtk_combo_box_set_active(comboUnit, papersize_unit);
2359 entry = GTK_ENTRY(g_object_get_data(G_OBJECT(papersize_dialog), "entryWidth"));
2360 g_snprintf(text, 20, "%.2f", papersize_width/unit_sizes[papersize_unit]);
2361 if (g_str_has_suffix(text, ".00"))
2362 g_snprintf(text, 20, "%d", (int) (papersize_width/unit_sizes[papersize_unit]));
2363 gtk_entry_set_text(entry, text);
2364 entry = GTK_ENTRY(g_object_get_data(G_OBJECT(papersize_dialog), "entryHeight"));
2365 g_snprintf(text, 20, "%.2f", papersize_height/unit_sizes[papersize_unit]);
2366 if (g_str_has_suffix(text, ".00"))
2367 g_snprintf(text, 20, "%d", (int) (papersize_height/unit_sizes[papersize_unit]));
2368 gtk_entry_set_text(entry, text);
2373 on_entryWidth_changed (GtkEditable *editable,
2379 GtkComboBox *comboStdSizes;
2381 text = gtk_entry_get_text(GTK_ENTRY(editable));
2382 val = strtod(text, &ptr);
2383 papersize_width_valid = (*ptr == 0 && val > 0.);
2384 if (!papersize_width_valid) return; // invalid entry
2385 val *= unit_sizes[papersize_unit];
2386 if (fabs(val - papersize_width) < 0.1) return; // no change
2387 papersize_std = STD_SIZE_CUSTOM;
2388 papersize_width = val;
2389 comboStdSizes = GTK_COMBO_BOX(g_object_get_data(G_OBJECT(papersize_dialog), "comboStdSizes"));
2390 gtk_combo_box_set_active(comboStdSizes, papersize_std);
2395 on_entryHeight_changed (GtkEditable *editable,
2401 GtkComboBox *comboStdSizes;
2403 text = gtk_entry_get_text(GTK_ENTRY(editable));
2404 val = strtod(text, &ptr);
2405 papersize_height_valid = (*ptr == 0 && val > 0.);
2406 if (!papersize_height_valid) return; // invalid entry
2407 val *= unit_sizes[papersize_unit];
2408 if (fabs(val - papersize_height) < 0.1) return; // no change
2409 papersize_std = STD_SIZE_CUSTOM;
2410 papersize_height = val;
2411 comboStdSizes = GTK_COMBO_BOX(g_object_get_data(G_OBJECT(papersize_dialog), "comboStdSizes"));
2412 gtk_combo_box_set_active(comboStdSizes, papersize_std);
2417 on_comboUnit_changed (GtkComboBox *combobox,
2424 val = gtk_combo_box_get_active(combobox);
2425 if (val == -1 || val == papersize_unit) return;
2426 papersize_unit = val;
2427 entry = GTK_ENTRY(g_object_get_data(G_OBJECT(papersize_dialog), "entryWidth"));
2428 if (papersize_width_valid) {
2429 g_snprintf(text, 20, "%.2f", papersize_width/unit_sizes[papersize_unit]);
2430 if (g_str_has_suffix(text, ".00"))
2431 g_snprintf(text, 20, "%d", (int) (papersize_width/unit_sizes[papersize_unit]));
2433 gtk_entry_set_text(entry, text);
2434 if (papersize_height_valid) {
2435 entry = GTK_ENTRY(g_object_get_data(G_OBJECT(papersize_dialog), "entryHeight"));
2436 g_snprintf(text, 20, "%.2f", papersize_height/unit_sizes[papersize_unit]);
2437 if (g_str_has_suffix(text, ".00"))
2438 g_snprintf(text, 20, "%d", (int) (papersize_height/unit_sizes[papersize_unit]));
2440 gtk_entry_set_text(entry, text);
2445 on_viewFullscreen_activate (GtkMenuItem *menuitem,
2450 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_CHECK_MENU_ITEM)
2451 active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
2453 active = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem));
2455 if (active == ui.fullscreen) return;
2456 ui.fullscreen = active;
2458 if (ui.fullscreen) {
2459 gtk_window_fullscreen(GTK_WINDOW(winMain));
2460 gtk_widget_hide(GET_COMPONENT("menubar"));
2461 gtk_widget_hide(GET_COMPONENT("hbox1"));
2464 gtk_window_unfullscreen(GTK_WINDOW(winMain));
2465 gtk_widget_show(GET_COMPONENT("menubar"));
2466 gtk_widget_show(GET_COMPONENT("hbox1"));
2472 on_optionsEmulateEraser_activate (GtkMenuItem *menuitem,
2476 gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
2481 on_optionsAntialiasBG_activate (GtkMenuItem *menuitem,
2486 active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
2487 if (ui.antialias_bg == active) return;
2488 ui.antialias_bg = active;
2489 rescale_bg_pixmaps();
2494 on_optionsProgressiveBG_activate (GtkMenuItem *menuitem,
2499 active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
2500 if (ui.progressive_bg == active) return;
2501 ui.progressive_bg = active;
2502 if (!ui.progressive_bg) rescale_bg_pixmaps();