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 gtk_file_chooser_set_filename(GTK_FILE_CHOOSER (dialog), ui.filename);
192 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), g_basename(ui.filename));
195 if (bgpdf.status!=STATUS_NOT_INIT && bgpdf.file_domain == DOMAIN_ABSOLUTE
196 && bgpdf.filename != NULL) {
197 filename = g_strdup_printf("%s.xoj", bgpdf.filename->s);
198 gtk_file_chooser_set_filename(GTK_FILE_CHOOSER (dialog), filename);
199 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), g_basename(filename));
203 curtime = time(NULL);
204 strftime(stime, 30, "%F-Note-%H-%M.xoj", localtime(&curtime));
205 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), stime);
208 filt_all = gtk_file_filter_new();
209 gtk_file_filter_set_name(filt_all, "All files");
210 gtk_file_filter_add_pattern(filt_all, "*");
211 filt_xoj = gtk_file_filter_new();
212 gtk_file_filter_set_name(filt_xoj, "Xournal files");
213 gtk_file_filter_add_pattern(filt_xoj, "*.xoj");
214 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_xoj);
215 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_all);
217 // somehow this doesn't seem to be set by default
218 gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
221 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
222 gtk_widget_destroy(dialog);
225 filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
226 warn = g_file_test (filename, G_FILE_TEST_EXISTS);
227 if (warn) { // ok to overwrite an empty file
228 if (!g_stat(filename, &stat_buf))
229 if (stat_buf.st_size == 0) warn=FALSE;
231 if (warn && ui.filename!=NULL) { // ok to overwrite oneself
232 if (ui.filename[0]=='/' && !strcmp(ui.filename, filename)) warn=FALSE;
233 if (ui.filename[0]!='/' && g_str_has_suffix(filename, ui.filename)) warn=FALSE;
236 warning_dialog = gtk_message_dialog_new(GTK_WINDOW(winMain),
237 GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO,
238 "Should the file %s be overwritten?", filename);
239 if (gtk_dialog_run(GTK_DIALOG(warning_dialog)) == GTK_RESPONSE_YES)
241 gtk_widget_destroy(warning_dialog);
245 gtk_widget_destroy(dialog);
247 set_cursor_busy(TRUE);
248 if (save_journal(filename)) { // success
250 set_cursor_busy(FALSE);
251 update_file_name(filename);
254 set_cursor_busy(FALSE);
256 dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
257 GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Error saving file '%s'", filename);
258 gtk_dialog_run(GTK_DIALOG(dialog));
259 gtk_widget_destroy(dialog);
265 on_filePrintOptions_activate (GtkMenuItem *menuitem,
273 on_filePrint_activate (GtkMenuItem *menuitem,
276 GtkWidget *printDialog, *preview;
278 int fromPage, toPage;
282 GnomePrintConfig *config = gnome_print_config_default();
284 if (ui.filename!=NULL) {
285 if (g_str_has_suffix(ui.filename, ".xoj")) {
286 in_fn = g_strdup(ui.filename);
287 g_strlcpy(g_strrstr(in_fn, "xoj"), "pdf", 4);
290 in_fn = g_strdup_printf("%s.pdf", ui.filename);
291 gnome_print_config_set(config, (guchar *)"Printer", (guchar *)"PDF");
292 gnome_print_config_set(config, (guchar *)GNOME_PRINT_KEY_OUTPUT_FILENAME, (guchar *)in_fn);
293 gnome_print_config_set(config, (guchar *)"Settings.Transport.Backend.FileName", (guchar *)in_fn);
294 g_strlcpy(g_strrstr(in_fn, "pdf"), "ps", 3);
295 gnome_print_config_set(config, (guchar *)"Printer", (guchar *)"GENERIC");
296 gnome_print_config_set (config, (guchar *)GNOME_PRINT_KEY_OUTPUT_FILENAME, (guchar *)in_fn);
297 s = gnome_print_config_get(config, (guchar *)"Settings.Transport.Backend.FileName");
300 gnome_print_config_set(config, (guchar *)"Settings.Transport.Backend.FileName", (guchar *)in_fn);
305 gpj = gnome_print_job_new(config); /* was NULL */
306 gnome_print_config_unref(config);
308 printDialog = gnome_print_dialog_new(gpj, (guchar *)"Print", GNOME_PRINT_DIALOG_RANGE);
309 gnome_print_dialog_construct_range_page(GNOME_PRINT_DIALOG(printDialog),
310 GNOME_PRINT_RANGE_ALL | GNOME_PRINT_RANGE_RANGE,
311 1, journal.npages, (guchar *)"Current page", (guchar *)"Pages");
312 /* don't have "Current page" as option, else it becomes the default!! */
314 gtk_dialog_set_response_sensitive(GTK_DIALOG(printDialog),
315 GNOME_PRINT_DIALOG_RESPONSE_PREVIEW, FALSE);
316 /* the print-job-preview "feature" is completely, hopelessly broken */
318 response = gtk_dialog_run(GTK_DIALOG(printDialog));
320 gtk_widget_destroy(printDialog);
325 if (response == GNOME_PRINT_DIALOG_RESPONSE_PREVIEW) {
326 print_job_render(gpj, 0, journal.npages-1);
327 gtk_widget_destroy(printDialog);
328 preview = gnome_print_job_preview_new(gpj, (guchar *)"Preview");
329 try_fix_print_preview_ui(preview);
330 gtk_window_set_modal(GTK_WINDOW(preview), TRUE);
331 gtk_widget_show_all(preview);
335 if (response == GNOME_PRINT_DIALOG_RESPONSE_PRINT) {
336 switch(gnome_print_dialog_get_range(GNOME_PRINT_DIALOG(printDialog))) {
337 case GNOME_PRINT_RANGE_RANGE:
338 gnome_print_dialog_get_range_page(GNOME_PRINT_DIALOG(printDialog), &fromPage, &toPage);
344 toPage = journal.npages-1;
347 gtk_widget_destroy(printDialog);
348 print_job_render(gpj, fromPage, toPage);
354 on_filePrintPDF_activate (GtkMenuItem *menuitem,
359 GtkFileFilter *filt_all, *filt_pdf;
360 char *filename, *in_fn;
364 GnomePrintConfig *config;
367 dialog = gtk_file_chooser_dialog_new("Print to PDF", GTK_WINDOW (winMain),
368 GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
369 GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL);
371 if (ui.filename!=NULL) {
372 if (g_str_has_suffix(ui.filename, ".xoj")) {
373 in_fn = g_strdup(ui.filename);
374 g_strlcpy(g_strrstr(in_fn, "xoj"), "pdf", 4);
377 in_fn = g_strdup_printf("%s.pdf", ui.filename);
378 gtk_file_chooser_set_filename(GTK_FILE_CHOOSER (dialog), in_fn);
379 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), g_basename(in_fn));
381 curtime = time(NULL);
382 strftime(stime, 30, "%F-Note-%H-%M.pdf", localtime(&curtime));
383 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), stime);
387 filt_all = gtk_file_filter_new();
388 gtk_file_filter_set_name(filt_all, "All files");
389 gtk_file_filter_add_pattern(filt_all, "*");
390 filt_pdf = gtk_file_filter_new();
391 gtk_file_filter_set_name(filt_pdf, "PDF files");
392 gtk_file_filter_add_pattern(filt_pdf, "*.pdf");
393 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_pdf);
394 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_all);
396 // somehow this doesn't seem to be set by default
397 gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
399 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
401 gtk_widget_destroy(dialog);
404 filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
406 gtk_widget_destroy(dialog);
408 config = gnome_print_config_default();
409 gnome_print_config_set(config, (guchar *)"Printer", (guchar *)"PDF");
410 gpj = gnome_print_job_new(config);
411 gnome_print_job_print_to_file(gpj, filename);
413 print_job_render(gpj, 0, journal.npages-1);
414 gnome_print_config_unref(config);
421 on_fileQuit_activate (GtkMenuItem *menuitem,
424 if (ok_to_close()) gtk_main_quit ();
429 on_editUndo_activate (GtkMenuItem *menuitem,
433 GList *list, *itemlist;
434 struct UndoErasureData *erasure;
436 struct Brush tmp_brush;
437 struct Background *tmp_bg;
440 if (undo == NULL) return; // nothing to undo!
441 reset_selection(); // safer
442 if (undo->type == ITEM_STROKE) {
443 // we're keeping the stroke info, but deleting the canvas item
444 gtk_object_destroy(GTK_OBJECT(undo->item->canvas_item));
445 undo->item->canvas_item = NULL;
446 // we also remove the object from its layer!
447 undo->layer->items = g_list_remove(undo->layer->items, undo->item);
448 undo->layer->nitems--;
450 else if (undo->type == ITEM_ERASURE) {
451 for (list = undo->erasurelist; list!=NULL; list = list->next) {
452 erasure = (struct UndoErasureData *)list->data;
453 // delete all the created items
454 for (itemlist = erasure->replacement_items; itemlist!=NULL; itemlist = itemlist->next) {
455 it = (struct Item *)itemlist->data;
456 gtk_object_destroy(GTK_OBJECT(it->canvas_item));
457 it->canvas_item = NULL;
458 undo->layer->items = g_list_remove(undo->layer->items, it);
459 undo->layer->nitems--;
461 // recreate the deleted one
462 erasure->item->canvas_item = gnome_canvas_item_new(undo->layer->group,
463 gnome_canvas_line_get_type(), "points", erasure->item->path,
464 "cap-style", GDK_CAP_ROUND, "join-style", GDK_JOIN_ROUND,
465 "fill-color-rgba", erasure->item->brush.color_rgba,
466 "width-units", erasure->item->brush.thickness, NULL);
467 undo->layer->items = g_list_insert(undo->layer->items, erasure->item,
469 if (erasure->npos == 0)
470 lower_canvas_item_to(undo->layer->group, erasure->item->canvas_item, NULL);
472 lower_canvas_item_to(undo->layer->group, erasure->item->canvas_item,
473 ((struct Item *)g_list_nth_data(undo->layer->items, erasure->npos-1))->canvas_item);
474 undo->layer->nitems++;
477 else if (undo->type == ITEM_NEW_BG_ONE || undo->type == ITEM_NEW_BG_RESIZE
478 || undo->type == ITEM_PAPER_RESIZE) {
479 if (undo->type != ITEM_PAPER_RESIZE) {
481 tmp_bg = undo->page->bg;
482 undo->page->bg = undo->bg;
484 undo->page->bg->canvas_item = undo->bg->canvas_item;
485 undo->bg->canvas_item = NULL;
487 if (undo->type != ITEM_NEW_BG_ONE) {
488 tmp_x = undo->page->width;
489 tmp_y = undo->page->height;
490 undo->page->width = undo->val_x;
491 undo->page->height = undo->val_y;
494 make_page_clipbox(undo->page);
496 update_canvas_bg(undo->page);
497 do_switch_page(g_list_index(journal.pages, undo->page), TRUE, TRUE);
499 else if (undo->type == ITEM_NEW_DEFAULT_BG) {
500 tmp_bg = ui.default_page.bg;
501 ui.default_page.bg = undo->bg;
503 tmp_x = ui.default_page.width;
504 tmp_y = ui.default_page.height;
505 ui.default_page.width = undo->val_x;
506 ui.default_page.height = undo->val_y;
510 else if (undo->type == ITEM_NEW_PAGE) {
511 // unmap the page; keep the page & its empty layer in memory
512 if (undo->page->group!=NULL) gtk_object_destroy(GTK_OBJECT(undo->page->group));
513 // also destroys the background and layer's canvas items
514 undo->page->group = NULL;
515 undo->page->bg->canvas_item = NULL;
516 journal.pages = g_list_remove(journal.pages, undo->page);
518 if (ui.cur_page == undo->page) ui.cur_page = NULL;
519 // so do_switch_page() won't try to remap the layers of the defunct page
520 if (ui.pageno >= undo->val) ui.pageno--;
521 if (ui.pageno < 0) ui.pageno = 0;
522 do_switch_page(ui.pageno, TRUE, TRUE);
524 else if (undo->type == ITEM_DELETE_PAGE) {
525 journal.pages = g_list_insert(journal.pages, undo->page, undo->val);
527 make_canvas_items(); // re-create the canvas items
528 do_switch_page(undo->val, TRUE, TRUE);
530 else if (undo->type == ITEM_MOVESEL) {
531 for (itemlist = undo->itemlist; itemlist != NULL; itemlist = itemlist->next) {
532 it = (struct Item *)itemlist->data;
533 if (it->canvas_item != NULL)
534 gnome_canvas_item_move(it->canvas_item, -undo->val_x, -undo->val_y);
536 move_journal_items_by(undo->itemlist, -undo->val_x, -undo->val_y);
538 else if (undo->type == ITEM_PASTE) {
539 for (itemlist = undo->itemlist; itemlist != NULL; itemlist = itemlist->next) {
540 it = (struct Item *)itemlist->data;
541 gtk_object_destroy(GTK_OBJECT(it->canvas_item));
542 it->canvas_item = NULL;
543 undo->layer->items = g_list_remove(undo->layer->items, it);
544 undo->layer->nitems--;
547 else if (undo->type == ITEM_NEW_LAYER) {
548 // unmap the layer; keep the empty layer in memory
549 if (undo->layer->group!=NULL) gtk_object_destroy(GTK_OBJECT(undo->layer->group));
550 undo->layer->group = NULL;
551 undo->page->layers = g_list_remove(undo->page->layers, undo->layer);
552 undo->page->nlayers--;
553 do_switch_page(ui.pageno, FALSE, FALSE); // don't stay with bad cur_layer info
555 else if (undo->type == ITEM_DELETE_LAYER) {
556 // special case of -1: deleted the last layer, created a new one
557 if (undo->val == -1) {
558 if (undo->layer2->group!=NULL) gtk_object_destroy(GTK_OBJECT(undo->layer2->group));
559 undo->layer2->group = NULL;
560 undo->page->layers = g_list_remove(undo->page->layers, undo->layer2);
561 undo->page->nlayers--;
564 undo->layer->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
565 undo->page->group, gnome_canvas_group_get_type(), NULL);
566 lower_canvas_item_to(undo->page->group, GNOME_CANVAS_ITEM(undo->layer->group),
567 (undo->val >= 1) ? GNOME_CANVAS_ITEM(((struct Layer *)
568 g_list_nth_data(undo->page->layers, undo->val-1))->group) :
569 undo->page->bg->canvas_item);
570 undo->page->layers = g_list_insert(undo->page->layers, undo->layer,
571 (undo->val >= 0) ? undo->val:0);
572 undo->page->nlayers++;
574 for (itemlist = undo->layer->items; itemlist!=NULL; itemlist = itemlist->next) {
575 it = (struct Item *)itemlist->data;
576 if (it->type == ITEM_STROKE) {
577 it->canvas_item = gnome_canvas_item_new(undo->layer->group,
578 gnome_canvas_line_get_type(), "points", it->path,
579 "cap-style", GDK_CAP_ROUND, "join-style", GDK_JOIN_ROUND,
580 "fill-color-rgba", it->brush.color_rgba,
581 "width-units", it->brush.thickness, NULL);
584 do_switch_page(ui.pageno, FALSE, FALSE); // show the restored layer & others...
586 else if (undo->type == ITEM_REPAINTSEL) {
587 for (itemlist = undo->itemlist, list = undo->auxlist; itemlist!=NULL;
588 itemlist = itemlist->next, list = list->next) {
589 it = (struct Item *)itemlist->data;
590 g_memmove(&tmp_brush, &(it->brush), sizeof(struct Brush));
591 g_memmove(&(it->brush), list->data, sizeof(struct Brush));
592 g_memmove(list->data, &tmp_brush, sizeof(struct Brush));
593 if (it->type == ITEM_STROKE && it->canvas_item != NULL)
594 gnome_canvas_item_set(it->canvas_item,
595 "fill-color-rgba", it->brush.color_rgba,
596 "width-units", it->brush.thickness, NULL);
600 // move item from undo to redo stack
606 update_undo_redo_enabled();
607 if (u->multiop & MULTIOP_CONT_UNDO) on_editUndo_activate(NULL,NULL); // loop
612 on_editRedo_activate (GtkMenuItem *menuitem,
616 GList *list, *itemlist, *target;
617 struct UndoErasureData *erasure;
619 struct Brush tmp_brush;
620 struct Background *tmp_bg;
624 if (redo == NULL) return; // nothing to redo!
625 reset_selection(); // safer
626 if (redo->type == ITEM_STROKE) {
627 // re-create the canvas_item
628 redo->item->canvas_item = gnome_canvas_item_new(redo->layer->group,
629 gnome_canvas_line_get_type(), "points", redo->item->path,
630 "cap-style", GDK_CAP_ROUND, "join-style", GDK_JOIN_ROUND,
631 "fill-color-rgba", redo->item->brush.color_rgba,
632 "width-units", redo->item->brush.thickness, NULL);
633 // reinsert the item on its layer
634 redo->layer->items = g_list_append(redo->layer->items, redo->item);
635 redo->layer->nitems++;
637 else if (redo->type == ITEM_ERASURE) {
638 for (list = redo->erasurelist; list!=NULL; list = list->next) {
639 erasure = (struct UndoErasureData *)list->data;
640 target = g_list_find(redo->layer->items, erasure->item);
641 // re-create all the created items
642 for (itemlist = erasure->replacement_items; itemlist!=NULL; itemlist = itemlist->next) {
643 it = (struct Item *)itemlist->data;
644 it->canvas_item = gnome_canvas_item_new(redo->layer->group,
645 gnome_canvas_line_get_type(), "points", it->path,
646 "cap-style", GDK_CAP_ROUND, "join-style", GDK_JOIN_ROUND,
647 "fill-color-rgba", it->brush.color_rgba,
648 "width-units", it->brush.thickness, NULL);
649 redo->layer->items = g_list_insert_before(redo->layer->items, target, it);
650 redo->layer->nitems++;
651 lower_canvas_item_to(redo->layer->group, it->canvas_item, erasure->item->canvas_item);
653 // re-delete the deleted one
654 gtk_object_destroy(GTK_OBJECT(erasure->item->canvas_item));
655 erasure->item->canvas_item = NULL;
656 redo->layer->items = g_list_delete_link(redo->layer->items, target);
657 redo->layer->nitems--;
660 else if (redo->type == ITEM_NEW_BG_ONE || redo->type == ITEM_NEW_BG_RESIZE
661 || redo->type == ITEM_PAPER_RESIZE) {
662 if (redo->type != ITEM_PAPER_RESIZE) {
664 tmp_bg = redo->page->bg;
665 redo->page->bg = redo->bg;
667 redo->page->bg->canvas_item = redo->bg->canvas_item;
668 redo->bg->canvas_item = NULL;
670 if (redo->type != ITEM_NEW_BG_ONE) {
671 tmp_x = redo->page->width;
672 tmp_y = redo->page->height;
673 redo->page->width = redo->val_x;
674 redo->page->height = redo->val_y;
677 make_page_clipbox(redo->page);
679 update_canvas_bg(redo->page);
680 do_switch_page(g_list_index(journal.pages, redo->page), TRUE, TRUE);
682 else if (redo->type == ITEM_NEW_DEFAULT_BG) {
683 tmp_bg = ui.default_page.bg;
684 ui.default_page.bg = redo->bg;
686 tmp_x = ui.default_page.width;
687 tmp_y = ui.default_page.height;
688 ui.default_page.width = redo->val_x;
689 ui.default_page.height = redo->val_y;
693 else if (redo->type == ITEM_NEW_PAGE) {
695 redo->page->bg->canvas_item = NULL;
696 redo->page->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
697 gnome_canvas_root(canvas), gnome_canvas_clipgroup_get_type(), NULL);
698 make_page_clipbox(redo->page);
699 update_canvas_bg(redo->page);
700 l = (struct Layer *)redo->page->layers->data;
701 l->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
702 redo->page->group, gnome_canvas_group_get_type(), NULL);
704 journal.pages = g_list_insert(journal.pages, redo->page, redo->val);
706 do_switch_page(redo->val, TRUE, TRUE);
708 else if (redo->type == ITEM_DELETE_PAGE) {
709 // unmap all the canvas items
710 gtk_object_destroy(GTK_OBJECT(redo->page->group));
711 redo->page->group = NULL;
712 redo->page->bg->canvas_item = NULL;
713 for (list = redo->page->layers; list!=NULL; list = list->next) {
714 l = (struct Layer *)list->data;
715 for (itemlist = l->items; itemlist!=NULL; itemlist = itemlist->next)
716 ((struct Item *)itemlist->data)->canvas_item = NULL;
719 journal.pages = g_list_remove(journal.pages, redo->page);
721 if (ui.pageno > undo->val || ui.pageno == journal.npages) ui.pageno--;
723 // so do_switch_page() won't try to remap the layers of the defunct page
724 do_switch_page(ui.pageno, TRUE, TRUE);
726 else if (redo->type == ITEM_MOVESEL) {
727 for (itemlist = redo->itemlist; itemlist != NULL; itemlist = itemlist->next) {
728 it = (struct Item *)itemlist->data;
729 if (it->canvas_item != NULL)
730 gnome_canvas_item_move(it->canvas_item, redo->val_x, redo->val_y);
732 move_journal_items_by(redo->itemlist, redo->val_x, redo->val_y);
734 else if (redo->type == ITEM_PASTE) {
735 for (itemlist = redo->itemlist; itemlist != NULL; itemlist = itemlist->next) {
736 it = (struct Item *)itemlist->data;
737 it->canvas_item = gnome_canvas_item_new(redo->layer->group,
738 gnome_canvas_line_get_type(), "points", it->path,
739 "cap-style", GDK_CAP_ROUND, "join-style", GDK_JOIN_ROUND,
740 "fill-color-rgba", it->brush.color_rgba,
741 "width-units", it->brush.thickness, NULL);
742 redo->layer->items = g_list_append(redo->layer->items, it);
743 redo->layer->nitems++;
746 else if (redo->type == ITEM_NEW_LAYER) {
747 redo->layer->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
748 redo->page->group, gnome_canvas_group_get_type(), NULL);
749 lower_canvas_item_to(redo->page->group, GNOME_CANVAS_ITEM(redo->layer->group),
750 (redo->val >= 1) ? GNOME_CANVAS_ITEM(((struct Layer *)
751 g_list_nth_data(redo->page->layers, redo->val-1))->group) :
752 redo->page->bg->canvas_item);
753 redo->page->layers = g_list_insert(redo->page->layers, redo->layer, redo->val);
754 redo->page->nlayers++;
755 do_switch_page(ui.pageno, FALSE, FALSE);
757 else if (redo->type == ITEM_DELETE_LAYER) {
758 gtk_object_destroy(GTK_OBJECT(redo->layer->group));
759 redo->layer->group = NULL;
760 for (list=redo->layer->items; list!=NULL; list=list->next)
761 ((struct Item *)list->data)->canvas_item = NULL;
762 redo->page->layers = g_list_remove(redo->page->layers, redo->layer);
763 redo->page->nlayers--;
764 if (redo->val == -1) {
765 redo->layer2->group = (GnomeCanvasGroup *)gnome_canvas_item_new(
766 redo->page->group, gnome_canvas_group_get_type(), NULL);
767 redo->page->layers = g_list_append(redo->page->layers, redo->layer2);
768 redo->page->nlayers++;
770 do_switch_page(ui.pageno, FALSE, FALSE);
772 else if (redo->type == ITEM_REPAINTSEL) {
773 for (itemlist = redo->itemlist, list = redo->auxlist; itemlist!=NULL;
774 itemlist = itemlist->next, list = list->next) {
775 it = (struct Item *)itemlist->data;
776 g_memmove(&tmp_brush, &(it->brush), sizeof(struct Brush));
777 g_memmove(&(it->brush), list->data, sizeof(struct Brush));
778 g_memmove(list->data, &tmp_brush, sizeof(struct Brush));
779 if (it->type == ITEM_STROKE && it->canvas_item != NULL)
780 gnome_canvas_item_set(it->canvas_item,
781 "fill-color-rgba", it->brush.color_rgba,
782 "width-units", it->brush.thickness, NULL);
786 // move item from redo to undo stack
792 update_undo_redo_enabled();
793 if (u->multiop & MULTIOP_CONT_REDO) on_editRedo_activate(NULL,NULL); // loop
798 on_editCut_activate (GtkMenuItem *menuitem,
807 on_editCopy_activate (GtkMenuItem *menuitem,
815 on_editPaste_activate (GtkMenuItem *menuitem,
823 on_editDelete_activate (GtkMenuItem *menuitem,
831 on_viewContinuous_activate (GtkMenuItem *menuitem,
834 GtkAdjustment *v_adj;
838 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
839 if (ui.view_continuous) return;
840 ui.view_continuous = TRUE;
841 v_adj = gtk_layout_get_vadjustment(GTK_LAYOUT(canvas));
843 yscroll = gtk_adjustment_get_value(v_adj) - pg->voffset*ui.zoom;
845 gtk_adjustment_set_value(v_adj, yscroll + pg->voffset*ui.zoom);
847 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
852 on_viewOnePage_activate (GtkMenuItem *menuitem,
855 GtkAdjustment *v_adj;
858 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
859 if (!ui.view_continuous) return;
860 ui.view_continuous = FALSE;
861 v_adj = gtk_layout_get_vadjustment(GTK_LAYOUT(canvas));
862 yscroll = gtk_adjustment_get_value(v_adj) - ui.cur_page->voffset*ui.zoom;
864 gtk_adjustment_set_value(v_adj, yscroll + ui.cur_page->voffset*ui.zoom);
866 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
871 on_viewZoomIn_activate (GtkMenuItem *menuitem,
874 if (ui.zoom > MAX_ZOOM) return;
876 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
877 rescale_bg_pixmaps();
882 on_viewZoomOut_activate (GtkMenuItem *menuitem,
885 if (ui.zoom < MIN_ZOOM) return;
887 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
888 rescale_bg_pixmaps();
893 on_viewNormalSize_activate (GtkMenuItem *menuitem,
896 ui.zoom = DEFAULT_ZOOM;
897 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
898 rescale_bg_pixmaps();
903 on_viewPageWidth_activate (GtkMenuItem *menuitem,
906 ui.zoom = (GTK_WIDGET(canvas))->allocation.width/ui.cur_page->width;
907 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
908 rescale_bg_pixmaps();
913 on_viewFirstPage_activate (GtkMenuItem *menuitem,
916 do_switch_page(0, TRUE, FALSE);
921 on_viewPreviousPage_activate (GtkMenuItem *menuitem,
924 if (ui.pageno == 0) return;
925 do_switch_page(ui.pageno-1, TRUE, FALSE);
930 on_viewNextPage_activate (GtkMenuItem *menuitem,
933 if (ui.pageno == journal.npages-1) { // create a page at end
934 if (page_ops_forbidden()) return;
935 on_journalNewPageEnd_activate(menuitem, user_data);
938 do_switch_page(ui.pageno+1, TRUE, FALSE);
943 on_viewLastPage_activate (GtkMenuItem *menuitem,
946 do_switch_page(journal.npages-1, TRUE, FALSE);
951 on_viewShowLayer_activate (GtkMenuItem *menuitem,
954 if (ui.layerno == ui.cur_page->nlayers-1) return;
957 ui.cur_layer = g_list_nth_data(ui.cur_page->layers, ui.layerno);
958 gnome_canvas_item_show(GNOME_CANVAS_ITEM(ui.cur_layer->group));
964 on_viewHideLayer_activate (GtkMenuItem *menuitem,
967 if (ui.layerno == -1) return;
969 gnome_canvas_item_hide(GNOME_CANVAS_ITEM(ui.cur_layer->group));
971 if (ui.layerno<0) ui.cur_layer = NULL;
972 else ui.cur_layer = g_list_nth_data(ui.cur_page->layers, ui.layerno);
978 on_journalNewPageBefore_activate (GtkMenuItem *menuitem,
983 if (page_ops_forbidden()) return;
985 pg = new_page(ui.cur_page);
986 journal.pages = g_list_insert(journal.pages, pg, ui.pageno);
988 do_switch_page(ui.pageno, TRUE, TRUE);
991 undo->type = ITEM_NEW_PAGE;
992 undo->val = ui.pageno;
998 on_journalNewPageAfter_activate (GtkMenuItem *menuitem,
1003 if (page_ops_forbidden()) return;
1005 pg = new_page(ui.cur_page);
1006 journal.pages = g_list_insert(journal.pages, pg, ui.pageno+1);
1008 do_switch_page(ui.pageno+1, TRUE, TRUE);
1011 undo->type = ITEM_NEW_PAGE;
1012 undo->val = ui.pageno;
1018 on_journalNewPageEnd_activate (GtkMenuItem *menuitem,
1023 if (page_ops_forbidden()) return;
1025 pg = new_page((struct Page *)g_list_last(journal.pages)->data);
1026 journal.pages = g_list_append(journal.pages, pg);
1028 do_switch_page(journal.npages-1, TRUE, TRUE);
1031 undo->type = ITEM_NEW_PAGE;
1032 undo->val = ui.pageno;
1038 on_journalDeletePage_activate (GtkMenuItem *menuitem,
1041 GList *layerlist, *itemlist;
1044 if (page_ops_forbidden()) return;
1045 if (journal.npages == 1) return;
1048 undo->type = ITEM_DELETE_PAGE;
1049 undo->val = ui.pageno;
1050 undo->page = ui.cur_page;
1052 // unmap all the canvas items
1053 gtk_object_destroy(GTK_OBJECT(ui.cur_page->group));
1054 ui.cur_page->group = NULL;
1055 ui.cur_page->bg->canvas_item = NULL;
1056 for (layerlist = ui.cur_page->layers; layerlist!=NULL; layerlist = layerlist->next) {
1057 l = (struct Layer *)layerlist->data;
1058 for (itemlist = l->items; itemlist!=NULL; itemlist = itemlist->next)
1059 ((struct Item *)itemlist->data)->canvas_item = NULL;
1063 journal.pages = g_list_remove(journal.pages, ui.cur_page);
1065 if (ui.pageno == journal.npages) ui.pageno--;
1067 // so do_switch_page() won't try to remap the layers of the defunct page
1068 do_switch_page(ui.pageno, TRUE, TRUE);
1073 on_journalNewLayer_activate (GtkMenuItem *menuitem,
1079 l = g_new(struct Layer, 1);
1082 l->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
1083 ui.cur_page->group, gnome_canvas_group_get_type(), NULL);
1084 lower_canvas_item_to(ui.cur_page->group, GNOME_CANVAS_ITEM(l->group),
1085 (ui.cur_layer!=NULL)?(GNOME_CANVAS_ITEM(ui.cur_layer->group)):(ui.cur_page->bg->canvas_item));
1086 ui.cur_page->layers = g_list_insert(ui.cur_page->layers, l, ui.layerno+1);
1089 ui.cur_page->nlayers++;
1090 update_page_stuff();
1093 undo->type = ITEM_NEW_LAYER;
1094 undo->val = ui.layerno;
1096 undo->page = ui.cur_page;
1101 on_journalDeleteLayer_activate (GtkMenuItem *menuitem,
1106 if (ui.cur_layer == NULL) return;
1109 undo->type = ITEM_DELETE_LAYER;
1110 undo->val = ui.layerno;
1111 undo->layer = ui.cur_layer;
1112 undo->layer2 = NULL;
1113 undo->page = ui.cur_page;
1114 // delete all the canvas items
1115 gtk_object_destroy(GTK_OBJECT(ui.cur_layer->group));
1116 ui.cur_layer->group = NULL;
1117 for (list=ui.cur_layer->items; list!=NULL; list=list->next)
1118 ((struct Item *)list->data)->canvas_item = NULL;
1120 ui.cur_page->layers = g_list_remove(ui.cur_page->layers, ui.cur_layer);
1122 if (ui.cur_page->nlayers>=2) {
1123 ui.cur_page->nlayers--;
1125 if (ui.layerno<0) ui.cur_layer = NULL;
1126 else ui.cur_layer = (struct Layer *)g_list_nth_data(ui.cur_page->layers, ui.layerno);
1128 else { // special case: can't remove the last layer
1129 ui.cur_layer = g_new(struct Layer, 1);
1130 ui.cur_layer->items = NULL;
1131 ui.cur_layer->nitems = 0;
1132 ui.cur_layer->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
1133 ui.cur_page->group, gnome_canvas_group_get_type(), NULL);
1134 ui.cur_page->layers = g_list_append(NULL, ui.cur_layer);
1136 undo->layer2 = ui.cur_layer;
1139 update_page_stuff();
1144 on_journalFlatten_activate (GtkMenuItem *menuitem,
1151 // the paper sizes dialog
1153 GtkWidget *papersize_dialog;
1154 int papersize_std, papersize_unit;
1155 double papersize_width, papersize_height;
1156 gboolean papersize_need_init, papersize_width_valid, papersize_height_valid;
1158 #define STD_SIZE_A4 0
1159 #define STD_SIZE_A4R 1
1160 #define STD_SIZE_LETTER 2
1161 #define STD_SIZE_LETTER_R 3
1162 #define STD_SIZE_CUSTOM 4
1169 double unit_sizes[4] = {28.346, 72., 1/DEFAULT_ZOOM, 1.};
1170 double std_widths[STD_SIZE_CUSTOM] = {595.27, 841.89, 612., 792.};
1171 double std_heights[STD_SIZE_CUSTOM] = {841.89, 595.27, 792., 612.};
1172 double std_units[STD_SIZE_CUSTOM] = {UNIT_CM, UNIT_CM, UNIT_IN, UNIT_IN};
1175 on_journalPaperSize_activate (GtkMenuItem *menuitem,
1180 papersize_dialog = create_papersizeDialog();
1181 papersize_width = ui.cur_page->width;
1182 papersize_height = ui.cur_page->height;
1183 papersize_unit = UNIT_CM;
1184 // if (ui.cur_page->bg->type == BG_PIXMAP) papersize_unit = UNIT_PX;
1185 papersize_std = STD_SIZE_CUSTOM;
1186 for (i=0;i<STD_SIZE_CUSTOM;i++)
1187 if (fabs(papersize_width - std_widths[i])<0.1 &&
1188 fabs(papersize_height - std_heights[i])<0.1)
1189 { papersize_std = i; papersize_unit = std_units[i]; }
1190 papersize_need_init = TRUE;
1191 papersize_width_valid = papersize_height_valid = TRUE;
1193 gtk_widget_show(papersize_dialog);
1194 on_comboStdSizes_changed(GTK_COMBO_BOX(g_object_get_data(
1195 G_OBJECT(papersize_dialog), "comboStdSizes")), NULL);
1196 gtk_dialog_set_default_response(GTK_DIALOG(papersize_dialog), GTK_RESPONSE_OK);
1198 response = gtk_dialog_run(GTK_DIALOG(papersize_dialog));
1199 gtk_widget_destroy(papersize_dialog);
1200 if (response != GTK_RESPONSE_OK) return;
1203 undo->type = ITEM_PAPER_RESIZE;
1204 undo->page = ui.cur_page;
1205 undo->val_x = ui.cur_page->width;
1206 undo->val_y = ui.cur_page->height;
1208 if (papersize_width_valid) ui.cur_page->width = papersize_width;
1209 if (papersize_height_valid) ui.cur_page->height = papersize_height;
1211 make_page_clipbox(ui.cur_page);
1212 update_canvas_bg(ui.cur_page);
1213 do_switch_page(ui.pageno, TRUE, TRUE);
1218 on_papercolorWhite_activate (GtkMenuItem *menuitem,
1221 process_papercolor_activate(menuitem, COLOR_WHITE);
1226 on_papercolorYellow_activate (GtkMenuItem *menuitem,
1229 process_papercolor_activate(menuitem, COLOR_YELLOW);
1234 on_papercolorPink_activate (GtkMenuItem *menuitem,
1237 process_papercolor_activate(menuitem, COLOR_RED);
1242 on_papercolorOrange_activate (GtkMenuItem *menuitem,
1245 process_papercolor_activate(menuitem, COLOR_ORANGE);
1250 on_papercolorBlue_activate (GtkMenuItem *menuitem,
1253 process_papercolor_activate(menuitem, COLOR_BLUE);
1258 on_papercolorGreen_activate (GtkMenuItem *menuitem,
1261 process_papercolor_activate(menuitem, COLOR_GREEN);
1266 on_papercolorOther_activate (GtkMenuItem *menuitem,
1274 on_paperstylePlain_activate (GtkMenuItem *menuitem,
1277 process_paperstyle_activate(menuitem, RULING_NONE);
1282 on_paperstyleLined_activate (GtkMenuItem *menuitem,
1285 process_paperstyle_activate(menuitem, RULING_LINED);
1290 on_paperstyleRuled_activate (GtkMenuItem *menuitem,
1293 process_paperstyle_activate(menuitem, RULING_RULED);
1298 on_paperstyleGraph_activate (GtkMenuItem *menuitem,
1301 process_paperstyle_activate(menuitem, RULING_GRAPH);
1306 on_journalLoadBackground_activate (GtkMenuItem *menuitem,
1309 GtkWidget *dialog, *attach_opt;
1310 struct Background *bg;
1313 GList *bglist, *bglistiter;
1314 GtkFileFilter *filt_all, *filt_pix, *filt_pspdf;
1318 dialog = gtk_file_chooser_dialog_new("Open Background", GTK_WINDOW (winMain),
1319 GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1320 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);
1322 filt_all = gtk_file_filter_new();
1323 gtk_file_filter_set_name(filt_all, "All files");
1324 gtk_file_filter_add_pattern(filt_all, "*");
1325 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_all);
1327 #if GTK_CHECK_VERSION(2,6,0)
1329 if (!gtk_check_version(2, 6, 0)) {
1330 filt_pix = gtk_file_filter_new();
1331 gtk_file_filter_set_name(filt_pix, "Bitmap files");
1332 gtk_file_filter_add_pixbuf_formats(filt_pix);
1333 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_pix);
1338 filt_pspdf = gtk_file_filter_new();
1339 gtk_file_filter_set_name(filt_pspdf, "PS/PDF files (as bitmaps)");
1340 gtk_file_filter_add_pattern(filt_pspdf, "*.ps");
1341 gtk_file_filter_add_pattern(filt_pspdf, "*.pdf");
1342 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_pspdf);
1344 attach_opt = gtk_check_button_new_with_label("Attach file to the journal");
1345 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(attach_opt), FALSE);
1346 gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER (dialog), attach_opt);
1348 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
1349 gtk_widget_destroy(dialog);
1352 filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
1353 attach = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(attach_opt));
1354 gtk_widget_destroy(dialog);
1356 set_cursor_busy(TRUE);
1357 bg = attempt_load_pix_bg(filename, attach);
1358 if (bg != NULL) bglist = g_list_append(NULL, bg);
1359 else bglist = attempt_load_gv_bg(filename);
1360 set_cursor_busy(FALSE);
1362 if (bglist == NULL) {
1363 dialog = gtk_message_dialog_new(GTK_WINDOW(winMain), GTK_DIALOG_MODAL,
1364 GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
1365 "Error opening background '%s'", filename);
1366 gtk_dialog_run(GTK_DIALOG(dialog));
1367 gtk_widget_destroy(dialog);
1376 for (bglistiter = bglist, pageno = ui.pageno;
1377 bglistiter!=NULL; bglistiter = bglistiter->next, pageno++) {
1379 if (bglistiter->next!=NULL) undo->multiop |= MULTIOP_CONT_REDO;
1380 if (bglistiter->prev!=NULL) undo->multiop |= MULTIOP_CONT_UNDO;
1382 bg = (struct Background *)bglistiter->data;
1384 if (pageno == journal.npages) {
1385 undo->type = ITEM_NEW_PAGE;
1386 pg = new_page_with_bg(bg,
1387 gdk_pixbuf_get_width(bg->pixbuf)/bg->pixbuf_scale,
1388 gdk_pixbuf_get_height(bg->pixbuf)/bg->pixbuf_scale);
1389 journal.pages = g_list_append(journal.pages, pg);
1395 pg = g_list_nth_data(journal.pages, pageno);
1396 undo->type = ITEM_NEW_BG_RESIZE;
1399 bg->canvas_item = undo->bg->canvas_item;
1400 undo->bg->canvas_item = NULL;
1401 undo->val_x = pg->width;
1402 undo->val_y = pg->height;
1404 pg->width = gdk_pixbuf_get_width(bg->pixbuf)/bg->pixbuf_scale;
1405 pg->height = gdk_pixbuf_get_height(bg->pixbuf)/bg->pixbuf_scale;
1406 make_page_clipbox(pg);
1407 update_canvas_bg(pg);
1411 g_list_free(bglist);
1412 if (ui.zoom != DEFAULT_ZOOM) {
1413 ui.zoom = DEFAULT_ZOOM;
1414 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
1415 rescale_bg_pixmaps();
1417 do_switch_page(ui.pageno, TRUE, TRUE);
1421 on_journalScreenshot_activate (GtkMenuItem *menuitem,
1424 struct Background *bg;
1427 gtk_window_iconify(GTK_WINDOW(winMain)); // hide ourselves
1428 gdk_display_sync(gdk_display_get_default());
1430 if (ui.cursor!=NULL)
1431 gdk_cursor_unref(ui.cursor);
1432 ui.cursor = gdk_cursor_new(GDK_TCROSS);
1434 bg = attempt_screenshot_bg();
1436 gtk_window_deiconify(GTK_WINDOW(winMain));
1438 if (bg==NULL) return;
1441 undo->type = ITEM_NEW_BG_RESIZE;
1442 undo->page = ui.cur_page;
1443 undo->bg = ui.cur_page->bg;
1444 bg->canvas_item = undo->bg->canvas_item;
1445 undo->bg->canvas_item = NULL;
1446 undo->val_x = ui.cur_page->width;
1447 undo->val_y = ui.cur_page->height;
1449 ui.cur_page->bg = bg;
1450 ui.cur_page->width = gdk_pixbuf_get_width(bg->pixbuf)/bg->pixbuf_scale;
1451 ui.cur_page->height = gdk_pixbuf_get_height(bg->pixbuf)/bg->pixbuf_scale;
1453 make_page_clipbox(ui.cur_page);
1454 update_canvas_bg(ui.cur_page);
1456 if (ui.zoom != DEFAULT_ZOOM) {
1457 ui.zoom = DEFAULT_ZOOM;
1458 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
1459 rescale_bg_pixmaps();
1461 do_switch_page(ui.pageno, TRUE, TRUE);
1466 on_journalApplyAllPages_activate (GtkMenuItem *menuitem,
1472 if (ui.cur_page->bg->type != BG_SOLID) return;
1474 for (pglist = journal.pages; pglist!=NULL; pglist = pglist->next) {
1475 page = (struct Page *)pglist->data;
1477 undo->type = ITEM_NEW_BG_RESIZE;
1479 undo->bg = page->bg;
1480 undo->val_x = page->width;
1481 undo->val_y = page->height;
1482 if (pglist->next!=NULL) undo->multiop |= MULTIOP_CONT_REDO;
1483 if (pglist->prev!=NULL) undo->multiop |= MULTIOP_CONT_UNDO;
1484 page->bg = (struct Background *)g_memdup(ui.cur_page->bg, sizeof(struct Background));
1485 page->width = ui.cur_page->width;
1486 page->height = ui.cur_page->height;
1487 page->bg->canvas_item = undo->bg->canvas_item;
1488 undo->bg->canvas_item = NULL;
1490 make_page_clipbox(page);
1491 update_canvas_bg(page);
1493 do_switch_page(ui.pageno, TRUE, TRUE);
1498 on_toolsPen_activate (GtkMenuItem *menuitem,
1501 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1502 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1505 if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1509 if (ui.toolno == TOOL_PEN) return;
1512 ui.toolno = TOOL_PEN;
1514 ui.cur_brush = ui.brushes+TOOL_PEN;
1515 update_tool_buttons();
1517 update_color_menu();
1523 on_toolsEraser_activate (GtkMenuItem *menuitem,
1526 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1527 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1530 if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1534 if (ui.toolno == TOOL_ERASER) return;
1537 ui.toolno = TOOL_ERASER;
1539 ui.cur_brush = ui.brushes+TOOL_ERASER;
1540 update_tool_buttons();
1542 update_color_menu();
1548 on_toolsHighlighter_activate (GtkMenuItem *menuitem,
1551 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1552 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1555 if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1559 if (ui.toolno == TOOL_HIGHLIGHTER) return;
1562 ui.toolno = TOOL_HIGHLIGHTER;
1564 ui.cur_brush = ui.brushes+TOOL_HIGHLIGHTER;
1565 update_tool_buttons();
1567 update_color_menu();
1573 on_toolsText_activate (GtkMenuItem *menuitem,
1581 on_toolsSelectRegion_activate (GtkMenuItem *menuitem,
1589 on_toolsSelectRectangle_activate (GtkMenuItem *menuitem,
1592 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1593 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1596 if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1600 if (ui.toolno == TOOL_SELECTRECT) return;
1602 ui.toolno = TOOL_SELECTRECT;
1604 update_tool_buttons();
1606 update_color_menu();
1612 on_toolsVerticalSpace_activate (GtkMenuItem *menuitem,
1615 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1616 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1619 if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1623 if (ui.toolno == TOOL_VERTSPACE) return;
1626 ui.toolno = TOOL_VERTSPACE;
1628 update_tool_buttons();
1630 update_color_menu();
1636 on_colorBlack_activate (GtkMenuItem *menuitem,
1639 process_color_activate(menuitem, COLOR_BLACK);
1644 on_colorBlue_activate (GtkMenuItem *menuitem,
1647 process_color_activate(menuitem, COLOR_BLUE);
1653 on_colorRed_activate (GtkMenuItem *menuitem,
1656 process_color_activate(menuitem, COLOR_RED);
1661 on_colorGreen_activate (GtkMenuItem *menuitem,
1664 process_color_activate(menuitem, COLOR_GREEN);
1669 on_colorGray_activate (GtkMenuItem *menuitem,
1672 process_color_activate(menuitem, COLOR_GRAY);
1677 on_colorLightBlue_activate (GtkMenuItem *menuitem,
1680 process_color_activate(menuitem, COLOR_LIGHTBLUE);
1685 on_colorLightGreen_activate (GtkMenuItem *menuitem,
1688 process_color_activate(menuitem, COLOR_LIGHTGREEN);
1693 on_colorMagenta_activate (GtkMenuItem *menuitem,
1696 process_color_activate(menuitem, COLOR_MAGENTA);
1701 on_colorOrange_activate (GtkMenuItem *menuitem,
1704 process_color_activate(menuitem, COLOR_ORANGE);
1709 on_colorYellow_activate (GtkMenuItem *menuitem,
1712 process_color_activate(menuitem, COLOR_YELLOW);
1717 on_colorWhite_activate (GtkMenuItem *menuitem,
1720 process_color_activate(menuitem, COLOR_WHITE);
1725 on_colorOther_activate (GtkMenuItem *menuitem,
1733 on_penthicknessVeryFine_activate (GtkMenuItem *menuitem,
1736 process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_VERYFINE);
1741 on_penthicknessFine_activate (GtkMenuItem *menuitem,
1744 process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_FINE);
1749 on_penthicknessMedium_activate (GtkMenuItem *menuitem,
1752 process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_MEDIUM);
1757 on_penthicknessThick_activate (GtkMenuItem *menuitem,
1760 process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_THICK);
1765 on_penthicknessVeryThick_activate (GtkMenuItem *menuitem,
1768 process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_VERYTHICK);
1773 on_eraserFine_activate (GtkMenuItem *menuitem,
1776 process_thickness_activate(menuitem, TOOL_ERASER, THICKNESS_FINE);
1781 on_eraserMedium_activate (GtkMenuItem *menuitem,
1784 process_thickness_activate(menuitem, TOOL_ERASER, THICKNESS_MEDIUM);
1789 on_eraserThick_activate (GtkMenuItem *menuitem,
1792 process_thickness_activate(menuitem, TOOL_ERASER, THICKNESS_THICK);
1797 on_eraserStandard_activate (GtkMenuItem *menuitem,
1800 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
1801 ui.brushes[TOOL_ERASER].tool_options = TOOLOPT_ERASER_STANDARD;
1806 on_eraserWhiteout_activate (GtkMenuItem *menuitem,
1809 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
1810 ui.brushes[TOOL_ERASER].tool_options = TOOLOPT_ERASER_WHITEOUT;
1815 on_eraserDeleteStrokes_activate (GtkMenuItem *menuitem,
1818 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
1819 ui.brushes[TOOL_ERASER].tool_options = TOOLOPT_ERASER_STROKES;
1824 on_highlighterFine_activate (GtkMenuItem *menuitem,
1827 process_thickness_activate(menuitem, TOOL_HIGHLIGHTER, THICKNESS_FINE);
1832 on_highlighterMedium_activate (GtkMenuItem *menuitem,
1835 process_thickness_activate(menuitem, TOOL_HIGHLIGHTER, THICKNESS_MEDIUM);
1840 on_highlighterThick_activate (GtkMenuItem *menuitem,
1843 process_thickness_activate(menuitem, TOOL_HIGHLIGHTER, THICKNESS_THICK);
1848 on_toolsTextFont_activate (GtkMenuItem *menuitem,
1856 on_toolsDefaultPen_activate (GtkMenuItem *menuitem,
1860 g_memmove(ui.brushes+TOOL_PEN, ui.default_brushes+TOOL_PEN, sizeof(struct Brush));
1861 ui.toolno = TOOL_PEN;
1862 ui.cur_brush = ui.brushes+TOOL_PEN;
1863 update_tool_buttons();
1865 update_pen_props_menu();
1866 update_color_menu();
1872 on_toolsDefaultEraser_activate (GtkMenuItem *menuitem,
1876 g_memmove(ui.brushes+TOOL_ERASER, ui.default_brushes+TOOL_ERASER, sizeof(struct Brush));
1877 ui.toolno = TOOL_ERASER;
1878 ui.cur_brush = ui.brushes+TOOL_ERASER;
1879 update_tool_buttons();
1881 update_eraser_props_menu();
1882 update_color_menu();
1888 on_toolsDefaultHighlighter_activate (GtkMenuItem *menuitem,
1892 g_memmove(ui.brushes+TOOL_HIGHLIGHTER, ui.default_brushes+TOOL_HIGHLIGHTER, sizeof(struct Brush));
1893 ui.toolno = TOOL_HIGHLIGHTER;
1894 ui.cur_brush = ui.brushes+TOOL_HIGHLIGHTER;
1895 update_tool_buttons();
1897 update_highlighter_props_menu();
1898 update_color_menu();
1903 on_toolsDefaultText_activate (GtkMenuItem *menuitem,
1911 on_toolsSetAsDefault_activate (GtkMenuItem *menuitem,
1914 if (ui.toolno < NUM_STROKE_TOOLS)
1915 g_memmove(ui.default_brushes+ui.toolno, ui.brushes+ui.toolno, sizeof(struct Brush));
1920 on_toolsRuler_activate (GtkMenuItem *menuitem,
1925 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_CHECK_MENU_ITEM)
1926 active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
1928 active = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem));
1930 if (active == ui.ruler) return;
1932 if (active && (ui.toolno!=TOOL_PEN && ui.toolno!=TOOL_HIGHLIGHTER)) {
1934 ui.toolno = TOOL_PEN;
1935 ui.cur_brush = ui.brushes+TOOL_PEN;
1936 update_color_menu();
1937 update_tool_buttons();
1943 update_ruler_indicator();
1948 on_optionsSavePreferences_activate (GtkMenuItem *menuitem,
1956 on_helpIndex_activate (GtkMenuItem *menuitem,
1964 on_helpAbout_activate (GtkMenuItem *menuitem,
1967 GtkWidget *aboutDialog;
1968 GtkLabel *labelTitle;
1970 aboutDialog = create_aboutDialog ();
1971 labelTitle = GTK_LABEL(g_object_get_data(G_OBJECT(aboutDialog), "labelTitle"));
1972 gtk_label_set_markup(labelTitle,
1973 "<span size=\"xx-large\" weight=\"bold\">Xournal " VERSION "</span>");
1974 gtk_dialog_run (GTK_DIALOG(aboutDialog));
1975 gtk_widget_destroy(aboutDialog);
1980 on_buttonToolDefault_clicked (GtkToolButton *toolbutton,
1983 if (ui.toolno < NUM_STROKE_TOOLS) {
1984 g_memmove(ui.brushes+ui.toolno, ui.default_brushes+ui.toolno, sizeof(struct Brush));
1985 update_thickness_buttons();
1986 update_color_buttons();
1987 update_color_menu();
1988 if (ui.toolno == TOOL_PEN) update_pen_props_menu();
1989 if (ui.toolno == TOOL_ERASER) update_eraser_props_menu();
1990 if (ui.toolno == TOOL_HIGHLIGHTER) update_highlighter_props_menu();
1997 on_buttonFine_clicked (GtkToolButton *toolbutton,
2000 process_thickness_activate((GtkMenuItem*)toolbutton, ui.toolno, THICKNESS_FINE);
2005 on_buttonMedium_clicked (GtkToolButton *toolbutton,
2008 process_thickness_activate((GtkMenuItem*)toolbutton, ui.toolno, THICKNESS_MEDIUM);
2013 on_buttonThick_clicked (GtkToolButton *toolbutton,
2016 process_thickness_activate((GtkMenuItem*)toolbutton, ui.toolno, THICKNESS_THICK);
2021 on_canvas_button_press_event (GtkWidget *widget,
2022 GdkEventButton *event,
2026 gboolean page_change;
2027 struct Page *tmppage;
2030 if (ui.cur_item_type != ITEM_NONE) return FALSE; // we're already doing something
2031 if (event->button > 3) return FALSE; // no painting with the mouse wheel!
2033 if (ui.use_xinput) {
2034 if (event->device->source == GDK_SOURCE_MOUSE) return FALSE;
2035 // re-get the axis values since Synaptics sends bogus ones
2036 gdk_device_get_state(event->device, event->window, event->axes, NULL);
2037 fix_xinput_coords((GdkEvent *)event);
2039 else if (event->device->source != GDK_SOURCE_MOUSE) return FALSE;
2041 if ((ui.use_xinput && event->device->source == GDK_SOURCE_ERASER) ||
2042 (ui.emulate_eraser && event->button >= 2)) {
2043 ui.saved_toolno = ui.toolno;
2044 ui.saved_ruler = ui.ruler;
2046 ui.toolno = TOOL_ERASER;
2048 ui.cur_brush = ui.brushes + TOOL_ERASER;
2049 update_tool_buttons();
2051 update_color_menu();
2055 // check whether we're in a page
2056 page_change = FALSE;
2057 tmppage = ui.cur_page;
2058 get_pointer_coords((GdkEvent *)event, pt);
2059 while (ui.view_continuous && (pt[1] < - VIEW_CONTINUOUS_SKIP)) {
2060 if (ui.pageno == 0) break;
2063 tmppage = g_list_nth_data(journal.pages, ui.pageno);
2064 pt[1] += tmppage->height + VIEW_CONTINUOUS_SKIP;
2066 while (ui.view_continuous && (pt[1] > tmppage->height + VIEW_CONTINUOUS_SKIP)) {
2067 if (ui.pageno == journal.npages-1) break;
2068 pt[1] -= tmppage->height + VIEW_CONTINUOUS_SKIP;
2071 tmppage = g_list_nth_data(journal.pages, ui.pageno);
2073 if (page_change) do_switch_page(ui.pageno, FALSE, FALSE);
2075 // can't paint on the background...
2077 if (ui.cur_layer == NULL) {
2078 if (ui.saved_toolno >=0) {
2079 ui.toolno = ui.saved_toolno;
2080 ui.ruler = ui.saved_ruler;
2081 ui.saved_toolno = -1;
2082 if (ui.toolno < NUM_STROKE_TOOLS) ui.cur_brush = ui.brushes + ui.toolno;
2083 update_tool_buttons();
2085 update_color_menu();
2089 dialog = gtk_message_dialog_new(GTK_WINDOW(winMain), GTK_DIALOG_MODAL,
2090 GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, "Drawing is not allowed on the "
2091 "background layer.\n Switching to Layer 1.");
2092 gtk_dialog_run(GTK_DIALOG(dialog));
2093 gtk_widget_destroy(dialog);
2094 on_viewShowLayer_activate(NULL, NULL);
2098 // process the event
2099 ui.which_mouse_button = event->button;
2101 if (ui.toolno == TOOL_PEN || ui.toolno == TOOL_HIGHLIGHTER ||
2102 (ui.toolno == TOOL_ERASER && ui.cur_brush->tool_options == TOOLOPT_ERASER_WHITEOUT)) {
2103 create_new_stroke((GdkEvent *)event);
2105 else if (ui.toolno == TOOL_ERASER) {
2106 ui.cur_item_type = ITEM_ERASURE;
2107 do_eraser((GdkEvent *)event, ui.cur_brush->thickness/2,
2108 ui.cur_brush->tool_options == TOOLOPT_ERASER_STROKES);
2110 else if (ui.toolno == TOOL_SELECTRECT) {
2111 if (!start_movesel((GdkEvent *)event))
2112 start_selectrect((GdkEvent *)event);
2114 else if (ui.toolno == TOOL_VERTSPACE) {
2115 start_vertspace((GdkEvent *)event);
2122 on_canvas_button_release_event (GtkWidget *widget,
2123 GdkEventButton *event,
2126 if (ui.cur_item_type == ITEM_NONE) return FALSE; // not doing anything
2128 if (event->button != ui.which_mouse_button) return FALSE; // ignore
2130 if (ui.use_xinput) {
2131 if (event->device->source == GDK_SOURCE_MOUSE) return FALSE;
2132 fix_xinput_coords((GdkEvent *)event);
2134 else if (event->device->source != GDK_SOURCE_MOUSE) return FALSE;
2136 if (ui.saved_toolno >= 0) {
2137 ui.toolno = ui.saved_toolno;
2138 ui.ruler = ui.saved_ruler;
2139 ui.saved_toolno = -1;
2140 if (ui.toolno < NUM_STROKE_TOOLS) ui.cur_brush = ui.brushes + ui.toolno;
2141 update_tool_buttons();
2143 update_color_menu();
2147 if (ui.cur_item_type == ITEM_STROKE) {
2150 else if (ui.cur_item_type == ITEM_ERASURE) {
2153 else if (ui.cur_item_type == ITEM_SELECTRECT) {
2154 finalize_selectrect();
2156 else if (ui.cur_item_type == ITEM_MOVESEL) {
2165 on_canvas_enter_notify_event (GtkWidget *widget,
2166 GdkEventCrossing *event,
2175 on_canvas_expose_event (GtkWidget *widget,
2176 GdkEventExpose *event,
2179 if (ui.view_continuous && ui.progressive_bg) rescale_bg_pixmaps();
2185 on_canvas_key_press_event (GtkWidget *widget,
2195 on_canvas_motion_notify_event (GtkWidget *widget,
2196 GdkEventMotion *event,
2199 gboolean looks_wrong;
2202 if (ui.cur_item_type == ITEM_NONE) return FALSE; // we don't care
2204 if (ui.use_xinput) {
2205 if (event->device->source == GDK_SOURCE_MOUSE) return FALSE;
2206 fix_xinput_coords((GdkEvent *)event);
2208 else if (event->device->source != GDK_SOURCE_MOUSE) return FALSE;
2210 looks_wrong = !(event->state & (1<<(7+ui.which_mouse_button)));
2212 if (looks_wrong) { /* mouse button shouldn't be up... give up */
2213 if (ui.cur_item_type == ITEM_STROKE) {
2216 else if (ui.cur_item_type == ITEM_ERASURE) {
2219 else if (ui.cur_item_type == ITEM_SELECTRECT) {
2220 finalize_selectrect();
2222 else if (ui.cur_item_type == ITEM_MOVESEL) {
2228 if (ui.cur_item_type == ITEM_STROKE) {
2229 continue_stroke((GdkEvent *)event);
2231 else if (ui.cur_item_type == ITEM_ERASURE) {
2232 do_eraser((GdkEvent *)event, ui.cur_brush->thickness/2,
2233 ui.cur_brush->tool_options == TOOLOPT_ERASER_STROKES);
2235 else if (ui.cur_item_type == ITEM_SELECTRECT) {
2236 get_pointer_coords((GdkEvent *)event, pt);
2237 ui.selection->bbox.right = pt[0];
2238 ui.selection->bbox.bottom = pt[1];
2239 gnome_canvas_item_set(ui.selection->canvas_item,
2240 "x2", pt[0], "y2", pt[1], NULL);
2242 else if (ui.cur_item_type == ITEM_MOVESEL) {
2243 continue_movesel((GdkEvent *)event);
2250 on_comboLayer_changed (GtkComboBox *combobox,
2255 if (ui.in_update_page_stuff) return; // avoid a bad retroaction
2257 gtk_widget_grab_focus(GTK_WIDGET(canvas)); // stop focus on us
2259 val = gtk_combo_box_get_active(combobox);
2260 if (val == -1) return;
2261 val = ui.cur_page->nlayers-1-val;
2262 if (val == ui.layerno) return;
2265 while (val>ui.layerno) {
2267 ui.cur_layer = g_list_nth_data(ui.cur_page->layers, ui.layerno);
2268 gnome_canvas_item_show(GNOME_CANVAS_ITEM(ui.cur_layer->group));
2270 while (val<ui.layerno) {
2271 gnome_canvas_item_hide(GNOME_CANVAS_ITEM(ui.cur_layer->group));
2273 if (ui.layerno<0) ui.cur_layer = NULL;
2274 else ui.cur_layer = g_list_nth_data(ui.cur_page->layers, ui.layerno);
2276 update_page_stuff();
2281 on_winMain_delete_event (GtkWidget *widget,
2285 if (ok_to_close()) gtk_main_quit();
2291 on_optionsUseXInput_activate (GtkMenuItem *menuitem,
2294 ui.allow_xinput = ui.use_xinput =
2295 gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
2299 on_vscroll_changed (GtkAdjustment *adjustment,
2302 gboolean need_update;
2303 double viewport_top, viewport_bottom;
2304 struct Page *tmppage;
2306 if (!ui.view_continuous) return;
2308 if (ui.progressive_bg) rescale_bg_pixmaps();
2309 need_update = FALSE;
2310 viewport_top = adjustment->value / ui.zoom;
2311 viewport_bottom = (adjustment->value + adjustment->page_size) / ui.zoom;
2312 tmppage = ui.cur_page;
2313 while (viewport_top > tmppage->voffset + tmppage->height) {
2314 if (ui.pageno == journal.npages-1) break;
2317 tmppage = g_list_nth_data(journal.pages, ui.pageno);
2319 while (viewport_bottom < tmppage->voffset) {
2320 if (ui.pageno == 0) break;
2323 tmppage = g_list_nth_data(journal.pages, ui.pageno);
2325 if (need_update) do_switch_page(ui.pageno, FALSE, FALSE);
2330 on_spinPageNo_value_changed (GtkSpinButton *spinbutton,
2335 if (ui.in_update_page_stuff) return; // avoid a bad retroaction
2337 gtk_widget_grab_focus(GTK_WIDGET(canvas)); // stop blink-blink text cursor
2339 val = gtk_spin_button_get_value_as_int(spinbutton) - 1;
2341 if (val == journal.npages) { // create a page at end
2342 if (page_ops_forbidden()) return;
2343 on_journalNewPageEnd_activate(NULL, NULL);
2347 if (val == ui.pageno) return;
2348 if (val < 0) val = 0;
2349 if (val > journal.npages-1) val = journal.npages-1;
2350 do_switch_page(val, TRUE, FALSE);
2355 on_journalDefaultBackground_activate (GtkMenuItem *menuitem,
2360 undo->type = ITEM_NEW_BG_RESIZE;
2361 undo->page = ui.cur_page;
2362 undo->bg = ui.cur_page->bg;
2363 undo->val_x = ui.cur_page->width;
2364 undo->val_y = ui.cur_page->height;
2366 ui.cur_page->bg = (struct Background *)g_memdup(ui.default_page.bg, sizeof(struct Background));
2367 ui.cur_page->width = ui.default_page.width;
2368 ui.cur_page->height = ui.default_page.height;
2369 ui.cur_page->bg->canvas_item = undo->bg->canvas_item;
2370 undo->bg->canvas_item = NULL;
2372 make_page_clipbox(ui.cur_page);
2373 update_canvas_bg(ui.cur_page);
2374 do_switch_page(ui.pageno, TRUE, TRUE);
2379 on_journalSetAsDefault_activate (GtkMenuItem *menuitem,
2382 if (ui.cur_page->bg->type != BG_SOLID) return;
2385 undo->type = ITEM_NEW_DEFAULT_BG;
2386 undo->val_x = ui.default_page.width;
2387 undo->val_y = ui.default_page.height;
2388 undo->bg = ui.default_page.bg;
2390 ui.default_page.width = ui.cur_page->width;
2391 ui.default_page.height = ui.cur_page->height;
2392 ui.default_page.bg = (struct Background *)g_memdup(ui.cur_page->bg, sizeof(struct Background));
2393 ui.default_page.bg->canvas_item = NULL;
2398 on_comboStdSizes_changed (GtkComboBox *combobox,
2402 GtkComboBox *comboUnit;
2406 if (papersize_need_init) {
2407 gtk_combo_box_set_active(combobox, papersize_std);
2408 papersize_need_init = FALSE;
2410 val = gtk_combo_box_get_active(combobox);
2411 if (val == -1 || val == papersize_std) return;
2412 papersize_std = val;
2413 if (val == STD_SIZE_CUSTOM) return;
2414 papersize_unit = std_units[val];
2415 papersize_width = std_widths[val];
2416 papersize_height = std_heights[val];
2418 comboUnit = GTK_COMBO_BOX(g_object_get_data(G_OBJECT(papersize_dialog), "comboUnit"));
2419 gtk_combo_box_set_active(comboUnit, papersize_unit);
2420 entry = GTK_ENTRY(g_object_get_data(G_OBJECT(papersize_dialog), "entryWidth"));
2421 g_snprintf(text, 20, "%.2f", papersize_width/unit_sizes[papersize_unit]);
2422 if (g_str_has_suffix(text, ".00"))
2423 g_snprintf(text, 20, "%d", (int) (papersize_width/unit_sizes[papersize_unit]));
2424 gtk_entry_set_text(entry, text);
2425 entry = GTK_ENTRY(g_object_get_data(G_OBJECT(papersize_dialog), "entryHeight"));
2426 g_snprintf(text, 20, "%.2f", papersize_height/unit_sizes[papersize_unit]);
2427 if (g_str_has_suffix(text, ".00"))
2428 g_snprintf(text, 20, "%d", (int) (papersize_height/unit_sizes[papersize_unit]));
2429 gtk_entry_set_text(entry, text);
2434 on_entryWidth_changed (GtkEditable *editable,
2440 GtkComboBox *comboStdSizes;
2442 text = gtk_entry_get_text(GTK_ENTRY(editable));
2443 val = strtod(text, &ptr);
2444 papersize_width_valid = (*ptr == 0 && val > 0.);
2445 if (!papersize_width_valid) return; // invalid entry
2446 val *= unit_sizes[papersize_unit];
2447 if (fabs(val - papersize_width) < 0.1) return; // no change
2448 papersize_std = STD_SIZE_CUSTOM;
2449 papersize_width = val;
2450 comboStdSizes = GTK_COMBO_BOX(g_object_get_data(G_OBJECT(papersize_dialog), "comboStdSizes"));
2451 gtk_combo_box_set_active(comboStdSizes, papersize_std);
2456 on_entryHeight_changed (GtkEditable *editable,
2462 GtkComboBox *comboStdSizes;
2464 text = gtk_entry_get_text(GTK_ENTRY(editable));
2465 val = strtod(text, &ptr);
2466 papersize_height_valid = (*ptr == 0 && val > 0.);
2467 if (!papersize_height_valid) return; // invalid entry
2468 val *= unit_sizes[papersize_unit];
2469 if (fabs(val - papersize_height) < 0.1) return; // no change
2470 papersize_std = STD_SIZE_CUSTOM;
2471 papersize_height = val;
2472 comboStdSizes = GTK_COMBO_BOX(g_object_get_data(G_OBJECT(papersize_dialog), "comboStdSizes"));
2473 gtk_combo_box_set_active(comboStdSizes, papersize_std);
2478 on_comboUnit_changed (GtkComboBox *combobox,
2485 val = gtk_combo_box_get_active(combobox);
2486 if (val == -1 || val == papersize_unit) return;
2487 papersize_unit = val;
2488 entry = GTK_ENTRY(g_object_get_data(G_OBJECT(papersize_dialog), "entryWidth"));
2489 if (papersize_width_valid) {
2490 g_snprintf(text, 20, "%.2f", papersize_width/unit_sizes[papersize_unit]);
2491 if (g_str_has_suffix(text, ".00"))
2492 g_snprintf(text, 20, "%d", (int) (papersize_width/unit_sizes[papersize_unit]));
2494 gtk_entry_set_text(entry, text);
2495 if (papersize_height_valid) {
2496 entry = GTK_ENTRY(g_object_get_data(G_OBJECT(papersize_dialog), "entryHeight"));
2497 g_snprintf(text, 20, "%.2f", papersize_height/unit_sizes[papersize_unit]);
2498 if (g_str_has_suffix(text, ".00"))
2499 g_snprintf(text, 20, "%d", (int) (papersize_height/unit_sizes[papersize_unit]));
2501 gtk_entry_set_text(entry, text);
2506 on_viewFullscreen_activate (GtkMenuItem *menuitem,
2511 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_CHECK_MENU_ITEM)
2512 active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
2514 active = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem));
2516 if (active == ui.fullscreen) return;
2517 ui.fullscreen = active;
2519 if (ui.fullscreen) {
2520 gtk_window_fullscreen(GTK_WINDOW(winMain));
2521 gtk_widget_hide(GET_COMPONENT("menubar"));
2522 gtk_widget_hide(GET_COMPONENT("hbox1"));
2525 gtk_window_unfullscreen(GTK_WINDOW(winMain));
2526 gtk_widget_show(GET_COMPONENT("menubar"));
2527 gtk_widget_show(GET_COMPONENT("hbox1"));
2533 on_optionsEmulateEraser_activate (GtkMenuItem *menuitem,
2537 gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
2542 on_optionsAntialiasBG_activate (GtkMenuItem *menuitem,
2547 active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
2548 if (ui.antialias_bg == active) return;
2549 ui.antialias_bg = active;
2550 rescale_bg_pixmaps();
2555 on_optionsProgressiveBG_activate (GtkMenuItem *menuitem,
2560 active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
2561 if (ui.progressive_bg == active) return;
2562 ui.progressive_bg = active;
2563 if (!ui.progressive_bg) rescale_bg_pixmaps();
2568 on_mru_activate (GtkMenuItem *menuitem,
2575 if (!ok_to_close()) return; // user aborted on save confirmation
2577 for (which = 0 ; which < MRU_SIZE; which++) {
2578 if (ui.mrumenu[which] == GTK_WIDGET(menuitem)) break;
2580 if (which == MRU_SIZE || ui.mru[which] == NULL) return; // not found...
2582 set_cursor_busy(TRUE);
2583 success = open_journal(ui.mru[which]);
2584 set_cursor_busy(FALSE);
2585 if (success) return;
2588 dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
2589 GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Error opening file '%s'", ui.mru[which]);
2590 gtk_dialog_run(GTK_DIALOG(dialog));
2591 gtk_widget_destroy(dialog);
2592 delete_mru_entry(which);