8 #include <libgnomecanvas/libgnomecanvas.h>
9 #include <gdk/gdkkeysyms.h>
12 #include "xo-interface.h"
13 #include "xo-support.h"
14 #include "xo-callbacks.h"
19 // some global constants
21 guint predef_colors_rgba[COLOR_MAX] =
22 { 0x000000ff, 0x3333ccff, 0xff0000ff, 0x008000ff,
23 0x808080ff, 0x00c0ffff, 0x00ff00ff, 0xff00ffff,
24 0xff8000ff, 0xffff00ff, 0xffffffff };
26 guint predef_bgcolors_rgba[COLOR_MAX] = // meaningless ones set to white
27 { 0xffffffff, 0xa0e8ffff, 0xffc0d4ff, 0x80ffc0ff,
28 0xffffffff, 0xa0e8ffff, 0x80ffc0ff, 0xffc0d4ff,
29 0xffc080ff, 0xffff80ff, 0xffffffff };
31 double predef_thickness[NUM_STROKE_TOOLS][THICKNESS_MAX] =
32 { { 0.42, 0.85, 1.41, 2.26, 5.67 }, // pen thicknesses = 0.15, 0.3, 0.5, 0.8, 2 mm
33 { 2.83, 2.83, 8.50, 19.84, 19.84 }, // eraser thicknesses = 1, 3, 7 mm
34 { 2.83, 2.83, 8.50, 19.84, 19.84 }, // highlighter thicknesses = 1, 3, 7 mm
37 // some manipulation functions
39 struct Page *new_page(struct Page *template)
41 struct Page *pg = (struct Page *) g_memdup(template, sizeof(struct Page));
42 struct Layer *l = g_new(struct Layer, 1);
46 pg->layers = g_list_append(NULL, l);
48 pg->bg = (struct Background *)g_memdup(template->bg, sizeof(struct Background));
49 pg->bg->canvas_item = NULL;
50 if (pg->bg->type == BG_PIXMAP || pg->bg->type == BG_PDF) {
51 gdk_pixbuf_ref(pg->bg->pixbuf);
52 refstring_ref(pg->bg->filename);
54 pg->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
55 gnome_canvas_root(canvas), gnome_canvas_clipgroup_get_type(), NULL);
56 make_page_clipbox(pg);
58 l->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
59 pg->group, gnome_canvas_group_get_type(), NULL);
64 /* Create a page from a background.
65 Note: bg should be an UNREFERENCED background.
66 If needed, first duplicate it and increase the refcount of the pixbuf.
68 struct Page *new_page_with_bg(struct Background *bg, double width, double height)
70 struct Page *pg = g_new(struct Page, 1);
71 struct Layer *l = g_new(struct Layer, 1);
75 pg->layers = g_list_append(NULL, l);
78 pg->bg->canvas_item = NULL;
81 pg->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
82 gnome_canvas_root(canvas), gnome_canvas_clipgroup_get_type(), NULL);
83 make_page_clipbox(pg);
85 l->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
86 pg->group, gnome_canvas_group_get_type(), NULL);
91 void realloc_cur_path(int n)
93 if (n <= ui.cur_path_storage_alloc) return;
94 ui.cur_path_storage_alloc = n+10;
95 ui.cur_path.coords = g_realloc(ui.cur_path.coords, 2*(n+10)*sizeof(double));
98 // undo utility functions
100 void prepare_new_undo(void)
103 // add a new UndoItem on the stack
104 u = (struct UndoItem *)g_malloc(sizeof(struct UndoItem));
112 void clear_redo_stack(void)
116 struct UndoErasureData *erasure;
119 /* Warning: the redo items might reference items from past redo entries,
120 which have been destroyed before them. Be careful! As a rule, it's
121 safe to destroy data which has been created at the current history step,
122 it's unsafe to refer to any data from previous history steps */
125 if (redo->type == ITEM_STROKE) {
126 gnome_canvas_points_free(redo->item->path);
128 /* the strokes are unmapped, so there are no associated canvas items */
130 else if (redo->type == ITEM_TEXT) {
131 g_free(redo->item->text);
132 g_free(redo->item->font_name);
135 else if (redo->type == ITEM_ERASURE) {
136 for (list = redo->erasurelist; list!=NULL; list=list->next) {
137 erasure = (struct UndoErasureData *)list->data;
138 for (repl = erasure->replacement_items; repl!=NULL; repl=repl->next) {
139 it = (struct Item *)repl->data;
140 gnome_canvas_points_free(it->path);
143 g_list_free(erasure->replacement_items);
146 g_list_free(redo->erasurelist);
148 else if (redo->type == ITEM_NEW_BG_ONE || redo->type == ITEM_NEW_BG_RESIZE
149 || redo->type == ITEM_NEW_DEFAULT_BG) {
150 if (redo->bg->type == BG_PIXMAP || redo->bg->type == BG_PDF) {
151 if (redo->bg->pixbuf!=NULL) gdk_pixbuf_unref(redo->bg->pixbuf);
152 refstring_unref(redo->bg->filename);
156 else if (redo->type == ITEM_NEW_PAGE) {
157 redo->page->group = NULL;
158 delete_page(redo->page);
160 else if (redo->type == ITEM_MOVESEL || redo->type == ITEM_REPAINTSEL) {
161 g_list_free(redo->itemlist); g_list_free(redo->auxlist);
163 else if (redo->type == ITEM_PASTE) {
164 for (list = redo->itemlist; list!=NULL; list=list->next) {
165 it = (struct Item *)list->data;
166 if (it->type == ITEM_STROKE) gnome_canvas_points_free(it->path);
169 g_list_free(redo->itemlist);
171 else if (redo->type == ITEM_NEW_LAYER) {
174 else if (redo->type == ITEM_TEXT_EDIT || redo->type == ITEM_TEXT_ATTRIB) {
176 if (redo->type == ITEM_TEXT_ATTRIB) g_free(redo->brush);
183 update_undo_redo_enabled();
186 void clear_undo_stack(void)
190 struct UndoErasureData *erasure;
193 // for strokes, items are already in the journal, so we don't free them
194 // for erasures, we need to free the dead items
195 if (undo->type == ITEM_ERASURE) {
196 for (list = undo->erasurelist; list!=NULL; list=list->next) {
197 erasure = (struct UndoErasureData *)list->data;
198 if (erasure->item->type == ITEM_STROKE)
199 gnome_canvas_points_free(erasure->item->path);
200 if (erasure->item->type == ITEM_TEXT)
201 { g_free(erasure->item->text); g_free(erasure->item->font_name); }
202 g_free(erasure->item);
203 g_list_free(erasure->replacement_items);
206 g_list_free(undo->erasurelist);
208 else if (undo->type == ITEM_NEW_BG_ONE || undo->type == ITEM_NEW_BG_RESIZE
209 || undo->type == ITEM_NEW_DEFAULT_BG) {
210 if (undo->bg->type == BG_PIXMAP || undo->bg->type == BG_PDF) {
211 if (undo->bg->pixbuf!=NULL) gdk_pixbuf_unref(undo->bg->pixbuf);
212 refstring_unref(undo->bg->filename);
216 else if (undo->type == ITEM_MOVESEL || undo->type == ITEM_REPAINTSEL) {
217 g_list_free(undo->itemlist); g_list_free(undo->auxlist);
219 else if (undo->type == ITEM_PASTE) {
220 g_list_free(undo->itemlist);
222 else if (undo->type == ITEM_DELETE_LAYER) {
223 undo->layer->group = NULL;
224 delete_layer(undo->layer);
226 else if (undo->type == ITEM_DELETE_PAGE) {
227 undo->page->group = NULL;
228 delete_page(undo->page);
230 else if (undo->type == ITEM_TEXT_EDIT || undo->type == ITEM_TEXT_ATTRIB) {
232 if (undo->type == ITEM_TEXT_ATTRIB) g_free(undo->brush);
239 update_undo_redo_enabled();
242 // free data structures
244 void delete_journal(struct Journal *j)
246 while (j->pages!=NULL) {
247 delete_page((struct Page *)j->pages->data);
248 j->pages = g_list_delete_link(j->pages, j->pages);
252 void delete_page(struct Page *pg)
256 while (pg->layers!=NULL) {
257 l = (struct Layer *)pg->layers->data;
260 pg->layers = g_list_delete_link(pg->layers, pg->layers);
262 if (pg->group!=NULL) gtk_object_destroy(GTK_OBJECT(pg->group));
263 // this also destroys the background's canvas items
264 if (pg->bg->type == BG_PIXMAP || pg->bg->type == BG_PDF) {
265 if (pg->bg->pixbuf != NULL) gdk_pixbuf_unref(pg->bg->pixbuf);
266 if (pg->bg->filename != NULL) refstring_unref(pg->bg->filename);
272 void delete_layer(struct Layer *l)
276 while (l->items!=NULL) {
277 item = (struct Item *)l->items->data;
278 if (item->type == ITEM_STROKE && item->path != NULL)
279 gnome_canvas_points_free(item->path);
280 if (item->type == ITEM_TEXT) {
281 g_free(item->font_name); g_free(item->text);
283 // don't need to delete the canvas_item, as it's part of the group destroyed below
285 l->items = g_list_delete_link(l->items, l->items);
287 if (l->group!= NULL) gtk_object_destroy(GTK_OBJECT(l->group));
291 // referenced strings
293 struct Refstring *new_refstring(const char *s)
295 struct Refstring *rs = g_new(struct Refstring, 1);
297 if (s!=NULL) rs->s = g_strdup(s);
303 struct Refstring *refstring_ref(struct Refstring *rs)
309 void refstring_unref(struct Refstring *rs)
313 if (rs->s!=NULL) g_free(rs->s);
314 if (rs->aux!=NULL) g_free(rs->aux);
320 // some helper functions
322 void get_pointer_coords(GdkEvent *event, gdouble *ret)
325 gdk_event_get_coords(event, &x, &y);
326 gnome_canvas_window_to_world(canvas, x, y, ret, ret+1);
327 ret[0] -= ui.cur_page->hoffset;
328 ret[1] -= ui.cur_page->voffset;
331 void fix_xinput_coords(GdkEvent *event)
333 #ifdef ENABLE_XINPUT_BUGFIX
334 double *axes, *px, *py, axis_width;
338 if (event->type == GDK_BUTTON_PRESS || event->type == GDK_BUTTON_RELEASE) {
339 axes = event->button.axes;
340 px = &(event->button.x);
341 py = &(event->button.y);
342 device = event->button.device;
344 else if (event->type == GDK_MOTION_NOTIFY) {
345 axes = event->motion.axes;
346 px = &(event->motion.x);
347 py = &(event->motion.y);
348 device = event->motion.device;
350 else return; // nothing we know how to do
352 // use canvas window, not event window (else get GTK+ 2.11 bugs!)
353 gdk_window_get_origin(GTK_WIDGET(canvas)->window, &wx, &wy);
354 gnome_canvas_get_scroll_offsets(canvas, &sx, &sy);
356 axis_width = device->axes[0].max - device->axes[0].min;
357 if (axis_width>EPSILON)
358 *px = (axes[0]/axis_width)*ui.screen_width + sx - wx;
360 axis_width = device->axes[1].max - device->axes[1].min;
361 if (axis_width>EPSILON)
362 *py = (axes[1]/axis_width)*ui.screen_height + sy - wy;
366 void update_item_bbox(struct Item *item)
371 if (item->type == ITEM_STROKE) {
372 item->bbox.left = item->bbox.right = item->path->coords[0];
373 item->bbox.top = item->bbox.bottom = item->path->coords[1];
374 for (i=1, p=item->path->coords+2; i<item->path->num_points; i++, p+=2)
376 if (p[0] < item->bbox.left) item->bbox.left = p[0];
377 if (p[0] > item->bbox.right) item->bbox.right = p[0];
378 if (p[1] < item->bbox.top) item->bbox.top = p[1];
379 if (p[1] > item->bbox.bottom) item->bbox.bottom = p[1];
382 if (item->type == ITEM_TEXT && item->canvas_item!=NULL) {
384 g_object_get(item->canvas_item, "text_width", &w, "text_height", &h, NULL);
385 item->bbox.right = item->bbox.left + w;
386 item->bbox.bottom = item->bbox.top + h;
390 void make_page_clipbox(struct Page *pg)
392 GnomeCanvasPathDef *pg_clip;
394 pg_clip = gnome_canvas_path_def_new_sized(4);
395 gnome_canvas_path_def_moveto(pg_clip, 0., 0.);
396 gnome_canvas_path_def_lineto(pg_clip, 0., pg->height);
397 gnome_canvas_path_def_lineto(pg_clip, pg->width, pg->height);
398 gnome_canvas_path_def_lineto(pg_clip, pg->width, 0.);
399 gnome_canvas_path_def_closepath(pg_clip);
400 gnome_canvas_item_set(GNOME_CANVAS_ITEM(pg->group), "path", pg_clip, NULL);
401 gnome_canvas_path_def_unref(pg_clip);
404 void make_canvas_item_one(GnomeCanvasGroup *group, struct Item *item)
407 PangoFontDescription *font_desc;
409 if (item->type == ITEM_STROKE)
410 item->canvas_item = gnome_canvas_item_new(group,
411 gnome_canvas_line_get_type(), "points", item->path,
412 "cap-style", GDK_CAP_ROUND, "join-style", GDK_JOIN_ROUND,
413 "fill-color-rgba", item->brush.color_rgba,
414 "width-units", item->brush.thickness, NULL);
415 if (item->type == ITEM_TEXT) {
416 font_desc = pango_font_description_from_string(item->font_name);
417 pango_font_description_set_absolute_size(font_desc,
418 item->font_size*ui.zoom*PANGO_SCALE);
419 item->canvas_item = gnome_canvas_item_new(group,
420 gnome_canvas_text_get_type(),
421 "x", item->bbox.left, "y", item->bbox.top, "anchor", GTK_ANCHOR_NW,
422 "font-desc", font_desc, "fill-color-rgba", item->brush.color_rgba,
423 "text", item->text, NULL);
424 update_item_bbox(item);
428 void make_canvas_items(void)
433 GList *pagelist, *layerlist, *itemlist;
435 for (pagelist = journal.pages; pagelist!=NULL; pagelist = pagelist->next) {
436 pg = (struct Page *)pagelist->data;
437 if (pg->group == NULL) {
438 pg->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
439 gnome_canvas_root(canvas), gnome_canvas_clipgroup_get_type(), NULL);
440 make_page_clipbox(pg);
442 if (pg->bg->canvas_item == NULL) update_canvas_bg(pg);
443 for (layerlist = pg->layers; layerlist!=NULL; layerlist = layerlist->next) {
444 l = (struct Layer *)layerlist->data;
445 if (l->group == NULL)
446 l->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
447 pg->group, gnome_canvas_group_get_type(), NULL);
448 for (itemlist = l->items; itemlist!=NULL; itemlist = itemlist->next) {
449 item = (struct Item *)itemlist->data;
450 if (item->canvas_item == NULL)
451 make_canvas_item_one(l->group, item);
457 void update_canvas_bg(struct Page *pg)
459 GnomeCanvasGroup *group;
460 GnomeCanvasPoints *seg;
461 GdkPixbuf *scaled_pix;
466 if (pg->bg->canvas_item != NULL)
467 gtk_object_destroy(GTK_OBJECT(pg->bg->canvas_item));
468 pg->bg->canvas_item = NULL;
470 if (pg->bg->type == BG_SOLID)
472 pg->bg->canvas_item = gnome_canvas_item_new(pg->group,
473 gnome_canvas_group_get_type(), NULL);
474 group = GNOME_CANVAS_GROUP(pg->bg->canvas_item);
475 lower_canvas_item_to(pg->group, pg->bg->canvas_item, NULL);
476 gnome_canvas_item_new(group, gnome_canvas_rect_get_type(),
477 "x1", 0., "x2", pg->width, "y1", 0., "y2", pg->height,
478 "fill-color-rgba", pg->bg->color_rgba, NULL);
479 if (pg->bg->ruling == RULING_NONE) return;
480 seg = gnome_canvas_points_new(2);
482 if (pg->bg->ruling == RULING_GRAPH) {
483 pt[1] = 0; pt[3] = pg->height;
484 for (x=RULING_GRAPHSPACING; x<pg->width-1; x+=RULING_GRAPHSPACING) {
486 gnome_canvas_item_new(group, gnome_canvas_line_get_type(),
487 "points", seg, "fill-color-rgba", RULING_COLOR,
488 "width-units", RULING_THICKNESS, NULL);
490 pt[0] = 0; pt[2] = pg->width;
491 for (y=RULING_GRAPHSPACING; y<pg->height-1; y+=RULING_GRAPHSPACING) {
493 gnome_canvas_item_new(group, gnome_canvas_line_get_type(),
494 "points", seg, "fill-color-rgba", RULING_COLOR,
495 "width-units", RULING_THICKNESS, NULL);
497 gnome_canvas_points_free(seg);
500 pt[0] = 0; pt[2] = pg->width;
501 for (y=RULING_TOPMARGIN; y<pg->height-1; y+=RULING_SPACING) {
503 gnome_canvas_item_new(group, gnome_canvas_line_get_type(),
504 "points", seg, "fill-color-rgba", RULING_COLOR,
505 "width-units", RULING_THICKNESS, NULL);
507 if (pg->bg->ruling == RULING_LINED) {
508 pt[0] = pt[2] = RULING_LEFTMARGIN;
509 pt[1] = 0; pt[3] = pg->height;
510 gnome_canvas_item_new(group, gnome_canvas_line_get_type(),
511 "points", seg, "fill-color-rgba", RULING_MARGIN_COLOR,
512 "width-units", RULING_THICKNESS, NULL);
514 gnome_canvas_points_free(seg);
518 if (pg->bg->type == BG_PIXMAP)
520 if (ui.antialias_bg) {
521 set_cursor_busy(TRUE);
522 w = (int)floor(pg->width*ui.zoom+0.5);
523 h = (int)floor(pg->height*ui.zoom+0.5);
524 if (w == gdk_pixbuf_get_width(pg->bg->pixbuf) &&
525 h == gdk_pixbuf_get_height(pg->bg->pixbuf))
526 scaled_pix = gdk_pixbuf_ref(pg->bg->pixbuf);
528 scaled_pix = gdk_pixbuf_scale_simple(pg->bg->pixbuf, w, h, GDK_INTERP_BILINEAR);
529 pg->bg->pixbuf_scale = ui.zoom;
530 set_cursor_busy(FALSE);
533 scaled_pix = gdk_pixbuf_ref(pg->bg->pixbuf);
534 pg->bg->pixbuf_scale = 0;
536 pg->bg->canvas_item = gnome_canvas_item_new(pg->group,
537 gnome_canvas_pixbuf_get_type(),
538 "pixbuf", scaled_pix,
539 "width", pg->width, "height", pg->height,
540 "width-set", TRUE, "height-set", TRUE,
542 gdk_pixbuf_unref(scaled_pix);
543 lower_canvas_item_to(pg->group, pg->bg->canvas_item, NULL);
546 if (pg->bg->type == BG_PDF)
548 if (pg->bg->pixbuf == NULL) return;
549 pg->bg->canvas_item = gnome_canvas_item_new(pg->group,
550 gnome_canvas_pixbuf_get_type(),
551 "pixbuf", pg->bg->pixbuf,
552 "width", pg->width, "height", pg->height,
553 "width-set", TRUE, "height-set", TRUE,
555 lower_canvas_item_to(pg->group, pg->bg->canvas_item, NULL);
560 gboolean is_visible(struct Page *pg)
562 GtkAdjustment *v_adj;
565 if (!ui.view_continuous) return (pg == ui.cur_page);
566 v_adj = gtk_layout_get_vadjustment(GTK_LAYOUT(canvas));
567 ytop = v_adj->value/ui.zoom;
568 ybot = (v_adj->value + v_adj->page_size) / ui.zoom;
569 return (MAX(ytop, pg->voffset) < MIN(ybot, pg->voffset+pg->height));
572 void rescale_bg_pixmaps(void)
578 for (pglist = journal.pages; pglist!=NULL; pglist = pglist->next) {
579 pg = (struct Page *)pglist->data;
580 // in progressive mode we scale only visible pages
581 if (ui.progressive_bg && !is_visible(pg)) continue;
583 if (pg->bg->type == BG_PIXMAP && pg->bg->canvas_item!=NULL) { // do the rescaling ourselves
584 if (ui.antialias_bg) {
585 if (pg->bg->pixbuf_scale == ui.zoom) continue;
586 set_cursor_busy(TRUE);
587 pix = gdk_pixbuf_scale_simple(pg->bg->pixbuf,
588 (int)floor(pg->width*ui.zoom+0.5), (int)floor(pg->height*ui.zoom+0.5),
589 GDK_INTERP_BILINEAR);
590 gnome_canvas_item_set(pg->bg->canvas_item, "pixbuf", pix, NULL);
591 gdk_pixbuf_unref(pix);
592 pg->bg->pixbuf_scale = ui.zoom;
593 set_cursor_busy(FALSE);
596 g_object_get(G_OBJECT(pg->bg->canvas_item), "pixbuf", &pix, NULL);
597 if (pix!=pg->bg->pixbuf)
598 gnome_canvas_item_set(pg->bg->canvas_item, "pixbuf", pg->bg->pixbuf, NULL);
599 pg->bg->pixbuf_scale = 0;
602 if (pg->bg->type == BG_PDF) { // request an asynchronous update
603 if (pg->bg->pixbuf_scale == ui.zoom) continue;
604 add_bgpdf_request(pg->bg->file_page_seq, ui.zoom, FALSE);
605 pg->bg->pixbuf_scale = ui.zoom;
610 gboolean have_intersect(struct BBox *a, struct BBox *b)
612 return (MAX(a->top, b->top) <= MIN(a->bottom, b->bottom)) &&
613 (MAX(a->left, b->left) <= MIN(a->right, b->right));
616 /* In libgnomecanvas 2.10.0, the lower/raise functions fail to update
617 correctly the end of the group's item list. We try to work around this.
618 DON'T USE gnome_canvas_item_raise/lower directly !! */
620 void lower_canvas_item_to(GnomeCanvasGroup *g, GnomeCanvasItem *item, GnomeCanvasItem *after)
624 i1 = g_list_index(g->item_list, item);
625 if (i1 == -1) return;
627 if (after == NULL) i2 = -1;
628 else i2 = g_list_index(g->item_list, after);
630 if (i1 < i2) gnome_canvas_item_raise(item, i2-i1);
631 if (i1 > i2+1) gnome_canvas_item_lower(item, i1-i2-1);
633 // BUGFIX for libgnomecanvas
634 g->item_list_end = g_list_last(g->item_list);
637 void rgb_to_gdkcolor(guint rgba, GdkColor *color)
640 color->red = ((rgba>>24)&0xff)*0x101;
641 color->green = ((rgba>>16)&0xff)*0x101;
642 color->blue = ((rgba>>8)&0xff)*0x101;
645 // some interface functions
647 void update_thickness_buttons(void)
649 if (ui.selection!=NULL || ui.toolno[ui.cur_mapping] >= NUM_STROKE_TOOLS) {
650 gtk_toggle_tool_button_set_active(
651 GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonThicknessOther")), TRUE);
653 switch (ui.cur_brush->thickness_no) {
655 gtk_toggle_tool_button_set_active(
656 GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonFine")), TRUE);
658 case THICKNESS_MEDIUM:
659 gtk_toggle_tool_button_set_active(
660 GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonMedium")), TRUE);
662 case THICKNESS_THICK:
663 gtk_toggle_tool_button_set_active(
664 GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonThick")), TRUE);
667 gtk_toggle_tool_button_set_active(
668 GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonThicknessOther")), TRUE);
672 void update_color_buttons(void)
674 if (ui.selection!=NULL || (ui.toolno[ui.cur_mapping] != TOOL_PEN
675 && ui.toolno[ui.cur_mapping] != TOOL_HIGHLIGHTER && ui.toolno[ui.cur_mapping] != TOOL_TEXT)) {
676 gtk_toggle_tool_button_set_active(
677 GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonColorOther")), TRUE);
679 switch (ui.cur_brush->color_no) {
681 gtk_toggle_tool_button_set_active(
682 GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonBlack")), TRUE);
685 gtk_toggle_tool_button_set_active(
686 GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonBlue")), TRUE);
689 gtk_toggle_tool_button_set_active(
690 GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonRed")), TRUE);
693 gtk_toggle_tool_button_set_active(
694 GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonGreen")), TRUE);
697 gtk_toggle_tool_button_set_active(
698 GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonGray")), TRUE);
700 case COLOR_LIGHTBLUE:
701 gtk_toggle_tool_button_set_active(
702 GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonLightBlue")), TRUE);
704 case COLOR_LIGHTGREEN:
705 gtk_toggle_tool_button_set_active(
706 GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonLightGreen")), TRUE);
709 gtk_toggle_tool_button_set_active(
710 GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonMagenta")), TRUE);
713 gtk_toggle_tool_button_set_active(
714 GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonOrange")), TRUE);
717 gtk_toggle_tool_button_set_active(
718 GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonYellow")), TRUE);
721 gtk_toggle_tool_button_set_active(
722 GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonWhite")), TRUE);
725 gtk_toggle_tool_button_set_active(
726 GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonColorOther")), TRUE);
730 void update_tool_buttons(void)
732 switch(ui.toolno[ui.cur_mapping]) {
734 gtk_toggle_tool_button_set_active(
735 GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonPen")), TRUE);
738 gtk_toggle_tool_button_set_active(
739 GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonEraser")), TRUE);
741 case TOOL_HIGHLIGHTER:
742 gtk_toggle_tool_button_set_active(
743 GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonHighlighter")), TRUE);
746 gtk_toggle_tool_button_set_active(
747 GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonText")), TRUE);
749 case TOOL_SELECTREGION:
750 gtk_toggle_tool_button_set_active(
751 GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonSelectRegion")), TRUE);
753 case TOOL_SELECTRECT:
754 gtk_toggle_tool_button_set_active(
755 GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonSelectRectangle")), TRUE);
758 gtk_toggle_tool_button_set_active(
759 GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonVerticalSpace")), TRUE);
762 gtk_toggle_tool_button_set_active(
763 GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonHand")), TRUE);
767 gtk_toggle_tool_button_set_active(
768 GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonRuler")), ui.ruler[ui.cur_mapping]);
769 update_thickness_buttons();
770 update_color_buttons();
773 void update_tool_menu(void)
775 switch(ui.toolno[0]) {
777 gtk_check_menu_item_set_active(
778 GTK_CHECK_MENU_ITEM(GET_COMPONENT("toolsPen")), TRUE);
781 gtk_check_menu_item_set_active(
782 GTK_CHECK_MENU_ITEM(GET_COMPONENT("toolsEraser")), TRUE);
784 case TOOL_HIGHLIGHTER:
785 gtk_check_menu_item_set_active(
786 GTK_CHECK_MENU_ITEM(GET_COMPONENT("toolsHighlighter")), TRUE);
789 gtk_check_menu_item_set_active(
790 GTK_CHECK_MENU_ITEM(GET_COMPONENT("toolsText")), TRUE);
792 case TOOL_SELECTREGION:
793 gtk_check_menu_item_set_active(
794 GTK_CHECK_MENU_ITEM(GET_COMPONENT("toolsSelectRegion")), TRUE);
796 case TOOL_SELECTRECT:
797 gtk_check_menu_item_set_active(
798 GTK_CHECK_MENU_ITEM(GET_COMPONENT("toolsSelectRectangle")), TRUE);
801 gtk_check_menu_item_set_active(
802 GTK_CHECK_MENU_ITEM(GET_COMPONENT("toolsVerticalSpace")), TRUE);
805 gtk_check_menu_item_set_active(
806 GTK_CHECK_MENU_ITEM(GET_COMPONENT("toolsHand")), TRUE);
810 gtk_check_menu_item_set_active(
811 GTK_CHECK_MENU_ITEM(GET_COMPONENT("toolsRuler")), ui.ruler[0]);
814 void update_ruler_indicator(void)
816 gtk_toggle_tool_button_set_active(
817 GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonRuler")), ui.ruler[ui.cur_mapping]);
818 gtk_check_menu_item_set_active(
819 GTK_CHECK_MENU_ITEM(GET_COMPONENT("toolsRuler")), ui.ruler[0]);
822 void update_color_menu(void)
824 if (ui.selection!=NULL || (ui.toolno[ui.cur_mapping] != TOOL_PEN
825 && ui.toolno[ui.cur_mapping] != TOOL_HIGHLIGHTER && ui.toolno[ui.cur_mapping] != TOOL_TEXT)) {
826 gtk_check_menu_item_set_active(
827 GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorNA")), TRUE);
829 switch (ui.cur_brush->color_no) {
831 gtk_check_menu_item_set_active(
832 GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorBlack")), TRUE);
835 gtk_check_menu_item_set_active(
836 GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorBlue")), TRUE);
839 gtk_check_menu_item_set_active(
840 GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorRed")), TRUE);
843 gtk_check_menu_item_set_active(
844 GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorGreen")), TRUE);
847 gtk_check_menu_item_set_active(
848 GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorGray")), TRUE);
850 case COLOR_LIGHTBLUE:
851 gtk_check_menu_item_set_active(
852 GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorLightBlue")), TRUE);
854 case COLOR_LIGHTGREEN:
855 gtk_check_menu_item_set_active(
856 GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorLightGreen")), TRUE);
859 gtk_check_menu_item_set_active(
860 GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorMagenta")), TRUE);
863 gtk_check_menu_item_set_active(
864 GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorOrange")), TRUE);
867 gtk_check_menu_item_set_active(
868 GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorYellow")), TRUE);
871 gtk_check_menu_item_set_active(
872 GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorWhite")), TRUE);
875 gtk_check_menu_item_set_active(
876 GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorOther")), TRUE);
880 void update_pen_props_menu(void)
882 switch(ui.brushes[0][TOOL_PEN].thickness_no) {
883 case THICKNESS_VERYFINE:
884 gtk_check_menu_item_set_active(
885 GTK_CHECK_MENU_ITEM(GET_COMPONENT("penthicknessVeryFine")), TRUE);
888 gtk_check_menu_item_set_active(
889 GTK_CHECK_MENU_ITEM(GET_COMPONENT("penthicknessFine")), TRUE);
891 case THICKNESS_MEDIUM:
892 gtk_check_menu_item_set_active(
893 GTK_CHECK_MENU_ITEM(GET_COMPONENT("penthicknessMedium")), TRUE);
895 case THICKNESS_THICK:
896 gtk_check_menu_item_set_active(
897 GTK_CHECK_MENU_ITEM(GET_COMPONENT("penthicknessThick")), TRUE);
899 case THICKNESS_VERYTHICK:
900 gtk_check_menu_item_set_active(
901 GTK_CHECK_MENU_ITEM(GET_COMPONENT("penthicknessVeryThick")), TRUE);
906 void update_eraser_props_menu(void)
908 switch (ui.brushes[0][TOOL_ERASER].thickness_no) {
910 gtk_check_menu_item_set_active(
911 GTK_CHECK_MENU_ITEM(GET_COMPONENT("eraserFine")), TRUE);
913 case THICKNESS_MEDIUM:
914 gtk_check_menu_item_set_active(
915 GTK_CHECK_MENU_ITEM(GET_COMPONENT("eraserMedium")), TRUE);
917 case THICKNESS_THICK:
918 gtk_check_menu_item_set_active(
919 GTK_CHECK_MENU_ITEM(GET_COMPONENT("eraserThick")), TRUE);
923 gtk_check_menu_item_set_active(
924 GTK_CHECK_MENU_ITEM(GET_COMPONENT("eraserStandard")),
925 ui.brushes[0][TOOL_ERASER].tool_options == TOOLOPT_ERASER_STANDARD);
926 gtk_check_menu_item_set_active(
927 GTK_CHECK_MENU_ITEM(GET_COMPONENT("eraserWhiteout")),
928 ui.brushes[0][TOOL_ERASER].tool_options == TOOLOPT_ERASER_WHITEOUT);
929 gtk_check_menu_item_set_active(
930 GTK_CHECK_MENU_ITEM(GET_COMPONENT("eraserDeleteStrokes")),
931 ui.brushes[0][TOOL_ERASER].tool_options == TOOLOPT_ERASER_STROKES);
934 void update_highlighter_props_menu(void)
936 switch (ui.brushes[0][TOOL_HIGHLIGHTER].thickness_no) {
938 gtk_check_menu_item_set_active(
939 GTK_CHECK_MENU_ITEM(GET_COMPONENT("highlighterFine")), TRUE);
941 case THICKNESS_MEDIUM:
942 gtk_check_menu_item_set_active(
943 GTK_CHECK_MENU_ITEM(GET_COMPONENT("highlighterMedium")), TRUE);
945 case THICKNESS_THICK:
946 gtk_check_menu_item_set_active(
947 GTK_CHECK_MENU_ITEM(GET_COMPONENT("highlighterThick")), TRUE);
952 void update_mappings_menu_linkings(void)
954 switch (ui.linked_brush[1]) {
956 gtk_check_menu_item_set_active(
957 GTK_CHECK_MENU_ITEM(GET_COMPONENT("button2LinkBrush")), TRUE);
960 gtk_check_menu_item_set_active(
961 GTK_CHECK_MENU_ITEM(GET_COMPONENT("button2CopyBrush")), TRUE);
964 gtk_check_menu_item_set_active(
965 GTK_CHECK_MENU_ITEM(GET_COMPONENT("button2NABrush")), TRUE);
968 switch (ui.linked_brush[2]) {
970 gtk_check_menu_item_set_active(
971 GTK_CHECK_MENU_ITEM(GET_COMPONENT("button3LinkBrush")), TRUE);
974 gtk_check_menu_item_set_active(
975 GTK_CHECK_MENU_ITEM(GET_COMPONENT("button3CopyBrush")), TRUE);
978 gtk_check_menu_item_set_active(
979 GTK_CHECK_MENU_ITEM(GET_COMPONENT("button3NABrush")), TRUE);
984 void update_mappings_menu(void)
986 gtk_widget_set_sensitive(GET_COMPONENT("optionsButtonMappings"), ui.use_xinput);
987 gtk_widget_set_sensitive(GET_COMPONENT("optionsDiscardCoreEvents"), ui.use_xinput);
988 gtk_check_menu_item_set_active(
989 GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsButtonMappings")), ui.use_erasertip);
990 gtk_check_menu_item_set_active(
991 GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsDiscardCoreEvents")), ui.discard_corepointer);
993 switch(ui.toolno[1]) {
995 gtk_check_menu_item_set_active(
996 GTK_CHECK_MENU_ITEM(GET_COMPONENT("button2Pen")), TRUE);
999 gtk_check_menu_item_set_active(
1000 GTK_CHECK_MENU_ITEM(GET_COMPONENT("button2Eraser")), TRUE);
1002 case TOOL_HIGHLIGHTER:
1003 gtk_check_menu_item_set_active(
1004 GTK_CHECK_MENU_ITEM(GET_COMPONENT("button2Highlighter")), TRUE);
1007 gtk_check_menu_item_set_active(
1008 GTK_CHECK_MENU_ITEM(GET_COMPONENT("button2Text")), TRUE);
1010 case TOOL_SELECTREGION:
1011 gtk_check_menu_item_set_active(
1012 GTK_CHECK_MENU_ITEM(GET_COMPONENT("button2SelectRegion")), TRUE);
1014 case TOOL_SELECTRECT:
1015 gtk_check_menu_item_set_active(
1016 GTK_CHECK_MENU_ITEM(GET_COMPONENT("button2SelectRectangle")), TRUE);
1018 case TOOL_VERTSPACE:
1019 gtk_check_menu_item_set_active(
1020 GTK_CHECK_MENU_ITEM(GET_COMPONENT("button2VerticalSpace")), TRUE);
1023 switch(ui.toolno[2]) {
1025 gtk_check_menu_item_set_active(
1026 GTK_CHECK_MENU_ITEM(GET_COMPONENT("button3Pen")), TRUE);
1029 gtk_check_menu_item_set_active(
1030 GTK_CHECK_MENU_ITEM(GET_COMPONENT("button3Eraser")), TRUE);
1032 case TOOL_HIGHLIGHTER:
1033 gtk_check_menu_item_set_active(
1034 GTK_CHECK_MENU_ITEM(GET_COMPONENT("button3Highlighter")), TRUE);
1037 gtk_check_menu_item_set_active(
1038 GTK_CHECK_MENU_ITEM(GET_COMPONENT("button3Text")), TRUE);
1040 case TOOL_SELECTREGION:
1041 gtk_check_menu_item_set_active(
1042 GTK_CHECK_MENU_ITEM(GET_COMPONENT("button3SelectRegion")), TRUE);
1044 case TOOL_SELECTRECT:
1045 gtk_check_menu_item_set_active(
1046 GTK_CHECK_MENU_ITEM(GET_COMPONENT("button3SelectRectangle")), TRUE);
1048 case TOOL_VERTSPACE:
1049 gtk_check_menu_item_set_active(
1050 GTK_CHECK_MENU_ITEM(GET_COMPONENT("button3VerticalSpace")), TRUE);
1053 update_mappings_menu_linkings();
1056 void do_switch_page(int pg, gboolean rescroll, gboolean refresh_all)
1059 struct Layer *layer;
1064 /* re-show all the layers of the old page */
1065 if (ui.cur_page != NULL)
1066 for (i=0, list = ui.cur_page->layers; list!=NULL; i++, list = list->next) {
1067 layer = (struct Layer *)list->data;
1068 if (layer->group!=NULL)
1069 gnome_canvas_item_show(GNOME_CANVAS_ITEM(layer->group));
1072 ui.cur_page = g_list_nth_data(journal.pages, ui.pageno);
1073 ui.layerno = ui.cur_page->nlayers-1;
1074 ui.cur_layer = (struct Layer *)(g_list_last(ui.cur_page->layers)->data);
1075 update_page_stuff();
1076 if (ui.progressive_bg) rescale_bg_pixmaps();
1078 if (rescroll) { // scroll and force a refresh
1079 /* -- this seems to cause some display bugs ??
1080 gtk_adjustment_set_value(gtk_layout_get_vadjustment(GTK_LAYOUT(canvas)),
1081 ui.cur_page->voffset*ui.zoom); */
1082 gnome_canvas_get_scroll_offsets(canvas, &cx, &cy);
1083 cy = ui.cur_page->voffset*ui.zoom;
1084 gnome_canvas_scroll_to(canvas, cx, cy);
1087 gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
1088 else if (!ui.view_continuous)
1089 gnome_canvas_item_move(GNOME_CANVAS_ITEM(ui.cur_page->group), 0., 0.);
1093 void update_page_stuff(void)
1096 GtkComboBox *layerbox;
1099 GtkSpinButton *spin;
1101 double vertpos, maxwidth;
1102 struct Layer *layer;
1105 // move the page groups to their rightful locations or hide them
1106 if (ui.view_continuous) {
1109 for (i=0, pglist = journal.pages; pglist!=NULL; i++, pglist = pglist->next) {
1110 pg = (struct Page *)pglist->data;
1111 if (pg->group!=NULL) {
1112 pg->hoffset = 0.; pg->voffset = vertpos;
1113 gnome_canvas_item_set(GNOME_CANVAS_ITEM(pg->group),
1114 "x", pg->hoffset, "y", pg->voffset, NULL);
1115 gnome_canvas_item_show(GNOME_CANVAS_ITEM(pg->group));
1117 vertpos += pg->height + VIEW_CONTINUOUS_SKIP;
1118 if (pg->width > maxwidth) maxwidth = pg->width;
1120 vertpos -= VIEW_CONTINUOUS_SKIP;
1121 gnome_canvas_set_scroll_region(canvas, 0, 0, maxwidth, vertpos);
1123 for (pglist = journal.pages; pglist!=NULL; pglist = pglist->next) {
1124 pg = (struct Page *)pglist->data;
1125 if (pg == ui.cur_page && pg->group!=NULL) {
1126 pg->hoffset = 0.; pg->voffset = 0.;
1127 gnome_canvas_item_set(GNOME_CANVAS_ITEM(pg->group),
1128 "x", pg->hoffset, "y", pg->voffset, NULL);
1129 gnome_canvas_item_show(GNOME_CANVAS_ITEM(pg->group));
1131 if (pg->group!=NULL) gnome_canvas_item_hide(GNOME_CANVAS_ITEM(pg->group));
1134 gnome_canvas_set_scroll_region(canvas, 0, 0, ui.cur_page->width, ui.cur_page->height);
1137 // update the page / layer info at bottom of screen
1139 spin = GTK_SPIN_BUTTON(GET_COMPONENT("spinPageNo"));
1140 ui.in_update_page_stuff = TRUE; // avoid a bad retroaction
1141 gtk_spin_button_set_range(spin, 1, journal.npages+1);
1142 /* npages+1 will be used to create a new page at end */
1143 gtk_spin_button_set_value(spin, ui.pageno+1);
1144 g_snprintf(tmp, 10, " of %d", journal.npages);
1145 gtk_label_set_text(GTK_LABEL(GET_COMPONENT("labelNumpages")), tmp);
1147 layerbox = GTK_COMBO_BOX(GET_COMPONENT("comboLayer"));
1148 if (ui.layerbox_length == 0) {
1149 gtk_combo_box_prepend_text(layerbox, "Background");
1150 ui.layerbox_length++;
1152 while (ui.layerbox_length > ui.cur_page->nlayers+1) {
1153 gtk_combo_box_remove_text(layerbox, 0);
1154 ui.layerbox_length--;
1156 while (ui.layerbox_length < ui.cur_page->nlayers+1) {
1157 g_snprintf(tmp, 10, "Layer %d", ui.layerbox_length++);
1158 gtk_combo_box_prepend_text(layerbox, tmp);
1160 gtk_combo_box_set_active(layerbox, ui.cur_page->nlayers-1-ui.layerno);
1161 ui.in_update_page_stuff = FALSE;
1163 // update the paper-style menu radio buttons
1165 if (ui.view_continuous)
1166 gtk_check_menu_item_set_active(
1167 GTK_CHECK_MENU_ITEM(GET_COMPONENT("viewContinuous")), TRUE);
1169 gtk_check_menu_item_set_active(
1170 GTK_CHECK_MENU_ITEM(GET_COMPONENT("viewOnePage")), TRUE);
1172 if (ui.cur_page->bg->type == BG_SOLID && !ui.bg_apply_all_pages) {
1173 switch (ui.cur_page->bg->color_no) {
1175 gtk_check_menu_item_set_active(
1176 GTK_CHECK_MENU_ITEM(GET_COMPONENT("papercolorWhite")), TRUE);
1179 gtk_check_menu_item_set_active(
1180 GTK_CHECK_MENU_ITEM(GET_COMPONENT("papercolorYellow")), TRUE);
1183 gtk_check_menu_item_set_active(
1184 GTK_CHECK_MENU_ITEM(GET_COMPONENT("papercolorPink")), TRUE);
1187 gtk_check_menu_item_set_active(
1188 GTK_CHECK_MENU_ITEM(GET_COMPONENT("papercolorOrange")), TRUE);
1191 gtk_check_menu_item_set_active(
1192 GTK_CHECK_MENU_ITEM(GET_COMPONENT("papercolorBlue")), TRUE);
1195 gtk_check_menu_item_set_active(
1196 GTK_CHECK_MENU_ITEM(GET_COMPONENT("papercolorGreen")), TRUE);
1199 gtk_check_menu_item_set_active(
1200 GTK_CHECK_MENU_ITEM(GET_COMPONENT("papercolorOther")), TRUE);
1203 switch (ui.cur_page->bg->ruling) {
1205 gtk_check_menu_item_set_active(
1206 GTK_CHECK_MENU_ITEM(GET_COMPONENT("paperstylePlain")), TRUE);
1209 gtk_check_menu_item_set_active(
1210 GTK_CHECK_MENU_ITEM(GET_COMPONENT("paperstyleLined")), TRUE);
1213 gtk_check_menu_item_set_active(
1214 GTK_CHECK_MENU_ITEM(GET_COMPONENT("paperstyleRuled")), TRUE);
1217 gtk_check_menu_item_set_active(
1218 GTK_CHECK_MENU_ITEM(GET_COMPONENT("paperstyleGraph")), TRUE);
1222 gtk_check_menu_item_set_active(
1223 GTK_CHECK_MENU_ITEM(GET_COMPONENT("papercolorNA")), TRUE);
1224 gtk_check_menu_item_set_active(
1225 GTK_CHECK_MENU_ITEM(GET_COMPONENT("paperstyleNA")), TRUE);
1228 // enable/disable the page/layer menu items and toolbar buttons
1230 gtk_widget_set_sensitive(GET_COMPONENT("journalPaperColor"),
1231 ui.cur_page->bg->type == BG_SOLID || ui.bg_apply_all_pages);
1232 gtk_widget_set_sensitive(GET_COMPONENT("journalSetAsDefault"),
1233 ui.cur_page->bg->type == BG_SOLID);
1235 gtk_widget_set_sensitive(GET_COMPONENT("viewFirstPage"), ui.pageno!=0);
1236 gtk_widget_set_sensitive(GET_COMPONENT("viewPreviousPage"), ui.pageno!=0);
1237 gtk_widget_set_sensitive(GET_COMPONENT("viewNextPage"), TRUE);
1238 gtk_widget_set_sensitive(GET_COMPONENT("viewLastPage"), ui.pageno!=journal.npages-1);
1239 gtk_widget_set_sensitive(GET_COMPONENT("buttonFirstPage"), ui.pageno!=0);
1240 gtk_widget_set_sensitive(GET_COMPONENT("buttonPreviousPage"), ui.pageno!=0);
1241 gtk_widget_set_sensitive(GET_COMPONENT("buttonNextPage"), TRUE);
1242 gtk_widget_set_sensitive(GET_COMPONENT("buttonLastPage"), ui.pageno!=journal.npages-1);
1244 gtk_widget_set_sensitive(GET_COMPONENT("viewShowLayer"), ui.layerno!=ui.cur_page->nlayers-1);
1245 gtk_widget_set_sensitive(GET_COMPONENT("viewHideLayer"), ui.layerno>=0);
1247 gtk_widget_set_sensitive(GET_COMPONENT("editPaste"), ui.cur_layer!=NULL);
1248 gtk_widget_set_sensitive(GET_COMPONENT("buttonPaste"), ui.cur_layer!=NULL);
1251 void update_toolbar_and_menu(void)
1253 update_tool_buttons(); // takes care of other toolbar buttons as well
1255 update_color_menu();
1256 update_pen_props_menu();
1257 update_eraser_props_menu();
1258 update_highlighter_props_menu();
1259 update_mappings_menu();
1261 gtk_toggle_tool_button_set_active(
1262 GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonFullscreen")), ui.fullscreen);
1263 gtk_check_menu_item_set_active(
1264 GTK_CHECK_MENU_ITEM(GET_COMPONENT("viewFullscreen")), ui.fullscreen);
1267 void update_file_name(char *filename)
1270 if (ui.filename != NULL) g_free(ui.filename);
1271 ui.filename = filename;
1272 if (filename == NULL) {
1273 gtk_window_set_title(GTK_WINDOW (winMain), "Xournal");
1276 p = g_utf8_strrchr(filename, -1, '/');
1277 if (p == NULL) p = filename;
1278 else p = g_utf8_next_char(p);
1279 g_snprintf(tmp, 100, "Xournal - %s", p);
1280 gtk_window_set_title(GTK_WINDOW (winMain), tmp);
1281 new_mru_entry(filename);
1284 void update_undo_redo_enabled(void)
1286 gtk_widget_set_sensitive(GET_COMPONENT("editUndo"), undo!=NULL);
1287 gtk_widget_set_sensitive(GET_COMPONENT("editRedo"), redo!=NULL);
1288 gtk_widget_set_sensitive(GET_COMPONENT("buttonUndo"), undo!=NULL);
1289 gtk_widget_set_sensitive(GET_COMPONENT("buttonRedo"), redo!=NULL);
1292 void update_copy_paste_enabled(void)
1294 gtk_widget_set_sensitive(GET_COMPONENT("editCut"), ui.selection!=NULL);
1295 gtk_widget_set_sensitive(GET_COMPONENT("editCopy"), ui.selection!=NULL);
1296 gtk_widget_set_sensitive(GET_COMPONENT("editPaste"), ui.cur_item_type!=ITEM_TEXT);
1297 gtk_widget_set_sensitive(GET_COMPONENT("editDelete"), ui.selection!=NULL);
1298 gtk_widget_set_sensitive(GET_COMPONENT("buttonCut"), ui.selection!=NULL);
1299 gtk_widget_set_sensitive(GET_COMPONENT("buttonCopy"), ui.selection!=NULL);
1300 gtk_widget_set_sensitive(GET_COMPONENT("buttonPaste"), ui.cur_item_type!=ITEM_TEXT);
1303 void update_mapping_linkings(int toolno)
1307 for (i = 1; i<=NUM_BUTTONS; i++) {
1308 if (ui.linked_brush[i] == BRUSH_LINKED) {
1309 if (toolno >= 0 && toolno < NUM_STROKE_TOOLS)
1310 g_memmove(&(ui.brushes[i][toolno]), &(ui.brushes[0][toolno]), sizeof(struct Brush));
1311 ui.ruler[i] = ui.ruler[0];
1312 if (ui.toolno[i]!=TOOL_PEN && ui.toolno[i]!=TOOL_HIGHLIGHTER)
1313 ui.ruler[i] = FALSE;
1315 if (ui.linked_brush[i] == BRUSH_COPIED && toolno == ui.toolno[i]) {
1316 ui.linked_brush[i] = BRUSH_STATIC;
1317 if (i==1 || i==2) update_mappings_menu_linkings();
1322 void set_cur_color(int color)
1324 ui.cur_brush->color_no = color;
1325 if (ui.toolno[0] == TOOL_HIGHLIGHTER)
1326 ui.cur_brush->color_rgba = predef_colors_rgba[color] & ui.hiliter_alpha_mask;
1328 ui.cur_brush->color_rgba = predef_colors_rgba[color];
1329 update_mapping_linkings(ui.toolno[0]);
1332 void recolor_temp_text(int color_no, guint color_rgba)
1336 if (ui.cur_item_type!=ITEM_TEXT) return;
1337 if (ui.cur_item->text!=NULL && ui.cur_item->brush.color_rgba != color_rgba) {
1339 undo->type = ITEM_TEXT_ATTRIB;
1340 undo->item = ui.cur_item;
1341 undo->str = g_strdup(ui.cur_item->font_name);
1342 undo->val_x = ui.cur_item->font_size;
1343 undo->brush = (struct Brush *)g_memdup(&(ui.cur_item->brush), sizeof(struct Brush));
1345 ui.cur_item->brush.color_no = color_no;
1346 ui.cur_item->brush.color_rgba = color_rgba;
1347 rgb_to_gdkcolor(color_rgba, &gdkcolor);
1348 gtk_widget_modify_text(ui.cur_item->widget, GTK_STATE_NORMAL, &gdkcolor);
1349 gtk_widget_grab_focus(ui.cur_item->widget);
1352 void process_color_activate(GtkMenuItem *menuitem, int color)
1354 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1355 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1358 if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1362 if (ui.cur_mapping != 0) return; // not user-generated
1365 if (ui.cur_item_type == ITEM_TEXT)
1366 recolor_temp_text(color, predef_colors_rgba[color]);
1368 if (ui.selection != NULL) {
1369 recolor_selection(color);
1370 update_color_buttons();
1371 update_color_menu();
1374 if (ui.toolno[0] != TOOL_PEN && ui.toolno[0] != TOOL_HIGHLIGHTER
1375 && ui.toolno[0] != TOOL_TEXT) {
1376 if (ui.selection != NULL) return;
1378 ui.toolno[0] = TOOL_PEN;
1379 ui.cur_brush = &(ui.brushes[0][TOOL_PEN]);
1380 update_tool_buttons();
1384 set_cur_color(color);
1385 update_color_buttons();
1386 update_color_menu();
1390 void process_thickness_activate(GtkMenuItem *menuitem, int tool, int val)
1392 if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1393 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1396 if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1400 if (ui.cur_mapping != 0) return; // not user-generated
1402 if (ui.selection != NULL && GTK_OBJECT_TYPE(menuitem) != GTK_TYPE_RADIO_MENU_ITEM) {
1404 rethicken_selection(val);
1405 update_thickness_buttons();
1408 if (tool >= NUM_STROKE_TOOLS) {
1409 update_thickness_buttons(); // undo illegal button selection
1413 if (ui.brushes[0][tool].thickness_no == val) return;
1416 ui.brushes[0][tool].thickness_no = val;
1417 ui.brushes[0][tool].thickness = predef_thickness[tool][val];
1418 update_mapping_linkings(tool);
1420 update_thickness_buttons();
1421 if (tool == TOOL_PEN) update_pen_props_menu();
1422 if (tool == TOOL_ERASER) update_eraser_props_menu();
1423 if (tool == TOOL_HIGHLIGHTER) update_highlighter_props_menu();
1427 void process_papercolor_activate(GtkMenuItem *menuitem, int color)
1433 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1436 if ((ui.cur_page->bg->type != BG_SOLID) || ui.bg_apply_all_pages)
1437 gtk_check_menu_item_set_active(
1438 GTK_CHECK_MENU_ITEM(GET_COMPONENT("papercolorNA")), TRUE);
1442 for (pglist = journal.pages; pglist!=NULL; pglist = pglist->next) {
1443 if (ui.bg_apply_all_pages) pg = (struct Page *)pglist->data;
1444 if (pg->bg->type == BG_SOLID && pg->bg->color_no != color) {
1446 if (hasdone) undo->multiop |= MULTIOP_CONT_UNDO;
1447 undo->multiop |= MULTIOP_CONT_REDO;
1449 undo->type = ITEM_NEW_BG_ONE;
1451 undo->bg = (struct Background *)g_memdup(pg->bg, sizeof(struct Background));
1452 undo->bg->canvas_item = NULL;
1454 pg->bg->color_no = color;
1455 pg->bg->color_rgba = predef_bgcolors_rgba[color];
1456 update_canvas_bg(pg);
1458 if (!ui.bg_apply_all_pages) break;
1460 if (hasdone) undo->multiop -= MULTIOP_CONT_REDO;
1463 void process_paperstyle_activate(GtkMenuItem *menuitem, int style)
1467 gboolean hasdone, must_upd;
1469 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1472 if (ui.bg_apply_all_pages)
1473 gtk_check_menu_item_set_active(
1474 GTK_CHECK_MENU_ITEM(GET_COMPONENT("paperstyleNA")), TRUE);
1479 for (pglist = journal.pages; pglist!=NULL; pglist = pglist->next) {
1480 if (ui.bg_apply_all_pages) pg = (struct Page *)pglist->data;
1481 if (pg->bg->type != BG_SOLID || pg->bg->ruling != style) {
1483 undo->type = ITEM_NEW_BG_ONE;
1484 if (hasdone) undo->multiop |= MULTIOP_CONT_UNDO;
1485 undo->multiop |= MULTIOP_CONT_REDO;
1488 undo->bg = (struct Background *)g_memdup(pg->bg, sizeof(struct Background));
1489 undo->bg->canvas_item = NULL;
1491 if (pg->bg->type != BG_SOLID) {
1492 pg->bg->type = BG_SOLID;
1493 pg->bg->color_no = COLOR_WHITE;
1494 pg->bg->color_rgba = predef_bgcolors_rgba[COLOR_WHITE];
1495 pg->bg->filename = NULL;
1496 pg->bg->pixbuf = NULL;
1499 pg->bg->ruling = style;
1500 update_canvas_bg(pg);
1502 if (!ui.bg_apply_all_pages) break;
1504 if (hasdone) undo->multiop -= MULTIOP_CONT_REDO;
1505 if (must_upd) update_page_stuff();
1508 gboolean ok_to_close(void)
1511 GtkResponseType response;
1514 if (ui.saved) return TRUE;
1515 dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
1516 GTK_MESSAGE_WARNING, GTK_BUTTONS_YES_NO, "Save changes to '%s'?",
1517 (ui.filename!=NULL) ? ui.filename:"Untitled");
1518 gtk_dialog_add_button(GTK_DIALOG (dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
1519 response = gtk_dialog_run(GTK_DIALOG (dialog));
1520 gtk_widget_destroy(dialog);
1521 if (response == GTK_RESPONSE_CANCEL || response == GTK_RESPONSE_DELETE_EVENT)
1522 return FALSE; // aborted
1523 if (response == GTK_RESPONSE_YES) {
1524 on_fileSave_activate(NULL, NULL);
1525 if (!ui.saved) return FALSE; // if save failed, then we abort
1530 // test if we're still busy loading a PDF background file
1531 gboolean page_ops_forbidden(void)
1533 return (bgpdf.status != STATUS_NOT_INIT && bgpdf.create_pages);
1536 // send the focus back to the appropriate widget
1537 void reset_focus(void)
1539 if (ui.cur_item_type == ITEM_TEXT)
1540 gtk_widget_grab_focus(ui.cur_item->widget);
1542 gtk_widget_grab_focus(GTK_WIDGET(canvas));
1545 // selection / clipboard stuff
1547 void reset_selection(void)
1549 if (ui.selection == NULL) return;
1550 if (ui.selection->canvas_item != NULL)
1551 gtk_object_destroy(GTK_OBJECT(ui.selection->canvas_item));
1552 g_list_free(ui.selection->items);
1553 g_free(ui.selection);
1554 ui.selection = NULL;
1555 update_copy_paste_enabled();
1556 update_color_menu();
1557 update_thickness_buttons();
1558 update_color_buttons();
1559 update_font_button();
1562 void move_journal_items_by(GList *itemlist, double dx, double dy,
1563 struct Layer *l1, struct Layer *l2, GList *depths)
1566 GnomeCanvasItem *refitem;
1571 while (itemlist!=NULL) {
1572 item = (struct Item *)itemlist->data;
1573 if (item->type == ITEM_STROKE)
1574 for (pt=item->path->coords, i=0; i<item->path->num_points; i++, pt+=2)
1575 { pt[0] += dx; pt[1] += dy; }
1576 if (item->type == ITEM_STROKE || item->type == ITEM_TEXT || item->type == ITEM_TEMP_TEXT) {
1577 item->bbox.left += dx;
1578 item->bbox.right += dx;
1579 item->bbox.top += dy;
1580 item->bbox.bottom += dy;
1583 // find out where to insert
1584 if (depths != NULL) {
1585 if (depths->data == NULL) link = l2->items;
1587 link = g_list_find(l2->items, depths->data);
1588 if (link != NULL) link = link->next;
1591 l2->items = g_list_insert_before(l2->items, link, item);
1593 l1->items = g_list_remove(l1->items, item);
1596 if (depths != NULL) { // also raise/lower the canvas items
1597 if (item->canvas_item!=NULL) {
1598 if (depths->data == NULL) link = NULL;
1599 else link = g_list_find(l2->items, depths->data);
1600 if (link != NULL) refitem = ((struct Item *)(link->data))->canvas_item;
1601 else refitem = NULL;
1602 lower_canvas_item_to(l2->group, item->canvas_item, refitem);
1604 depths = depths->next;
1606 itemlist = itemlist->next;
1610 // Switch between button mappings
1612 /* NOTE ABOUT BUTTON MAPPINGS: ui.cur_mapping is 0 except while a canvas
1613 click event is being processed ... */
1615 void switch_mapping(int m)
1617 if (ui.cur_mapping == m) return;
1620 if (ui.toolno[m] < NUM_STROKE_TOOLS)
1621 ui.cur_brush = &(ui.brushes[m][ui.toolno[m]]);
1622 if (ui.toolno[m] == TOOL_TEXT)
1623 ui.cur_brush = &(ui.brushes[m][TOOL_PEN]);
1624 update_tool_buttons();
1625 update_color_menu();
1629 void process_mapping_activate(GtkMenuItem *menuitem, int m, int tool)
1631 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem))) return;
1632 if (ui.cur_mapping!=0) return;
1633 if (ui.toolno[m] == tool) return;
1637 ui.toolno[m] = tool;
1638 ui.ruler[m] = FALSE;
1639 if (ui.linked_brush[m] == BRUSH_LINKED
1640 && (tool==TOOL_PEN || tool==TOOL_HIGHLIGHTER))
1641 ui.ruler[m] = ui.ruler[0];
1642 if (ui.linked_brush[m] == BRUSH_COPIED) {
1643 ui.linked_brush[m] = BRUSH_STATIC;
1644 update_mappings_menu_linkings();
1648 // update the ordering of components in the main vbox
1650 const char *vbox_component_names[VBOX_MAIN_NITEMS]=
1651 {"scrolledwindowMain", "menubar", "toolbarMain", "toolbarPen", "hbox1"};
1653 void update_vbox_order(int *order)
1657 GtkBox *vboxMain = GTK_BOX(GET_COMPONENT("vboxMain"));
1658 gboolean present[VBOX_MAIN_NITEMS];
1660 for (i=0; i<VBOX_MAIN_NITEMS; i++) present[i] = FALSE;
1662 for (i=0; i<VBOX_MAIN_NITEMS; i++) {
1663 if (order[i]<0 || order[i]>=VBOX_MAIN_NITEMS) continue;
1664 present[order[i]] = TRUE;
1665 child = GET_COMPONENT(vbox_component_names[order[i]]);
1666 gtk_box_reorder_child(vboxMain, child, j++);
1667 gtk_widget_show(child);
1669 for (i=1; i<VBOX_MAIN_NITEMS; i++) // hide others, but not the drawing area!
1670 if (!present[i]) gtk_widget_hide(GET_COMPONENT(vbox_component_names[i]));
1673 gchar *make_cur_font_name(void)
1678 if (ui.cur_item_type == ITEM_TEXT)
1679 str = g_strdup_printf("%s %.1f", ui.cur_item->font_name, ui.cur_item->font_size);
1680 else if (ui.selection!=NULL && ui.selection->items!=NULL &&
1681 ui.selection->items->next==NULL &&
1682 (it=(struct Item*)ui.selection->items->data)->type == ITEM_TEXT)
1683 str = g_strdup_printf("%s %.1f", it->font_name, it->font_size);
1685 str = g_strdup_printf("%s %.1f", ui.font_name, ui.font_size);
1689 void update_font_button(void)
1693 str = make_cur_font_name();
1694 gtk_font_button_set_font_name(GTK_FONT_BUTTON(GET_COMPONENT("fontButton")), str);
1698 gboolean can_accel(GtkWidget *widget, guint id, gpointer data)
1700 return GTK_WIDGET_SENSITIVE(widget);
1703 void allow_all_accels(void)
1705 g_signal_connect((gpointer) GET_COMPONENT("fileNew"),
1706 "can-activate-accel", G_CALLBACK(can_accel), NULL);
1707 g_signal_connect((gpointer) GET_COMPONENT("fileOpen"),
1708 "can-activate-accel", G_CALLBACK(can_accel), NULL);
1709 g_signal_connect((gpointer) GET_COMPONENT("fileSave"),
1710 "can-activate-accel", G_CALLBACK(can_accel), NULL);
1711 g_signal_connect((gpointer) GET_COMPONENT("filePrint"),
1712 "can-activate-accel", G_CALLBACK(can_accel), NULL);
1713 g_signal_connect((gpointer) GET_COMPONENT("filePrintPDF"),
1714 "can-activate-accel", G_CALLBACK(can_accel), NULL);
1715 g_signal_connect((gpointer) GET_COMPONENT("fileQuit"),
1716 "can-activate-accel", G_CALLBACK(can_accel), NULL);
1717 g_signal_connect((gpointer) GET_COMPONENT("editUndo"),
1718 "can-activate-accel", G_CALLBACK(can_accel), NULL);
1719 g_signal_connect((gpointer) GET_COMPONENT("editRedo"),
1720 "can-activate-accel", G_CALLBACK(can_accel), NULL);
1721 g_signal_connect((gpointer) GET_COMPONENT("editCut"),
1722 "can-activate-accel", G_CALLBACK(can_accel), NULL);
1723 g_signal_connect((gpointer) GET_COMPONENT("editCopy"),
1724 "can-activate-accel", G_CALLBACK(can_accel), NULL);
1725 g_signal_connect((gpointer) GET_COMPONENT("editPaste"),
1726 "can-activate-accel", G_CALLBACK(can_accel), NULL);
1727 g_signal_connect((gpointer) GET_COMPONENT("editDelete"),
1728 "can-activate-accel", G_CALLBACK(can_accel), NULL);
1729 g_signal_connect((gpointer) GET_COMPONENT("viewFullscreen"),
1730 "can-activate-accel", G_CALLBACK(can_accel), NULL);
1731 g_signal_connect((gpointer) GET_COMPONENT("viewZoomIn"),
1732 "can-activate-accel", G_CALLBACK(can_accel), NULL);
1733 g_signal_connect((gpointer) GET_COMPONENT("viewZoomOut"),
1734 "can-activate-accel", G_CALLBACK(can_accel), NULL);
1735 g_signal_connect((gpointer) GET_COMPONENT("viewNormalSize"),
1736 "can-activate-accel", G_CALLBACK(can_accel), NULL);
1737 g_signal_connect((gpointer) GET_COMPONENT("viewPageWidth"),
1738 "can-activate-accel", G_CALLBACK(can_accel), NULL);
1739 g_signal_connect((gpointer) GET_COMPONENT("viewFirstPage"),
1740 "can-activate-accel", G_CALLBACK(can_accel), NULL);
1741 g_signal_connect((gpointer) GET_COMPONENT("viewPreviousPage"),
1742 "can-activate-accel", G_CALLBACK(can_accel), NULL);
1743 g_signal_connect((gpointer) GET_COMPONENT("viewNextPage"),
1744 "can-activate-accel", G_CALLBACK(can_accel), NULL);
1745 g_signal_connect((gpointer) GET_COMPONENT("viewLastPage"),
1746 "can-activate-accel", G_CALLBACK(can_accel), NULL);
1747 g_signal_connect((gpointer) GET_COMPONENT("toolsPen"),
1748 "can-activate-accel", G_CALLBACK(can_accel), NULL);
1749 g_signal_connect((gpointer) GET_COMPONENT("toolsEraser"),
1750 "can-activate-accel", G_CALLBACK(can_accel), NULL);
1751 g_signal_connect((gpointer) GET_COMPONENT("toolsHighlighter"),
1752 "can-activate-accel", G_CALLBACK(can_accel), NULL);
1753 g_signal_connect((gpointer) GET_COMPONENT("toolsText"),
1754 "can-activate-accel", G_CALLBACK(can_accel), NULL);
1755 /* g_signal_connect((gpointer) GET_COMPONENT("toolsSelectRegion"),
1756 "can-activate-accel", G_CALLBACK(can_accel), NULL); */
1757 g_signal_connect((gpointer) GET_COMPONENT("toolsSelectRectangle"),
1758 "can-activate-accel", G_CALLBACK(can_accel), NULL);
1759 g_signal_connect((gpointer) GET_COMPONENT("toolsVerticalSpace"),
1760 "can-activate-accel", G_CALLBACK(can_accel), NULL);
1761 g_signal_connect((gpointer) GET_COMPONENT("toolsHand"),
1762 "can-activate-accel", G_CALLBACK(can_accel), NULL);
1763 g_signal_connect((gpointer) GET_COMPONENT("toolsTextFont"),
1764 "can-activate-accel", G_CALLBACK(can_accel), NULL);
1765 g_signal_connect((gpointer) GET_COMPONENT("toolsRuler"),
1766 "can-activate-accel", G_CALLBACK(can_accel), NULL);
1769 void add_scroll_bindings(void)
1771 GtkBindingSet *binding_set;
1773 binding_set = gtk_binding_set_by_class(
1774 G_OBJECT_GET_CLASS(GET_COMPONENT("scrolledwindowMain")));
1775 gtk_binding_entry_add_signal(binding_set, GDK_Up, 0,
1776 "scroll_child", 2, GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_STEP_BACKWARD,
1777 G_TYPE_BOOLEAN, FALSE);
1778 gtk_binding_entry_add_signal(binding_set, GDK_KP_Up, 0,
1779 "scroll_child", 2, GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_STEP_BACKWARD,
1780 G_TYPE_BOOLEAN, FALSE);
1781 gtk_binding_entry_add_signal(binding_set, GDK_Down, 0,
1782 "scroll_child", 2, GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_STEP_FORWARD,
1783 G_TYPE_BOOLEAN, FALSE);
1784 gtk_binding_entry_add_signal(binding_set, GDK_KP_Down, 0,
1785 "scroll_child", 2, GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_STEP_FORWARD,
1786 G_TYPE_BOOLEAN, FALSE);
1787 gtk_binding_entry_add_signal(binding_set, GDK_Left, 0,
1788 "scroll_child", 2, GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_STEP_BACKWARD,
1789 G_TYPE_BOOLEAN, TRUE);
1790 gtk_binding_entry_add_signal(binding_set, GDK_KP_Left, 0,
1791 "scroll_child", 2, GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_STEP_BACKWARD,
1792 G_TYPE_BOOLEAN, TRUE);
1793 gtk_binding_entry_add_signal(binding_set, GDK_Right, 0,
1794 "scroll_child", 2, GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_STEP_FORWARD,
1795 G_TYPE_BOOLEAN, TRUE);
1796 gtk_binding_entry_add_signal(binding_set, GDK_KP_Right, 0,
1797 "scroll_child", 2, GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_STEP_FORWARD,
1798 G_TYPE_BOOLEAN, TRUE);
1801 gboolean is_event_within_textview(GdkEventButton *event)
1805 if (ui.cur_item_type!=ITEM_TEXT) return FALSE;
1806 get_pointer_coords((GdkEvent *)event, pt);
1807 if (pt[0]<ui.cur_item->bbox.left || pt[0]>ui.cur_item->bbox.right) return FALSE;
1808 if (pt[1]<ui.cur_item->bbox.top || pt[1]>ui.cur_item->bbox.bottom) return FALSE;
1812 void hide_unimplemented(void)
1814 gtk_widget_hide(GET_COMPONENT("filePrintOptions"));
1815 gtk_widget_hide(GET_COMPONENT("journalFlatten"));
1816 gtk_widget_hide(GET_COMPONENT("papercolorOther"));
1817 gtk_widget_hide(GET_COMPONENT("toolsSelectRegion"));
1818 gtk_widget_hide(GET_COMPONENT("buttonSelectRegion"));
1819 gtk_widget_hide(GET_COMPONENT("button2SelectRegion"));
1820 gtk_widget_hide(GET_COMPONENT("button3SelectRegion"));
1821 gtk_widget_hide(GET_COMPONENT("colorOther"));
1822 gtk_widget_hide(GET_COMPONENT("helpIndex"));
1824 /* config file only works with glib 2.6 */
1825 if (glib_minor_version<6) {
1826 gtk_widget_hide(GET_COMPONENT("optionsAutoSavePrefs"));
1827 gtk_widget_hide(GET_COMPONENT("optionsSavePreferences"));