2 * This program is free software; you can redistribute it and/or
3 * modify it under the terms of the GNU General Public
4 * License as published by the Free Software Foundation; either
5 * version 2 of the License, or (at your option) any later version.
7 * This software is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
10 * General Public License for more details.
12 * You should have received a copy of the GNU General Public License
13 * along with this program. If not, see <http://www.gnu.org/licenses/>.
24 #include <libgnomecanvas/libgnomecanvas.h>
26 #include <glib/gstdio.h>
27 #include <gdk/gdkkeysyms.h>
30 #include "xo-callbacks.h"
31 #include "xo-interface.h"
32 #include "xo-support.h"
37 #include "xo-shapes.h"
40 on_fileNew_activate (GtkMenuItem *menuitem,
44 if (close_journal()) {
46 ui.zoom = ui.startup_zoom;
48 gtk_adjustment_set_value(gtk_layout_get_vadjustment(GTK_LAYOUT(canvas)), 0);
49 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
55 on_fileNewBackground_activate (GtkMenuItem *menuitem,
58 GtkWidget *dialog, *attach_opt;
59 GtkFileFilter *filt_all, *filt_pdf;
65 if (!ok_to_close()) return; // user aborted on save confirmation
67 dialog = gtk_file_chooser_dialog_new(_("Open PDF"), GTK_WINDOW (winMain),
68 GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
69 GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL);
70 #ifdef FILE_DIALOG_SIZE_BUGFIX
71 gtk_window_set_default_size(GTK_WINDOW(dialog), 500, 400);
74 filt_all = gtk_file_filter_new();
75 gtk_file_filter_set_name(filt_all, _("All files"));
76 gtk_file_filter_add_pattern(filt_all, "*");
77 filt_pdf = gtk_file_filter_new();
78 gtk_file_filter_set_name(filt_pdf, _("PDF files"));
79 gtk_file_filter_add_pattern(filt_pdf, "*.pdf");
80 gtk_file_filter_add_pattern(filt_pdf, "*.PDF");
81 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_pdf);
82 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_all);
84 if (ui.default_path!=NULL) gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (dialog), ui.default_path);
86 attach_opt = gtk_check_button_new_with_label(_("Attach file to the journal"));
87 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(attach_opt), FALSE);
88 gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER (dialog), attach_opt);
90 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
91 gtk_widget_destroy(dialog);
94 filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
95 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(attach_opt)))
96 file_domain = DOMAIN_ATTACH;
97 else file_domain = DOMAIN_ABSOLUTE;
99 gtk_widget_destroy(dialog);
101 set_cursor_busy(TRUE);
102 ui.saved = TRUE; // force close_journal to work
104 while (bgpdf.status != STATUS_NOT_INIT) {
105 // waiting for pdf processes to finish dying
106 gtk_main_iteration();
109 ui.zoom = ui.startup_zoom;
110 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
112 success = init_bgpdf(filename, TRUE, file_domain);
113 set_cursor_busy(FALSE);
120 dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
121 GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Error opening file '%s'"), filename);
122 gtk_dialog_run(GTK_DIALOG(dialog));
123 gtk_widget_destroy(dialog);
129 on_fileOpen_activate (GtkMenuItem *menuitem,
133 GtkFileFilter *filt_all, *filt_xoj;
138 if (!ok_to_close()) return; // user aborted on save confirmation
140 dialog = gtk_file_chooser_dialog_new(_("Open Journal"), GTK_WINDOW (winMain),
141 GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
142 GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL);
143 #ifdef FILE_DIALOG_SIZE_BUGFIX
144 gtk_window_set_default_size(GTK_WINDOW(dialog), 500, 400);
147 filt_all = gtk_file_filter_new();
148 gtk_file_filter_set_name(filt_all, _("All files"));
149 gtk_file_filter_add_pattern(filt_all, "*");
150 filt_xoj = gtk_file_filter_new();
151 gtk_file_filter_set_name(filt_xoj, _("Xournal files"));
152 gtk_file_filter_add_pattern(filt_xoj, "*.xoj");
153 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_xoj);
154 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_all);
156 if (ui.default_path!=NULL) gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (dialog), ui.default_path);
158 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
159 gtk_widget_destroy(dialog);
162 filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
163 gtk_widget_destroy(dialog);
165 set_cursor_busy(TRUE);
166 success = open_journal(filename);
167 set_cursor_busy(FALSE);
168 if (success) { g_free(filename); return; }
171 dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
172 GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Error opening file '%s'"), filename);
173 gtk_dialog_run(GTK_DIALOG(dialog));
174 gtk_widget_destroy(dialog);
181 on_fileSave_activate (GtkMenuItem *menuitem,
187 if (ui.filename == NULL) {
188 on_fileSaveAs_activate(menuitem, user_data);
191 set_cursor_busy(TRUE);
192 if (save_journal(ui.filename)) { // success
193 set_cursor_busy(FALSE);
197 set_cursor_busy(FALSE);
199 dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
200 GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Error saving file '%s'"), ui.filename);
201 gtk_dialog_run(GTK_DIALOG(dialog));
202 gtk_widget_destroy(dialog);
207 on_fileSaveAs_activate (GtkMenuItem *menuitem,
210 GtkWidget *dialog, *warning_dialog;
211 GtkFileFilter *filt_all, *filt_xoj;
216 struct stat stat_buf;
219 dialog = gtk_file_chooser_dialog_new(_("Save Journal"), GTK_WINDOW (winMain),
220 GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
221 GTK_STOCK_SAVE, GTK_RESPONSE_OK, NULL);
222 #ifdef FILE_DIALOG_SIZE_BUGFIX
223 gtk_window_set_default_size(GTK_WINDOW(dialog), 500, 400);
226 if (ui.filename!=NULL) {
227 gtk_file_chooser_set_filename(GTK_FILE_CHOOSER (dialog), ui.filename);
228 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), g_basename(ui.filename));
231 if (bgpdf.status!=STATUS_NOT_INIT && bgpdf.file_domain == DOMAIN_ABSOLUTE
232 && bgpdf.filename != NULL) {
233 filename = g_strdup_printf("%s.xoj", bgpdf.filename->s);
234 gtk_file_chooser_set_filename(GTK_FILE_CHOOSER (dialog), filename);
235 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), g_basename(filename));
239 curtime = time(NULL);
240 strftime(stime, 30, "%Y-%m-%d-Note-%H-%M.xoj", localtime(&curtime));
241 if (ui.default_path!=NULL)
242 gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (dialog), ui.default_path);
243 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), stime);
246 filt_all = gtk_file_filter_new();
247 gtk_file_filter_set_name(filt_all, _("All files"));
248 gtk_file_filter_add_pattern(filt_all, "*");
249 filt_xoj = gtk_file_filter_new();
250 gtk_file_filter_set_name(filt_xoj, _("Xournal files"));
251 gtk_file_filter_add_pattern(filt_xoj, "*.xoj");
252 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_xoj);
253 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_all);
255 // somehow this doesn't seem to be set by default
256 gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
259 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
260 gtk_widget_destroy(dialog);
263 filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
264 warn = g_file_test (filename, G_FILE_TEST_EXISTS);
265 if (warn) { // ok to overwrite an empty file
266 if (!g_stat(filename, &stat_buf))
267 if (stat_buf.st_size == 0) warn=FALSE;
269 if (warn && ui.filename!=NULL) { // ok to overwrite oneself
270 if (ui.filename[0]=='/' && !strcmp(ui.filename, filename)) warn=FALSE;
271 if (ui.filename[0]!='/' && g_str_has_suffix(filename, ui.filename)) warn=FALSE;
274 warning_dialog = gtk_message_dialog_new(GTK_WINDOW(winMain),
275 GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO,
276 _("Should the file %s be overwritten?"), filename);
277 if (gtk_dialog_run(GTK_DIALOG(warning_dialog)) == GTK_RESPONSE_YES)
279 gtk_widget_destroy(warning_dialog);
283 gtk_widget_destroy(dialog);
285 set_cursor_busy(TRUE);
286 if (save_journal(filename)) { // success
288 set_cursor_busy(FALSE);
289 update_file_name(filename);
292 set_cursor_busy(FALSE);
294 dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
295 GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Error saving file '%s'"), filename);
296 gtk_dialog_run(GTK_DIALOG(dialog));
297 gtk_widget_destroy(dialog);
303 on_filePrintOptions_activate (GtkMenuItem *menuitem,
310 on_filePrint_activate (GtkMenuItem *menuitem,
313 #if GTK_CHECK_VERSION(2, 10, 0)
314 GtkPrintOperation *print;
315 GtkPrintOperationResult res;
317 int fromPage, toPage;
322 if (!gtk_check_version(2, 10, 0)) {
323 print = gtk_print_operation_new();
325 if (!ui.print_settings)
326 ui.print_settings = gtk_print_settings_new();
327 if (ui.filename!=NULL) {
328 if (g_str_has_suffix(ui.filename, ".xoj")) {
329 in_fn = g_strdup(ui.filename);
330 g_strlcpy(g_strrstr(in_fn, "xoj"), "pdf", 4);
332 else in_fn = g_strdup_printf("%s.pdf", ui.filename);
333 gtk_print_settings_set(ui.print_settings, GTK_PRINT_SETTINGS_OUTPUT_URI,
334 g_filename_to_uri(in_fn, NULL, NULL));
338 if (ui.print_settings!=NULL)
339 gtk_print_operation_set_print_settings (print, ui.print_settings);
340 gtk_print_operation_set_n_pages(print, journal.npages);
341 gtk_print_operation_set_current_page(print, ui.pageno);
342 gtk_print_operation_set_show_progress(print, TRUE);
343 if (ui.filename!=NULL) {
344 p = g_utf8_strrchr(ui.filename, -1, '/');
345 if (p==NULL) p = ui.filename;
347 gtk_print_operation_set_job_name(print, p);
349 g_signal_connect (print, "draw_page", G_CALLBACK (print_job_render_page), NULL);
350 res = gtk_print_operation_run(print, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG,
351 GTK_WINDOW(winMain), NULL);
352 if (res == GTK_PRINT_OPERATION_RESULT_APPLY) {
353 if (ui.print_settings!=NULL) g_object_unref(ui.print_settings);
354 ui.print_settings = g_object_ref(gtk_print_operation_get_print_settings(print));
356 g_object_unref(print);
363 on_filePrintPDF_activate (GtkMenuItem *menuitem,
367 GtkWidget *dialog, *warning_dialog;
368 GtkFileFilter *filt_all, *filt_pdf;
369 char *filename, *in_fn;
375 dialog = gtk_file_chooser_dialog_new(_("Export to PDF"), GTK_WINDOW (winMain),
376 GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
377 GTK_STOCK_SAVE, GTK_RESPONSE_OK, NULL);
378 #ifdef FILE_DIALOG_SIZE_BUGFIX
379 gtk_window_set_default_size(GTK_WINDOW(dialog), 500, 400);
382 if (ui.filename!=NULL) {
383 if (g_str_has_suffix(ui.filename, ".xoj")) {
384 in_fn = g_strdup(ui.filename);
385 g_strlcpy(g_strrstr(in_fn, "xoj"), "pdf", 4);
388 in_fn = g_strdup_printf("%s.pdf", ui.filename);
389 gtk_file_chooser_set_filename(GTK_FILE_CHOOSER (dialog), in_fn);
390 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), g_basename(in_fn));
392 curtime = time(NULL);
393 strftime(stime, 30, "%Y-%m-%d-Note-%H-%M.pdf", localtime(&curtime));
394 if (ui.default_path!=NULL)
395 gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (dialog), ui.default_path);
396 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), stime);
400 filt_all = gtk_file_filter_new();
401 gtk_file_filter_set_name(filt_all, _("All files"));
402 gtk_file_filter_add_pattern(filt_all, "*");
403 filt_pdf = gtk_file_filter_new();
404 gtk_file_filter_set_name(filt_pdf, _("PDF files"));
405 gtk_file_filter_add_pattern(filt_pdf, "*.pdf");
406 gtk_file_filter_add_pattern(filt_pdf, "*.PDF");
407 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_pdf);
408 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_all);
409 gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
413 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
414 gtk_widget_destroy(dialog);
417 filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
418 warn = g_file_test(filename, G_FILE_TEST_EXISTS);
420 warning_dialog = gtk_message_dialog_new(GTK_WINDOW(winMain),
421 GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO,
422 _("Should the file %s be overwritten?"), filename);
423 if (gtk_dialog_run(GTK_DIALOG(warning_dialog)) == GTK_RESPONSE_YES)
425 gtk_widget_destroy(warning_dialog);
429 gtk_widget_destroy(dialog);
431 set_cursor_busy(TRUE);
432 if (!print_to_pdf(filename)) {
433 set_cursor_busy(FALSE);
434 dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
435 GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Error creating file '%s'"), filename);
436 gtk_dialog_run(GTK_DIALOG(dialog));
437 gtk_widget_destroy(dialog);
439 set_cursor_busy(FALSE);
445 on_fileQuit_activate (GtkMenuItem *menuitem,
449 if (ok_to_close()) gtk_main_quit ();
454 on_editUndo_activate (GtkMenuItem *menuitem,
458 GList *list, *itemlist;
459 struct UndoErasureData *erasure;
461 struct Brush tmp_brush;
462 struct Background *tmp_bg;
465 GnomeCanvasGroup *group;
468 if (undo == NULL) return; // nothing to undo!
469 reset_selection(); // safer
470 reset_recognizer(); // safer
471 if (undo->type == ITEM_STROKE || undo->type == ITEM_TEXT || undo->type == ITEM_IMAGE) {
472 // we're keeping the stroke info, but deleting the canvas item
473 gtk_object_destroy(GTK_OBJECT(undo->item->canvas_item));
474 undo->item->canvas_item = NULL;
475 // we also remove the object from its layer!
476 undo->layer->items = g_list_remove(undo->layer->items, undo->item);
477 undo->layer->nitems--;
479 else if (undo->type == ITEM_ERASURE || undo->type == ITEM_RECOGNIZER) {
480 for (list = undo->erasurelist; list!=NULL; list = list->next) {
481 erasure = (struct UndoErasureData *)list->data;
482 // delete all the created items
483 for (itemlist = erasure->replacement_items; itemlist!=NULL; itemlist = itemlist->next) {
484 it = (struct Item *)itemlist->data;
485 gtk_object_destroy(GTK_OBJECT(it->canvas_item));
486 it->canvas_item = NULL;
487 undo->layer->items = g_list_remove(undo->layer->items, it);
488 undo->layer->nitems--;
490 // recreate the deleted one
491 make_canvas_item_one(undo->layer->group, erasure->item);
493 undo->layer->items = g_list_insert(undo->layer->items, erasure->item,
495 if (erasure->npos == 0)
496 lower_canvas_item_to(undo->layer->group, erasure->item->canvas_item, NULL);
498 lower_canvas_item_to(undo->layer->group, erasure->item->canvas_item,
499 ((struct Item *)g_list_nth_data(undo->layer->items, erasure->npos-1))->canvas_item);
500 undo->layer->nitems++;
503 else if (undo->type == ITEM_NEW_BG_ONE || undo->type == ITEM_NEW_BG_RESIZE
504 || undo->type == ITEM_PAPER_RESIZE) {
505 if (undo->type != ITEM_PAPER_RESIZE) {
507 tmp_bg = undo->page->bg;
508 undo->page->bg = undo->bg;
510 undo->page->bg->canvas_item = undo->bg->canvas_item;
511 undo->bg->canvas_item = NULL;
513 if (undo->type != ITEM_NEW_BG_ONE) {
514 tmp_x = undo->page->width;
515 tmp_y = undo->page->height;
516 undo->page->width = undo->val_x;
517 undo->page->height = undo->val_y;
520 make_page_clipbox(undo->page);
522 update_canvas_bg(undo->page);
523 do_switch_page(g_list_index(journal.pages, undo->page), TRUE, TRUE);
525 else if (undo->type == ITEM_NEW_DEFAULT_BG) {
526 tmp_bg = ui.default_page.bg;
527 ui.default_page.bg = undo->bg;
529 tmp_x = ui.default_page.width;
530 tmp_y = ui.default_page.height;
531 ui.default_page.width = undo->val_x;
532 ui.default_page.height = undo->val_y;
536 else if (undo->type == ITEM_NEW_PAGE) {
537 // unmap the page; keep the page & its empty layer in memory
538 if (undo->page->group!=NULL) gtk_object_destroy(GTK_OBJECT(undo->page->group));
539 // also destroys the background and layer's canvas items
540 undo->page->group = NULL;
541 undo->page->bg->canvas_item = NULL;
542 journal.pages = g_list_remove(journal.pages, undo->page);
544 if (ui.cur_page == undo->page) ui.cur_page = NULL;
545 // so do_switch_page() won't try to remap the layers of the defunct page
546 if (ui.pageno >= undo->val) ui.pageno--;
547 if (ui.pageno < 0) ui.pageno = 0;
548 do_switch_page(ui.pageno, TRUE, TRUE);
550 else if (undo->type == ITEM_DELETE_PAGE) {
551 journal.pages = g_list_insert(journal.pages, undo->page, undo->val);
553 make_canvas_items(); // re-create the canvas items
554 do_switch_page(undo->val, TRUE, TRUE);
556 else if (undo->type == ITEM_MOVESEL) {
557 for (itemlist = undo->itemlist; itemlist != NULL; itemlist = itemlist->next) {
558 it = (struct Item *)itemlist->data;
559 if (it->canvas_item != NULL) {
560 if (undo->layer != undo->layer2)
561 gnome_canvas_item_reparent(it->canvas_item, undo->layer->group);
562 gnome_canvas_item_move(it->canvas_item, -undo->val_x, -undo->val_y);
565 move_journal_items_by(undo->itemlist, -undo->val_x, -undo->val_y,
566 undo->layer2, undo->layer, undo->auxlist);
568 else if (undo->type == ITEM_RESIZESEL) {
569 resize_journal_items_by(undo->itemlist,
570 1/undo->scaling_x, 1/undo->scaling_y,
571 -undo->val_x/undo->scaling_x, -undo->val_y/undo->scaling_y);
573 else if (undo->type == ITEM_PASTE) {
574 for (itemlist = undo->itemlist; itemlist != NULL; itemlist = itemlist->next) {
575 it = (struct Item *)itemlist->data;
576 gtk_object_destroy(GTK_OBJECT(it->canvas_item));
577 it->canvas_item = NULL;
578 undo->layer->items = g_list_remove(undo->layer->items, it);
579 undo->layer->nitems--;
582 else if (undo->type == ITEM_NEW_LAYER) {
583 // unmap the layer; keep the empty layer in memory
584 if (undo->layer->group!=NULL) gtk_object_destroy(GTK_OBJECT(undo->layer->group));
585 undo->layer->group = NULL;
586 undo->page->layers = g_list_remove(undo->page->layers, undo->layer);
587 undo->page->nlayers--;
588 do_switch_page(ui.pageno, FALSE, FALSE); // don't stay with bad cur_layer info
590 else if (undo->type == ITEM_DELETE_LAYER) {
591 // special case of -1: deleted the last layer, created a new one
592 if (undo->val == -1) {
593 if (undo->layer2->group!=NULL) gtk_object_destroy(GTK_OBJECT(undo->layer2->group));
594 undo->layer2->group = NULL;
595 undo->page->layers = g_list_remove(undo->page->layers, undo->layer2);
596 undo->page->nlayers--;
599 undo->layer->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
600 undo->page->group, gnome_canvas_group_get_type(), NULL);
601 lower_canvas_item_to(undo->page->group, GNOME_CANVAS_ITEM(undo->layer->group),
602 (undo->val >= 1) ? GNOME_CANVAS_ITEM(((struct Layer *)
603 g_list_nth_data(undo->page->layers, undo->val-1))->group) :
604 undo->page->bg->canvas_item);
605 undo->page->layers = g_list_insert(undo->page->layers, undo->layer,
606 (undo->val >= 0) ? undo->val:0);
607 undo->page->nlayers++;
609 for (itemlist = undo->layer->items; itemlist!=NULL; itemlist = itemlist->next)
610 make_canvas_item_one(undo->layer->group, (struct Item *)itemlist->data);
612 do_switch_page(ui.pageno, FALSE, FALSE); // show the restored layer & others...
614 else if (undo->type == ITEM_REPAINTSEL) {
615 for (itemlist = undo->itemlist, list = undo->auxlist; itemlist!=NULL;
616 itemlist = itemlist->next, list = list->next) {
617 it = (struct Item *)itemlist->data;
618 g_memmove(&tmp_brush, &(it->brush), sizeof(struct Brush));
619 g_memmove(&(it->brush), list->data, sizeof(struct Brush));
620 g_memmove(list->data, &tmp_brush, sizeof(struct Brush));
621 if (it->type == ITEM_STROKE && it->canvas_item != NULL) {
622 // remark: a variable-width item might have lost its variable-width
623 group = (GnomeCanvasGroup *) it->canvas_item->parent;
624 gtk_object_destroy(GTK_OBJECT(it->canvas_item));
625 make_canvas_item_one(group, it);
627 if (it->type == ITEM_TEXT && it->canvas_item != NULL)
628 gnome_canvas_item_set(it->canvas_item,
629 "fill-color-rgba", it->brush.color_rgba, NULL);
632 else if (undo->type == ITEM_TEXT_EDIT) {
634 undo->str = undo->item->text;
635 undo->item->text = tmpstr;
636 gnome_canvas_item_set(undo->item->canvas_item, "text", tmpstr, NULL);
637 update_item_bbox(undo->item);
639 else if (undo->type == ITEM_TEXT_ATTRIB) {
641 undo->str = undo->item->font_name;
642 undo->item->font_name = tmpstr;
644 undo->val_x = undo->item->font_size;
645 undo->item->font_size = tmp_x;
646 g_memmove(&tmp_brush, undo->brush, sizeof(struct Brush));
647 g_memmove(undo->brush, &(undo->item->brush), sizeof(struct Brush));
648 g_memmove(&(undo->item->brush), &tmp_brush, sizeof(struct Brush));
649 gnome_canvas_item_set(undo->item->canvas_item,
650 "fill-color-rgba", undo->item->brush.color_rgba, NULL);
651 update_text_item_displayfont(undo->item);
652 update_item_bbox(undo->item);
655 // move item from undo to redo stack
661 update_undo_redo_enabled();
662 if (u->multiop & MULTIOP_CONT_UNDO) on_editUndo_activate(NULL,NULL); // loop
667 on_editRedo_activate (GtkMenuItem *menuitem,
671 GList *list, *itemlist, *target;
672 struct UndoErasureData *erasure;
674 struct Brush tmp_brush;
675 struct Background *tmp_bg;
679 GnomeCanvasGroup *group;
682 if (redo == NULL) return; // nothing to redo!
683 reset_selection(); // safer
684 reset_recognizer(); // safer
685 if (redo->type == ITEM_STROKE || redo->type == ITEM_TEXT || redo->type == ITEM_IMAGE) {
686 // re-create the canvas_item
687 make_canvas_item_one(redo->layer->group, redo->item);
688 // reinsert the item on its layer
689 redo->layer->items = g_list_append(redo->layer->items, redo->item);
690 redo->layer->nitems++;
692 else if (redo->type == ITEM_ERASURE || redo->type == ITEM_RECOGNIZER) {
693 for (list = redo->erasurelist; list!=NULL; list = list->next) {
694 erasure = (struct UndoErasureData *)list->data;
695 target = g_list_find(redo->layer->items, erasure->item);
696 // re-create all the created items
697 for (itemlist = erasure->replacement_items; itemlist!=NULL; itemlist = itemlist->next) {
698 it = (struct Item *)itemlist->data;
699 make_canvas_item_one(redo->layer->group, it);
700 redo->layer->items = g_list_insert_before(redo->layer->items, target, it);
701 redo->layer->nitems++;
702 lower_canvas_item_to(redo->layer->group, it->canvas_item, erasure->item->canvas_item);
704 // re-delete the deleted one
705 gtk_object_destroy(GTK_OBJECT(erasure->item->canvas_item));
706 erasure->item->canvas_item = NULL;
707 redo->layer->items = g_list_delete_link(redo->layer->items, target);
708 redo->layer->nitems--;
711 else if (redo->type == ITEM_NEW_BG_ONE || redo->type == ITEM_NEW_BG_RESIZE
712 || redo->type == ITEM_PAPER_RESIZE) {
713 if (redo->type != ITEM_PAPER_RESIZE) {
715 tmp_bg = redo->page->bg;
716 redo->page->bg = redo->bg;
718 redo->page->bg->canvas_item = redo->bg->canvas_item;
719 redo->bg->canvas_item = NULL;
721 if (redo->type != ITEM_NEW_BG_ONE) {
722 tmp_x = redo->page->width;
723 tmp_y = redo->page->height;
724 redo->page->width = redo->val_x;
725 redo->page->height = redo->val_y;
728 make_page_clipbox(redo->page);
730 update_canvas_bg(redo->page);
731 do_switch_page(g_list_index(journal.pages, redo->page), TRUE, TRUE);
733 else if (redo->type == ITEM_NEW_DEFAULT_BG) {
734 tmp_bg = ui.default_page.bg;
735 ui.default_page.bg = redo->bg;
737 tmp_x = ui.default_page.width;
738 tmp_y = ui.default_page.height;
739 ui.default_page.width = redo->val_x;
740 ui.default_page.height = redo->val_y;
744 else if (redo->type == ITEM_NEW_PAGE) {
746 redo->page->bg->canvas_item = NULL;
747 redo->page->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
748 gnome_canvas_root(canvas), gnome_canvas_clipgroup_get_type(), NULL);
749 make_page_clipbox(redo->page);
750 update_canvas_bg(redo->page);
751 l = (struct Layer *)redo->page->layers->data;
752 l->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
753 redo->page->group, gnome_canvas_group_get_type(), NULL);
755 journal.pages = g_list_insert(journal.pages, redo->page, redo->val);
757 do_switch_page(redo->val, TRUE, TRUE);
759 else if (redo->type == ITEM_DELETE_PAGE) {
760 // unmap all the canvas items
761 gtk_object_destroy(GTK_OBJECT(redo->page->group));
762 redo->page->group = NULL;
763 redo->page->bg->canvas_item = NULL;
764 for (list = redo->page->layers; list!=NULL; list = list->next) {
765 l = (struct Layer *)list->data;
766 for (itemlist = l->items; itemlist!=NULL; itemlist = itemlist->next)
767 ((struct Item *)itemlist->data)->canvas_item = NULL;
770 journal.pages = g_list_remove(journal.pages, redo->page);
772 if (ui.pageno > redo->val || ui.pageno == journal.npages) ui.pageno--;
774 // so do_switch_page() won't try to remap the layers of the defunct page
775 do_switch_page(ui.pageno, TRUE, TRUE);
777 else if (redo->type == ITEM_MOVESEL) {
778 for (itemlist = redo->itemlist; itemlist != NULL; itemlist = itemlist->next) {
779 it = (struct Item *)itemlist->data;
780 if (it->canvas_item != NULL) {
781 if (redo->layer != redo->layer2)
782 gnome_canvas_item_reparent(it->canvas_item, redo->layer2->group);
783 gnome_canvas_item_move(it->canvas_item, redo->val_x, redo->val_y);
786 move_journal_items_by(redo->itemlist, redo->val_x, redo->val_y,
787 redo->layer, redo->layer2, NULL);
789 else if (redo->type == ITEM_RESIZESEL) {
790 resize_journal_items_by(redo->itemlist,
791 redo->scaling_x, redo->scaling_y, redo->val_x, redo->val_y);
793 else if (redo->type == ITEM_PASTE) {
794 for (itemlist = redo->itemlist; itemlist != NULL; itemlist = itemlist->next) {
795 it = (struct Item *)itemlist->data;
796 make_canvas_item_one(redo->layer->group, it);
797 redo->layer->items = g_list_append(redo->layer->items, it);
798 redo->layer->nitems++;
801 else if (redo->type == ITEM_NEW_LAYER) {
802 redo->layer->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
803 redo->page->group, gnome_canvas_group_get_type(), NULL);
804 lower_canvas_item_to(redo->page->group, GNOME_CANVAS_ITEM(redo->layer->group),
805 (redo->val >= 1) ? GNOME_CANVAS_ITEM(((struct Layer *)
806 g_list_nth_data(redo->page->layers, redo->val-1))->group) :
807 redo->page->bg->canvas_item);
808 redo->page->layers = g_list_insert(redo->page->layers, redo->layer, redo->val);
809 redo->page->nlayers++;
810 do_switch_page(ui.pageno, FALSE, FALSE);
812 else if (redo->type == ITEM_DELETE_LAYER) {
813 gtk_object_destroy(GTK_OBJECT(redo->layer->group));
814 redo->layer->group = NULL;
815 for (list=redo->layer->items; list!=NULL; list=list->next)
816 ((struct Item *)list->data)->canvas_item = NULL;
817 redo->page->layers = g_list_remove(redo->page->layers, redo->layer);
818 redo->page->nlayers--;
819 if (redo->val == -1) {
820 redo->layer2->group = (GnomeCanvasGroup *)gnome_canvas_item_new(
821 redo->page->group, gnome_canvas_group_get_type(), NULL);
822 redo->page->layers = g_list_append(redo->page->layers, redo->layer2);
823 redo->page->nlayers++;
825 do_switch_page(ui.pageno, FALSE, FALSE);
827 else if (redo->type == ITEM_REPAINTSEL) {
828 for (itemlist = redo->itemlist, list = redo->auxlist; itemlist!=NULL;
829 itemlist = itemlist->next, list = list->next) {
830 it = (struct Item *)itemlist->data;
831 g_memmove(&tmp_brush, &(it->brush), sizeof(struct Brush));
832 g_memmove(&(it->brush), list->data, sizeof(struct Brush));
833 g_memmove(list->data, &tmp_brush, sizeof(struct Brush));
834 if (it->type == ITEM_STROKE && it->canvas_item != NULL) {
835 // remark: a variable-width item might have lost its variable-width
836 group = (GnomeCanvasGroup *) it->canvas_item->parent;
837 gtk_object_destroy(GTK_OBJECT(it->canvas_item));
838 make_canvas_item_one(group, it);
840 if (it->type == ITEM_TEXT && it->canvas_item != NULL)
841 gnome_canvas_item_set(it->canvas_item,
842 "fill-color-rgba", it->brush.color_rgba, NULL);
843 if (it->type == ITEM_IMAGE && it->canvas_item != NULL) {
844 // remark: a variable-width item might have lost its variable-width
845 group = (GnomeCanvasGroup *) it->canvas_item->parent;
846 gtk_object_destroy(GTK_OBJECT(it->canvas_item));
847 make_canvas_item_one(group, it);
851 else if (redo->type == ITEM_TEXT_EDIT) {
853 redo->str = redo->item->text;
854 redo->item->text = tmpstr;
855 gnome_canvas_item_set(redo->item->canvas_item, "text", tmpstr, NULL);
856 update_item_bbox(redo->item);
858 else if (redo->type == ITEM_TEXT_ATTRIB) {
860 redo->str = redo->item->font_name;
861 redo->item->font_name = tmpstr;
863 redo->val_x = redo->item->font_size;
864 redo->item->font_size = tmp_x;
865 g_memmove(&tmp_brush, redo->brush, sizeof(struct Brush));
866 g_memmove(redo->brush, &(redo->item->brush), sizeof(struct Brush));
867 g_memmove(&(redo->item->brush), &tmp_brush, sizeof(struct Brush));
868 gnome_canvas_item_set(redo->item->canvas_item,
869 "fill-color-rgba", redo->item->brush.color_rgba, NULL);
870 update_text_item_displayfont(redo->item);
871 update_item_bbox(redo->item);
874 // move item from redo to undo stack
880 update_undo_redo_enabled();
881 if (u->multiop & MULTIOP_CONT_REDO) on_editRedo_activate(NULL,NULL); // loop
886 on_editCut_activate (GtkMenuItem *menuitem,
896 on_editCopy_activate (GtkMenuItem *menuitem,
905 on_editPaste_activate (GtkMenuItem *menuitem,
914 on_editDelete_activate (GtkMenuItem *menuitem,
923 on_viewContinuous_activate (GtkMenuItem *menuitem,
926 GtkAdjustment *v_adj;
930 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
931 if (ui.view_continuous) return;
932 ui.view_continuous = TRUE;
933 v_adj = gtk_layout_get_vadjustment(GTK_LAYOUT(canvas));
935 yscroll = gtk_adjustment_get_value(v_adj) - pg->voffset*ui.zoom;
937 gtk_adjustment_set_value(v_adj, yscroll + pg->voffset*ui.zoom);
939 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
944 on_viewOnePage_activate (GtkMenuItem *menuitem,
947 GtkAdjustment *v_adj;
950 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
951 if (!ui.view_continuous) return;
952 ui.view_continuous = FALSE;
953 v_adj = gtk_layout_get_vadjustment(GTK_LAYOUT(canvas));
954 yscroll = gtk_adjustment_get_value(v_adj) - ui.cur_page->voffset*ui.zoom;
956 gtk_adjustment_set_value(v_adj, yscroll + ui.cur_page->voffset*ui.zoom);
958 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
963 on_viewZoomIn_activate (GtkMenuItem *menuitem,
966 if (ui.zoom > MAX_ZOOM) return;
967 ui.zoom *= ui.zoom_step_factor;
968 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
969 rescale_text_items();
970 rescale_bg_pixmaps();
976 on_viewZoomOut_activate (GtkMenuItem *menuitem,
979 if (ui.zoom < MIN_ZOOM) return;
980 ui.zoom /= ui.zoom_step_factor;
981 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
982 rescale_text_items();
983 rescale_bg_pixmaps();
989 on_viewNormalSize_activate (GtkMenuItem *menuitem,
992 ui.zoom = DEFAULT_ZOOM;
993 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
994 rescale_text_items();
995 rescale_bg_pixmaps();
1001 on_viewPageWidth_activate (GtkMenuItem *menuitem,
1004 ui.zoom = (GTK_WIDGET(canvas))->allocation.width/ui.cur_page->width;
1005 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
1006 rescale_text_items();
1007 rescale_bg_pixmaps();
1013 on_viewFirstPage_activate (GtkMenuItem *menuitem,
1017 do_switch_page(0, TRUE, FALSE);
1022 on_viewPreviousPage_activate (GtkMenuItem *menuitem,
1026 if (ui.pageno == 0) return;
1027 do_switch_page(ui.pageno-1, TRUE, FALSE);
1032 on_viewNextPage_activate (GtkMenuItem *menuitem,
1036 if (ui.pageno == journal.npages-1) { // create a page at end
1037 on_journalNewPageEnd_activate(menuitem, user_data);
1040 do_switch_page(ui.pageno+1, TRUE, FALSE);
1045 on_viewLastPage_activate (GtkMenuItem *menuitem,
1049 do_switch_page(journal.npages-1, TRUE, FALSE);
1054 on_viewShowLayer_activate (GtkMenuItem *menuitem,
1058 if (ui.layerno == ui.cur_page->nlayers-1) return;
1061 ui.cur_layer = g_list_nth_data(ui.cur_page->layers, ui.layerno);
1062 gnome_canvas_item_show(GNOME_CANVAS_ITEM(ui.cur_layer->group));
1063 update_page_stuff();
1068 on_viewHideLayer_activate (GtkMenuItem *menuitem,
1072 if (ui.layerno == -1) return;
1074 gnome_canvas_item_hide(GNOME_CANVAS_ITEM(ui.cur_layer->group));
1076 if (ui.layerno<0) ui.cur_layer = NULL;
1077 else ui.cur_layer = g_list_nth_data(ui.cur_page->layers, ui.layerno);
1078 update_page_stuff();
1083 on_journalNewPageBefore_activate (GtkMenuItem *menuitem,
1090 pg = new_page(ui.cur_page);
1091 journal.pages = g_list_insert(journal.pages, pg, ui.pageno);
1093 do_switch_page(ui.pageno, TRUE, TRUE);
1096 undo->type = ITEM_NEW_PAGE;
1097 undo->val = ui.pageno;
1103 on_journalNewPageAfter_activate (GtkMenuItem *menuitem,
1110 pg = new_page(ui.cur_page);
1111 journal.pages = g_list_insert(journal.pages, pg, ui.pageno+1);
1113 do_switch_page(ui.pageno+1, TRUE, TRUE);
1116 undo->type = ITEM_NEW_PAGE;
1117 undo->val = ui.pageno;
1123 on_journalNewPageEnd_activate (GtkMenuItem *menuitem,
1130 pg = new_page((struct Page *)g_list_last(journal.pages)->data);
1131 journal.pages = g_list_append(journal.pages, pg);
1133 do_switch_page(journal.npages-1, TRUE, TRUE);
1136 undo->type = ITEM_NEW_PAGE;
1137 undo->val = ui.pageno;
1143 on_journalDeletePage_activate (GtkMenuItem *menuitem,
1146 GList *layerlist, *itemlist;
1150 if (journal.npages == 1) return;
1152 reset_recognizer(); // safer
1154 undo->type = ITEM_DELETE_PAGE;
1155 undo->val = ui.pageno;
1156 undo->page = ui.cur_page;
1158 // unmap all the canvas items
1159 gtk_object_destroy(GTK_OBJECT(ui.cur_page->group));
1160 ui.cur_page->group = NULL;
1161 ui.cur_page->bg->canvas_item = NULL;
1162 for (layerlist = ui.cur_page->layers; layerlist!=NULL; layerlist = layerlist->next) {
1163 l = (struct Layer *)layerlist->data;
1164 for (itemlist = l->items; itemlist!=NULL; itemlist = itemlist->next)
1165 ((struct Item *)itemlist->data)->canvas_item = NULL;
1169 journal.pages = g_list_remove(journal.pages, ui.cur_page);
1171 if (ui.pageno == journal.npages) ui.pageno--;
1173 // so do_switch_page() won't try to remap the layers of the defunct page
1174 do_switch_page(ui.pageno, TRUE, TRUE);
1179 on_journalNewLayer_activate (GtkMenuItem *menuitem,
1186 l = g_new(struct Layer, 1);
1189 l->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
1190 ui.cur_page->group, gnome_canvas_group_get_type(), NULL);
1191 lower_canvas_item_to(ui.cur_page->group, GNOME_CANVAS_ITEM(l->group),
1192 (ui.cur_layer!=NULL)?(GNOME_CANVAS_ITEM(ui.cur_layer->group)):(ui.cur_page->bg->canvas_item));
1193 ui.cur_page->layers = g_list_insert(ui.cur_page->layers, l, ui.layerno+1);
1196 ui.cur_page->nlayers++;
1197 update_page_stuff();
1200 undo->type = ITEM_NEW_LAYER;
1201 undo->val = ui.layerno;
1203 undo->page = ui.cur_page;
1208 on_journalDeleteLayer_activate (GtkMenuItem *menuitem,
1214 if (ui.cur_layer == NULL) return;
1216 reset_recognizer(); // safer
1218 undo->type = ITEM_DELETE_LAYER;
1219 undo->val = ui.layerno;
1220 undo->layer = ui.cur_layer;
1221 undo->layer2 = NULL;
1222 undo->page = ui.cur_page;
1223 // delete all the canvas items
1224 gtk_object_destroy(GTK_OBJECT(ui.cur_layer->group));
1225 ui.cur_layer->group = NULL;
1226 for (list=ui.cur_layer->items; list!=NULL; list=list->next)
1227 ((struct Item *)list->data)->canvas_item = NULL;
1229 ui.cur_page->layers = g_list_remove(ui.cur_page->layers, ui.cur_layer);
1231 if (ui.cur_page->nlayers>=2) {
1232 ui.cur_page->nlayers--;
1234 if (ui.layerno<0) ui.cur_layer = NULL;
1235 else ui.cur_layer = (struct Layer *)g_list_nth_data(ui.cur_page->layers, ui.layerno);
1237 else { // special case: can't remove the last layer
1238 ui.cur_layer = g_new(struct Layer, 1);
1239 ui.cur_layer->items = NULL;
1240 ui.cur_layer->nitems = 0;
1241 ui.cur_layer->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
1242 ui.cur_page->group, gnome_canvas_group_get_type(), NULL);
1243 ui.cur_page->layers = g_list_append(NULL, ui.cur_layer);
1245 undo->layer2 = ui.cur_layer;
1248 update_page_stuff();
1253 on_journalFlatten_activate (GtkMenuItem *menuitem,
1260 // the paper sizes dialog
1262 GtkWidget *papersize_dialog;
1263 int papersize_std, papersize_unit;
1264 double papersize_width, papersize_height;
1265 gboolean papersize_need_init, papersize_width_valid, papersize_height_valid;
1267 #define STD_SIZE_A4 0
1268 #define STD_SIZE_A4R 1
1269 #define STD_SIZE_LETTER 2
1270 #define STD_SIZE_LETTER_R 3
1271 #define STD_SIZE_CUSTOM 4
1273 double unit_sizes[4] = {28.346, 72., 72./DISPLAY_DPI_DEFAULT, 1.};
1274 double std_widths[STD_SIZE_CUSTOM] = {595.27, 841.89, 612., 792.};
1275 double std_heights[STD_SIZE_CUSTOM] = {841.89, 595.27, 792., 612.};
1276 double std_units[STD_SIZE_CUSTOM] = {UNIT_CM, UNIT_CM, UNIT_IN, UNIT_IN};
1279 on_journalPaperSize_activate (GtkMenuItem *menuitem,
1287 papersize_dialog = create_papersizeDialog();
1288 papersize_width = ui.cur_page->width;
1289 papersize_height = ui.cur_page->height;
1290 papersize_unit = ui.default_unit;
1291 unit_sizes[UNIT_PX] = 1./DEFAULT_ZOOM;
1292 // if (ui.cur_page->bg->type == BG_PIXMAP) papersize_unit = UNIT_PX;
1293 papersize_std = STD_SIZE_CUSTOM;
1294 for (i=0;i<STD_SIZE_CUSTOM;i++)
1295 if (fabs(papersize_width - std_widths[i])<0.1 &&
1296 fabs(papersize_height - std_heights[i])<0.1)
1297 { papersize_std = i; papersize_unit = std_units[i]; }
1298 papersize_need_init = TRUE;
1299 papersize_width_valid = papersize_height_valid = TRUE;
1301 gtk_widget_show(papersize_dialog);
1302 on_comboStdSizes_changed(GTK_COMBO_BOX(g_object_get_data(
1303 G_OBJECT(papersize_dialog), "comboStdSizes")), NULL);
1304 gtk_dialog_set_default_response(GTK_DIALOG(papersize_dialog), GTK_RESPONSE_OK);
1306 response = gtk_dialog_run(GTK_DIALOG(papersize_dialog));
1307 gtk_widget_destroy(papersize_dialog);
1308 if (response != GTK_RESPONSE_OK) return;
1311 for (pglist = journal.pages; pglist!=NULL; pglist = pglist->next) {
1312 if (ui.bg_apply_all_pages) pg = (struct Page *)pglist->data;
1314 if (ui.bg_apply_all_pages) {
1315 if (pglist->next!=NULL) undo->multiop |= MULTIOP_CONT_REDO;
1316 if (pglist->prev!=NULL) undo->multiop |= MULTIOP_CONT_UNDO;
1318 undo->type = ITEM_PAPER_RESIZE;
1320 undo->val_x = pg->width;
1321 undo->val_y = pg->height;
1322 if (papersize_width_valid) pg->width = papersize_width;
1323 if (papersize_height_valid) pg->height = papersize_height;
1324 make_page_clipbox(pg);
1325 update_canvas_bg(pg);
1326 if (!ui.bg_apply_all_pages) break;
1328 do_switch_page(ui.pageno, TRUE, TRUE);
1333 on_papercolorWhite_activate (GtkMenuItem *menuitem,
1337 process_papercolor_activate(menuitem, COLOR_WHITE, predef_bgcolors_rgba[COLOR_WHITE]);
1342 on_papercolorYellow_activate (GtkMenuItem *menuitem,
1346 process_papercolor_activate(menuitem, COLOR_YELLOW, predef_bgcolors_rgba[COLOR_YELLOW]);
1351 on_papercolorPink_activate (GtkMenuItem *menuitem,
1355 process_papercolor_activate(menuitem, COLOR_RED, predef_bgcolors_rgba[COLOR_RED]);
1360 on_papercolorOrange_activate (GtkMenuItem *menuitem,
1364 process_papercolor_activate(menuitem, COLOR_ORANGE, predef_bgcolors_rgba[COLOR_ORANGE]);
1369 on_papercolorBlue_activate (GtkMenuItem *menuitem,
1373 process_papercolor_activate(menuitem, COLOR_BLUE, predef_bgcolors_rgba[COLOR_BLUE]);
1378 on_papercolorGreen_activate (GtkMenuItem *menuitem,
1382 process_papercolor_activate(menuitem, COLOR_GREEN, predef_bgcolors_rgba[COLOR_GREEN]);
1387 on_papercolorOther_activate (GtkMenuItem *menuitem,
1391 GtkColorSelection *colorsel;
1397 dialog = gtk_color_selection_dialog_new(_("Pick a Paper Color"));
1398 colorsel = GTK_COLOR_SELECTION(GTK_COLOR_SELECTION_DIALOG(dialog)->colorsel);
1399 if (ui.cur_page->bg->type == BG_SOLID) rgba = ui.cur_page->bg->color_rgba;
1400 else rgba = ui.default_page.bg->color_rgba;
1401 rgb_to_gdkcolor(rgba, &gdkcolor);
1402 gtk_color_selection_set_current_color(colorsel, &gdkcolor);
1404 if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK) {
1405 gtk_color_selection_get_current_color(colorsel, &gdkcolor);
1406 process_papercolor_activate(menuitem, COLOR_OTHER, gdkcolor_to_rgba(gdkcolor, 0xffff));
1408 gtk_widget_destroy(dialog);
1413 on_paperstylePlain_activate (GtkMenuItem *menuitem,
1417 process_paperstyle_activate(menuitem, RULING_NONE);
1422 on_paperstyleLined_activate (GtkMenuItem *menuitem,
1426 process_paperstyle_activate(menuitem, RULING_LINED);
1431 on_paperstyleRuled_activate (GtkMenuItem *menuitem,
1435 process_paperstyle_activate(menuitem, RULING_RULED);
1440 on_paperstyleGraph_activate (GtkMenuItem *menuitem,
1444 process_paperstyle_activate(menuitem, RULING_GRAPH);
1449 on_journalLoadBackground_activate (GtkMenuItem *menuitem,
1452 GtkWidget *dialog, *attach_opt;
1453 struct Background *bg;
1456 GList *bglist, *bglistiter;
1457 GtkFileFilter *filt_all, *filt_pix, *filt_pspdf;
1462 dialog = gtk_file_chooser_dialog_new(_("Open Background"), GTK_WINDOW (winMain),
1463 GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1464 GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL);
1465 #ifdef FILE_DIALOG_SIZE_BUGFIX
1466 gtk_window_set_default_size(GTK_WINDOW(dialog), 500, 400);
1469 filt_all = gtk_file_filter_new();
1470 gtk_file_filter_set_name(filt_all, _("All files"));
1471 gtk_file_filter_add_pattern(filt_all, "*");
1472 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_all);
1474 #if GTK_CHECK_VERSION(2,6,0)
1476 if (!gtk_check_version(2, 6, 0)) {
1477 filt_pix = gtk_file_filter_new();
1478 gtk_file_filter_set_name(filt_pix, _("Bitmap files"));
1479 gtk_file_filter_add_pixbuf_formats(filt_pix);
1480 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_pix);
1485 filt_pspdf = gtk_file_filter_new();
1486 gtk_file_filter_set_name(filt_pspdf, _("PS/PDF files (as bitmaps)"));
1487 gtk_file_filter_add_pattern(filt_pspdf, "*.ps");
1488 gtk_file_filter_add_pattern(filt_pspdf, "*.PS");
1489 gtk_file_filter_add_pattern(filt_pspdf, "*.pdf");
1490 gtk_file_filter_add_pattern(filt_pspdf, "*.PDF");
1491 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_pspdf);
1493 attach_opt = gtk_check_button_new_with_label(_("Attach file to the journal"));
1494 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(attach_opt), FALSE);
1495 gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER (dialog), attach_opt);
1497 if (ui.default_path!=NULL) gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (dialog), ui.default_path);
1499 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
1500 gtk_widget_destroy(dialog);
1503 filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
1504 attach = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(attach_opt));
1505 gtk_widget_destroy(dialog);
1507 set_cursor_busy(TRUE);
1508 bg = attempt_load_pix_bg(filename, attach);
1509 if (bg != NULL) bglist = g_list_append(NULL, bg);
1510 else bglist = attempt_load_gv_bg(filename);
1511 set_cursor_busy(FALSE);
1513 if (bglist == NULL) {
1514 dialog = gtk_message_dialog_new(GTK_WINDOW(winMain), GTK_DIALOG_MODAL,
1515 GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
1516 _("Error opening background '%s'"), filename);
1517 gtk_dialog_run(GTK_DIALOG(dialog));
1518 gtk_widget_destroy(dialog);
1527 for (bglistiter = bglist, pageno = ui.pageno;
1528 bglistiter!=NULL; bglistiter = bglistiter->next, pageno++) {
1530 if (bglistiter->next!=NULL) undo->multiop |= MULTIOP_CONT_REDO;
1531 if (bglistiter->prev!=NULL) undo->multiop |= MULTIOP_CONT_UNDO;
1533 bg = (struct Background *)bglistiter->data;
1535 if (pageno == journal.npages) {
1536 undo->type = ITEM_NEW_PAGE;
1537 pg = new_page_with_bg(bg,
1538 gdk_pixbuf_get_width(bg->pixbuf)/bg->pixbuf_scale,
1539 gdk_pixbuf_get_height(bg->pixbuf)/bg->pixbuf_scale);
1540 journal.pages = g_list_append(journal.pages, pg);
1546 pg = g_list_nth_data(journal.pages, pageno);
1547 undo->type = ITEM_NEW_BG_RESIZE;
1550 bg->canvas_item = undo->bg->canvas_item;
1551 undo->bg->canvas_item = NULL;
1552 undo->val_x = pg->width;
1553 undo->val_y = pg->height;
1555 pg->width = gdk_pixbuf_get_width(bg->pixbuf)/bg->pixbuf_scale;
1556 pg->height = gdk_pixbuf_get_height(bg->pixbuf)/bg->pixbuf_scale;
1557 make_page_clipbox(pg);
1558 update_canvas_bg(pg);
1562 g_list_free(bglist);
1563 if (ui.zoom != DEFAULT_ZOOM) {
1564 ui.zoom = DEFAULT_ZOOM;
1565 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
1566 rescale_text_items();
1567 rescale_bg_pixmaps();
1570 do_switch_page(ui.pageno, TRUE, TRUE);
1574 on_journalScreenshot_activate (GtkMenuItem *menuitem,
1577 struct Background *bg;
1581 gtk_window_iconify(GTK_WINDOW(winMain)); // hide ourselves
1582 gdk_display_sync(gdk_display_get_default());
1584 if (ui.cursor!=NULL)
1585 gdk_cursor_unref(ui.cursor);
1586 ui.cursor = gdk_cursor_new(GDK_TCROSS);
1588 bg = attempt_screenshot_bg();
1590 gtk_window_deiconify(GTK_WINDOW(winMain));
1592 if (bg==NULL) return;
1595 undo->type = ITEM_NEW_BG_RESIZE;
1596 undo->page = ui.cur_page;
1597 undo->bg = ui.cur_page->bg;
1598 bg->canvas_item = undo->bg->canvas_item;
1599 undo->bg->canvas_item = NULL;
1600 undo->val_x = ui.cur_page->width;
1601 undo->val_y = ui.cur_page->height;
1603 ui.cur_page->bg = bg;
1604 ui.cur_page->width = gdk_pixbuf_get_width(bg->pixbuf)/bg->pixbuf_scale;
1605 ui.cur_page->height = gdk_pixbuf_get_height(bg->pixbuf)/bg->pixbuf_scale;
1607 make_page_clipbox(ui.cur_page);
1608 update_canvas_bg(ui.cur_page);
1610 if (ui.zoom != DEFAULT_ZOOM) {
1611 ui.zoom = DEFAULT_ZOOM;
1612 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
1613 rescale_text_items();
1614 rescale_bg_pixmaps();
1617 do_switch_page(ui.pageno, TRUE, TRUE);
1622 on_journalApplyAllPages_activate (GtkMenuItem *menuitem,
1628 active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
1629 if (active == ui.bg_apply_all_pages) return;
1630 ui.bg_apply_all_pages = active;
1631 update_page_stuff();
1633 /* THIS IS THE OLD VERSION OF THE FEATURE -- APPLIED CURRENT BG TO ALL
1637 if (ui.cur_page->bg->type != BG_SOLID) return;
1639 for (pglist = journal.pages; pglist!=NULL; pglist = pglist->next) {
1640 page = (struct Page *)pglist->data;
1642 undo->type = ITEM_NEW_BG_RESIZE;
1644 undo->bg = page->bg;
1645 undo->val_x = page->width;
1646 undo->val_y = page->height;
1647 if (pglist->next!=NULL) undo->multiop |= MULTIOP_CONT_REDO;
1648 if (pglist->prev!=NULL) undo->multiop |= MULTIOP_CONT_UNDO;
1649 page->bg = (struct Background *)g_memdup(ui.cur_page->bg, sizeof(struct Background));
1650 page->width = ui.cur_page->width;
1651 page->height = ui.cur_page->height;
1652 page->bg->canvas_item = undo->bg->canvas_item;
1653 undo->bg->canvas_item = NULL;
1655 make_page_clipbox(page);
1656 update_canvas_bg(page);
1658 do_switch_page(ui.pageno, TRUE, TRUE);
1665 on_toolsPen_activate (GtkMenuItem *menuitem,
1668 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1669 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1672 if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1676 if (ui.cur_mapping != 0 && !ui.button_switch_mapping) return; // not user-generated
1677 if (ui.toolno[ui.cur_mapping] == TOOL_PEN) return;
1679 ui.cur_mapping = 0; // don't use switch_mapping() (refreshes buttons too soon)
1682 ui.toolno[ui.cur_mapping] = TOOL_PEN;
1683 ui.cur_brush = &(ui.brushes[ui.cur_mapping][TOOL_PEN]);
1684 ui.cur_brush->ruler = ui.default_brushes[TOOL_PEN].ruler;
1685 ui.cur_brush->recognizer = ui.default_brushes[TOOL_PEN].recognizer;
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 && !ui.button_switch_mapping) return; // not user-generated
1707 if (ui.toolno[ui.cur_mapping] == TOOL_ERASER) return;
1709 ui.cur_mapping = 0; // don't use switch_mapping() (refreshes buttons too soon)
1712 ui.toolno[ui.cur_mapping] = TOOL_ERASER;
1713 ui.cur_brush = &(ui.brushes[ui.cur_mapping][TOOL_ERASER]);
1714 update_mapping_linkings(TOOL_ERASER);
1715 update_tool_buttons();
1717 update_color_menu();
1723 on_toolsHighlighter_activate (GtkMenuItem *menuitem,
1726 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1727 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1730 if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1734 if (ui.cur_mapping != 0 && !ui.button_switch_mapping) return; // not user-generated
1735 if (ui.toolno[ui.cur_mapping] == TOOL_HIGHLIGHTER) return;
1737 ui.cur_mapping = 0; // don't use switch_mapping() (refreshes buttons too soon)
1740 ui.toolno[ui.cur_mapping] = TOOL_HIGHLIGHTER;
1741 ui.cur_brush = &(ui.brushes[ui.cur_mapping][TOOL_HIGHLIGHTER]);
1742 ui.cur_brush->ruler = ui.default_brushes[TOOL_HIGHLIGHTER].ruler;
1743 ui.cur_brush->recognizer = ui.default_brushes[TOOL_HIGHLIGHTER].recognizer;
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 && !ui.button_switch_mapping) return; // not user-generated
1765 if (ui.toolno[ui.cur_mapping] == TOOL_TEXT) return;
1767 ui.cur_mapping = 0; // don't use switch_mapping() (refreshes buttons too soon)
1769 ui.toolno[ui.cur_mapping] = TOOL_TEXT;
1770 ui.cur_brush = &(ui.brushes[ui.cur_mapping][TOOL_PEN]);
1771 update_mapping_linkings(-1);
1772 update_tool_buttons();
1774 update_color_menu();
1780 on_toolsImage_activate (GtkMenuItem *menuitem,
1783 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1784 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1787 if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1791 if (ui.cur_mapping != 0 && !ui.button_switch_mapping) return; // not user-generated
1792 if (ui.toolno[ui.cur_mapping] == TOOL_IMAGE) return;
1794 ui.cur_mapping = 0; // don't use switch_mapping() (refreshes buttons too soon)
1797 ui.toolno[ui.cur_mapping] = TOOL_IMAGE;
1798 update_mapping_linkings(-1);
1799 update_tool_buttons();
1801 update_color_menu();
1807 on_toolsSelectRegion_activate (GtkMenuItem *menuitem,
1815 on_toolsSelectRectangle_activate (GtkMenuItem *menuitem,
1818 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1819 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1822 if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1826 if (ui.cur_mapping != 0 && !ui.button_switch_mapping) return; // not user-generated
1827 if (ui.toolno[ui.cur_mapping] == TOOL_SELECTRECT) return;
1829 ui.cur_mapping = 0; // don't use switch_mapping() (refreshes buttons too soon)
1831 ui.toolno[ui.cur_mapping] = TOOL_SELECTRECT;
1832 update_mapping_linkings(-1);
1833 update_tool_buttons();
1835 update_color_menu();
1841 on_toolsVerticalSpace_activate (GtkMenuItem *menuitem,
1844 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1845 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1848 if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1852 if (ui.cur_mapping != 0 && !ui.button_switch_mapping) return; // not user-generated
1853 if (ui.toolno[ui.cur_mapping] == TOOL_VERTSPACE) return;
1855 ui.cur_mapping = 0; // don't use switch_mapping() (refreshes buttons too soon)
1858 ui.toolno[ui.cur_mapping] = TOOL_VERTSPACE;
1859 update_mapping_linkings(-1);
1860 update_tool_buttons();
1862 update_color_menu();
1868 on_colorBlack_activate (GtkMenuItem *menuitem,
1871 process_color_activate(menuitem, COLOR_BLACK, predef_colors_rgba[COLOR_BLACK]);
1876 on_colorBlue_activate (GtkMenuItem *menuitem,
1879 process_color_activate(menuitem, COLOR_BLUE, predef_colors_rgba[COLOR_BLUE]);
1884 on_colorRed_activate (GtkMenuItem *menuitem,
1887 process_color_activate(menuitem, COLOR_RED, predef_colors_rgba[COLOR_RED]);
1892 on_colorGreen_activate (GtkMenuItem *menuitem,
1895 process_color_activate(menuitem, COLOR_GREEN, predef_colors_rgba[COLOR_GREEN]);
1900 on_colorGray_activate (GtkMenuItem *menuitem,
1903 process_color_activate(menuitem, COLOR_GRAY, predef_colors_rgba[COLOR_GRAY]);
1908 on_colorLightBlue_activate (GtkMenuItem *menuitem,
1911 process_color_activate(menuitem, COLOR_LIGHTBLUE, predef_colors_rgba[COLOR_LIGHTBLUE]);
1916 on_colorLightGreen_activate (GtkMenuItem *menuitem,
1919 process_color_activate(menuitem, COLOR_LIGHTGREEN, predef_colors_rgba[COLOR_LIGHTGREEN]);
1924 on_colorMagenta_activate (GtkMenuItem *menuitem,
1927 process_color_activate(menuitem, COLOR_MAGENTA, predef_colors_rgba[COLOR_MAGENTA]);
1932 on_colorOrange_activate (GtkMenuItem *menuitem,
1935 process_color_activate(menuitem, COLOR_ORANGE, predef_colors_rgba[COLOR_ORANGE]);
1940 on_colorYellow_activate (GtkMenuItem *menuitem,
1943 process_color_activate(menuitem, COLOR_YELLOW, predef_colors_rgba[COLOR_YELLOW]);
1948 on_colorWhite_activate (GtkMenuItem *menuitem,
1951 process_color_activate(menuitem, COLOR_WHITE, predef_colors_rgba[COLOR_WHITE]);
1956 on_colorOther_activate (GtkMenuItem *menuitem,
1959 gtk_button_clicked(GTK_BUTTON(GET_COMPONENT("buttonColorChooser")));
1964 on_penthicknessVeryFine_activate (GtkMenuItem *menuitem,
1967 process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_VERYFINE);
1972 on_penthicknessFine_activate (GtkMenuItem *menuitem,
1975 process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_FINE);
1980 on_penthicknessMedium_activate (GtkMenuItem *menuitem,
1983 process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_MEDIUM);
1988 on_penthicknessThick_activate (GtkMenuItem *menuitem,
1991 process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_THICK);
1996 on_penthicknessVeryThick_activate (GtkMenuItem *menuitem,
1999 process_thickness_activate(menuitem, TOOL_PEN, THICKNESS_VERYTHICK);
2004 on_eraserFine_activate (GtkMenuItem *menuitem,
2007 process_thickness_activate(menuitem, TOOL_ERASER, THICKNESS_FINE);
2012 on_eraserMedium_activate (GtkMenuItem *menuitem,
2015 process_thickness_activate(menuitem, TOOL_ERASER, THICKNESS_MEDIUM);
2020 on_eraserThick_activate (GtkMenuItem *menuitem,
2023 process_thickness_activate(menuitem, TOOL_ERASER, THICKNESS_THICK);
2028 on_eraserStandard_activate (GtkMenuItem *menuitem,
2031 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
2033 ui.brushes[0][TOOL_ERASER].tool_options = TOOLOPT_ERASER_STANDARD;
2034 update_mapping_linkings(TOOL_ERASER);
2039 on_eraserWhiteout_activate (GtkMenuItem *menuitem,
2042 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
2044 ui.brushes[0][TOOL_ERASER].tool_options = TOOLOPT_ERASER_WHITEOUT;
2045 update_mapping_linkings(TOOL_ERASER);
2050 on_eraserDeleteStrokes_activate (GtkMenuItem *menuitem,
2053 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem))) return;
2055 ui.brushes[0][TOOL_ERASER].tool_options = TOOLOPT_ERASER_STROKES;
2056 update_mapping_linkings(TOOL_ERASER);
2061 on_highlighterFine_activate (GtkMenuItem *menuitem,
2064 process_thickness_activate(menuitem, TOOL_HIGHLIGHTER, THICKNESS_FINE);
2069 on_highlighterMedium_activate (GtkMenuItem *menuitem,
2072 process_thickness_activate(menuitem, TOOL_HIGHLIGHTER, THICKNESS_MEDIUM);
2077 on_highlighterThick_activate (GtkMenuItem *menuitem,
2080 process_thickness_activate(menuitem, TOOL_HIGHLIGHTER, THICKNESS_THICK);
2085 on_toolsTextFont_activate (GtkMenuItem *menuitem,
2091 dialog = gtk_font_selection_dialog_new(_("Select Font"));
2092 str = make_cur_font_name();
2093 gtk_font_selection_dialog_set_font_name(GTK_FONT_SELECTION_DIALOG(dialog), str);
2095 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
2096 gtk_widget_destroy(dialog);
2099 str = gtk_font_selection_dialog_get_font_name(GTK_FONT_SELECTION_DIALOG(dialog));
2100 gtk_widget_destroy(dialog);
2101 process_font_sel(str);
2105 on_toolsDefaultPen_activate (GtkMenuItem *menuitem,
2111 g_memmove(&(ui.brushes[0][TOOL_PEN]), ui.default_brushes+TOOL_PEN, sizeof(struct Brush));
2112 ui.toolno[0] = TOOL_PEN;
2113 ui.cur_brush = &(ui.brushes[0][TOOL_PEN]);
2114 update_mapping_linkings(TOOL_PEN);
2115 update_tool_buttons();
2117 update_pen_props_menu();
2118 update_color_menu();
2124 on_toolsDefaultEraser_activate (GtkMenuItem *menuitem,
2130 g_memmove(&(ui.brushes[0][TOOL_ERASER]), ui.default_brushes+TOOL_ERASER, sizeof(struct Brush));
2131 ui.toolno[0] = TOOL_ERASER;
2132 ui.cur_brush = &(ui.brushes[0][TOOL_ERASER]);
2133 update_mapping_linkings(TOOL_ERASER);
2134 update_tool_buttons();
2136 update_eraser_props_menu();
2137 update_color_menu();
2143 on_toolsDefaultHighlighter_activate (GtkMenuItem *menuitem,
2149 g_memmove(&(ui.brushes[0][TOOL_HIGHLIGHTER]), ui.default_brushes+TOOL_HIGHLIGHTER, sizeof(struct Brush));
2150 ui.toolno[0] = TOOL_HIGHLIGHTER;
2151 ui.cur_brush = &(ui.brushes[0][TOOL_HIGHLIGHTER]);
2152 update_mapping_linkings(TOOL_HIGHLIGHTER);
2153 update_tool_buttons();
2155 update_highlighter_props_menu();
2156 update_color_menu();
2161 on_toolsDefaultText_activate (GtkMenuItem *menuitem,
2165 if (ui.toolno[0]!=TOOL_TEXT) end_text();
2167 ui.toolno[0] = TOOL_TEXT;
2168 ui.cur_brush = &(ui.brushes[0][TOOL_PEN]);
2169 ui.cur_brush->color_no = ui.default_brushes[TOOL_PEN].color_no;
2170 ui.cur_brush->color_rgba = ui.default_brushes[TOOL_PEN].color_rgba;
2171 g_free(ui.font_name);
2172 ui.font_name = g_strdup(ui.default_font_name);
2173 ui.font_size = ui.default_font_size;
2174 if (ui.cur_item_type == ITEM_TEXT) {
2175 refont_text_item(ui.cur_item, ui.font_name, ui.font_size);
2177 update_font_button();
2178 update_mapping_linkings(-1);
2179 update_tool_buttons();
2181 update_color_menu();
2187 on_toolsSetAsDefault_activate (GtkMenuItem *menuitem,
2192 if (ui.cur_mapping!=0 && !ui.button_switch_mapping) return;
2193 if (ui.toolno[ui.cur_mapping] < NUM_STROKE_TOOLS)
2194 g_memmove(ui.default_brushes+ui.toolno[ui.cur_mapping],
2195 &(ui.brushes[ui.cur_mapping][ui.toolno[ui.cur_mapping]]), sizeof(struct Brush));
2196 if (ui.toolno[ui.cur_mapping] == TOOL_TEXT) {
2197 if (ui.cur_item_type == ITEM_TEXT) {
2198 g_free(ui.font_name);
2199 ui.font_name = g_strdup(ui.cur_item->font_name);
2200 ui.font_size = ui.cur_item->font_size;
2202 else if (ui.selection!=NULL && ui.selection->items!=NULL &&
2203 ui.selection->items->next==NULL &&
2204 (it=(struct Item*)ui.selection->items->data)->type == ITEM_TEXT) {
2205 g_free(ui.font_name);
2206 ui.font_name = g_strdup(it->font_name);
2207 ui.font_size = it->font_size;
2209 g_free(ui.default_font_name);
2210 ui.default_font_name = g_strdup(ui.font_name);
2211 ui.default_font_size = ui.font_size;
2218 on_toolsRuler_activate (GtkMenuItem *menuitem,
2221 gboolean active, current;
2223 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_CHECK_MENU_ITEM)
2224 active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
2226 active = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem));
2228 if (ui.cur_mapping != 0 && !ui.button_switch_mapping) return;
2229 current = (ui.toolno[ui.cur_mapping] == TOOL_PEN || ui.toolno[ui.cur_mapping] == TOOL_HIGHLIGHTER) && ui.cur_brush->ruler;
2230 if (active == current) return;
2234 if (ui.toolno[ui.cur_mapping]!=TOOL_PEN && ui.toolno[ui.cur_mapping]!=TOOL_HIGHLIGHTER) {
2236 ui.toolno[ui.cur_mapping] = TOOL_PEN;
2237 ui.cur_brush = &(ui.brushes[ui.cur_mapping][TOOL_PEN]);
2238 update_color_menu();
2239 update_tool_buttons();
2244 ui.cur_brush->ruler = active;
2245 if (active) ui.cur_brush->recognizer = FALSE;
2246 update_mapping_linkings(ui.toolno[ui.cur_mapping]);
2247 update_ruler_indicator();
2252 on_toolsReco_activate (GtkMenuItem *menuitem,
2255 gboolean active, current;
2257 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_CHECK_MENU_ITEM)
2258 active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
2260 active = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem));
2262 if (ui.cur_mapping != 0 && !ui.button_switch_mapping) return;
2263 current = (ui.toolno[ui.cur_mapping] == TOOL_PEN || ui.toolno[ui.cur_mapping] == TOOL_HIGHLIGHTER) && ui.cur_brush->recognizer;
2264 if (active == current) return;
2268 if (ui.toolno[ui.cur_mapping]!=TOOL_PEN && ui.toolno[ui.cur_mapping]!=TOOL_HIGHLIGHTER) {
2270 ui.toolno[ui.cur_mapping] = TOOL_PEN;
2271 ui.cur_brush = &(ui.brushes[ui.cur_mapping][TOOL_PEN]);
2272 update_color_menu();
2273 update_tool_buttons();
2278 ui.cur_brush->recognizer = active;
2280 ui.cur_brush->ruler = FALSE;
2283 update_mapping_linkings(ui.toolno[ui.cur_mapping]);
2284 update_ruler_indicator();
2289 on_optionsSavePreferences_activate (GtkMenuItem *menuitem,
2293 save_config_to_file();
2298 on_helpIndex_activate (GtkMenuItem *menuitem,
2306 on_helpAbout_activate (GtkMenuItem *menuitem,
2309 GtkWidget *aboutDialog;
2310 GtkLabel *labelTitle;
2313 aboutDialog = create_aboutDialog ();
2314 labelTitle = GTK_LABEL(g_object_get_data(G_OBJECT(aboutDialog), "labelTitle"));
2315 gtk_label_set_markup(labelTitle,
2316 "<span size=\"xx-large\" weight=\"bold\">Xournal " VERSION_STRING "</span>");
2317 gtk_dialog_run (GTK_DIALOG(aboutDialog));
2318 gtk_widget_destroy(aboutDialog);
2323 on_buttonToolDefault_clicked (GtkToolButton *toolbutton,
2326 if (ui.toolno[0]==TOOL_TEXT) {
2327 on_toolsDefaultText_activate(NULL, NULL);
2332 if (ui.toolno[0] < NUM_STROKE_TOOLS) {
2333 g_memmove(&(ui.brushes[0][ui.toolno[0]]), ui.default_brushes+ui.toolno[0], sizeof(struct Brush));
2334 update_mapping_linkings(ui.toolno[0]);
2335 update_thickness_buttons();
2336 update_color_buttons();
2337 update_color_menu();
2338 if (ui.toolno[0] == TOOL_PEN) update_pen_props_menu();
2339 if (ui.toolno[0] == TOOL_ERASER) update_eraser_props_menu();
2340 if (ui.toolno[0] == TOOL_HIGHLIGHTER) update_highlighter_props_menu();
2347 on_buttonFine_clicked (GtkToolButton *toolbutton,
2350 if (ui.cur_mapping != 0 && !ui.button_switch_mapping) return;
2351 process_thickness_activate((GtkMenuItem*)toolbutton, ui.toolno[ui.cur_mapping], THICKNESS_FINE);
2356 on_buttonMedium_clicked (GtkToolButton *toolbutton,
2359 if (ui.cur_mapping != 0 && !ui.button_switch_mapping) return;
2360 process_thickness_activate((GtkMenuItem*)toolbutton, ui.toolno[ui.cur_mapping], THICKNESS_MEDIUM);
2365 on_buttonThick_clicked (GtkToolButton *toolbutton,
2368 if (ui.cur_mapping != 0 && !ui.button_switch_mapping) return;
2369 process_thickness_activate((GtkMenuItem*)toolbutton, ui.toolno[ui.cur_mapping], THICKNESS_THICK);
2374 on_canvas_button_press_event (GtkWidget *widget,
2375 GdkEventButton *event,
2383 GdkEvent scroll_event;
2386 printf("DEBUG: ButtonPress (%s) (x,y)=(%.2f,%.2f), button %d, modifier %x\n",
2387 event->device->name, event->x, event->y, event->button, event->state);
2390 // abort any page changes pending in the spin button, and take the focus
2391 gtk_spin_button_set_value(GTK_SPIN_BUTTON(GET_COMPONENT("spinPageNo")), ui.pageno+1);
2394 is_core = (event->device == gdk_device_get_core_pointer());
2395 if (!ui.use_xinput && !is_core) return FALSE;
2396 if (ui.use_xinput && is_core && ui.discard_corepointer) return FALSE;
2397 if (event->type != GDK_BUTTON_PRESS) return FALSE;
2398 // double-clicks may have broken axes member (free'd) due to a bug in GDK
2400 if (event->button > 3) { // scroll wheel events! don't paint...
2401 if (ui.use_xinput && !gtk_check_version(2, 17, 0) && event->button <= 7) {
2402 /* with GTK+ 2.17 and later, the entire widget hierarchy is xinput-aware,
2403 so the core button event gets discarded and the scroll event never
2404 gets processed by the main window. This is arguably a GTK+ bug.
2405 We work around it. */
2406 scroll_event.scroll.type = GDK_SCROLL;
2407 scroll_event.scroll.window = event->window;
2408 scroll_event.scroll.send_event = event->send_event;
2409 scroll_event.scroll.time = event->time;
2410 scroll_event.scroll.x = event->x;
2411 scroll_event.scroll.y = event->y;
2412 scroll_event.scroll.state = event->state;
2413 scroll_event.scroll.device = event->device;
2414 scroll_event.scroll.x_root = event->x_root;
2415 scroll_event.scroll.y_root = event->y_root;
2416 if (event->button == 4) scroll_event.scroll.direction = GDK_SCROLL_UP;
2417 else if (event->button == 5) scroll_event.scroll.direction = GDK_SCROLL_DOWN;
2418 else if (event->button == 6) scroll_event.scroll.direction = GDK_SCROLL_LEFT;
2419 else scroll_event.scroll.direction = GDK_SCROLL_RIGHT;
2420 gtk_widget_event(GET_COMPONENT("scrolledwindowMain"), &scroll_event);
2424 if ((event->state & (GDK_CONTROL_MASK|GDK_MOD1_MASK)) != 0) return FALSE;
2425 // no control-clicking or alt-clicking
2426 if (!is_core) gdk_device_get_state(event->device, event->window, event->axes, NULL);
2427 // synaptics touchpads send bogus axis values with ButtonDown
2429 fix_xinput_coords((GdkEvent *)event);
2431 if (!finite_sized(event->x) || !finite_sized(event->y)) return FALSE; // Xorg 7.3 bug
2433 if (ui.cur_item_type == ITEM_TEXT) {
2434 if (!is_event_within_textview(event)) end_text();
2437 if (ui.cur_item_type == ITEM_STROKE && ui.is_corestroke && !is_core &&
2438 ui.cur_path.num_points == 1) {
2439 // Xorg 7.3+ sent core event before XInput event: fix initial point
2440 ui.is_corestroke = FALSE;
2441 get_pointer_coords((GdkEvent *)event, ui.cur_path.coords);
2443 if (ui.cur_item_type != ITEM_NONE) return FALSE; // we're already doing something
2445 // if button_switch_mapping enabled, button 2 or 3 clicks only switch mapping
2446 if (ui.button_switch_mapping && event->button > 1) {
2447 ui.which_unswitch_button = event->button;
2448 switch_mapping(event->button-1);
2452 ui.is_corestroke = is_core;
2453 ui.stroke_device = event->device;
2455 if (ui.use_erasertip && event->device->source == GDK_SOURCE_ERASER)
2456 mapping = NUM_BUTTONS;
2457 else if (ui.button_switch_mapping) {
2458 mapping = ui.cur_mapping;
2459 if (!mapping && (event->state & GDK_BUTTON2_MASK)) mapping = 1;
2460 if (!mapping && (event->state & GDK_BUTTON3_MASK)) mapping = 2;
2462 else mapping = event->button-1;
2464 // check whether we're in a page
2465 get_pointer_coords((GdkEvent *)event, pt);
2466 set_current_page(pt);
2468 // can't paint on the background...
2470 if (ui.cur_layer == NULL) {
2472 dialog = gtk_message_dialog_new(GTK_WINDOW(winMain), GTK_DIALOG_MODAL,
2473 GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, _("Drawing is not allowed on the "
2474 "background layer.\n Switching to Layer 1."));
2475 gtk_dialog_run(GTK_DIALOG(dialog));
2476 gtk_widget_destroy(dialog);
2477 on_viewShowLayer_activate(NULL, NULL);
2481 // switch mappings if needed
2483 ui.which_mouse_button = event->button;
2484 switch_mapping(mapping);
2489 // in text tool, clicking in a text area edits it
2490 if (ui.toolno[mapping] == TOOL_TEXT) {
2491 item = click_is_in_text(ui.cur_layer, pt[0], pt[1]);
2494 start_text((GdkEvent *)event, item);
2499 // if this can be a selection move or resize, then it takes precedence over anything else
2500 if (start_resizesel((GdkEvent *)event)) return FALSE;
2501 if (start_movesel((GdkEvent *)event)) return FALSE;
2503 if (ui.toolno[mapping] != TOOL_SELECTREGION && ui.toolno[mapping] != TOOL_SELECTRECT)
2506 // process the event
2508 if (ui.toolno[mapping] == TOOL_HAND) {
2509 ui.cur_item_type = ITEM_HAND;
2510 get_pointer_coords((GdkEvent *)event, ui.hand_refpt);
2511 ui.hand_refpt[0] += ui.cur_page->hoffset;
2512 ui.hand_refpt[1] += ui.cur_page->voffset;
2514 else if (ui.toolno[mapping] == TOOL_PEN || ui.toolno[mapping] == TOOL_HIGHLIGHTER ||
2515 (ui.toolno[mapping] == TOOL_ERASER && ui.cur_brush->tool_options == TOOLOPT_ERASER_WHITEOUT)) {
2516 create_new_stroke((GdkEvent *)event);
2518 else if (ui.toolno[mapping] == TOOL_ERASER) {
2519 ui.cur_item_type = ITEM_ERASURE;
2520 do_eraser((GdkEvent *)event, ui.cur_brush->thickness/2,
2521 ui.cur_brush->tool_options == TOOLOPT_ERASER_STROKES);
2523 else if (ui.toolno[mapping] == TOOL_SELECTRECT) {
2524 start_selectrect((GdkEvent *)event);
2526 else if (ui.toolno[mapping] == TOOL_VERTSPACE) {
2527 start_vertspace((GdkEvent *)event);
2529 else if (ui.toolno[mapping] == TOOL_TEXT) {
2530 start_text((GdkEvent *)event, NULL);
2532 else if (ui.toolno[mapping] == TOOL_IMAGE) {
2533 insert_image((GdkEvent *)event);
2540 on_canvas_button_release_event (GtkWidget *widget,
2541 GdkEventButton *event,
2547 printf("DEBUG: ButtonRelease (%s) (x,y)=(%.2f,%.2f), button %d, modifier %x\n",
2548 event->device->name, event->x, event->y, event->button, event->state);
2551 is_core = (event->device == gdk_device_get_core_pointer());
2552 if (!ui.use_xinput && !is_core) return FALSE;
2553 if (ui.use_xinput && is_core && !ui.is_corestroke) return FALSE;
2554 if (!is_core) fix_xinput_coords((GdkEvent *)event);
2556 if (event->button != ui.which_mouse_button &&
2557 event->button != ui.which_unswitch_button)
2560 if (ui.cur_item_type == ITEM_STROKE) {
2562 if (ui.cur_brush->recognizer) recognize_patterns();
2564 else if (ui.cur_item_type == ITEM_ERASURE) {
2567 else if (ui.cur_item_type == ITEM_SELECTRECT) {
2568 finalize_selectrect();
2570 else if (ui.cur_item_type == ITEM_MOVESEL || ui.cur_item_type == ITEM_MOVESEL_VERT) {
2573 else if (ui.cur_item_type == ITEM_RESIZESEL) {
2574 finalize_resizesel();
2576 else if (ui.cur_item_type == ITEM_HAND) {
2577 ui.cur_item_type = ITEM_NONE;
2580 if (!ui.which_unswitch_button || event->button == ui.which_unswitch_button)
2581 switch_mapping(0); // will reset ui.which_unswitch_button
2588 on_canvas_enter_notify_event (GtkWidget *widget,
2589 GdkEventCrossing *event,
2596 printf("DEBUG: enter notify\n");
2598 /* re-enable input devices after they've been emergency-disabled
2600 if (!gtk_check_version(2, 17, 0)) {
2602 gdk_error_trap_push();
2603 for (dev_list = gdk_devices_list(); dev_list != NULL; dev_list = dev_list->next) {
2604 dev = GDK_DEVICE(dev_list->data);
2605 gdk_device_set_mode(dev, GDK_MODE_SCREEN);
2607 ui.is_corestroke = ui.saved_is_corestroke;
2609 gdk_error_trap_pop();
2615 on_canvas_leave_notify_event (GtkWidget *widget,
2616 GdkEventCrossing *event,
2623 printf("DEBUG: leave notify (mode=%d, details=%d)\n", event->mode, event->detail);
2625 /* emergency disable XInput to avoid segfaults (GTK+ 2.17) or
2626 interface non-responsiveness (GTK+ 2.18) */
2627 if (!gtk_check_version(2, 17, 0)) {
2629 gdk_error_trap_push();
2630 for (dev_list = gdk_devices_list(); dev_list != NULL; dev_list = dev_list->next) {
2631 dev = GDK_DEVICE(dev_list->data);
2632 gdk_device_set_mode(dev, GDK_MODE_DISABLED);
2634 ui.saved_is_corestroke = ui.is_corestroke;
2635 ui.is_corestroke = TRUE;
2637 gdk_error_trap_pop();
2644 on_canvas_expose_event (GtkWidget *widget,
2645 GdkEventExpose *event,
2648 if (ui.view_continuous && ui.progressive_bg) rescale_bg_pixmaps();
2654 on_canvas_key_press_event (GtkWidget *widget,
2661 // Esc leaves text edition, or leaves fullscreen mode
2662 if (event->keyval == GDK_Escape) {
2663 if (ui.cur_item_type == ITEM_TEXT) {
2667 else if (ui.fullscreen) {
2668 do_fullscreen(FALSE);
2674 /* In single page mode, switch pages with PgUp/PgDn (or Up/Dn)
2675 when there's nowhere else to go. */
2676 pgheight = GTK_WIDGET(canvas)->allocation.height;
2677 adj = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(GET_COMPONENT("scrolledwindowMain")));
2679 if (event->keyval == GDK_Page_Down || event->keyval == GDK_Down) {
2680 if (!ui.view_continuous &&
2681 (0.96 * ui.zoom * ui.cur_page->height < pgheight ||
2682 adj->value == adj->upper-pgheight))
2685 if (ui.pageno < journal.npages-1)
2686 do_switch_page(ui.pageno+1, TRUE, FALSE);
2689 if (adj->value == adj->upper-pgheight) return TRUE; // don't send focus away
2692 if (event->keyval == GDK_Page_Up || event->keyval == GDK_Up) {
2693 if (!ui.view_continuous &&
2694 (0.96 * ui.zoom * ui.cur_page->height < pgheight ||
2695 adj->value == adj->lower))
2698 if (ui.pageno != 0) {
2699 do_switch_page(ui.pageno-1, TRUE, FALSE);
2700 gtk_adjustment_set_value(adj, adj->upper-pgheight);
2704 if (adj->value == adj->lower) return TRUE; // don't send focus away
2712 on_canvas_motion_notify_event (GtkWidget *widget,
2713 GdkEventMotion *event,
2716 gboolean looks_wrong, is_core;
2718 GdkModifierType mask;
2720 /* we don't care about this event unless some operation is in progress;
2721 or if there's a selection (then we might want to change the mouse
2722 cursor to indicate the possibility of resizing) */
2723 if (ui.cur_item_type == ITEM_NONE && ui.selection==NULL) return FALSE;
2724 if (ui.cur_item_type == ITEM_TEXT || ui.cur_item_type == ITEM_IMAGE) return FALSE;
2726 is_core = (event->device == gdk_device_get_core_pointer());
2727 if (!ui.use_xinput && !is_core) return FALSE;
2728 if (!is_core) fix_xinput_coords((GdkEvent *)event);
2729 if (!finite_sized(event->x) || !finite_sized(event->y)) return FALSE; // Xorg 7.3 bug
2731 if (ui.selection!=NULL && ui.cur_item_type == ITEM_NONE) {
2732 get_pointer_coords((GdkEvent *)event, pt);
2733 update_cursor_for_resize(pt);
2737 if (ui.use_xinput && is_core && !ui.is_corestroke) return FALSE;
2738 if (!is_core) ui.is_corestroke = FALSE;
2741 printf("DEBUG: MotionNotify (%s) (x,y)=(%.2f,%.2f), modifier %x\n",
2742 is_core?"core":"xinput", event->x, event->y, event->state);
2745 looks_wrong = !(event->state & (1<<(7+ui.which_mouse_button)));
2747 gdk_device_get_state(ui.stroke_device, event->window, NULL, &mask);
2748 looks_wrong = !(mask & (1<<(7+ui.which_mouse_button)));
2751 if (looks_wrong) { /* mouse button shouldn't be up... give up */
2752 if (ui.cur_item_type == ITEM_STROKE) {
2754 if (ui.cur_brush->recognizer) recognize_patterns();
2756 else if (ui.cur_item_type == ITEM_ERASURE) {
2759 else if (ui.cur_item_type == ITEM_SELECTRECT) {
2760 finalize_selectrect();
2762 else if (ui.cur_item_type == ITEM_MOVESEL || ui.cur_item_type == ITEM_MOVESEL_VERT) {
2765 else if (ui.cur_item_type == ITEM_RESIZESEL) {
2766 finalize_resizesel();
2768 else if (ui.cur_item_type == ITEM_HAND) {
2769 ui.cur_item_type = ITEM_NONE;
2775 if (ui.cur_item_type == ITEM_STROKE) {
2776 continue_stroke((GdkEvent *)event);
2778 else if (ui.cur_item_type == ITEM_ERASURE) {
2779 do_eraser((GdkEvent *)event, ui.cur_brush->thickness/2,
2780 ui.cur_brush->tool_options == TOOLOPT_ERASER_STROKES);
2782 else if (ui.cur_item_type == ITEM_SELECTRECT) {
2783 get_pointer_coords((GdkEvent *)event, pt);
2784 ui.selection->bbox.right = pt[0];
2785 ui.selection->bbox.bottom = pt[1];
2786 gnome_canvas_item_set(ui.selection->canvas_item,
2787 "x2", pt[0], "y2", pt[1], NULL);
2789 else if (ui.cur_item_type == ITEM_MOVESEL || ui.cur_item_type == ITEM_MOVESEL_VERT) {
2790 continue_movesel((GdkEvent *)event);
2792 else if (ui.cur_item_type == ITEM_RESIZESEL) {
2793 continue_resizesel((GdkEvent *)event);
2795 else if (ui.cur_item_type == ITEM_HAND) {
2796 do_hand((GdkEvent *)event);
2803 on_comboLayer_changed (GtkComboBox *combobox,
2808 if (ui.in_update_page_stuff) return; // avoid a bad retroaction
2812 val = gtk_combo_box_get_active(combobox);
2813 if (val == -1) return;
2814 val = ui.cur_page->nlayers-1-val;
2815 if (val == ui.layerno) return;
2818 while (val>ui.layerno) {
2820 ui.cur_layer = g_list_nth_data(ui.cur_page->layers, ui.layerno);
2821 gnome_canvas_item_show(GNOME_CANVAS_ITEM(ui.cur_layer->group));
2823 while (val<ui.layerno) {
2824 gnome_canvas_item_hide(GNOME_CANVAS_ITEM(ui.cur_layer->group));
2826 if (ui.layerno<0) ui.cur_layer = NULL;
2827 else ui.cur_layer = g_list_nth_data(ui.cur_page->layers, ui.layerno);
2829 update_page_stuff();
2834 on_winMain_delete_event (GtkWidget *widget,
2839 if (ok_to_close()) gtk_main_quit();
2845 on_optionsUseXInput_activate (GtkMenuItem *menuitem,
2849 ui.allow_xinput = ui.use_xinput =
2850 gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
2852 /* HOW THINGS USED TO BE:
2854 We'd like on_canvas_... to get BOTH core and xinput events. Up to
2855 GTK+ 2.16 this is achieved by making only the canvas's parent
2856 GdkWindow xinput-aware, rather than the entire hierarchy.
2857 Otherwise, the proximity detection code in GDK is broken and
2858 we'll lose core events.
2860 Up to GTK+ 2.10, gtk_widget_set_extension_events() only sets
2861 extension events for the widget's main window itself; in GTK+ 2.11
2862 also traverses GDK child windows that belong to the widget
2863 and sets their extension events too. We want to avoid that.
2864 So we use gdk_input_set_extension_events() directly on the canvas.
2866 As much as possible, we'd like to keep doing this, though GTK+ 2.17
2867 is making our life harder (crasher bugs require us to disable XInput
2868 while editing text or using the layers combo box, but disabling
2869 XInput while in a XInput-aware window causes the interface to become
2874 if (!gtk_check_version(2, 17, 0)) {
2876 /* GTK+ 2.17 and later: everybody shares a single native window,
2877 so we'll never get any core events, and we might as well set
2878 extension events the way we're supposed to. Doing so helps solve
2879 crasher bugs in 2.17, and prevents us from losing two-button
2881 gtk_widget_set_extension_events(GTK_WIDGET (canvas),
2882 ui.use_xinput?GDK_EXTENSION_EVENTS_ALL:GDK_EXTENSION_EVENTS_NONE);
2886 /* GTK+ 2.16 and earlier: we only activate extension events on the
2887 canvas's parent GdkWindow. This allows us to keep receiving core
2889 gdk_input_set_extension_events(GTK_WIDGET(canvas)->window,
2890 GDK_POINTER_MOTION_MASK | GDK_BUTTON_MOTION_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK,
2891 ui.use_xinput?GDK_EXTENSION_EVENTS_ALL:GDK_EXTENSION_EVENTS_NONE);
2896 update_mappings_menu();
2900 on_vscroll_changed (GtkAdjustment *adjustment,
2903 gboolean need_update;
2904 double viewport_top, viewport_bottom;
2905 struct Page *tmppage;
2907 if (!ui.view_continuous) return;
2909 if (ui.progressive_bg) rescale_bg_pixmaps();
2910 need_update = FALSE;
2911 viewport_top = adjustment->value / ui.zoom;
2912 viewport_bottom = (adjustment->value + adjustment->page_size) / ui.zoom;
2913 tmppage = ui.cur_page;
2914 while (viewport_top > tmppage->voffset + tmppage->height) {
2915 if (ui.pageno == journal.npages-1) break;
2918 tmppage = g_list_nth_data(journal.pages, ui.pageno);
2920 while (viewport_bottom < tmppage->voffset) {
2921 if (ui.pageno == 0) break;
2924 tmppage = g_list_nth_data(journal.pages, ui.pageno);
2928 do_switch_page(ui.pageno, FALSE, FALSE);
2934 on_spinPageNo_value_changed (GtkSpinButton *spinbutton,
2939 if (ui.in_update_page_stuff) return; // avoid a bad retroaction
2941 /* in preparation for end_text(), send focus to the canvas if it's not ours.
2942 (avoid issues with Gtk trying to send focus to the dead text widget) */
2944 if (!GTK_WIDGET_HAS_FOCUS(spinbutton))
2945 gtk_widget_grab_focus(GTK_WIDGET(canvas));
2948 val = gtk_spin_button_get_value_as_int(spinbutton) - 1;
2950 if (val == journal.npages) { // create a page at end
2951 on_journalNewPageEnd_activate(NULL, NULL);
2955 if (val == ui.pageno) return;
2956 if (val < 0) val = 0;
2957 if (val > journal.npages-1) val = journal.npages-1;
2958 do_switch_page(val, TRUE, FALSE);
2963 on_journalDefaultBackground_activate (GtkMenuItem *menuitem,
2973 for (pglist = journal.pages; pglist!=NULL; pglist = pglist->next) {
2974 if (ui.bg_apply_all_pages) pg = (struct Page *)pglist->data;
2976 if (ui.bg_apply_all_pages) {
2977 if (pglist->next!=NULL) undo->multiop |= MULTIOP_CONT_REDO;
2978 if (pglist->prev!=NULL) undo->multiop |= MULTIOP_CONT_UNDO;
2980 undo->type = ITEM_NEW_BG_RESIZE;
2983 undo->val_x = pg->width;
2984 undo->val_y = pg->height;
2985 pg->bg = (struct Background *)g_memdup(ui.default_page.bg, sizeof(struct Background));
2986 pg->width = ui.default_page.width;
2987 pg->height = ui.default_page.height;
2988 pg->bg->canvas_item = undo->bg->canvas_item;
2989 undo->bg->canvas_item = NULL;
2991 make_page_clipbox(pg);
2992 update_canvas_bg(pg);
2993 if (!ui.bg_apply_all_pages) break;
2995 do_switch_page(ui.pageno, TRUE, TRUE);
3000 on_journalSetAsDefault_activate (GtkMenuItem *menuitem,
3003 if (ui.cur_page->bg->type != BG_SOLID) return;
3007 undo->type = ITEM_NEW_DEFAULT_BG;
3008 undo->val_x = ui.default_page.width;
3009 undo->val_y = ui.default_page.height;
3010 undo->bg = ui.default_page.bg;
3012 ui.default_page.width = ui.cur_page->width;
3013 ui.default_page.height = ui.cur_page->height;
3014 ui.default_page.bg = (struct Background *)g_memdup(ui.cur_page->bg, sizeof(struct Background));
3015 ui.default_page.bg->canvas_item = NULL;
3020 on_comboStdSizes_changed (GtkComboBox *combobox,
3024 GtkComboBox *comboUnit;
3028 if (papersize_need_init) {
3029 gtk_combo_box_set_active(combobox, papersize_std);
3030 papersize_need_init = FALSE;
3032 val = gtk_combo_box_get_active(combobox);
3033 if (val == -1 || val == papersize_std) return;
3034 papersize_std = val;
3035 if (val == STD_SIZE_CUSTOM) return;
3036 papersize_unit = std_units[val];
3037 papersize_width = std_widths[val];
3038 papersize_height = std_heights[val];
3040 comboUnit = GTK_COMBO_BOX(g_object_get_data(G_OBJECT(papersize_dialog), "comboUnit"));
3041 gtk_combo_box_set_active(comboUnit, papersize_unit);
3042 entry = GTK_ENTRY(g_object_get_data(G_OBJECT(papersize_dialog), "entryWidth"));
3043 g_snprintf(text, 20, "%.2f", papersize_width/unit_sizes[papersize_unit]);
3044 if (g_str_has_suffix(text, ".00"))
3045 g_snprintf(text, 20, "%d", (int) (papersize_width/unit_sizes[papersize_unit]));
3046 gtk_entry_set_text(entry, text);
3047 entry = GTK_ENTRY(g_object_get_data(G_OBJECT(papersize_dialog), "entryHeight"));
3048 g_snprintf(text, 20, "%.2f", papersize_height/unit_sizes[papersize_unit]);
3049 if (g_str_has_suffix(text, ".00"))
3050 g_snprintf(text, 20, "%d", (int) (papersize_height/unit_sizes[papersize_unit]));
3051 gtk_entry_set_text(entry, text);
3056 on_entryWidth_changed (GtkEditable *editable,
3062 GtkComboBox *comboStdSizes;
3064 text = gtk_entry_get_text(GTK_ENTRY(editable));
3065 val = strtod(text, &ptr);
3066 papersize_width_valid = (*ptr == 0 && val > 0.);
3067 if (!papersize_width_valid) return; // invalid entry
3068 val *= unit_sizes[papersize_unit];
3069 if (fabs(val - papersize_width) < 0.1) return; // no change
3070 papersize_std = STD_SIZE_CUSTOM;
3071 papersize_width = val;
3072 comboStdSizes = GTK_COMBO_BOX(g_object_get_data(G_OBJECT(papersize_dialog), "comboStdSizes"));
3073 gtk_combo_box_set_active(comboStdSizes, papersize_std);
3078 on_entryHeight_changed (GtkEditable *editable,
3084 GtkComboBox *comboStdSizes;
3086 text = gtk_entry_get_text(GTK_ENTRY(editable));
3087 val = strtod(text, &ptr);
3088 papersize_height_valid = (*ptr == 0 && val > 0.);
3089 if (!papersize_height_valid) return; // invalid entry
3090 val *= unit_sizes[papersize_unit];
3091 if (fabs(val - papersize_height) < 0.1) return; // no change
3092 papersize_std = STD_SIZE_CUSTOM;
3093 papersize_height = val;
3094 comboStdSizes = GTK_COMBO_BOX(g_object_get_data(G_OBJECT(papersize_dialog), "comboStdSizes"));
3095 gtk_combo_box_set_active(comboStdSizes, papersize_std);
3100 on_comboUnit_changed (GtkComboBox *combobox,
3107 val = gtk_combo_box_get_active(combobox);
3108 if (val == -1 || val == papersize_unit) return;
3109 papersize_unit = val;
3110 entry = GTK_ENTRY(g_object_get_data(G_OBJECT(papersize_dialog), "entryWidth"));
3111 if (papersize_width_valid) {
3112 g_snprintf(text, 20, "%.2f", papersize_width/unit_sizes[papersize_unit]);
3113 if (g_str_has_suffix(text, ".00"))
3114 g_snprintf(text, 20, "%d", (int) (papersize_width/unit_sizes[papersize_unit]));
3116 gtk_entry_set_text(entry, text);
3117 if (papersize_height_valid) {
3118 entry = GTK_ENTRY(g_object_get_data(G_OBJECT(papersize_dialog), "entryHeight"));
3119 g_snprintf(text, 20, "%.2f", papersize_height/unit_sizes[papersize_unit]);
3120 if (g_str_has_suffix(text, ".00"))
3121 g_snprintf(text, 20, "%d", (int) (papersize_height/unit_sizes[papersize_unit]));
3123 gtk_entry_set_text(entry, text);
3128 on_viewFullscreen_activate (GtkMenuItem *menuitem,
3133 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_CHECK_MENU_ITEM)
3134 active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
3136 active = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem));
3138 if (active == ui.fullscreen) return;
3139 do_fullscreen(active);
3144 on_optionsButtonMappings_activate (GtkMenuItem *menuitem,
3149 gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
3150 update_mappings_menu();
3155 on_optionsProgressiveBG_activate (GtkMenuItem *menuitem,
3160 active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
3161 if (ui.progressive_bg == active) return;
3163 ui.progressive_bg = active;
3164 if (!ui.progressive_bg) rescale_bg_pixmaps();
3169 on_mru_activate (GtkMenuItem *menuitem,
3177 if (!ok_to_close()) return; // user aborted on save confirmation
3179 for (which = 0 ; which < MRU_SIZE; which++) {
3180 if (ui.mrumenu[which] == GTK_WIDGET(menuitem)) break;
3182 if (which == MRU_SIZE || ui.mru[which] == NULL) return; // not found...
3184 set_cursor_busy(TRUE);
3185 success = open_journal(ui.mru[which]);
3186 set_cursor_busy(FALSE);
3187 if (success) return;
3190 dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
3191 GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Error opening file '%s'"), ui.mru[which]);
3192 gtk_dialog_run(GTK_DIALOG(dialog));
3193 gtk_widget_destroy(dialog);
3194 delete_mru_entry(which);
3199 on_button2Pen_activate (GtkMenuItem *menuitem,
3202 process_mapping_activate(menuitem, 1, TOOL_PEN);
3207 on_button2Eraser_activate (GtkMenuItem *menuitem,
3210 process_mapping_activate(menuitem, 1, TOOL_ERASER);
3215 on_button2Highlighter_activate (GtkMenuItem *menuitem,
3218 process_mapping_activate(menuitem, 1, TOOL_HIGHLIGHTER);
3223 on_button2Text_activate (GtkMenuItem *menuitem,
3226 process_mapping_activate(menuitem, 1, TOOL_TEXT);
3231 on_button2Image_activate (GtkMenuItem *menuitem,
3234 process_mapping_activate(menuitem, 1, TOOL_IMAGE);
3239 on_button2SelectRegion_activate (GtkMenuItem *menuitem,
3242 process_mapping_activate(menuitem, 1, TOOL_SELECTREGION);
3247 on_button2SelectRectangle_activate (GtkMenuItem *menuitem,
3250 process_mapping_activate(menuitem, 1, TOOL_SELECTRECT);
3255 on_button2VerticalSpace_activate (GtkMenuItem *menuitem,
3258 process_mapping_activate(menuitem, 1, TOOL_VERTSPACE);
3263 on_button2LinkBrush_activate (GtkMenuItem *menuitem,
3268 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem))) return;
3270 ui.linked_brush[1] = BRUSH_LINKED;
3271 for (i=0;i<NUM_STROKE_TOOLS;i++) update_mapping_linkings(i);
3276 on_button2CopyBrush_activate (GtkMenuItem *menuitem,
3279 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem))) return;
3281 if (ui.toolno[1] >= NUM_STROKE_TOOLS) {
3282 ui.linked_brush[1] = BRUSH_STATIC;
3283 update_mappings_menu_linkings();
3286 ui.linked_brush[1] = BRUSH_COPIED;
3287 g_memmove(&(ui.brushes[1][ui.toolno[1]]), &(ui.brushes[0][ui.toolno[1]]), sizeof(struct Brush));
3292 on_button3Pen_activate (GtkMenuItem *menuitem,
3295 process_mapping_activate(menuitem, 2, TOOL_PEN);
3300 on_button3Eraser_activate (GtkMenuItem *menuitem,
3303 process_mapping_activate(menuitem, 2, TOOL_ERASER);
3308 on_button3Highlighter_activate (GtkMenuItem *menuitem,
3311 process_mapping_activate(menuitem, 2, TOOL_HIGHLIGHTER);
3316 on_button3Text_activate (GtkMenuItem *menuitem,
3319 process_mapping_activate(menuitem, 2, TOOL_TEXT);
3324 on_button3Image_activate (GtkMenuItem *menuitem,
3327 process_mapping_activate(menuitem, 2, TOOL_IMAGE);
3332 on_button3SelectRegion_activate (GtkMenuItem *menuitem,
3335 process_mapping_activate(menuitem, 2, TOOL_SELECTREGION);
3340 on_button3SelectRectangle_activate (GtkMenuItem *menuitem,
3343 process_mapping_activate(menuitem, 2, TOOL_SELECTRECT);
3348 on_button3VerticalSpace_activate (GtkMenuItem *menuitem,
3351 process_mapping_activate(menuitem, 2, TOOL_VERTSPACE);
3356 on_button3LinkBrush_activate (GtkMenuItem *menuitem,
3361 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem))) return;
3363 ui.linked_brush[2] = BRUSH_LINKED;
3364 for (i=0;i<NUM_STROKE_TOOLS;i++) update_mapping_linkings(i);
3369 on_button3CopyBrush_activate (GtkMenuItem *menuitem,
3372 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem))) return;
3374 if (ui.toolno[2] >= NUM_STROKE_TOOLS) {
3375 ui.linked_brush[2] = BRUSH_STATIC;
3376 update_mappings_menu_linkings();
3379 ui.linked_brush[2] = BRUSH_COPIED;
3380 g_memmove(&(ui.brushes[2][ui.toolno[2]]), &(ui.brushes[0][ui.toolno[2]]), sizeof(struct Brush));
3383 // the set zoom dialog
3385 GtkWidget *zoom_dialog;
3386 double zoom_percent;
3389 on_viewSetZoom_activate (GtkMenuItem *menuitem,
3393 double test_w, test_h;
3394 GtkSpinButton *spinZoom;
3397 zoom_dialog = create_zoomDialog();
3398 zoom_percent = 100*ui.zoom / DEFAULT_ZOOM;
3399 spinZoom = GTK_SPIN_BUTTON(g_object_get_data(G_OBJECT(zoom_dialog), "spinZoom"));
3400 gtk_spin_button_set_increments(spinZoom, ui.zoom_step_increment, 5*ui.zoom_step_increment);
3401 gtk_spin_button_set_value(spinZoom, zoom_percent);
3402 test_w = 100*(GTK_WIDGET(canvas))->allocation.width/ui.cur_page->width/DEFAULT_ZOOM;
3403 test_h = 100*(GTK_WIDGET(canvas))->allocation.height/ui.cur_page->height/DEFAULT_ZOOM;
3404 if (zoom_percent > 99.9 && zoom_percent < 100.1)
3405 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_object_get_data(
3406 G_OBJECT(zoom_dialog), "radioZoom100")), TRUE);
3407 else if (zoom_percent > test_w-0.1 && zoom_percent < test_w+0.1)
3408 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_object_get_data(
3409 G_OBJECT(zoom_dialog), "radioZoomWidth")), TRUE);
3410 else if (zoom_percent > test_h-0.1 && zoom_percent < test_h+0.1)
3411 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_object_get_data(
3412 G_OBJECT(zoom_dialog), "radioZoomHeight")), TRUE);
3413 else gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_object_get_data(
3414 G_OBJECT(zoom_dialog), "radioZoom")), TRUE);
3415 gtk_widget_show(zoom_dialog);
3418 response = gtk_dialog_run(GTK_DIALOG(zoom_dialog));
3419 if (response == GTK_RESPONSE_OK || response == GTK_RESPONSE_APPLY) {
3420 ui.zoom = DEFAULT_ZOOM*zoom_percent/100;
3421 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
3422 rescale_text_items();
3423 rescale_bg_pixmaps();
3426 } while (response == GTK_RESPONSE_APPLY);
3428 gtk_widget_destroy(zoom_dialog);
3433 on_spinZoom_value_changed (GtkSpinButton *spinbutton,
3438 val = gtk_spin_button_get_value(GTK_SPIN_BUTTON(g_object_get_data(
3439 G_OBJECT(zoom_dialog), "spinZoom")));
3441 if (val<10) val=10.;
3442 if (val>1500) val=1500.;
3443 if (val<zoom_percent-1 || val>zoom_percent+1)
3444 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_object_get_data(
3445 G_OBJECT(zoom_dialog), "radioZoom")), TRUE);
3451 on_radioZoom_toggled (GtkToggleButton *togglebutton,
3459 on_radioZoom100_toggled (GtkToggleButton *togglebutton,
3462 if (!gtk_toggle_button_get_active(togglebutton)) return;
3463 zoom_percent = 100.;
3464 gtk_spin_button_set_value(GTK_SPIN_BUTTON(g_object_get_data(
3465 G_OBJECT(zoom_dialog), "spinZoom")), zoom_percent);
3470 on_radioZoomWidth_toggled (GtkToggleButton *togglebutton,
3473 if (!gtk_toggle_button_get_active(togglebutton)) return;
3474 zoom_percent = 100*(GTK_WIDGET(canvas))->allocation.width/ui.cur_page->width/DEFAULT_ZOOM;
3475 gtk_spin_button_set_value(GTK_SPIN_BUTTON(g_object_get_data(
3476 G_OBJECT(zoom_dialog), "spinZoom")), zoom_percent);
3481 on_radioZoomHeight_toggled (GtkToggleButton *togglebutton,
3484 if (!gtk_toggle_button_get_active(togglebutton)) return;
3485 zoom_percent = 100*(GTK_WIDGET(canvas))->allocation.height/ui.cur_page->height/DEFAULT_ZOOM;
3486 gtk_spin_button_set_value(GTK_SPIN_BUTTON(g_object_get_data(
3487 G_OBJECT(zoom_dialog), "spinZoom")), zoom_percent);
3492 on_toolsHand_activate (GtkMenuItem *menuitem,
3495 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
3496 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
3499 if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
3503 if (ui.cur_mapping != 0 && !ui.button_switch_mapping) return;
3504 if (ui.toolno[ui.cur_mapping] == TOOL_HAND) return;
3509 ui.toolno[ui.cur_mapping] = TOOL_HAND;
3510 update_mapping_linkings(-1);
3511 update_tool_buttons();
3513 update_color_menu();
3519 on_button2Hand_activate (GtkMenuItem *menuitem,
3522 process_mapping_activate(menuitem, 1, TOOL_HAND);
3527 on_button3Hand_activate (GtkMenuItem *menuitem,
3530 process_mapping_activate(menuitem, 2, TOOL_HAND);
3535 on_optionsPrintRuling_activate (GtkMenuItem *menuitem,
3539 ui.print_ruling = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
3543 on_optionsAutoloadPdfXoj_activate (GtkMenuItem *menuitem,
3547 ui.autoload_pdf_xoj = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
3551 on_fontButton_font_set (GtkFontButton *fontbutton,
3556 str = g_strdup(gtk_font_button_get_font_name(fontbutton));
3557 process_font_sel(str);
3561 on_optionsLeftHanded_activate (GtkMenuItem *menuitem,
3565 ui.left_handed = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
3566 gtk_scrolled_window_set_placement(GTK_SCROLLED_WINDOW(GET_COMPONENT("scrolledwindowMain")),
3567 ui.left_handed?GTK_CORNER_TOP_RIGHT:GTK_CORNER_TOP_LEFT);
3571 on_optionsShortenMenus_activate (GtkMenuItem *menuitem,
3574 gchar *item, *nextptr;
3578 ui.shorten_menus = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
3580 /* go over the item list */
3581 item = ui.shorten_menu_items;
3582 while (*item==' ') item++;
3584 nextptr = strchr(item, ' ');
3585 if (nextptr!=NULL) *nextptr = 0;
3586 // hide or show the item
3587 w = GET_COMPONENT(item);
3589 if (ui.shorten_menus) gtk_widget_hide(w);
3590 else gtk_widget_show(w);
3593 if (nextptr==NULL) break;
3596 while (*item==' ') item++;
3599 // just in case someone tried to unhide stuff they shouldn't be seeing
3600 hide_unimplemented();
3601 // maybe we should also make sure the drawing area stays visible ?
3605 on_optionsAutoSavePrefs_activate (GtkMenuItem *menuitem,
3609 ui.auto_save_prefs = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
3613 on_optionsPressureSensitive_activate (GtkMenuItem *menuitem,
3618 ui.pressure_sensitivity =
3619 gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));
3620 for (i=0; i<=NUM_BUTTONS; i++)
3621 ui.brushes[i][TOOL_PEN].variable_width = ui.pressure_sensitivity;
3622 update_mappings_menu();
3627 on_buttonColorChooser_set (GtkColorButton *colorbutton,
3633 gtk_color_button_get_color(colorbutton, &gdkcolor);
3634 alpha = gtk_color_button_get_alpha(colorbutton);
3635 process_color_activate((GtkMenuItem*)colorbutton, COLOR_OTHER, gdkcolor_to_rgba(gdkcolor, alpha));
3640 on_optionsButtonsSwitchMappings_activate(GtkMenuItem *menuitem,
3645 ui.button_switch_mapping = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem));