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,
28 if (close_journal()) {
30 ui.zoom = ui.startup_zoom;
32 gtk_adjustment_set_value(gtk_layout_get_vadjustment(GTK_LAYOUT(canvas)), 0);
33 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
39 on_fileNewBackground_activate (GtkMenuItem *menuitem,
42 GtkWidget *dialog, *attach_opt;
43 GtkFileFilter *filt_all, *filt_pdf;
50 if (!ok_to_close()) return; // user aborted on save confirmation
52 dialog = gtk_file_chooser_dialog_new("Open PDF", GTK_WINDOW (winMain),
53 GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
54 GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL);
56 filt_all = gtk_file_filter_new();
57 gtk_file_filter_set_name(filt_all, "All files");
58 gtk_file_filter_add_pattern(filt_all, "*");
59 filt_pdf = gtk_file_filter_new();
60 gtk_file_filter_set_name(filt_pdf, "PDF files");
61 gtk_file_filter_add_pattern(filt_pdf, "*.pdf");
62 gtk_file_filter_add_pattern(filt_pdf, "*.PDF");
63 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_pdf);
64 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_all);
66 if (ui.default_path!=NULL) gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (dialog), ui.default_path);
68 attach_opt = gtk_check_button_new_with_label("Attach file to the journal");
69 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(attach_opt), FALSE);
70 gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER (dialog), attach_opt);
72 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
73 gtk_widget_destroy(dialog);
76 filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
77 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(attach_opt)))
78 file_domain = DOMAIN_ATTACH;
79 else file_domain = DOMAIN_ABSOLUTE;
81 gtk_widget_destroy(dialog);
83 set_cursor_busy(TRUE);
84 ui.saved = TRUE; // force close_journal to work
86 while (bgpdf.status != STATUS_NOT_INIT) {
87 // waiting for pdf processes to finish dying
91 ui.zoom = ui.startup_zoom;
92 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
94 success = init_bgpdf(filename, TRUE, file_domain);
95 set_cursor_busy(FALSE);
102 dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
103 GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Error opening file '%s'", filename);
104 gtk_dialog_run(GTK_DIALOG(dialog));
105 gtk_widget_destroy(dialog);
111 on_fileOpen_activate (GtkMenuItem *menuitem,
115 GtkFileFilter *filt_all, *filt_xoj;
121 if (!ok_to_close()) return; // user aborted on save confirmation
123 dialog = gtk_file_chooser_dialog_new("Open Journal", GTK_WINDOW (winMain),
124 GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
125 GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL);
127 filt_all = gtk_file_filter_new();
128 gtk_file_filter_set_name(filt_all, "All files");
129 gtk_file_filter_add_pattern(filt_all, "*");
130 filt_xoj = gtk_file_filter_new();
131 gtk_file_filter_set_name(filt_xoj, "Xournal files");
132 gtk_file_filter_add_pattern(filt_xoj, "*.xoj");
133 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_xoj);
134 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_all);
136 if (ui.default_path!=NULL) gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (dialog), ui.default_path);
138 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
139 gtk_widget_destroy(dialog);
142 filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
143 gtk_widget_destroy(dialog);
145 set_cursor_busy(TRUE);
146 success = open_journal(filename);
147 set_cursor_busy(FALSE);
148 if (success) { g_free(filename); return; }
151 dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
152 GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Error opening file '%s'", filename);
153 gtk_dialog_run(GTK_DIALOG(dialog));
154 gtk_widget_destroy(dialog);
161 on_fileSave_activate (GtkMenuItem *menuitem,
168 if (ui.filename == NULL) {
169 on_fileSaveAs_activate(menuitem, user_data);
172 set_cursor_busy(TRUE);
173 if (save_journal(ui.filename)) { // success
174 set_cursor_busy(FALSE);
178 set_cursor_busy(FALSE);
180 dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
181 GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Error saving file '%s'", ui.filename);
182 gtk_dialog_run(GTK_DIALOG(dialog));
183 gtk_widget_destroy(dialog);
188 on_fileSaveAs_activate (GtkMenuItem *menuitem,
191 GtkWidget *dialog, *warning_dialog;
192 GtkFileFilter *filt_all, *filt_xoj;
197 struct stat stat_buf;
201 dialog = gtk_file_chooser_dialog_new("Save Journal", GTK_WINDOW (winMain),
202 GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
203 GTK_STOCK_SAVE, GTK_RESPONSE_OK, NULL);
205 if (ui.filename!=NULL) {
206 gtk_file_chooser_set_filename(GTK_FILE_CHOOSER (dialog), ui.filename);
207 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), g_basename(ui.filename));
210 if (bgpdf.status!=STATUS_NOT_INIT && bgpdf.file_domain == DOMAIN_ABSOLUTE
211 && bgpdf.filename != NULL) {
212 filename = g_strdup_printf("%s.xoj", bgpdf.filename->s);
213 gtk_file_chooser_set_filename(GTK_FILE_CHOOSER (dialog), filename);
214 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), g_basename(filename));
218 curtime = time(NULL);
219 strftime(stime, 30, "%F-Note-%H-%M.xoj", localtime(&curtime));
220 if (ui.default_path!=NULL)
221 gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (dialog), ui.default_path);
222 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), stime);
225 filt_all = gtk_file_filter_new();
226 gtk_file_filter_set_name(filt_all, "All files");
227 gtk_file_filter_add_pattern(filt_all, "*");
228 filt_xoj = gtk_file_filter_new();
229 gtk_file_filter_set_name(filt_xoj, "Xournal files");
230 gtk_file_filter_add_pattern(filt_xoj, "*.xoj");
231 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_xoj);
232 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_all);
234 // somehow this doesn't seem to be set by default
235 gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
238 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
239 gtk_widget_destroy(dialog);
242 filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
243 warn = g_file_test (filename, G_FILE_TEST_EXISTS);
244 if (warn) { // ok to overwrite an empty file
245 if (!g_stat(filename, &stat_buf))
246 if (stat_buf.st_size == 0) warn=FALSE;
248 if (warn && ui.filename!=NULL) { // ok to overwrite oneself
249 if (ui.filename[0]=='/' && !strcmp(ui.filename, filename)) warn=FALSE;
250 if (ui.filename[0]!='/' && g_str_has_suffix(filename, ui.filename)) warn=FALSE;
253 warning_dialog = gtk_message_dialog_new(GTK_WINDOW(winMain),
254 GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO,
255 "Should the file %s be overwritten?", filename);
256 if (gtk_dialog_run(GTK_DIALOG(warning_dialog)) == GTK_RESPONSE_YES)
258 gtk_widget_destroy(warning_dialog);
262 gtk_widget_destroy(dialog);
264 set_cursor_busy(TRUE);
265 if (save_journal(filename)) { // success
267 set_cursor_busy(FALSE);
268 update_file_name(filename);
271 set_cursor_busy(FALSE);
273 dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
274 GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Error saving file '%s'", filename);
275 gtk_dialog_run(GTK_DIALOG(dialog));
276 gtk_widget_destroy(dialog);
282 on_filePrintOptions_activate (GtkMenuItem *menuitem,
290 on_filePrint_activate (GtkMenuItem *menuitem,
293 GtkWidget *printDialog, *preview;
295 int fromPage, toPage;
299 GnomePrintConfig *config = gnome_print_config_default();
303 if (ui.filename!=NULL) {
304 if (g_str_has_suffix(ui.filename, ".xoj")) {
305 in_fn = g_strdup(ui.filename);
306 g_strlcpy(g_strrstr(in_fn, "xoj"), "pdf", 4);
309 in_fn = g_strdup_printf("%s.pdf", ui.filename);
310 gnome_print_config_set(config, (guchar *)"Printer", (guchar *)"PDF");
311 gnome_print_config_set(config, (guchar *)GNOME_PRINT_KEY_OUTPUT_FILENAME, (guchar *)in_fn);
312 gnome_print_config_set(config, (guchar *)"Settings.Transport.Backend.FileName", (guchar *)in_fn);
313 g_strlcpy(g_strrstr(in_fn, "pdf"), "ps", 3);
314 gnome_print_config_set(config, (guchar *)"Printer", (guchar *)"GENERIC");
315 gnome_print_config_set (config, (guchar *)GNOME_PRINT_KEY_OUTPUT_FILENAME, (guchar *)in_fn);
316 s = gnome_print_config_get(config, (guchar *)"Settings.Transport.Backend.FileName");
319 gnome_print_config_set(config, (guchar *)"Settings.Transport.Backend.FileName", (guchar *)in_fn);
324 gpj = gnome_print_job_new(config); /* was NULL */
325 gnome_print_config_unref(config);
327 printDialog = gnome_print_dialog_new(gpj, (guchar *)"Print", GNOME_PRINT_DIALOG_RANGE);
328 gnome_print_dialog_construct_range_page(GNOME_PRINT_DIALOG(printDialog),
329 GNOME_PRINT_RANGE_ALL | GNOME_PRINT_RANGE_RANGE,
330 1, journal.npages, (guchar *)"Current page", (guchar *)"Pages");
331 /* don't have "Current page" as option, else it becomes the default!! */
333 gtk_dialog_set_response_sensitive(GTK_DIALOG(printDialog),
334 GNOME_PRINT_DIALOG_RESPONSE_PREVIEW, FALSE);
335 /* the print-job-preview "feature" is completely, hopelessly broken */
337 response = gtk_dialog_run(GTK_DIALOG(printDialog));
339 gtk_widget_destroy(printDialog);
344 if (response == GNOME_PRINT_DIALOG_RESPONSE_PREVIEW) {
345 print_job_render(gpj, 0, journal.npages-1);
346 gtk_widget_destroy(printDialog);
347 preview = gnome_print_job_preview_new(gpj, (guchar *)"Preview");
348 try_fix_print_preview_ui(preview);
349 gtk_window_set_modal(GTK_WINDOW(preview), TRUE);
350 gtk_widget_show_all(preview);
354 if (response == GNOME_PRINT_DIALOG_RESPONSE_PRINT) {
355 switch(gnome_print_dialog_get_range(GNOME_PRINT_DIALOG(printDialog))) {
356 case GNOME_PRINT_RANGE_RANGE:
357 gnome_print_dialog_get_range_page(GNOME_PRINT_DIALOG(printDialog), &fromPage, &toPage);
363 toPage = journal.npages-1;
366 gtk_widget_destroy(printDialog);
367 print_job_render(gpj, fromPage, toPage);
373 on_filePrintPDF_activate (GtkMenuItem *menuitem,
377 GtkWidget *dialog, *warning_dialog;
378 GtkFileFilter *filt_all, *filt_pdf;
379 char *filename, *in_fn;
387 dialog = gtk_file_chooser_dialog_new("Export to PDF", GTK_WINDOW (winMain),
388 GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
389 GTK_STOCK_SAVE, GTK_RESPONSE_OK, NULL);
391 if (ui.filename!=NULL) {
392 if (g_str_has_suffix(ui.filename, ".xoj")) {
393 in_fn = g_strdup(ui.filename);
394 g_strlcpy(g_strrstr(in_fn, "xoj"), "pdf", 4);
397 in_fn = g_strdup_printf("%s.pdf", ui.filename);
398 gtk_file_chooser_set_filename(GTK_FILE_CHOOSER (dialog), in_fn);
399 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), g_basename(in_fn));
401 curtime = time(NULL);
402 strftime(stime, 30, "%F-Note-%H-%M.pdf", localtime(&curtime));
403 if (ui.default_path!=NULL)
404 gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (dialog), ui.default_path);
405 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), stime);
409 filt_all = gtk_file_filter_new();
410 gtk_file_filter_set_name(filt_all, "All files");
411 gtk_file_filter_add_pattern(filt_all, "*");
412 filt_pdf = gtk_file_filter_new();
413 gtk_file_filter_set_name(filt_pdf, "PDF files");
414 gtk_file_filter_add_pattern(filt_pdf, "*.pdf");
415 gtk_file_filter_add_pattern(filt_pdf, "*.PDF");
416 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_pdf);
417 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_all);
418 gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
422 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
423 gtk_widget_destroy(dialog);
426 filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
427 warn = g_file_test(filename, G_FILE_TEST_EXISTS);
429 warning_dialog = gtk_message_dialog_new(GTK_WINDOW(winMain),
430 GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO,
431 "Should the file %s be overwritten?", filename);
432 if (gtk_dialog_run(GTK_DIALOG(warning_dialog)) == GTK_RESPONSE_YES)
434 gtk_widget_destroy(warning_dialog);
438 gtk_widget_destroy(dialog);
440 set_cursor_busy(TRUE);
441 if (!print_to_pdf(filename)) {
442 set_cursor_busy(FALSE);
443 dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
444 GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Error creating file '%s'", filename);
445 gtk_dialog_run(GTK_DIALOG(dialog));
446 gtk_widget_destroy(dialog);
448 set_cursor_busy(FALSE);
454 on_fileQuit_activate (GtkMenuItem *menuitem,
459 if (ok_to_close()) gtk_main_quit ();
464 on_editUndo_activate (GtkMenuItem *menuitem,
468 GList *list, *itemlist;
469 struct UndoErasureData *erasure;
471 struct Brush tmp_brush;
472 struct Background *tmp_bg;
478 if (undo == NULL) return; // nothing to undo!
479 reset_selection(); // safer
480 if (undo->type == ITEM_STROKE || undo->type == ITEM_TEXT) {
481 // we're keeping the stroke info, but deleting the canvas item
482 gtk_object_destroy(GTK_OBJECT(undo->item->canvas_item));
483 undo->item->canvas_item = NULL;
484 // we also remove the object from its layer!
485 undo->layer->items = g_list_remove(undo->layer->items, undo->item);
486 undo->layer->nitems--;
488 else if (undo->type == ITEM_ERASURE) {
489 for (list = undo->erasurelist; list!=NULL; list = list->next) {
490 erasure = (struct UndoErasureData *)list->data;
491 // delete all the created items
492 for (itemlist = erasure->replacement_items; itemlist!=NULL; itemlist = itemlist->next) {
493 it = (struct Item *)itemlist->data;
494 gtk_object_destroy(GTK_OBJECT(it->canvas_item));
495 it->canvas_item = NULL;
496 undo->layer->items = g_list_remove(undo->layer->items, it);
497 undo->layer->nitems--;
499 // recreate the deleted one
500 make_canvas_item_one(undo->layer->group, erasure->item);
502 undo->layer->items = g_list_insert(undo->layer->items, erasure->item,
504 if (erasure->npos == 0)
505 lower_canvas_item_to(undo->layer->group, erasure->item->canvas_item, NULL);
507 lower_canvas_item_to(undo->layer->group, erasure->item->canvas_item,
508 ((struct Item *)g_list_nth_data(undo->layer->items, erasure->npos-1))->canvas_item);
509 undo->layer->nitems++;
512 else if (undo->type == ITEM_NEW_BG_ONE || undo->type == ITEM_NEW_BG_RESIZE
513 || undo->type == ITEM_PAPER_RESIZE) {
514 if (undo->type != ITEM_PAPER_RESIZE) {
516 tmp_bg = undo->page->bg;
517 undo->page->bg = undo->bg;
519 undo->page->bg->canvas_item = undo->bg->canvas_item;
520 undo->bg->canvas_item = NULL;
522 if (undo->type != ITEM_NEW_BG_ONE) {
523 tmp_x = undo->page->width;
524 tmp_y = undo->page->height;
525 undo->page->width = undo->val_x;
526 undo->page->height = undo->val_y;
529 make_page_clipbox(undo->page);
531 update_canvas_bg(undo->page);
532 do_switch_page(g_list_index(journal.pages, undo->page), TRUE, TRUE);
534 else if (undo->type == ITEM_NEW_DEFAULT_BG) {
535 tmp_bg = ui.default_page.bg;
536 ui.default_page.bg = undo->bg;
538 tmp_x = ui.default_page.width;
539 tmp_y = ui.default_page.height;
540 ui.default_page.width = undo->val_x;
541 ui.default_page.height = undo->val_y;
545 else if (undo->type == ITEM_NEW_PAGE) {
546 // unmap the page; keep the page & its empty layer in memory
547 if (undo->page->group!=NULL) gtk_object_destroy(GTK_OBJECT(undo->page->group));
548 // also destroys the background and layer's canvas items
549 undo->page->group = NULL;
550 undo->page->bg->canvas_item = NULL;
551 journal.pages = g_list_remove(journal.pages, undo->page);
553 if (ui.cur_page == undo->page) ui.cur_page = NULL;
554 // so do_switch_page() won't try to remap the layers of the defunct page
555 if (ui.pageno >= undo->val) ui.pageno--;
556 if (ui.pageno < 0) ui.pageno = 0;
557 do_switch_page(ui.pageno, TRUE, TRUE);
559 else if (undo->type == ITEM_DELETE_PAGE) {
560 journal.pages = g_list_insert(journal.pages, undo->page, undo->val);
562 make_canvas_items(); // re-create the canvas items
563 do_switch_page(undo->val, TRUE, TRUE);
565 else if (undo->type == ITEM_MOVESEL) {
566 for (itemlist = undo->itemlist; itemlist != NULL; itemlist = itemlist->next) {
567 it = (struct Item *)itemlist->data;
568 if (it->canvas_item != NULL) {
569 if (undo->layer != undo->layer2)
570 gnome_canvas_item_reparent(it->canvas_item, undo->layer->group);
571 gnome_canvas_item_move(it->canvas_item, -undo->val_x, -undo->val_y);
574 move_journal_items_by(undo->itemlist, -undo->val_x, -undo->val_y,
575 undo->layer2, undo->layer, undo->auxlist);
577 else if (undo->type == ITEM_PASTE) {
578 for (itemlist = undo->itemlist; itemlist != NULL; itemlist = itemlist->next) {
579 it = (struct Item *)itemlist->data;
580 gtk_object_destroy(GTK_OBJECT(it->canvas_item));
581 it->canvas_item = NULL;
582 undo->layer->items = g_list_remove(undo->layer->items, it);
583 undo->layer->nitems--;
586 else if (undo->type == ITEM_NEW_LAYER) {
587 // unmap the layer; keep the empty layer in memory
588 if (undo->layer->group!=NULL) gtk_object_destroy(GTK_OBJECT(undo->layer->group));
589 undo->layer->group = NULL;
590 undo->page->layers = g_list_remove(undo->page->layers, undo->layer);
591 undo->page->nlayers--;
592 do_switch_page(ui.pageno, FALSE, FALSE); // don't stay with bad cur_layer info
594 else if (undo->type == ITEM_DELETE_LAYER) {
595 // special case of -1: deleted the last layer, created a new one
596 if (undo->val == -1) {
597 if (undo->layer2->group!=NULL) gtk_object_destroy(GTK_OBJECT(undo->layer2->group));
598 undo->layer2->group = NULL;
599 undo->page->layers = g_list_remove(undo->page->layers, undo->layer2);
600 undo->page->nlayers--;
603 undo->layer->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
604 undo->page->group, gnome_canvas_group_get_type(), NULL);
605 lower_canvas_item_to(undo->page->group, GNOME_CANVAS_ITEM(undo->layer->group),
606 (undo->val >= 1) ? GNOME_CANVAS_ITEM(((struct Layer *)
607 g_list_nth_data(undo->page->layers, undo->val-1))->group) :
608 undo->page->bg->canvas_item);
609 undo->page->layers = g_list_insert(undo->page->layers, undo->layer,
610 (undo->val >= 0) ? undo->val:0);
611 undo->page->nlayers++;
613 for (itemlist = undo->layer->items; itemlist!=NULL; itemlist = itemlist->next)
614 make_canvas_item_one(undo->layer->group, (struct Item *)itemlist->data);
616 do_switch_page(ui.pageno, FALSE, FALSE); // show the restored layer & others...
618 else if (undo->type == ITEM_REPAINTSEL) {
619 for (itemlist = undo->itemlist, list = undo->auxlist; itemlist!=NULL;
620 itemlist = itemlist->next, list = list->next) {
621 it = (struct Item *)itemlist->data;
622 g_memmove(&tmp_brush, &(it->brush), sizeof(struct Brush));
623 g_memmove(&(it->brush), list->data, sizeof(struct Brush));
624 g_memmove(list->data, &tmp_brush, sizeof(struct Brush));
625 if (it->type == ITEM_STROKE && it->canvas_item != NULL)
626 gnome_canvas_item_set(it->canvas_item,
627 "fill-color-rgba", it->brush.color_rgba,
628 "width-units", it->brush.thickness, NULL);
629 if (it->type == ITEM_TEXT && it->canvas_item != NULL)
630 gnome_canvas_item_set(it->canvas_item,
631 "fill-color-rgba", it->brush.color_rgba, NULL);
634 else if (undo->type == ITEM_TEXT_EDIT) {
636 undo->str = undo->item->text;
637 undo->item->text = tmpstr;
638 gnome_canvas_item_set(undo->item->canvas_item, "text", tmpstr, NULL);
639 update_item_bbox(undo->item);
641 else if (undo->type == ITEM_TEXT_ATTRIB) {
643 undo->str = undo->item->font_name;
644 undo->item->font_name = tmpstr;
646 undo->val_x = undo->item->font_size;
647 undo->item->font_size = tmp_x;
648 g_memmove(&tmp_brush, undo->brush, sizeof(struct Brush));
649 g_memmove(undo->brush, &(undo->item->brush), sizeof(struct Brush));
650 g_memmove(&(undo->item->brush), &tmp_brush, sizeof(struct Brush));
651 gnome_canvas_item_set(undo->item->canvas_item,
652 "fill-color-rgba", undo->item->brush.color_rgba, NULL);
653 update_text_item_displayfont(undo->item);
654 update_item_bbox(undo->item);
657 // move item from undo to redo stack
663 update_undo_redo_enabled();
664 if (u->multiop & MULTIOP_CONT_UNDO) on_editUndo_activate(NULL,NULL); // loop
669 on_editRedo_activate (GtkMenuItem *menuitem,
673 GList *list, *itemlist, *target;
674 struct UndoErasureData *erasure;
676 struct Brush tmp_brush;
677 struct Background *tmp_bg;
684 if (redo == NULL) return; // nothing to redo!
685 reset_selection(); // safer
686 if (redo->type == ITEM_STROKE || redo->type == ITEM_TEXT) {
687 // re-create the canvas_item
688 make_canvas_item_one(redo->layer->group, redo->item);
689 // reinsert the item on its layer
690 redo->layer->items = g_list_append(redo->layer->items, redo->item);
691 redo->layer->nitems++;
693 else if (redo->type == ITEM_ERASURE) {
694 for (list = redo->erasurelist; list!=NULL; list = list->next) {
695 erasure = (struct UndoErasureData *)list->data;
696 target = g_list_find(redo->layer->items, erasure->item);
697 // re-create all the created items
698 for (itemlist = erasure->replacement_items; itemlist!=NULL; itemlist = itemlist->next) {
699 it = (struct Item *)itemlist->data;
700 make_canvas_item_one(redo->layer->group, it);
701 redo->layer->items = g_list_insert_before(redo->layer->items, target, it);
702 redo->layer->nitems++;
703 lower_canvas_item_to(redo->layer->group, it->canvas_item, erasure->item->canvas_item);
705 // re-delete the deleted one
706 gtk_object_destroy(GTK_OBJECT(erasure->item->canvas_item));
707 erasure->item->canvas_item = NULL;
708 redo->layer->items = g_list_delete_link(redo->layer->items, target);
709 redo->layer->nitems--;
712 else if (redo->type == ITEM_NEW_BG_ONE || redo->type == ITEM_NEW_BG_RESIZE
713 || redo->type == ITEM_PAPER_RESIZE) {
714 if (redo->type != ITEM_PAPER_RESIZE) {
716 tmp_bg = redo->page->bg;
717 redo->page->bg = redo->bg;
719 redo->page->bg->canvas_item = redo->bg->canvas_item;
720 redo->bg->canvas_item = NULL;
722 if (redo->type != ITEM_NEW_BG_ONE) {
723 tmp_x = redo->page->width;
724 tmp_y = redo->page->height;
725 redo->page->width = redo->val_x;
726 redo->page->height = redo->val_y;
729 make_page_clipbox(redo->page);
731 update_canvas_bg(redo->page);
732 do_switch_page(g_list_index(journal.pages, redo->page), TRUE, TRUE);
734 else if (redo->type == ITEM_NEW_DEFAULT_BG) {
735 tmp_bg = ui.default_page.bg;
736 ui.default_page.bg = redo->bg;
738 tmp_x = ui.default_page.width;
739 tmp_y = ui.default_page.height;
740 ui.default_page.width = redo->val_x;
741 ui.default_page.height = redo->val_y;
745 else if (redo->type == ITEM_NEW_PAGE) {
747 redo->page->bg->canvas_item = NULL;
748 redo->page->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
749 gnome_canvas_root(canvas), gnome_canvas_clipgroup_get_type(), NULL);
750 make_page_clipbox(redo->page);
751 update_canvas_bg(redo->page);
752 l = (struct Layer *)redo->page->layers->data;
753 l->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
754 redo->page->group, gnome_canvas_group_get_type(), NULL);
756 journal.pages = g_list_insert(journal.pages, redo->page, redo->val);
758 do_switch_page(redo->val, TRUE, TRUE);
760 else if (redo->type == ITEM_DELETE_PAGE) {
761 // unmap all the canvas items
762 gtk_object_destroy(GTK_OBJECT(redo->page->group));
763 redo->page->group = NULL;
764 redo->page->bg->canvas_item = NULL;
765 for (list = redo->page->layers; list!=NULL; list = list->next) {
766 l = (struct Layer *)list->data;
767 for (itemlist = l->items; itemlist!=NULL; itemlist = itemlist->next)
768 ((struct Item *)itemlist->data)->canvas_item = NULL;
771 journal.pages = g_list_remove(journal.pages, redo->page);
773 if (ui.pageno > undo->val || ui.pageno == journal.npages) ui.pageno--;
775 // so do_switch_page() won't try to remap the layers of the defunct page
776 do_switch_page(ui.pageno, TRUE, TRUE);
778 else if (redo->type == ITEM_MOVESEL) {
779 for (itemlist = redo->itemlist; itemlist != NULL; itemlist = itemlist->next) {
780 it = (struct Item *)itemlist->data;
781 if (it->canvas_item != NULL) {
782 if (redo->layer != redo->layer2)
783 gnome_canvas_item_reparent(it->canvas_item, redo->layer2->group);
784 gnome_canvas_item_move(it->canvas_item, redo->val_x, redo->val_y);
787 move_journal_items_by(redo->itemlist, redo->val_x, redo->val_y,
788 redo->layer, redo->layer2, NULL);
790 else if (redo->type == ITEM_PASTE) {
791 for (itemlist = redo->itemlist; itemlist != NULL; itemlist = itemlist->next) {
792 it = (struct Item *)itemlist->data;
793 make_canvas_item_one(redo->layer->group, it);
794 redo->layer->items = g_list_append(redo->layer->items, it);
795 redo->layer->nitems++;
798 else if (redo->type == ITEM_NEW_LAYER) {
799 redo->layer->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
800 redo->page->group, gnome_canvas_group_get_type(), NULL);
801 lower_canvas_item_to(redo->page->group, GNOME_CANVAS_ITEM(redo->layer->group),
802 (redo->val >= 1) ? GNOME_CANVAS_ITEM(((struct Layer *)
803 g_list_nth_data(redo->page->layers, redo->val-1))->group) :
804 redo->page->bg->canvas_item);
805 redo->page->layers = g_list_insert(redo->page->layers, redo->layer, redo->val);
806 redo->page->nlayers++;
807 do_switch_page(ui.pageno, FALSE, FALSE);
809 else if (redo->type == ITEM_DELETE_LAYER) {
810 gtk_object_destroy(GTK_OBJECT(redo->layer->group));
811 redo->layer->group = NULL;
812 for (list=redo->layer->items; list!=NULL; list=list->next)
813 ((struct Item *)list->data)->canvas_item = NULL;
814 redo->page->layers = g_list_remove(redo->page->layers, redo->layer);
815 redo->page->nlayers--;
816 if (redo->val == -1) {
817 redo->layer2->group = (GnomeCanvasGroup *)gnome_canvas_item_new(
818 redo->page->group, gnome_canvas_group_get_type(), NULL);
819 redo->page->layers = g_list_append(redo->page->layers, redo->layer2);
820 redo->page->nlayers++;
822 do_switch_page(ui.pageno, FALSE, FALSE);
824 else if (redo->type == ITEM_REPAINTSEL) {
825 for (itemlist = redo->itemlist, list = redo->auxlist; itemlist!=NULL;
826 itemlist = itemlist->next, list = list->next) {
827 it = (struct Item *)itemlist->data;
828 g_memmove(&tmp_brush, &(it->brush), sizeof(struct Brush));
829 g_memmove(&(it->brush), list->data, sizeof(struct Brush));
830 g_memmove(list->data, &tmp_brush, sizeof(struct Brush));
831 if (it->type == ITEM_STROKE && it->canvas_item != NULL)
832 gnome_canvas_item_set(it->canvas_item,
833 "fill-color-rgba", it->brush.color_rgba,
834 "width-units", it->brush.thickness, NULL);
835 if (it->type == ITEM_TEXT && it->canvas_item != NULL)
836 gnome_canvas_item_set(it->canvas_item,
837 "fill-color-rgba", it->brush.color_rgba, NULL);
840 else if (redo->type == ITEM_TEXT_EDIT) {
842 redo->str = redo->item->text;
843 redo->item->text = tmpstr;
844 gnome_canvas_item_set(redo->item->canvas_item, "text", tmpstr, NULL);
845 update_item_bbox(redo->item);
847 else if (redo->type == ITEM_TEXT_ATTRIB) {
849 redo->str = redo->item->font_name;
850 redo->item->font_name = tmpstr;
852 redo->val_x = redo->item->font_size;
853 redo->item->font_size = tmp_x;
854 g_memmove(&tmp_brush, redo->brush, sizeof(struct Brush));
855 g_memmove(redo->brush, &(redo->item->brush), sizeof(struct Brush));
856 g_memmove(&(redo->item->brush), &tmp_brush, sizeof(struct Brush));
857 gnome_canvas_item_set(redo->item->canvas_item,
858 "fill-color-rgba", redo->item->brush.color_rgba, NULL);
859 update_text_item_displayfont(redo->item);
860 update_item_bbox(redo->item);
863 // move item from redo to undo stack
869 update_undo_redo_enabled();
870 if (u->multiop & MULTIOP_CONT_REDO) on_editRedo_activate(NULL,NULL); // loop
875 on_editCut_activate (GtkMenuItem *menuitem,
886 on_editCopy_activate (GtkMenuItem *menuitem,
896 on_editPaste_activate (GtkMenuItem *menuitem,
906 on_editDelete_activate (GtkMenuItem *menuitem,
916 on_viewContinuous_activate (GtkMenuItem *menuitem,
919 GtkAdjustment *v_adj;
924 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
925 if (ui.view_continuous) return;
926 ui.view_continuous = TRUE;
927 v_adj = gtk_layout_get_vadjustment(GTK_LAYOUT(canvas));
929 yscroll = gtk_adjustment_get_value(v_adj) - pg->voffset*ui.zoom;
931 gtk_adjustment_set_value(v_adj, yscroll + pg->voffset*ui.zoom);
933 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
938 on_viewOnePage_activate (GtkMenuItem *menuitem,
941 GtkAdjustment *v_adj;
945 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
946 if (!ui.view_continuous) return;
947 ui.view_continuous = FALSE;
948 v_adj = gtk_layout_get_vadjustment(GTK_LAYOUT(canvas));
949 yscroll = gtk_adjustment_get_value(v_adj) - ui.cur_page->voffset*ui.zoom;
951 gtk_adjustment_set_value(v_adj, yscroll + ui.cur_page->voffset*ui.zoom);
953 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
958 on_viewZoomIn_activate (GtkMenuItem *menuitem,
962 if (ui.zoom > MAX_ZOOM) return;
963 ui.zoom *= ui.zoom_step_factor;
964 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
965 rescale_text_items();
966 rescale_bg_pixmaps();
971 on_viewZoomOut_activate (GtkMenuItem *menuitem,
975 if (ui.zoom < MIN_ZOOM) return;
976 ui.zoom /= ui.zoom_step_factor;
977 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
978 rescale_text_items();
979 rescale_bg_pixmaps();
984 on_viewNormalSize_activate (GtkMenuItem *menuitem,
988 ui.zoom = DEFAULT_ZOOM;
989 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
990 rescale_text_items();
991 rescale_bg_pixmaps();
996 on_viewPageWidth_activate (GtkMenuItem *menuitem,
1000 ui.zoom = (GTK_WIDGET(canvas))->allocation.width/ui.cur_page->width;
1001 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
1002 rescale_text_items();
1003 rescale_bg_pixmaps();
1008 on_viewFirstPage_activate (GtkMenuItem *menuitem,
1013 do_switch_page(0, TRUE, FALSE);
1018 on_viewPreviousPage_activate (GtkMenuItem *menuitem,
1023 if (ui.pageno == 0) return;
1024 do_switch_page(ui.pageno-1, TRUE, FALSE);
1029 on_viewNextPage_activate (GtkMenuItem *menuitem,
1034 if (ui.pageno == journal.npages-1) { // create a page at end
1035 if (page_ops_forbidden()) return;
1036 on_journalNewPageEnd_activate(menuitem, user_data);
1039 do_switch_page(ui.pageno+1, TRUE, FALSE);
1044 on_viewLastPage_activate (GtkMenuItem *menuitem,
1049 do_switch_page(journal.npages-1, TRUE, FALSE);
1054 on_viewShowLayer_activate (GtkMenuItem *menuitem,
1059 if (ui.layerno == ui.cur_page->nlayers-1) return;
1062 ui.cur_layer = g_list_nth_data(ui.cur_page->layers, ui.layerno);
1063 gnome_canvas_item_show(GNOME_CANVAS_ITEM(ui.cur_layer->group));
1064 update_page_stuff();
1069 on_viewHideLayer_activate (GtkMenuItem *menuitem,
1074 if (ui.layerno == -1) return;
1076 gnome_canvas_item_hide(GNOME_CANVAS_ITEM(ui.cur_layer->group));
1078 if (ui.layerno<0) ui.cur_layer = NULL;
1079 else ui.cur_layer = g_list_nth_data(ui.cur_page->layers, ui.layerno);
1080 update_page_stuff();
1085 on_journalNewPageBefore_activate (GtkMenuItem *menuitem,
1092 if (page_ops_forbidden()) return;
1094 pg = new_page(ui.cur_page);
1095 journal.pages = g_list_insert(journal.pages, pg, ui.pageno);
1097 do_switch_page(ui.pageno, TRUE, TRUE);
1100 undo->type = ITEM_NEW_PAGE;
1101 undo->val = ui.pageno;
1107 on_journalNewPageAfter_activate (GtkMenuItem *menuitem,
1114 if (page_ops_forbidden()) return;
1116 pg = new_page(ui.cur_page);
1117 journal.pages = g_list_insert(journal.pages, pg, ui.pageno+1);
1119 do_switch_page(ui.pageno+1, TRUE, TRUE);
1122 undo->type = ITEM_NEW_PAGE;
1123 undo->val = ui.pageno;
1129 on_journalNewPageEnd_activate (GtkMenuItem *menuitem,
1136 if (page_ops_forbidden()) return;
1138 pg = new_page((struct Page *)g_list_last(journal.pages)->data);
1139 journal.pages = g_list_append(journal.pages, pg);
1141 do_switch_page(journal.npages-1, TRUE, TRUE);
1144 undo->type = ITEM_NEW_PAGE;
1145 undo->val = ui.pageno;
1151 on_journalDeletePage_activate (GtkMenuItem *menuitem,
1154 GList *layerlist, *itemlist;
1159 if (page_ops_forbidden()) return;
1160 if (journal.npages == 1) return;
1163 undo->type = ITEM_DELETE_PAGE;
1164 undo->val = ui.pageno;
1165 undo->page = ui.cur_page;
1167 // unmap all the canvas items
1168 gtk_object_destroy(GTK_OBJECT(ui.cur_page->group));
1169 ui.cur_page->group = NULL;
1170 ui.cur_page->bg->canvas_item = NULL;
1171 for (layerlist = ui.cur_page->layers; layerlist!=NULL; layerlist = layerlist->next) {
1172 l = (struct Layer *)layerlist->data;
1173 for (itemlist = l->items; itemlist!=NULL; itemlist = itemlist->next)
1174 ((struct Item *)itemlist->data)->canvas_item = NULL;
1178 journal.pages = g_list_remove(journal.pages, ui.cur_page);
1180 if (ui.pageno == journal.npages) ui.pageno--;
1182 // so do_switch_page() won't try to remap the layers of the defunct page
1183 do_switch_page(ui.pageno, TRUE, TRUE);
1188 on_journalNewLayer_activate (GtkMenuItem *menuitem,
1196 l = g_new(struct Layer, 1);
1199 l->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
1200 ui.cur_page->group, gnome_canvas_group_get_type(), NULL);
1201 lower_canvas_item_to(ui.cur_page->group, GNOME_CANVAS_ITEM(l->group),
1202 (ui.cur_layer!=NULL)?(GNOME_CANVAS_ITEM(ui.cur_layer->group)):(ui.cur_page->bg->canvas_item));
1203 ui.cur_page->layers = g_list_insert(ui.cur_page->layers, l, ui.layerno+1);
1206 ui.cur_page->nlayers++;
1207 update_page_stuff();
1210 undo->type = ITEM_NEW_LAYER;
1211 undo->val = ui.layerno;
1213 undo->page = ui.cur_page;
1218 on_journalDeleteLayer_activate (GtkMenuItem *menuitem,
1225 if (ui.cur_layer == NULL) return;
1228 undo->type = ITEM_DELETE_LAYER;
1229 undo->val = ui.layerno;
1230 undo->layer = ui.cur_layer;
1231 undo->layer2 = NULL;
1232 undo->page = ui.cur_page;
1233 // delete all the canvas items
1234 gtk_object_destroy(GTK_OBJECT(ui.cur_layer->group));
1235 ui.cur_layer->group = NULL;
1236 for (list=ui.cur_layer->items; list!=NULL; list=list->next)
1237 ((struct Item *)list->data)->canvas_item = NULL;
1239 ui.cur_page->layers = g_list_remove(ui.cur_page->layers, ui.cur_layer);
1241 if (ui.cur_page->nlayers>=2) {
1242 ui.cur_page->nlayers--;
1244 if (ui.layerno<0) ui.cur_layer = NULL;
1245 else ui.cur_layer = (struct Layer *)g_list_nth_data(ui.cur_page->layers, ui.layerno);
1247 else { // special case: can't remove the last layer
1248 ui.cur_layer = g_new(struct Layer, 1);
1249 ui.cur_layer->items = NULL;
1250 ui.cur_layer->nitems = 0;
1251 ui.cur_layer->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
1252 ui.cur_page->group, gnome_canvas_group_get_type(), NULL);
1253 ui.cur_page->layers = g_list_append(NULL, ui.cur_layer);
1255 undo->layer2 = ui.cur_layer;
1258 update_page_stuff();
1263 on_journalFlatten_activate (GtkMenuItem *menuitem,
1270 // the paper sizes dialog
1272 GtkWidget *papersize_dialog;
1273 int papersize_std, papersize_unit;
1274 double papersize_width, papersize_height;
1275 gboolean papersize_need_init, papersize_width_valid, papersize_height_valid;
1277 #define STD_SIZE_A4 0
1278 #define STD_SIZE_A4R 1
1279 #define STD_SIZE_LETTER 2
1280 #define STD_SIZE_LETTER_R 3
1281 #define STD_SIZE_CUSTOM 4
1283 double unit_sizes[4] = {28.346, 72., 72./DISPLAY_DPI_DEFAULT, 1.};
1284 double std_widths[STD_SIZE_CUSTOM] = {595.27, 841.89, 612., 792.};
1285 double std_heights[STD_SIZE_CUSTOM] = {841.89, 595.27, 792., 612.};
1286 double std_units[STD_SIZE_CUSTOM] = {UNIT_CM, UNIT_CM, UNIT_IN, UNIT_IN};
1289 on_journalPaperSize_activate (GtkMenuItem *menuitem,
1298 papersize_dialog = create_papersizeDialog();
1299 papersize_width = ui.cur_page->width;
1300 papersize_height = ui.cur_page->height;
1301 papersize_unit = ui.default_unit;
1302 unit_sizes[UNIT_PX] = 1./DEFAULT_ZOOM;
1303 // if (ui.cur_page->bg->type == BG_PIXMAP) papersize_unit = UNIT_PX;
1304 papersize_std = STD_SIZE_CUSTOM;
1305 for (i=0;i<STD_SIZE_CUSTOM;i++)
1306 if (fabs(papersize_width - std_widths[i])<0.1 &&
1307 fabs(papersize_height - std_heights[i])<0.1)
1308 { papersize_std = i; papersize_unit = std_units[i]; }
1309 papersize_need_init = TRUE;
1310 papersize_width_valid = papersize_height_valid = TRUE;
1312 gtk_widget_show(papersize_dialog);
1313 on_comboStdSizes_changed(GTK_COMBO_BOX(g_object_get_data(
1314 G_OBJECT(papersize_dialog), "comboStdSizes")), NULL);
1315 gtk_dialog_set_default_response(GTK_DIALOG(papersize_dialog), GTK_RESPONSE_OK);
1317 response = gtk_dialog_run(GTK_DIALOG(papersize_dialog));
1318 gtk_widget_destroy(papersize_dialog);
1319 if (response != GTK_RESPONSE_OK) return;
1322 for (pglist = journal.pages; pglist!=NULL; pglist = pglist->next) {
1323 if (ui.bg_apply_all_pages) pg = (struct Page *)pglist->data;
1325 if (ui.bg_apply_all_pages) {
1326 if (pglist->next!=NULL) undo->multiop |= MULTIOP_CONT_REDO;
1327 if (pglist->prev!=NULL) undo->multiop |= MULTIOP_CONT_UNDO;
1329 undo->type = ITEM_PAPER_RESIZE;
1331 undo->val_x = pg->width;
1332 undo->val_y = pg->height;
1333 if (papersize_width_valid) pg->width = papersize_width;
1334 if (papersize_height_valid) pg->height = papersize_height;
1335 make_page_clipbox(pg);
1336 update_canvas_bg(pg);
1337 if (!ui.bg_apply_all_pages) break;
1339 do_switch_page(ui.pageno, TRUE, TRUE);
1344 on_papercolorWhite_activate (GtkMenuItem *menuitem,
1349 process_papercolor_activate(menuitem, COLOR_WHITE);
1354 on_papercolorYellow_activate (GtkMenuItem *menuitem,
1359 process_papercolor_activate(menuitem, COLOR_YELLOW);
1364 on_papercolorPink_activate (GtkMenuItem *menuitem,
1369 process_papercolor_activate(menuitem, COLOR_RED);
1374 on_papercolorOrange_activate (GtkMenuItem *menuitem,
1379 process_papercolor_activate(menuitem, COLOR_ORANGE);
1384 on_papercolorBlue_activate (GtkMenuItem *menuitem,
1389 process_papercolor_activate(menuitem, COLOR_BLUE);
1394 on_papercolorGreen_activate (GtkMenuItem *menuitem,
1399 process_papercolor_activate(menuitem, COLOR_GREEN);
1404 on_papercolorOther_activate (GtkMenuItem *menuitem,
1412 on_paperstylePlain_activate (GtkMenuItem *menuitem,
1417 process_paperstyle_activate(menuitem, RULING_NONE);
1422 on_paperstyleLined_activate (GtkMenuItem *menuitem,
1427 process_paperstyle_activate(menuitem, RULING_LINED);
1432 on_paperstyleRuled_activate (GtkMenuItem *menuitem,
1437 process_paperstyle_activate(menuitem, RULING_RULED);
1442 on_paperstyleGraph_activate (GtkMenuItem *menuitem,
1447 process_paperstyle_activate(menuitem, RULING_GRAPH);
1452 on_journalLoadBackground_activate (GtkMenuItem *menuitem,
1455 GtkWidget *dialog, *attach_opt;
1456 struct Background *bg;
1459 GList *bglist, *bglistiter;
1460 GtkFileFilter *filt_all, *filt_pix, *filt_pspdf;
1466 dialog = gtk_file_chooser_dialog_new("Open Background", GTK_WINDOW (winMain),
1467 GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1468 GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL);
1470 filt_all = gtk_file_filter_new();
1471 gtk_file_filter_set_name(filt_all, "All files");
1472 gtk_file_filter_add_pattern(filt_all, "*");
1473 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_all);
1475 #if GTK_CHECK_VERSION(2,6,0)
1477 if (!gtk_check_version(2, 6, 0)) {
1478 filt_pix = gtk_file_filter_new();
1479 gtk_file_filter_set_name(filt_pix, "Bitmap files");
1480 gtk_file_filter_add_pixbuf_formats(filt_pix);
1481 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_pix);
1486 filt_pspdf = gtk_file_filter_new();
1487 gtk_file_filter_set_name(filt_pspdf, "PS/PDF files (as bitmaps)");
1488 gtk_file_filter_add_pattern(filt_pspdf, "*.ps");
1489 gtk_file_filter_add_pattern(filt_pspdf, "*.PS");
1490 gtk_file_filter_add_pattern(filt_pspdf, "*.pdf");
1491 gtk_file_filter_add_pattern(filt_pspdf, "*.PDF");
1492 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_pspdf);
1494 attach_opt = gtk_check_button_new_with_label("Attach file to the journal");
1495 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(attach_opt), FALSE);
1496 gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER (dialog), attach_opt);
1498 if (ui.default_path!=NULL) gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (dialog), ui.default_path);
1500 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
1501 gtk_widget_destroy(dialog);
1504 filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
1505 attach = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(attach_opt));
1506 gtk_widget_destroy(dialog);
1508 set_cursor_busy(TRUE);
1509 bg = attempt_load_pix_bg(filename, attach);
1510 if (bg != NULL) bglist = g_list_append(NULL, bg);
1511 else bglist = attempt_load_gv_bg(filename);
1512 set_cursor_busy(FALSE);
1514 if (bglist == NULL) {
1515 dialog = gtk_message_dialog_new(GTK_WINDOW(winMain), GTK_DIALOG_MODAL,
1516 GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
1517 "Error opening background '%s'", filename);
1518 gtk_dialog_run(GTK_DIALOG(dialog));
1519 gtk_widget_destroy(dialog);
1528 for (bglistiter = bglist, pageno = ui.pageno;
1529 bglistiter!=NULL; bglistiter = bglistiter->next, pageno++) {
1531 if (bglistiter->next!=NULL) undo->multiop |= MULTIOP_CONT_REDO;
1532 if (bglistiter->prev!=NULL) undo->multiop |= MULTIOP_CONT_UNDO;
1534 bg = (struct Background *)bglistiter->data;
1536 if (pageno == journal.npages) {
1537 undo->type = ITEM_NEW_PAGE;
1538 pg = new_page_with_bg(bg,
1539 gdk_pixbuf_get_width(bg->pixbuf)/bg->pixbuf_scale,
1540 gdk_pixbuf_get_height(bg->pixbuf)/bg->pixbuf_scale);
1541 journal.pages = g_list_append(journal.pages, pg);
1547 pg = g_list_nth_data(journal.pages, pageno);
1548 undo->type = ITEM_NEW_BG_RESIZE;
1551 bg->canvas_item = undo->bg->canvas_item;
1552 undo->bg->canvas_item = NULL;
1553 undo->val_x = pg->width;
1554 undo->val_y = pg->height;
1556 pg->width = gdk_pixbuf_get_width(bg->pixbuf)/bg->pixbuf_scale;
1557 pg->height = gdk_pixbuf_get_height(bg->pixbuf)/bg->pixbuf_scale;
1558 make_page_clipbox(pg);
1559 update_canvas_bg(pg);
1563 g_list_free(bglist);
1564 if (ui.zoom != DEFAULT_ZOOM) {
1565 ui.zoom = DEFAULT_ZOOM;
1566 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
1567 rescale_text_items();
1568 rescale_bg_pixmaps();
1570 do_switch_page(ui.pageno, TRUE, TRUE);
1574 on_journalScreenshot_activate (GtkMenuItem *menuitem,
1577 struct Background *bg;
1582 gtk_window_iconify(GTK_WINDOW(winMain)); // hide ourselves
1583 gdk_display_sync(gdk_display_get_default());
1585 if (ui.cursor!=NULL)
1586 gdk_cursor_unref(ui.cursor);
1587 ui.cursor = gdk_cursor_new(GDK_TCROSS);
1589 bg = attempt_screenshot_bg();
1591 gtk_window_deiconify(GTK_WINDOW(winMain));
1593 if (bg==NULL) return;
1596 undo->type = ITEM_NEW_BG_RESIZE;
1597 undo->page = ui.cur_page;
1598 undo->bg = ui.cur_page->bg;
1599 bg->canvas_item = undo->bg->canvas_item;
1600 undo->bg->canvas_item = NULL;
1601 undo->val_x = ui.cur_page->width;
1602 undo->val_y = ui.cur_page->height;
1604 ui.cur_page->bg = bg;
1605 ui.cur_page->width = gdk_pixbuf_get_width(bg->pixbuf)/bg->pixbuf_scale;
1606 ui.cur_page->height = gdk_pixbuf_get_height(bg->pixbuf)/bg->pixbuf_scale;
1608 make_page_clipbox(ui.cur_page);
1609 update_canvas_bg(ui.cur_page);
1611 if (ui.zoom != DEFAULT_ZOOM) {
1612 ui.zoom = DEFAULT_ZOOM;
1613 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
1614 rescale_text_items();
1615 rescale_bg_pixmaps();
1617 do_switch_page(ui.pageno, TRUE, TRUE);
1622 on_journalApplyAllPages_activate (GtkMenuItem *menuitem,
1629 active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
1630 if (active == ui.bg_apply_all_pages) return;
1631 ui.bg_apply_all_pages = active;
1632 update_page_stuff();
1634 /* THIS IS THE OLD VERSION OF THE FEATURE -- APPLIED CURRENT BG TO ALL
1638 if (ui.cur_page->bg->type != BG_SOLID) return;
1640 for (pglist = journal.pages; pglist!=NULL; pglist = pglist->next) {
1641 page = (struct Page *)pglist->data;
1643 undo->type = ITEM_NEW_BG_RESIZE;
1645 undo->bg = page->bg;
1646 undo->val_x = page->width;
1647 undo->val_y = page->height;
1648 if (pglist->next!=NULL) undo->multiop |= MULTIOP_CONT_REDO;
1649 if (pglist->prev!=NULL) undo->multiop |= MULTIOP_CONT_UNDO;
1650 page->bg = (struct Background *)g_memdup(ui.cur_page->bg, sizeof(struct Background));
1651 page->width = ui.cur_page->width;
1652 page->height = ui.cur_page->height;
1653 page->bg->canvas_item = undo->bg->canvas_item;
1654 undo->bg->canvas_item = NULL;
1656 make_page_clipbox(page);
1657 update_canvas_bg(page);
1659 do_switch_page(ui.pageno, TRUE, TRUE);
1666 on_toolsPen_activate (GtkMenuItem *menuitem,
1669 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1670 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1673 if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1677 if (ui.cur_mapping != 0) return;
1678 if (ui.toolno[0] == TOOL_PEN) return;
1683 ui.toolno[0] = TOOL_PEN;
1684 ui.ruler[0] = FALSE;
1685 ui.cur_brush = &(ui.brushes[0][TOOL_PEN]);
1686 update_mapping_linkings(TOOL_PEN);
1687 update_tool_buttons();
1689 update_color_menu();
1695 on_toolsEraser_activate (GtkMenuItem *menuitem,
1698 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1699 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1702 if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1706 if (ui.cur_mapping != 0) return;
1707 if (ui.toolno[0] == TOOL_ERASER) return;
1712 ui.toolno[0] = TOOL_ERASER;
1713 ui.ruler[0] = FALSE;
1714 ui.cur_brush = &(ui.brushes[0][TOOL_ERASER]);
1715 update_mapping_linkings(TOOL_ERASER);
1716 update_tool_buttons();
1718 update_color_menu();
1724 on_toolsHighlighter_activate (GtkMenuItem *menuitem,
1727 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1728 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1731 if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1735 if (ui.cur_mapping != 0) return; // not user-generated
1736 if (ui.toolno[0] == TOOL_HIGHLIGHTER) return;
1741 ui.toolno[0] = TOOL_HIGHLIGHTER;
1742 ui.ruler[0] = FALSE;
1743 ui.cur_brush = &(ui.brushes[0][TOOL_HIGHLIGHTER]);
1744 update_mapping_linkings(TOOL_HIGHLIGHTER);
1745 update_tool_buttons();
1747 update_color_menu();
1753 on_toolsText_activate (GtkMenuItem *menuitem,
1756 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1757 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1760 if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1764 if (ui.cur_mapping != 0) return; // not user-generated
1765 if (ui.toolno[0] == TOOL_TEXT) return;
1769 ui.toolno[0] = TOOL_TEXT;
1770 ui.ruler[0] = FALSE;
1771 ui.cur_brush = &(ui.brushes[0][TOOL_PEN]);
1772 update_mapping_linkings(-1);
1773 update_tool_buttons();
1775 update_color_menu();
1781 on_toolsSelectRegion_activate (GtkMenuItem *menuitem,
1789 on_toolsSelectRectangle_activate (GtkMenuItem *menuitem,
1792 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1793 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1796 if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1800 if (ui.cur_mapping != 0) return; // not user-generated
1801 if (ui.toolno[0] == TOOL_SELECTRECT) return;
1805 ui.toolno[0] = TOOL_SELECTRECT;
1806 ui.ruler[0] = FALSE;
1807 update_mapping_linkings(-1);
1808 update_tool_buttons();
1810 update_color_menu();
1816 on_toolsVerticalSpace_activate (GtkMenuItem *menuitem,
1819 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1820 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1823 if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1827 if (ui.cur_mapping != 0) return; // not user-generated
1828 if (ui.toolno[0] == TOOL_VERTSPACE) return;
1833 ui.toolno[0] = TOOL_VERTSPACE;
1834 ui.ruler[0] = FALSE;
1835 update_mapping_linkings(-1);
1836 update_tool_buttons();
1838 update_color_menu();
1844 on_colorBlack_activate (GtkMenuItem *menuitem,
1847 process_color_activate(menuitem, COLOR_BLACK);
1852 on_colorBlue_activate (GtkMenuItem *menuitem,
1855 process_color_activate(menuitem, COLOR_BLUE);
1861 on_colorRed_activate (GtkMenuItem *menuitem,
1864 process_color_activate(menuitem, COLOR_RED);
1869 on_colorGreen_activate (GtkMenuItem *menuitem,
1872 process_color_activate(menuitem, COLOR_GREEN);
1877 on_colorGray_activate (GtkMenuItem *menuitem,
1880 process_color_activate(menuitem, COLOR_GRAY);
1885 on_colorLightBlue_activate (GtkMenuItem *menuitem,
1888 process_color_activate(menuitem, COLOR_LIGHTBLUE);
1893 on_colorLightGreen_activate (GtkMenuItem *menuitem,
1896 process_color_activate(menuitem, COLOR_LIGHTGREEN);
1901 on_colorMagenta_activate (GtkMenuItem *menuitem,
1904 process_color_activate(menuitem, COLOR_MAGENTA);
1909 on_colorOrange_activate (GtkMenuItem *menuitem,
1912 process_color_activate(menuitem, COLOR_ORANGE);
1917 on_colorYellow_activate (GtkMenuItem *menuitem,
1920 process_color_activate(menuitem, COLOR_YELLOW);
1925 on_colorWhite_activate (GtkMenuItem *menuitem,
1928 process_color_activate(menuitem, COLOR_WHITE);
1933 on_colorOther_activate (GtkMenuItem *menuitem,
1941 on_penthicknessVeryFine_activate (GtkMenuItem *menuitem,
1944 process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_VERYFINE);
1949 on_penthicknessFine_activate (GtkMenuItem *menuitem,
1952 process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_FINE);
1957 on_penthicknessMedium_activate (GtkMenuItem *menuitem,
1960 process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_MEDIUM);
1965 on_penthicknessThick_activate (GtkMenuItem *menuitem,
1968 process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_THICK);
1973 on_penthicknessVeryThick_activate (GtkMenuItem *menuitem,
1976 process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_VERYTHICK);
1981 on_eraserFine_activate (GtkMenuItem *menuitem,
1984 process_thickness_activate(menuitem, TOOL_ERASER, THICKNESS_FINE);
1989 on_eraserMedium_activate (GtkMenuItem *menuitem,
1992 process_thickness_activate(menuitem, TOOL_ERASER, THICKNESS_MEDIUM);
1997 on_eraserThick_activate (GtkMenuItem *menuitem,
2000 process_thickness_activate(menuitem, TOOL_ERASER, THICKNESS_THICK);
2005 on_eraserStandard_activate (GtkMenuItem *menuitem,
2008 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
2011 ui.brushes[0][TOOL_ERASER].tool_options = TOOLOPT_ERASER_STANDARD;
2012 update_mapping_linkings(TOOL_ERASER);
2017 on_eraserWhiteout_activate (GtkMenuItem *menuitem,
2020 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
2023 ui.brushes[0][TOOL_ERASER].tool_options = TOOLOPT_ERASER_WHITEOUT;
2024 update_mapping_linkings(TOOL_ERASER);
2029 on_eraserDeleteStrokes_activate (GtkMenuItem *menuitem,
2032 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
2035 ui.brushes[0][TOOL_ERASER].tool_options = TOOLOPT_ERASER_STROKES;
2036 update_mapping_linkings(TOOL_ERASER);
2041 on_highlighterFine_activate (GtkMenuItem *menuitem,
2044 process_thickness_activate(menuitem, TOOL_HIGHLIGHTER, THICKNESS_FINE);
2049 on_highlighterMedium_activate (GtkMenuItem *menuitem,
2052 process_thickness_activate(menuitem, TOOL_HIGHLIGHTER, THICKNESS_MEDIUM);
2057 on_highlighterThick_activate (GtkMenuItem *menuitem,
2060 process_thickness_activate(menuitem, TOOL_HIGHLIGHTER, THICKNESS_THICK);
2065 on_toolsTextFont_activate (GtkMenuItem *menuitem,
2071 dialog = gtk_font_selection_dialog_new("Select Font");
2072 str = make_cur_font_name();
2073 gtk_font_selection_dialog_set_font_name(GTK_FONT_SELECTION_DIALOG(dialog), str);
2075 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
2076 gtk_widget_destroy(dialog);
2080 str = gtk_font_selection_dialog_get_font_name(GTK_FONT_SELECTION_DIALOG(dialog));
2081 gtk_widget_destroy(dialog);
2082 process_font_sel(str);
2086 on_toolsDefaultPen_activate (GtkMenuItem *menuitem,
2093 g_memmove(&(ui.brushes[0][TOOL_PEN]), ui.default_brushes+TOOL_PEN, sizeof(struct Brush));
2094 ui.toolno[0] = TOOL_PEN;
2095 ui.cur_brush = &(ui.brushes[0][TOOL_PEN]);
2096 ui.ruler[0] = FALSE;
2097 update_mapping_linkings(TOOL_PEN);
2098 update_tool_buttons();
2100 update_pen_props_menu();
2101 update_color_menu();
2107 on_toolsDefaultEraser_activate (GtkMenuItem *menuitem,
2114 g_memmove(&(ui.brushes[0][TOOL_ERASER]), ui.default_brushes+TOOL_ERASER, sizeof(struct Brush));
2115 ui.toolno[0] = TOOL_ERASER;
2116 ui.cur_brush = &(ui.brushes[0][TOOL_ERASER]);
2117 ui.ruler[0] = FALSE;
2118 update_mapping_linkings(TOOL_ERASER);
2119 update_tool_buttons();
2121 update_eraser_props_menu();
2122 update_color_menu();
2128 on_toolsDefaultHighlighter_activate (GtkMenuItem *menuitem,
2135 g_memmove(&(ui.brushes[0][TOOL_HIGHLIGHTER]), ui.default_brushes+TOOL_HIGHLIGHTER, sizeof(struct Brush));
2136 ui.toolno[0] = TOOL_HIGHLIGHTER;
2137 ui.cur_brush = &(ui.brushes[0][TOOL_HIGHLIGHTER]);
2138 ui.ruler[0] = FALSE;
2139 update_mapping_linkings(TOOL_HIGHLIGHTER);
2140 update_tool_buttons();
2142 update_highlighter_props_menu();
2143 update_color_menu();
2148 on_toolsDefaultText_activate (GtkMenuItem *menuitem,
2152 if (ui.toolno[0]!=TOOL_TEXT) end_text();
2155 ui.toolno[0] = TOOL_TEXT;
2156 ui.ruler[0] = FALSE;
2157 ui.cur_brush = &(ui.brushes[0][TOOL_PEN]);
2158 ui.cur_brush->color_no = ui.default_brushes[TOOL_PEN].color_no;
2159 ui.cur_brush->color_rgba = ui.default_brushes[TOOL_PEN].color_rgba;
2160 g_free(ui.font_name);
2161 ui.font_name = g_strdup(ui.default_font_name);
2162 ui.font_size = ui.default_font_size;
2163 if (ui.cur_item_type == ITEM_TEXT) {
2164 refont_text_item(ui.cur_item, ui.font_name, ui.font_size);
2166 update_font_button();
2167 update_mapping_linkings(-1);
2168 update_tool_buttons();
2170 update_color_menu();
2176 on_toolsSetAsDefault_activate (GtkMenuItem *menuitem,
2181 if (ui.cur_mapping!=0) return;
2182 if (ui.toolno[0] < NUM_STROKE_TOOLS)
2183 g_memmove(ui.default_brushes+ui.toolno[0], &(ui.brushes[0][ui.toolno[0]]), sizeof(struct Brush));
2184 if (ui.toolno[0] == TOOL_TEXT) {
2185 if (ui.cur_item_type == ITEM_TEXT) {
2186 g_free(ui.font_name);
2187 ui.font_name = g_strdup(ui.cur_item->font_name);
2188 ui.font_size = ui.cur_item->font_size;
2190 else if (ui.selection!=NULL && ui.selection->items!=NULL &&
2191 ui.selection->items->next==NULL &&
2192 (it=(struct Item*)ui.selection->items->data)->type == ITEM_TEXT) {
2193 g_free(ui.font_name);
2194 ui.font_name = g_strdup(it->font_name);
2195 ui.font_size = it->font_size;
2197 g_free(ui.default_font_name);
2198 ui.default_font_name = g_strdup(ui.font_name);
2199 ui.default_font_size = ui.font_size;
2207 on_toolsRuler_activate (GtkMenuItem *menuitem,
2212 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_CHECK_MENU_ITEM)
2213 active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
2215 active = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem));
2217 if (ui.cur_mapping != 0) return;
2218 if (active == ui.ruler[0]) return;
2222 if (active && (ui.toolno[0]!=TOOL_PEN && ui.toolno[0]!=TOOL_HIGHLIGHTER)) {
2224 ui.toolno[0] = TOOL_PEN;
2225 ui.cur_brush = &(ui.brushes[0][TOOL_PEN]);
2226 update_color_menu();
2227 update_tool_buttons();
2232 ui.ruler[0] = active;
2233 update_mapping_linkings(ui.toolno[0]);
2234 update_ruler_indicator();
2239 on_optionsSavePreferences_activate (GtkMenuItem *menuitem,
2244 save_config_to_file();
2249 on_helpIndex_activate (GtkMenuItem *menuitem,
2257 on_helpAbout_activate (GtkMenuItem *menuitem,
2260 GtkWidget *aboutDialog;
2261 GtkLabel *labelTitle;
2265 aboutDialog = create_aboutDialog ();
2266 labelTitle = GTK_LABEL(g_object_get_data(G_OBJECT(aboutDialog), "labelTitle"));
2267 gtk_label_set_markup(labelTitle,
2268 "<span size=\"xx-large\" weight=\"bold\">Xournal " VERSION "</span>");
2269 gtk_dialog_run (GTK_DIALOG(aboutDialog));
2270 gtk_widget_destroy(aboutDialog);
2275 on_buttonToolDefault_clicked (GtkToolButton *toolbutton,
2278 if (ui.toolno[0]==TOOL_TEXT) {
2279 on_toolsDefaultText_activate(NULL, NULL);
2285 if (ui.toolno[0] < NUM_STROKE_TOOLS) {
2286 g_memmove(&(ui.brushes[0][ui.toolno[0]]), ui.default_brushes+ui.toolno[0], sizeof(struct Brush));
2287 ui.ruler[0] = FALSE;
2288 update_mapping_linkings(ui.toolno[0]);
2289 update_thickness_buttons();
2290 update_color_buttons();
2291 update_color_menu();
2292 if (ui.toolno[0] == TOOL_PEN) update_pen_props_menu();
2293 if (ui.toolno[0] == TOOL_ERASER) update_eraser_props_menu();
2294 if (ui.toolno[0] == TOOL_HIGHLIGHTER) update_highlighter_props_menu();
2301 on_buttonFine_clicked (GtkToolButton *toolbutton,
2304 if (ui.cur_mapping != 0) return;
2305 process_thickness_activate((GtkMenuItem*)toolbutton, ui.toolno[0], THICKNESS_FINE);
2310 on_buttonMedium_clicked (GtkToolButton *toolbutton,
2313 if (ui.cur_mapping != 0) return;
2314 process_thickness_activate((GtkMenuItem*)toolbutton, ui.toolno[0], THICKNESS_MEDIUM);
2319 on_buttonThick_clicked (GtkToolButton *toolbutton,
2322 if (ui.cur_mapping != 0) return;
2323 process_thickness_activate((GtkMenuItem*)toolbutton, ui.toolno[0], THICKNESS_THICK);
2328 on_canvas_button_press_event (GtkWidget *widget,
2329 GdkEventButton *event,
2333 gboolean page_change;
2334 struct Page *tmppage;
2340 is_core = (event->device == gdk_device_get_core_pointer());
2341 if (!ui.use_xinput && !is_core) return FALSE;
2342 if (ui.use_xinput && is_core && ui.discard_corepointer) return FALSE;
2343 if (event->button > 3) return FALSE; // no painting with the mouse wheel!
2345 // re-get the axis values since Synaptics sends bogus ones
2346 gdk_device_get_state(event->device, event->window, event->axes, NULL);
2347 fix_xinput_coords((GdkEvent *)event);
2350 if (ui.cur_item_type == ITEM_TEXT && !is_event_within_textview(event))
2352 if (ui.cur_item_type != ITEM_NONE) return FALSE; // we're already doing something
2354 ui.is_corestroke = is_core;
2356 if (ui.use_erasertip && event->device->source == GDK_SOURCE_ERASER)
2357 mapping = NUM_BUTTONS;
2358 else mapping = event->button-1;
2360 // check whether we're in a page
2361 page_change = FALSE;
2362 tmppage = ui.cur_page;
2363 get_pointer_coords((GdkEvent *)event, pt);
2364 while (ui.view_continuous && (pt[1] < - VIEW_CONTINUOUS_SKIP)) {
2365 if (ui.pageno == 0) break;
2368 tmppage = g_list_nth_data(journal.pages, ui.pageno);
2369 pt[1] += tmppage->height + VIEW_CONTINUOUS_SKIP;
2371 while (ui.view_continuous && (pt[1] > tmppage->height + VIEW_CONTINUOUS_SKIP)) {
2372 if (ui.pageno == journal.npages-1) break;
2373 pt[1] -= tmppage->height + VIEW_CONTINUOUS_SKIP;
2376 tmppage = g_list_nth_data(journal.pages, ui.pageno);
2378 if (page_change) do_switch_page(ui.pageno, FALSE, FALSE);
2380 // can't paint on the background...
2382 if (ui.cur_layer == NULL) {
2384 dialog = gtk_message_dialog_new(GTK_WINDOW(winMain), GTK_DIALOG_MODAL,
2385 GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, "Drawing is not allowed on the "
2386 "background layer.\n Switching to Layer 1.");
2387 gtk_dialog_run(GTK_DIALOG(dialog));
2388 gtk_widget_destroy(dialog);
2389 on_viewShowLayer_activate(NULL, NULL);
2393 // switch mappings if needed
2395 ui.which_mouse_button = event->button;
2396 switch_mapping(mapping);
2398 // in text tool, clicking in a text area edits it
2399 if (ui.toolno[mapping] == TOOL_TEXT) {
2400 item = click_is_in_text(ui.cur_layer, pt[0], pt[1]);
2403 start_text((GdkEvent *)event, item);
2408 // if this can be a selection move, then it takes precedence over anything else
2409 if (start_movesel((GdkEvent *)event)) return FALSE;
2411 if (ui.toolno[mapping] != TOOL_SELECTREGION && ui.toolno[mapping] != TOOL_SELECTRECT)
2414 // process the event
2416 if (ui.toolno[mapping] == TOOL_HAND) {
2417 ui.cur_item_type = ITEM_HAND;
2418 get_pointer_coords((GdkEvent *)event, ui.hand_refpt);
2420 else if (ui.toolno[mapping] == TOOL_PEN || ui.toolno[mapping] == TOOL_HIGHLIGHTER ||
2421 (ui.toolno[mapping] == TOOL_ERASER && ui.cur_brush->tool_options == TOOLOPT_ERASER_WHITEOUT)) {
2422 create_new_stroke((GdkEvent *)event);
2424 else if (ui.toolno[mapping] == TOOL_ERASER) {
2425 ui.cur_item_type = ITEM_ERASURE;
2426 do_eraser((GdkEvent *)event, ui.cur_brush->thickness/2,
2427 ui.cur_brush->tool_options == TOOLOPT_ERASER_STROKES);
2429 else if (ui.toolno[mapping] == TOOL_SELECTRECT) {
2430 start_selectrect((GdkEvent *)event);
2432 else if (ui.toolno[mapping] == TOOL_VERTSPACE) {
2433 start_vertspace((GdkEvent *)event);
2435 else if (ui.toolno[mapping] == TOOL_TEXT) {
2436 start_text((GdkEvent *)event, NULL);
2443 on_canvas_button_release_event (GtkWidget *widget,
2444 GdkEventButton *event,
2449 if (ui.cur_item_type == ITEM_NONE) return FALSE; // not doing anything
2451 if (event->button != ui.which_mouse_button) return FALSE; // ignore
2453 is_core = (event->device == gdk_device_get_core_pointer());
2454 if (!ui.use_xinput && !is_core) return FALSE;
2455 if (ui.use_xinput && is_core && !ui.is_corestroke) return FALSE;
2456 if (!is_core) fix_xinput_coords((GdkEvent *)event);
2458 if (ui.cur_item_type == ITEM_STROKE) {
2461 else if (ui.cur_item_type == ITEM_ERASURE) {
2464 else if (ui.cur_item_type == ITEM_SELECTRECT) {
2465 finalize_selectrect();
2467 else if (ui.cur_item_type == ITEM_MOVESEL || ui.cur_item_type == ITEM_MOVESEL_VERT) {
2470 else if (ui.cur_item_type == ITEM_HAND) {
2471 ui.cur_item_type = ITEM_NONE;
2480 on_canvas_enter_notify_event (GtkWidget *widget,
2481 GdkEventCrossing *event,
2490 on_canvas_expose_event (GtkWidget *widget,
2491 GdkEventExpose *event,
2494 if (ui.view_continuous && ui.progressive_bg) rescale_bg_pixmaps();
2500 on_canvas_key_press_event (GtkWidget *widget,
2509 on_canvas_motion_notify_event (GtkWidget *widget,
2510 GdkEventMotion *event,
2513 gboolean looks_wrong, is_core;
2516 if (ui.cur_item_type == ITEM_NONE) return FALSE; // we don't care
2518 is_core = (event->device == gdk_device_get_core_pointer());
2519 if (!ui.use_xinput && !is_core) return FALSE;
2520 if (ui.use_xinput && is_core && !ui.is_corestroke) return FALSE;
2521 if (!is_core) fix_xinput_coords((GdkEvent *)event);
2523 looks_wrong = !(event->state & (1<<(7+ui.which_mouse_button)));
2525 if (looks_wrong) { /* mouse button shouldn't be up... give up */
2526 if (ui.cur_item_type == ITEM_STROKE) {
2529 else if (ui.cur_item_type == ITEM_ERASURE) {
2532 else if (ui.cur_item_type == ITEM_SELECTRECT) {
2533 finalize_selectrect();
2535 else if (ui.cur_item_type == ITEM_MOVESEL || ui.cur_item_type == ITEM_MOVESEL_VERT) {
2542 if (ui.cur_item_type == ITEM_STROKE) {
2543 continue_stroke((GdkEvent *)event);
2545 else if (ui.cur_item_type == ITEM_ERASURE) {
2546 do_eraser((GdkEvent *)event, ui.cur_brush->thickness/2,
2547 ui.cur_brush->tool_options == TOOLOPT_ERASER_STROKES);
2549 else if (ui.cur_item_type == ITEM_SELECTRECT) {
2550 get_pointer_coords((GdkEvent *)event, pt);
2551 ui.selection->bbox.right = pt[0];
2552 ui.selection->bbox.bottom = pt[1];
2553 gnome_canvas_item_set(ui.selection->canvas_item,
2554 "x2", pt[0], "y2", pt[1], NULL);
2556 else if (ui.cur_item_type == ITEM_MOVESEL || ui.cur_item_type == ITEM_MOVESEL_VERT) {
2557 continue_movesel((GdkEvent *)event);
2559 else if (ui.cur_item_type == ITEM_HAND) {
2560 do_hand((GdkEvent *)event);
2567 on_comboLayer_changed (GtkComboBox *combobox,
2572 if (ui.in_update_page_stuff) return; // avoid a bad retroaction
2577 val = gtk_combo_box_get_active(combobox);
2578 if (val == -1) return;
2579 val = ui.cur_page->nlayers-1-val;
2580 if (val == ui.layerno) return;
2583 while (val>ui.layerno) {
2585 ui.cur_layer = g_list_nth_data(ui.cur_page->layers, ui.layerno);
2586 gnome_canvas_item_show(GNOME_CANVAS_ITEM(ui.cur_layer->group));
2588 while (val<ui.layerno) {
2589 gnome_canvas_item_hide(GNOME_CANVAS_ITEM(ui.cur_layer->group));
2591 if (ui.layerno<0) ui.cur_layer = NULL;
2592 else ui.cur_layer = g_list_nth_data(ui.cur_page->layers, ui.layerno);
2594 update_page_stuff();
2599 on_winMain_delete_event (GtkWidget *widget,
2605 if (ok_to_close()) gtk_main_quit();
2611 on_optionsUseXInput_activate (GtkMenuItem *menuitem,
2616 ui.allow_xinput = ui.use_xinput =
2617 gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
2618 gtk_widget_set_extension_events(GTK_WIDGET (canvas),
2619 ui.use_xinput?GDK_EXTENSION_EVENTS_ALL:GDK_EXTENSION_EVENTS_NONE);
2620 update_mappings_menu();
2624 on_vscroll_changed (GtkAdjustment *adjustment,
2627 gboolean need_update;
2628 double viewport_top, viewport_bottom;
2629 struct Page *tmppage;
2631 if (!ui.view_continuous) return;
2633 if (ui.progressive_bg) rescale_bg_pixmaps();
2634 need_update = FALSE;
2635 viewport_top = adjustment->value / ui.zoom;
2636 viewport_bottom = (adjustment->value + adjustment->page_size) / ui.zoom;
2637 tmppage = ui.cur_page;
2638 while (viewport_top > tmppage->voffset + tmppage->height) {
2639 if (ui.pageno == journal.npages-1) break;
2642 tmppage = g_list_nth_data(journal.pages, ui.pageno);
2644 while (viewport_bottom < tmppage->voffset) {
2645 if (ui.pageno == 0) break;
2648 tmppage = g_list_nth_data(journal.pages, ui.pageno);
2652 do_switch_page(ui.pageno, FALSE, FALSE);
2659 on_spinPageNo_value_changed (GtkSpinButton *spinbutton,
2664 if (ui.in_update_page_stuff) return; // avoid a bad retroaction
2669 val = gtk_spin_button_get_value_as_int(spinbutton) - 1;
2671 if (val == journal.npages) { // create a page at end
2672 if (page_ops_forbidden()) return;
2673 on_journalNewPageEnd_activate(NULL, NULL);
2677 if (val == ui.pageno) return;
2678 if (val < 0) val = 0;
2679 if (val > journal.npages-1) val = journal.npages-1;
2680 do_switch_page(val, TRUE, FALSE);
2685 on_journalDefaultBackground_activate (GtkMenuItem *menuitem,
2696 for (pglist = journal.pages; pglist!=NULL; pglist = pglist->next) {
2697 if (ui.bg_apply_all_pages) pg = (struct Page *)pglist->data;
2699 if (ui.bg_apply_all_pages) {
2700 if (pglist->next!=NULL) undo->multiop |= MULTIOP_CONT_REDO;
2701 if (pglist->prev!=NULL) undo->multiop |= MULTIOP_CONT_UNDO;
2703 undo->type = ITEM_NEW_BG_RESIZE;
2706 undo->val_x = pg->width;
2707 undo->val_y = pg->height;
2708 pg->bg = (struct Background *)g_memdup(ui.default_page.bg, sizeof(struct Background));
2709 pg->width = ui.default_page.width;
2710 pg->height = ui.default_page.height;
2711 pg->bg->canvas_item = undo->bg->canvas_item;
2712 undo->bg->canvas_item = NULL;
2714 make_page_clipbox(pg);
2715 update_canvas_bg(pg);
2716 if (!ui.bg_apply_all_pages) break;
2718 do_switch_page(ui.pageno, TRUE, TRUE);
2723 on_journalSetAsDefault_activate (GtkMenuItem *menuitem,
2726 if (ui.cur_page->bg->type != BG_SOLID) return;
2731 undo->type = ITEM_NEW_DEFAULT_BG;
2732 undo->val_x = ui.default_page.width;
2733 undo->val_y = ui.default_page.height;
2734 undo->bg = ui.default_page.bg;
2736 ui.default_page.width = ui.cur_page->width;
2737 ui.default_page.height = ui.cur_page->height;
2738 ui.default_page.bg = (struct Background *)g_memdup(ui.cur_page->bg, sizeof(struct Background));
2739 ui.default_page.bg->canvas_item = NULL;
2744 on_comboStdSizes_changed (GtkComboBox *combobox,
2748 GtkComboBox *comboUnit;
2752 if (papersize_need_init) {
2753 gtk_combo_box_set_active(combobox, papersize_std);
2754 papersize_need_init = FALSE;
2756 val = gtk_combo_box_get_active(combobox);
2757 if (val == -1 || val == papersize_std) return;
2758 papersize_std = val;
2759 if (val == STD_SIZE_CUSTOM) return;
2760 papersize_unit = std_units[val];
2761 papersize_width = std_widths[val];
2762 papersize_height = std_heights[val];
2764 comboUnit = GTK_COMBO_BOX(g_object_get_data(G_OBJECT(papersize_dialog), "comboUnit"));
2765 gtk_combo_box_set_active(comboUnit, papersize_unit);
2766 entry = GTK_ENTRY(g_object_get_data(G_OBJECT(papersize_dialog), "entryWidth"));
2767 g_snprintf(text, 20, "%.2f", papersize_width/unit_sizes[papersize_unit]);
2768 if (g_str_has_suffix(text, ".00"))
2769 g_snprintf(text, 20, "%d", (int) (papersize_width/unit_sizes[papersize_unit]));
2770 gtk_entry_set_text(entry, text);
2771 entry = GTK_ENTRY(g_object_get_data(G_OBJECT(papersize_dialog), "entryHeight"));
2772 g_snprintf(text, 20, "%.2f", papersize_height/unit_sizes[papersize_unit]);
2773 if (g_str_has_suffix(text, ".00"))
2774 g_snprintf(text, 20, "%d", (int) (papersize_height/unit_sizes[papersize_unit]));
2775 gtk_entry_set_text(entry, text);
2780 on_entryWidth_changed (GtkEditable *editable,
2786 GtkComboBox *comboStdSizes;
2788 text = gtk_entry_get_text(GTK_ENTRY(editable));
2789 val = strtod(text, &ptr);
2790 papersize_width_valid = (*ptr == 0 && val > 0.);
2791 if (!papersize_width_valid) return; // invalid entry
2792 val *= unit_sizes[papersize_unit];
2793 if (fabs(val - papersize_width) < 0.1) return; // no change
2794 papersize_std = STD_SIZE_CUSTOM;
2795 papersize_width = val;
2796 comboStdSizes = GTK_COMBO_BOX(g_object_get_data(G_OBJECT(papersize_dialog), "comboStdSizes"));
2797 gtk_combo_box_set_active(comboStdSizes, papersize_std);
2802 on_entryHeight_changed (GtkEditable *editable,
2808 GtkComboBox *comboStdSizes;
2810 text = gtk_entry_get_text(GTK_ENTRY(editable));
2811 val = strtod(text, &ptr);
2812 papersize_height_valid = (*ptr == 0 && val > 0.);
2813 if (!papersize_height_valid) return; // invalid entry
2814 val *= unit_sizes[papersize_unit];
2815 if (fabs(val - papersize_height) < 0.1) return; // no change
2816 papersize_std = STD_SIZE_CUSTOM;
2817 papersize_height = val;
2818 comboStdSizes = GTK_COMBO_BOX(g_object_get_data(G_OBJECT(papersize_dialog), "comboStdSizes"));
2819 gtk_combo_box_set_active(comboStdSizes, papersize_std);
2824 on_comboUnit_changed (GtkComboBox *combobox,
2831 val = gtk_combo_box_get_active(combobox);
2832 if (val == -1 || val == papersize_unit) return;
2833 papersize_unit = val;
2834 entry = GTK_ENTRY(g_object_get_data(G_OBJECT(papersize_dialog), "entryWidth"));
2835 if (papersize_width_valid) {
2836 g_snprintf(text, 20, "%.2f", papersize_width/unit_sizes[papersize_unit]);
2837 if (g_str_has_suffix(text, ".00"))
2838 g_snprintf(text, 20, "%d", (int) (papersize_width/unit_sizes[papersize_unit]));
2840 gtk_entry_set_text(entry, text);
2841 if (papersize_height_valid) {
2842 entry = GTK_ENTRY(g_object_get_data(G_OBJECT(papersize_dialog), "entryHeight"));
2843 g_snprintf(text, 20, "%.2f", papersize_height/unit_sizes[papersize_unit]);
2844 if (g_str_has_suffix(text, ".00"))
2845 g_snprintf(text, 20, "%d", (int) (papersize_height/unit_sizes[papersize_unit]));
2847 gtk_entry_set_text(entry, text);
2852 on_viewFullscreen_activate (GtkMenuItem *menuitem,
2857 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_CHECK_MENU_ITEM)
2858 active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
2860 active = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem));
2862 if (active == ui.fullscreen) return;
2865 ui.fullscreen = active;
2866 gtk_check_menu_item_set_active(
2867 GTK_CHECK_MENU_ITEM(GET_COMPONENT("viewFullscreen")), ui.fullscreen);
2868 gtk_toggle_tool_button_set_active(
2869 GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonFullscreen")), ui.fullscreen);
2871 if (ui.fullscreen) gtk_window_fullscreen(GTK_WINDOW(winMain));
2872 else gtk_window_unfullscreen(GTK_WINDOW(winMain));
2874 update_vbox_order(ui.vertical_order[ui.fullscreen?1:0]);
2879 on_optionsButtonMappings_activate (GtkMenuItem *menuitem,
2885 gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
2886 update_mappings_menu();
2891 on_optionsAntialiasBG_activate (GtkMenuItem *menuitem,
2896 active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
2897 if (ui.antialias_bg == active) return;
2900 ui.antialias_bg = active;
2901 rescale_bg_pixmaps();
2906 on_optionsProgressiveBG_activate (GtkMenuItem *menuitem,
2911 active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
2912 if (ui.progressive_bg == active) return;
2915 ui.progressive_bg = active;
2916 if (!ui.progressive_bg) rescale_bg_pixmaps();
2921 on_mru_activate (GtkMenuItem *menuitem,
2930 if (!ok_to_close()) return; // user aborted on save confirmation
2932 for (which = 0 ; which < MRU_SIZE; which++) {
2933 if (ui.mrumenu[which] == GTK_WIDGET(menuitem)) break;
2935 if (which == MRU_SIZE || ui.mru[which] == NULL) return; // not found...
2937 set_cursor_busy(TRUE);
2938 success = open_journal(ui.mru[which]);
2939 set_cursor_busy(FALSE);
2940 if (success) return;
2943 dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
2944 GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Error opening file '%s'", ui.mru[which]);
2945 gtk_dialog_run(GTK_DIALOG(dialog));
2946 gtk_widget_destroy(dialog);
2947 delete_mru_entry(which);
2952 on_button2Pen_activate (GtkMenuItem *menuitem,
2955 process_mapping_activate(menuitem, 1, TOOL_PEN);
2960 on_button2Eraser_activate (GtkMenuItem *menuitem,
2963 process_mapping_activate(menuitem, 1, TOOL_ERASER);
2968 on_button2Highlighter_activate (GtkMenuItem *menuitem,
2971 process_mapping_activate(menuitem, 1, TOOL_HIGHLIGHTER);
2976 on_button2Text_activate (GtkMenuItem *menuitem,
2979 process_mapping_activate(menuitem, 1, TOOL_TEXT);
2984 on_button2SelectRegion_activate (GtkMenuItem *menuitem,
2987 process_mapping_activate(menuitem, 1, TOOL_SELECTREGION);
2992 on_button2SelectRectangle_activate (GtkMenuItem *menuitem,
2995 process_mapping_activate(menuitem, 1, TOOL_SELECTRECT);
3000 on_button2VerticalSpace_activate (GtkMenuItem *menuitem,
3003 process_mapping_activate(menuitem, 1, TOOL_VERTSPACE);
3008 on_button2LinkBrush_activate (GtkMenuItem *menuitem,
3013 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem))) return;
3016 ui.linked_brush[1] = BRUSH_LINKED;
3017 for (i=0;i<NUM_STROKE_TOOLS;i++) update_mapping_linkings(i);
3022 on_button2CopyBrush_activate (GtkMenuItem *menuitem,
3025 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem))) return;
3028 if (ui.toolno[1] >= NUM_STROKE_TOOLS) {
3029 ui.linked_brush[1] = BRUSH_STATIC;
3030 update_mappings_menu_linkings();
3033 ui.linked_brush[1] = BRUSH_COPIED;
3034 g_memmove(&(ui.brushes[1][ui.toolno[1]]), &(ui.brushes[0][ui.toolno[1]]), sizeof(struct Brush));
3035 ui.ruler[1] = ui.ruler[0];
3036 if (ui.toolno[1]!=TOOL_PEN && ui.toolno[1]!=TOOL_HIGHLIGHTER)
3037 ui.ruler[1] = FALSE;
3042 on_button3Pen_activate (GtkMenuItem *menuitem,
3045 process_mapping_activate(menuitem, 2, TOOL_PEN);
3050 on_button3Eraser_activate (GtkMenuItem *menuitem,
3053 process_mapping_activate(menuitem, 2, TOOL_ERASER);
3058 on_button3Highlighter_activate (GtkMenuItem *menuitem,
3061 process_mapping_activate(menuitem, 2, TOOL_HIGHLIGHTER);
3066 on_button3Text_activate (GtkMenuItem *menuitem,
3069 process_mapping_activate(menuitem, 2, TOOL_TEXT);
3074 on_button3SelectRegion_activate (GtkMenuItem *menuitem,
3077 process_mapping_activate(menuitem, 2, TOOL_SELECTREGION);
3082 on_button3SelectRectangle_activate (GtkMenuItem *menuitem,
3085 process_mapping_activate(menuitem, 2, TOOL_SELECTRECT);
3090 on_button3VerticalSpace_activate (GtkMenuItem *menuitem,
3093 process_mapping_activate(menuitem, 2, TOOL_VERTSPACE);
3098 on_button3LinkBrush_activate (GtkMenuItem *menuitem,
3103 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem))) return;
3106 ui.linked_brush[2] = BRUSH_LINKED;
3107 for (i=0;i<NUM_STROKE_TOOLS;i++) update_mapping_linkings(i);
3112 on_button3CopyBrush_activate (GtkMenuItem *menuitem,
3115 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem))) return;
3118 if (ui.toolno[2] >= NUM_STROKE_TOOLS) {
3119 ui.linked_brush[2] = BRUSH_STATIC;
3120 update_mappings_menu_linkings();
3123 ui.linked_brush[2] = BRUSH_COPIED;
3124 g_memmove(&(ui.brushes[2][ui.toolno[2]]), &(ui.brushes[0][ui.toolno[2]]), sizeof(struct Brush));
3125 ui.ruler[2] = ui.ruler[0];
3126 if (ui.toolno[2]!=TOOL_PEN && ui.toolno[2]!=TOOL_HIGHLIGHTER)
3127 ui.ruler[2] = FALSE;
3130 // the set zoom dialog
3132 GtkWidget *zoom_dialog;
3133 double zoom_percent;
3136 on_viewSetZoom_activate (GtkMenuItem *menuitem,
3140 double test_w, test_h;
3141 GtkSpinButton *spinZoom;
3145 zoom_dialog = create_zoomDialog();
3146 zoom_percent = 100*ui.zoom / DEFAULT_ZOOM;
3147 spinZoom = GTK_SPIN_BUTTON(g_object_get_data(G_OBJECT(zoom_dialog), "spinZoom"));
3148 gtk_spin_button_set_increments(spinZoom, ui.zoom_step_increment, 5*ui.zoom_step_increment);
3149 gtk_spin_button_set_value(spinZoom, zoom_percent);
3150 test_w = 100*(GTK_WIDGET(canvas))->allocation.width/ui.cur_page->width/DEFAULT_ZOOM;
3151 test_h = 100*(GTK_WIDGET(canvas))->allocation.height/ui.cur_page->height/DEFAULT_ZOOM;
3152 if (zoom_percent > 99.9 && zoom_percent < 100.1)
3153 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_object_get_data(
3154 G_OBJECT(zoom_dialog), "radioZoom100")), TRUE);
3155 else if (zoom_percent > test_w-0.1 && zoom_percent < test_w+0.1)
3156 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_object_get_data(
3157 G_OBJECT(zoom_dialog), "radioZoomWidth")), TRUE);
3158 else if (zoom_percent > test_h-0.1 && zoom_percent < test_h+0.1)
3159 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_object_get_data(
3160 G_OBJECT(zoom_dialog), "radioZoomHeight")), TRUE);
3161 else gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_object_get_data(
3162 G_OBJECT(zoom_dialog), "radioZoom")), TRUE);
3163 gtk_widget_show(zoom_dialog);
3166 response = gtk_dialog_run(GTK_DIALOG(zoom_dialog));
3167 if (response == GTK_RESPONSE_OK || response == GTK_RESPONSE_APPLY) {
3168 ui.zoom = DEFAULT_ZOOM*zoom_percent/100;
3169 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
3170 rescale_text_items();
3171 rescale_bg_pixmaps();
3173 } while (response == GTK_RESPONSE_APPLY);
3175 gtk_widget_destroy(zoom_dialog);
3180 on_spinZoom_value_changed (GtkSpinButton *spinbutton,
3185 val = gtk_spin_button_get_value(GTK_SPIN_BUTTON(g_object_get_data(
3186 G_OBJECT(zoom_dialog), "spinZoom")));
3188 if (val<10) val=10.;
3189 if (val>1500) val=1500.;
3190 if (val<zoom_percent-1 || val>zoom_percent+1)
3191 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_object_get_data(
3192 G_OBJECT(zoom_dialog), "radioZoom")), TRUE);
3198 on_radioZoom_toggled (GtkToggleButton *togglebutton,
3206 on_radioZoom100_toggled (GtkToggleButton *togglebutton,
3209 if (!gtk_toggle_button_get_active(togglebutton)) return;
3210 zoom_percent = 100.;
3211 gtk_spin_button_set_value(GTK_SPIN_BUTTON(g_object_get_data(
3212 G_OBJECT(zoom_dialog), "spinZoom")), zoom_percent);
3217 on_radioZoomWidth_toggled (GtkToggleButton *togglebutton,
3220 if (!gtk_toggle_button_get_active(togglebutton)) return;
3221 zoom_percent = 100*(GTK_WIDGET(canvas))->allocation.width/ui.cur_page->width/DEFAULT_ZOOM;
3222 gtk_spin_button_set_value(GTK_SPIN_BUTTON(g_object_get_data(
3223 G_OBJECT(zoom_dialog), "spinZoom")), zoom_percent);
3228 on_radioZoomHeight_toggled (GtkToggleButton *togglebutton,
3231 if (!gtk_toggle_button_get_active(togglebutton)) return;
3232 zoom_percent = 100*(GTK_WIDGET(canvas))->allocation.height/ui.cur_page->height/DEFAULT_ZOOM;
3233 gtk_spin_button_set_value(GTK_SPIN_BUTTON(g_object_get_data(
3234 G_OBJECT(zoom_dialog), "spinZoom")), zoom_percent);
3239 on_toolsHand_activate (GtkMenuItem *menuitem,
3242 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
3243 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
3246 if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
3250 if (ui.cur_mapping != 0) return;
3251 if (ui.toolno[0] == TOOL_HAND) return;
3256 ui.toolno[0] = TOOL_HAND;
3257 ui.ruler[0] = FALSE;
3258 update_mapping_linkings(-1);
3259 update_tool_buttons();
3261 update_color_menu();
3267 on_button2Hand_activate (GtkMenuItem *menuitem,
3270 process_mapping_activate(menuitem, 1, TOOL_HAND);
3275 on_button3Hand_activate (GtkMenuItem *menuitem,
3278 process_mapping_activate(menuitem, 2, TOOL_HAND);
3283 on_optionsPrintRuling_activate (GtkMenuItem *menuitem,
3288 ui.print_ruling = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
3292 on_optionsDiscardCore_activate (GtkMenuItem *menuitem,
3297 ui.discard_corepointer =
3298 gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
3299 update_mappings_menu();
3303 on_fontButton_font_set (GtkFontButton *fontbutton,
3308 str = g_strdup(gtk_font_button_get_font_name(fontbutton));
3309 process_font_sel(str);