src/xo-misc.c

   1 #ifdef HAVE_CONFIG_H
   2 #  include <config.h>
   3 #endif
   4
   5 #include <math.h>
   6 #include <string.h>
   7 #include <gtk/gtk.h>
   8 #include <libgnomecanvas/libgnomecanvas.h>
   9 #include <gdk/gdkkeysyms.h>
  10
  11 #include "xournal.h"
  12 #include "xo-interface.h"
  13 #include "xo-support.h"
  14 #include "xo-callbacks.h"
  15 #include "xo-misc.h"
  16 #include "xo-file.h"
  17 #include "xo-paint.h"
  18
  19 // some global constants
  20
  21 guint predef_colors_rgba[COLOR_MAX] =
  22   { 0x000000ff, 0x3333ccff, 0xff0000ff, 0x008000ff,
  23     0x808080ff, 0x00c0ffff, 0x00ff00ff, 0xff00ffff,
  24     0xff8000ff, 0xffff00ff, 0xffffffff };
  25
  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 };
  30
  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
  35   };
  36
  37 // some manipulation functions
  38
  39 struct Page *new_page(struct Page *template)
  40 {
  41   struct Page *pg = (struct Page *) g_memdup(template, sizeof(struct Page));
  42   struct Layer *l = g_new(struct Layer, 1);
  43
  44   l->items = NULL;
  45   l->nitems = 0;
  46   pg->layers = g_list_append(NULL, l);
  47   pg->nlayers = 1;
  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);
  53   }
  54   pg->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
  55       gnome_canvas_root(canvas), gnome_canvas_clipgroup_get_type(), NULL);
  56   make_page_clipbox(pg);
  57   update_canvas_bg(pg);
  58   l->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
  59       pg->group, gnome_canvas_group_get_type(), NULL);
  60
  61   return pg;
  62 }
  63
  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.
  67 */
  68 struct Page *new_page_with_bg(struct Background *bg, double width, double height)
  69 {
  70   struct Page *pg = g_new(struct Page, 1);
  71   struct Layer *l = g_new(struct Layer, 1);
  72
  73   l->items = NULL;
  74   l->nitems = 0;
  75   pg->layers = g_list_append(NULL, l);
  76   pg->nlayers = 1;
  77   pg->bg = bg;
  78   pg->bg->canvas_item = NULL;
  79   pg->height = height;
  80   pg->width = width;
  81   pg->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
  82       gnome_canvas_root(canvas), gnome_canvas_clipgroup_get_type(), NULL);
  83   make_page_clipbox(pg);
  84   update_canvas_bg(pg);
  85   l->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
  86       pg->group, gnome_canvas_group_get_type(), NULL);
  87
  88   return pg;
  89 }
  90
  91 void realloc_cur_path(int n)
  92 {
  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));
  96 }
  97
  98 // undo utility functions
  99
 100 void prepare_new_undo(void)
 101 {
 102   struct UndoItem *u;
 103   // add a new UndoItem on the stack
 104   u = (struct UndoItem *)g_malloc(sizeof(struct UndoItem));
 105   u->next = undo;
 106   u->multiop = 0;
 107   undo = u;
 108   ui.saved = FALSE;
 109   clear_redo_stack();
 110 }
 111
 112 void clear_redo_stack(void)
 113 {
 114   struct UndoItem *u;
 115   GList *list, *repl;
 116   struct UndoErasureData *erasure;
 117   struct Item *it;
 118
 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 */
 123
 124   while (redo!=NULL) {
 125     if (redo->type == ITEM_STROKE) {
 126       gnome_canvas_points_free(redo->item->path);
 127       g_free(redo->item);
 128       /* the strokes are unmapped, so there are no associated canvas items */
 129     }
 130     else if (redo->type == ITEM_TEXT) {
 131       g_free(redo->item->text);
 132       g_free(redo->item->font_name);
 133       g_free(redo->item);
 134     }
 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);
 141           g_free(it);
 142         }
 143         g_list_free(erasure->replacement_items);
 144         g_free(erasure);
 145       }
 146       g_list_free(redo->erasurelist);
 147     }
 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);
 153       }
 154       g_free(redo->bg);
 155     }
 156     else if (redo->type == ITEM_NEW_PAGE) {
 157       redo->page->group = NULL;
 158       delete_page(redo->page);
 159     }
 160     else if (redo->type == ITEM_MOVESEL || redo->type == ITEM_REPAINTSEL) {
 161       g_list_free(redo->itemlist); g_list_free(redo->auxlist);
 162     }
 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);
 167         g_free(it);
 168       }
 169       g_list_free(redo->itemlist);
 170     }
 171     else if (redo->type == ITEM_NEW_LAYER) {
 172       g_free(redo->layer);
 173     }
 174     else if (redo->type == ITEM_TEXT_EDIT || redo->type == ITEM_TEXT_ATTRIB) {
 175       g_free(redo->str);
 176       if (redo->type == ITEM_TEXT_ATTRIB) g_free(redo->brush);
 177     }
 178
 179     u = redo;
 180     redo = redo->next;
 181     g_free(u);
 182   }
 183   update_undo_redo_enabled();
 184 }
 185
 186 void clear_undo_stack(void)
 187 {
 188   struct UndoItem *u;
 189   GList *list;
 190   struct UndoErasureData *erasure;
 191
 192   while (undo!=NULL) {
 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);
 204         g_free(erasure);
 205       }
 206       g_list_free(undo->erasurelist);
 207     }
 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);
 213       }
 214       g_free(undo->bg);
 215     }
 216     else if (undo->type == ITEM_MOVESEL || undo->type == ITEM_REPAINTSEL) {
 217       g_list_free(undo->itemlist); g_list_free(undo->auxlist);
 218     }
 219     else if (undo->type == ITEM_PASTE) {
 220       g_list_free(undo->itemlist);
 221     }
 222     else if (undo->type == ITEM_DELETE_LAYER) {
 223       undo->layer->group = NULL;
 224       delete_layer(undo->layer);
 225     }
 226     else if (undo->type == ITEM_DELETE_PAGE) {
 227       undo->page->group = NULL;
 228       delete_page(undo->page);
 229     }
 230     else if (undo->type == ITEM_TEXT_EDIT || undo->type == ITEM_TEXT_ATTRIB) {
 231       g_free(undo->str);
 232       if (undo->type == ITEM_TEXT_ATTRIB) g_free(undo->brush);
 233     }
 234
 235     u = undo;
 236     undo = undo->next;
 237     g_free(u);
 238   }
 239   update_undo_redo_enabled();
 240 }
 241
 242 // free data structures
 243
 244 void delete_journal(struct Journal *j)
 245 {
 246   while (j->pages!=NULL) {
 247     delete_page((struct Page *)j->pages->data);
 248     j->pages = g_list_delete_link(j->pages, j->pages);
 249   }
 250 }
 251
 252 void delete_page(struct Page *pg)
 253 {
 254   struct Layer *l;
 255
 256   while (pg->layers!=NULL) {
 257     l = (struct Layer *)pg->layers->data;
 258     l->group = NULL;
 259     delete_layer(l);
 260     pg->layers = g_list_delete_link(pg->layers, pg->layers);
 261   }
 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);
 267   }
 268   g_free(pg->bg);
 269   g_free(pg);
 270 }
 271
 272 void delete_layer(struct Layer *l)
 273 {
 274   struct Item *item;
 275
 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);
 282     }
 283     // don't need to delete the canvas_item, as it's part of the group destroyed below
 284     g_free(item);
 285     l->items = g_list_delete_link(l->items, l->items);
 286   }
 287   if (l->group!= NULL) gtk_object_destroy(GTK_OBJECT(l->group));
 288   g_free(l);
 289 }
 290
 291 // referenced strings
 292
 293 struct Refstring *new_refstring(const char *s)
 294 {
 295   struct Refstring *rs = g_new(struct Refstring, 1);
 296   rs->nref = 1;
 297   if (s!=NULL) rs->s = g_strdup(s);
 298   else rs->s = NULL;
 299   rs->aux = NULL;
 300   return rs;
 301 }
 302
 303 struct Refstring *refstring_ref(struct Refstring *rs)
 304 {
 305   rs->nref++;
 306   return rs;
 307 }
 308
 309 void refstring_unref(struct Refstring *rs)
 310 {
 311   rs->nref--;
 312   if (rs->nref == 0) {
 313     if (rs->s!=NULL) g_free(rs->s);
 314     if (rs->aux!=NULL) g_free(rs->aux);
 315     g_free(rs);
 316   }
 317 }
 318
 319
 320 // some helper functions
 321
 322 void get_pointer_coords(GdkEvent *event, gdouble *ret)
 323 {
 324   double x, y;
 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;
 329 }
 330
 331 void fix_xinput_coords(GdkEvent *event)
 332 {
 333 #ifdef ENABLE_XINPUT_BUGFIX
 334   double *axes, *px, *py, axis_width;
 335   GdkDevice *device;
 336   int wx, wy, sx, sy;
 337
 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;
 343   }
 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;
 349   }
 350   else return; // nothing we know how to do
 351
 352   gdk_window_get_origin(event->any.window, &wx, &wy);
 353   // somehow, behavior changed starting with GTK+ 2.11.0
 354   if (!gtk_check_version(2, 11, 0)) sx = sy = 0;
 355   else gnome_canvas_get_scroll_offsets(canvas, &sx, &sy);
 356
 357   axis_width = device->axes[0].max - device->axes[0].min;
 358   if (axis_width>EPSILON)
 359     *px = (axes[0]/axis_width)*ui.screen_width + sx - wx;
 360
 361   axis_width = device->axes[1].max - device->axes[1].min;
 362   if (axis_width>EPSILON)
 363     *py = (axes[1]/axis_width)*ui.screen_height + sy - wy;
 364 #endif
 365 }
 366
 367 void update_item_bbox(struct Item *item)
 368 {
 369   int i;
 370   gdouble *p, h, w;
 371
 372   if (item->type == ITEM_STROKE) {
 373     item->bbox.left = item->bbox.right = item->path->coords[0];
 374     item->bbox.top = item->bbox.bottom = item->path->coords[1];
 375     for (i=1, p=item->path->coords+2; i<item->path->num_points; i++, p+=2)
 376     {
 377       if (p[0] < item->bbox.left) item->bbox.left = p[0];
 378       if (p[0] > item->bbox.right) item->bbox.right = p[0];
 379       if (p[1] < item->bbox.top) item->bbox.top = p[1];
 380       if (p[1] > item->bbox.bottom) item->bbox.bottom = p[1];
 381     }
 382   }
 383   if (item->type == ITEM_TEXT && item->canvas_item!=NULL) {
 384     h=0.; w=0.;
 385     g_object_get(item->canvas_item, "text_width", &w, "text_height", &h, NULL);
 386     item->bbox.right = item->bbox.left + w;
 387     item->bbox.bottom = item->bbox.top + h;
 388   }
 389 }
 390
 391 void make_page_clipbox(struct Page *pg)
 392 {
 393   GnomeCanvasPathDef *pg_clip;
 394
 395   pg_clip = gnome_canvas_path_def_new_sized(4);
 396   gnome_canvas_path_def_moveto(pg_clip, 0., 0.);
 397   gnome_canvas_path_def_lineto(pg_clip, 0., pg->height);
 398   gnome_canvas_path_def_lineto(pg_clip, pg->width, pg->height);
 399   gnome_canvas_path_def_lineto(pg_clip, pg->width, 0.);
 400   gnome_canvas_path_def_closepath(pg_clip);
 401   gnome_canvas_item_set(GNOME_CANVAS_ITEM(pg->group), "path", pg_clip, NULL);
 402   gnome_canvas_path_def_unref(pg_clip);
 403 }
 404
 405 void make_canvas_item_one(GnomeCanvasGroup *group, struct Item *item)
 406 {
 407   GnomeCanvasItem *i;
 408   PangoFontDescription *font_desc;
 409
 410   if (item->type == ITEM_STROKE)
 411     item->canvas_item = gnome_canvas_item_new(group,
 412           gnome_canvas_line_get_type(), "points", item->path,
 413           "cap-style", GDK_CAP_ROUND, "join-style", GDK_JOIN_ROUND,
 414           "fill-color-rgba", item->brush.color_rgba,
 415           "width-units", item->brush.thickness, NULL);
 416   if (item->type == ITEM_TEXT) {
 417     font_desc = pango_font_description_from_string(item->font_name);
 418     pango_font_description_set_absolute_size(font_desc,
 419             item->font_size*ui.zoom*PANGO_SCALE);
 420     item->canvas_item = gnome_canvas_item_new(group,
 421           gnome_canvas_text_get_type(),
 422           "x", item->bbox.left, "y", item->bbox.top, "anchor", GTK_ANCHOR_NW,
 423           "font-desc", font_desc, "fill-color-rgba", item->brush.color_rgba,
 424           "text", item->text, NULL);
 425     update_item_bbox(item);
 426   }
 427 }
 428
 429 void make_canvas_items(void)
 430 {
 431   struct Page *pg;
 432   struct Layer *l;
 433   struct Item *item;
 434   GList *pagelist, *layerlist, *itemlist;
 435
 436   for (pagelist = journal.pages; pagelist!=NULL; pagelist = pagelist->next) {
 437     pg = (struct Page *)pagelist->data;
 438     if (pg->group == NULL) {
 439       pg->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
 440          gnome_canvas_root(canvas), gnome_canvas_clipgroup_get_type(), NULL);
 441       make_page_clipbox(pg);
 442     }
 443     if (pg->bg->canvas_item == NULL) update_canvas_bg(pg);
 444     for (layerlist = pg->layers; layerlist!=NULL; layerlist = layerlist->next) {
 445       l = (struct Layer *)layerlist->data;
 446       if (l->group == NULL)
 447         l->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
 448            pg->group, gnome_canvas_group_get_type(), NULL);
 449       for (itemlist = l->items; itemlist!=NULL; itemlist = itemlist->next) {
 450         item = (struct Item *)itemlist->data;
 451         if (item->canvas_item == NULL)
 452           make_canvas_item_one(l->group, item);
 453       }
 454     }
 455   }
 456 }
 457
 458 void update_canvas_bg(struct Page *pg)
 459 {
 460   GnomeCanvasGroup *group;
 461   GnomeCanvasPoints *seg;
 462   GdkPixbuf *scaled_pix;
 463   double *pt;
 464   double x, y;
 465   int w, h;
 466
 467   if (pg->bg->canvas_item != NULL)
 468     gtk_object_destroy(GTK_OBJECT(pg->bg->canvas_item));
 469   pg->bg->canvas_item = NULL;
 470
 471   if (pg->bg->type == BG_SOLID)
 472   {
 473     pg->bg->canvas_item = gnome_canvas_item_new(pg->group,
 474                                gnome_canvas_group_get_type(), NULL);
 475     group = GNOME_CANVAS_GROUP(pg->bg->canvas_item);
 476     lower_canvas_item_to(pg->group, pg->bg->canvas_item, NULL);
 477     gnome_canvas_item_new(group, gnome_canvas_rect_get_type(),
 478       "x1", 0., "x2", pg->width, "y1", 0., "y2", pg->height,
 479       "fill-color-rgba", pg->bg->color_rgba, NULL);
 480     if (pg->bg->ruling == RULING_NONE) return;
 481     seg = gnome_canvas_points_new(2);
 482     pt = seg->coords;
 483     if (pg->bg->ruling == RULING_GRAPH) {
 484       pt[1] = 0; pt[3] = pg->height;
 485       for (x=RULING_GRAPHSPACING; x<pg->width-1; x+=RULING_GRAPHSPACING) {
 486         pt[0] = pt[2] = x;
 487         gnome_canvas_item_new(group, gnome_canvas_line_get_type(),
 488            "points", seg, "fill-color-rgba", RULING_COLOR,
 489            "width-units", RULING_THICKNESS, NULL);
 490       }
 491       pt[0] = 0; pt[2] = pg->width;
 492       for (y=RULING_GRAPHSPACING; y<pg->height-1; y+=RULING_GRAPHSPACING) {
 493         pt[1] = pt[3] = y;
 494         gnome_canvas_item_new(group, gnome_canvas_line_get_type(),
 495            "points", seg, "fill-color-rgba", RULING_COLOR,
 496            "width-units", RULING_THICKNESS, NULL);
 497       }
 498       gnome_canvas_points_free(seg);
 499       return;
 500     }
 501     pt[0] = 0; pt[2] = pg->width;
 502     for (y=RULING_TOPMARGIN; y<pg->height-1; y+=RULING_SPACING) {
 503       pt[1] = pt[3] = y;
 504       gnome_canvas_item_new(group, gnome_canvas_line_get_type(),
 505          "points", seg, "fill-color-rgba", RULING_COLOR,
 506          "width-units", RULING_THICKNESS, NULL);
 507     }
 508     if (pg->bg->ruling == RULING_LINED) {
 509       pt[0] = pt[2] = RULING_LEFTMARGIN;
 510       pt[1] = 0; pt[3] = pg->height;
 511       gnome_canvas_item_new(group, gnome_canvas_line_get_type(),
 512          "points", seg, "fill-color-rgba", RULING_MARGIN_COLOR,
 513          "width-units", RULING_THICKNESS, NULL);
 514     }
 515     gnome_canvas_points_free(seg);
 516     return;
 517   }
 518
 519   if (pg->bg->type == BG_PIXMAP)
 520   {
 521     if (ui.antialias_bg) {
 522       set_cursor_busy(TRUE);
 523       w = (int)floor(pg->width*ui.zoom+0.5);
 524       h = (int)floor(pg->height*ui.zoom+0.5);
 525       if (w == gdk_pixbuf_get_width(pg->bg->pixbuf) &&
 526           h == gdk_pixbuf_get_height(pg->bg->pixbuf))
 527         scaled_pix = gdk_pixbuf_ref(pg->bg->pixbuf);
 528       else
 529         scaled_pix = gdk_pixbuf_scale_simple(pg->bg->pixbuf, w, h, GDK_INTERP_BILINEAR);
 530       pg->bg->pixbuf_scale = ui.zoom;
 531       set_cursor_busy(FALSE);
 532     }
 533     else {
 534       scaled_pix = gdk_pixbuf_ref(pg->bg->pixbuf);
 535       pg->bg->pixbuf_scale = 0;
 536     }
 537     pg->bg->canvas_item = gnome_canvas_item_new(pg->group,
 538         gnome_canvas_pixbuf_get_type(),
 539         "pixbuf", scaled_pix,
 540         "width", pg->width, "height", pg->height,
 541         "width-set", TRUE, "height-set", TRUE,
 542         NULL);
 543     gdk_pixbuf_unref(scaled_pix);
 544     lower_canvas_item_to(pg->group, pg->bg->canvas_item, NULL);
 545   }
 546
 547   if (pg->bg->type == BG_PDF)
 548   {
 549     if (pg->bg->pixbuf == NULL) return;
 550     pg->bg->canvas_item = gnome_canvas_item_new(pg->group,
 551         gnome_canvas_pixbuf_get_type(),
 552         "pixbuf", pg->bg->pixbuf,
 553         "width", pg->width, "height", pg->height,
 554         "width-set", TRUE, "height-set", TRUE,
 555         NULL);
 556     lower_canvas_item_to(pg->group, pg->bg->canvas_item, NULL);
 557   }
 558
 559 }
 560
 561 gboolean is_visible(struct Page *pg)
 562 {
 563   GtkAdjustment *v_adj;
 564   double ytop, ybot;
 565
 566   if (!ui.view_continuous) return (pg == ui.cur_page);
 567   v_adj = gtk_layout_get_vadjustment(GTK_LAYOUT(canvas));
 568   ytop = v_adj->value/ui.zoom;
 569   ybot = (v_adj->value + v_adj->page_size) / ui.zoom;
 570   return (MAX(ytop, pg->voffset) < MIN(ybot, pg->voffset+pg->height));
 571 }
 572
 573 void rescale_bg_pixmaps(void)
 574 {
 575   GList *pglist;
 576   struct Page *pg;
 577   GdkPixbuf *pix;
 578
 579   for (pglist = journal.pages; pglist!=NULL; pglist = pglist->next) {
 580     pg = (struct Page *)pglist->data;
 581     // in progressive mode we scale only visible pages
 582     if (ui.progressive_bg && !is_visible(pg)) continue;
 583
 584     if (pg->bg->type == BG_PIXMAP && pg->bg->canvas_item!=NULL) { // do the rescaling ourselves
 585       if (ui.antialias_bg) {
 586         if (pg->bg->pixbuf_scale == ui.zoom) continue;
 587         set_cursor_busy(TRUE);
 588         pix = gdk_pixbuf_scale_simple(pg->bg->pixbuf,
 589           (int)floor(pg->width*ui.zoom+0.5), (int)floor(pg->height*ui.zoom+0.5),
 590           GDK_INTERP_BILINEAR);
 591         gnome_canvas_item_set(pg->bg->canvas_item, "pixbuf", pix, NULL);
 592         gdk_pixbuf_unref(pix);
 593         pg->bg->pixbuf_scale = ui.zoom;
 594         set_cursor_busy(FALSE);
 595       } else
 596       {
 597         g_object_get(G_OBJECT(pg->bg->canvas_item), "pixbuf", &pix, NULL);
 598         if (pix!=pg->bg->pixbuf)
 599           gnome_canvas_item_set(pg->bg->canvas_item, "pixbuf", pg->bg->pixbuf, NULL);
 600         pg->bg->pixbuf_scale = 0;
 601       }
 602     }
 603     if (pg->bg->type == BG_PDF) { // request an asynchronous update
 604       if (pg->bg->pixbuf_scale == ui.zoom) continue;
 605       add_bgpdf_request(pg->bg->file_page_seq, ui.zoom, FALSE);
 606       pg->bg->pixbuf_scale = ui.zoom;
 607     }
 608   }
 609 }
 610
 611 gboolean have_intersect(struct BBox *a, struct BBox *b)
 612 {
 613   return (MAX(a->top, b->top) <= MIN(a->bottom, b->bottom)) &&
 614          (MAX(a->left, b->left) <= MIN(a->right, b->right));
 615 }
 616
 617 /* In libgnomecanvas 2.10.0, the lower/raise functions fail to update
 618    correctly the end of the group's item list. We try to work around this.
 619    DON'T USE gnome_canvas_item_raise/lower directly !! */
 620
 621 void lower_canvas_item_to(GnomeCanvasGroup *g, GnomeCanvasItem *item, GnomeCanvasItem *after)
 622 {
 623   int i1, i2;
 624
 625   i1 = g_list_index(g->item_list, item);
 626   if (i1 == -1) return;
 627
 628   if (after == NULL) i2 = -1;
 629   else i2 = g_list_index(g->item_list, after);
 630
 631   if (i1 < i2) gnome_canvas_item_raise(item, i2-i1);
 632   if (i1 > i2+1) gnome_canvas_item_lower(item, i1-i2-1);
 633
 634   // BUGFIX for libgnomecanvas
 635   g->item_list_end = g_list_last(g->item_list);
 636 }
 637
 638 void rgb_to_gdkcolor(guint rgba, GdkColor *color)
 639 {
 640   color->pixel = 0;
 641   color->red = ((rgba>>24)&0xff)*0x101;
 642   color->green = ((rgba>>16)&0xff)*0x101;
 643   color->blue = ((rgba>>8)&0xff)*0x101;
 644 }
 645
 646 // some interface functions
 647
 648 void update_thickness_buttons(void)
 649 {
 650   if (ui.selection!=NULL || ui.toolno[ui.cur_mapping] >= NUM_STROKE_TOOLS) {
 651     gtk_toggle_tool_button_set_active(
 652       GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonThicknessOther")), TRUE);
 653   } else
 654   switch (ui.cur_brush->thickness_no) {
 655     case THICKNESS_FINE:
 656       gtk_toggle_tool_button_set_active(
 657         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonFine")), TRUE);
 658       break;
 659     case THICKNESS_MEDIUM:
 660       gtk_toggle_tool_button_set_active(
 661         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonMedium")), TRUE);
 662       break;
 663     case THICKNESS_THICK:
 664       gtk_toggle_tool_button_set_active(
 665         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonThick")), TRUE);
 666       break;
 667     default:
 668       gtk_toggle_tool_button_set_active(
 669         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonThicknessOther")), TRUE);
 670   }
 671 }
 672
 673 void update_color_buttons(void)
 674 {
 675   if (ui.selection!=NULL || (ui.toolno[ui.cur_mapping] != TOOL_PEN
 676       && ui.toolno[ui.cur_mapping] != TOOL_HIGHLIGHTER && ui.toolno[ui.cur_mapping] != TOOL_TEXT)) {
 677     gtk_toggle_tool_button_set_active(
 678       GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonColorOther")), TRUE);
 679   } else
 680   switch (ui.cur_brush->color_no) {
 681     case COLOR_BLACK:
 682       gtk_toggle_tool_button_set_active(
 683         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonBlack")), TRUE);
 684       break;
 685     case COLOR_BLUE:
 686       gtk_toggle_tool_button_set_active(
 687         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonBlue")), TRUE);
 688       break;
 689     case COLOR_RED:
 690       gtk_toggle_tool_button_set_active(
 691         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonRed")), TRUE);
 692       break;
 693     case COLOR_GREEN:
 694       gtk_toggle_tool_button_set_active(
 695         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonGreen")), TRUE);
 696       break;
 697     case COLOR_GRAY:
 698       gtk_toggle_tool_button_set_active(
 699         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonGray")), TRUE);
 700       break;
 701     case COLOR_LIGHTBLUE:
 702       gtk_toggle_tool_button_set_active(
 703         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonLightBlue")), TRUE);
 704       break;
 705     case COLOR_LIGHTGREEN:
 706       gtk_toggle_tool_button_set_active(
 707         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonLightGreen")), TRUE);
 708       break;
 709     case COLOR_MAGENTA:
 710       gtk_toggle_tool_button_set_active(
 711         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonMagenta")), TRUE);
 712       break;
 713     case COLOR_ORANGE:
 714       gtk_toggle_tool_button_set_active(
 715         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonOrange")), TRUE);
 716       break;
 717     case COLOR_YELLOW:
 718       gtk_toggle_tool_button_set_active(
 719         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonYellow")), TRUE);
 720       break;
 721     case COLOR_WHITE:
 722       gtk_toggle_tool_button_set_active(
 723         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonWhite")), TRUE);
 724       break;
 725     default:
 726       gtk_toggle_tool_button_set_active(
 727         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonColorOther")), TRUE);
 728   }
 729 }
 730
 731 void update_tool_buttons(void)
 732 {
 733   switch(ui.toolno[ui.cur_mapping]) {
 734     case TOOL_PEN:
 735       gtk_toggle_tool_button_set_active(
 736         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonPen")), TRUE);
 737       break;
 738     case TOOL_ERASER:
 739       gtk_toggle_tool_button_set_active(
 740         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonEraser")), TRUE);
 741       break;
 742     case TOOL_HIGHLIGHTER:
 743       gtk_toggle_tool_button_set_active(
 744         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonHighlighter")), TRUE);
 745       break;
 746     case TOOL_TEXT:
 747       gtk_toggle_tool_button_set_active(
 748         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonText")), TRUE);
 749       break;
 750     case TOOL_SELECTREGION:
 751       gtk_toggle_tool_button_set_active(
 752         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonSelectRegion")), TRUE);
 753       break;
 754     case TOOL_SELECTRECT:
 755       gtk_toggle_tool_button_set_active(
 756         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonSelectRectangle")), TRUE);
 757       break;
 758     case TOOL_VERTSPACE:
 759       gtk_toggle_tool_button_set_active(
 760         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonVerticalSpace")), TRUE);
 761       break;
 762     case TOOL_HAND:
 763       gtk_toggle_tool_button_set_active(
 764         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonHand")), TRUE);
 765       break;
 766   }
 767
 768   gtk_toggle_tool_button_set_active(
 769     GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonRuler")), ui.ruler[ui.cur_mapping]);
 770   update_thickness_buttons();
 771   update_color_buttons();
 772 }
 773
 774 void update_tool_menu(void)
 775 {
 776   switch(ui.toolno[0]) {
 777     case TOOL_PEN:
 778       gtk_check_menu_item_set_active(
 779         GTK_CHECK_MENU_ITEM(GET_COMPONENT("toolsPen")), TRUE);
 780       break;
 781     case TOOL_ERASER:
 782       gtk_check_menu_item_set_active(
 783         GTK_CHECK_MENU_ITEM(GET_COMPONENT("toolsEraser")), TRUE);
 784       break;
 785     case TOOL_HIGHLIGHTER:
 786       gtk_check_menu_item_set_active(
 787         GTK_CHECK_MENU_ITEM(GET_COMPONENT("toolsHighlighter")), TRUE);
 788       break;
 789     case TOOL_TEXT:
 790       gtk_check_menu_item_set_active(
 791         GTK_CHECK_MENU_ITEM(GET_COMPONENT("toolsText")), TRUE);
 792       break;
 793     case TOOL_SELECTREGION:
 794       gtk_check_menu_item_set_active(
 795         GTK_CHECK_MENU_ITEM(GET_COMPONENT("toolsSelectRegion")), TRUE);
 796       break;
 797     case TOOL_SELECTRECT:
 798       gtk_check_menu_item_set_active(
 799         GTK_CHECK_MENU_ITEM(GET_COMPONENT("toolsSelectRectangle")), TRUE);
 800       break;
 801     case TOOL_VERTSPACE:
 802       gtk_check_menu_item_set_active(
 803         GTK_CHECK_MENU_ITEM(GET_COMPONENT("toolsVerticalSpace")), TRUE);
 804       break;
 805     case TOOL_HAND:
 806       gtk_check_menu_item_set_active(
 807         GTK_CHECK_MENU_ITEM(GET_COMPONENT("toolsHand")), TRUE);
 808       break;
 809   }
 810
 811   gtk_check_menu_item_set_active(
 812     GTK_CHECK_MENU_ITEM(GET_COMPONENT("toolsRuler")), ui.ruler[0]);
 813 }
 814
 815 void update_ruler_indicator(void)
 816 {
 817   gtk_toggle_tool_button_set_active(
 818     GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonRuler")), ui.ruler[ui.cur_mapping]);
 819   gtk_check_menu_item_set_active(
 820     GTK_CHECK_MENU_ITEM(GET_COMPONENT("toolsRuler")), ui.ruler[0]);
 821 }
 822
 823 void update_color_menu(void)
 824 {
 825   if (ui.selection!=NULL || (ui.toolno[ui.cur_mapping] != TOOL_PEN
 826     && ui.toolno[ui.cur_mapping] != TOOL_HIGHLIGHTER && ui.toolno[ui.cur_mapping] != TOOL_TEXT)) {
 827     gtk_check_menu_item_set_active(
 828       GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorNA")), TRUE);
 829   } else
 830   switch (ui.cur_brush->color_no) {
 831     case COLOR_BLACK:
 832       gtk_check_menu_item_set_active(
 833         GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorBlack")), TRUE);
 834       break;
 835     case COLOR_BLUE:
 836       gtk_check_menu_item_set_active(
 837         GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorBlue")), TRUE);
 838       break;
 839     case COLOR_RED:
 840       gtk_check_menu_item_set_active(
 841         GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorRed")), TRUE);
 842       break;
 843     case COLOR_GREEN:
 844       gtk_check_menu_item_set_active(
 845         GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorGreen")), TRUE);
 846       break;
 847     case COLOR_GRAY:
 848       gtk_check_menu_item_set_active(
 849         GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorGray")), TRUE);
 850       break;
 851     case COLOR_LIGHTBLUE:
 852       gtk_check_menu_item_set_active(
 853         GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorLightBlue")), TRUE);
 854       break;
 855     case COLOR_LIGHTGREEN:
 856       gtk_check_menu_item_set_active(
 857         GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorLightGreen")), TRUE);
 858       break;
 859     case COLOR_MAGENTA:
 860       gtk_check_menu_item_set_active(
 861         GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorMagenta")), TRUE);
 862       break;
 863     case COLOR_ORANGE:
 864       gtk_check_menu_item_set_active(
 865         GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorOrange")), TRUE);
 866       break;
 867     case COLOR_YELLOW:
 868       gtk_check_menu_item_set_active(
 869         GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorYellow")), TRUE);
 870       break;
 871     case COLOR_WHITE:
 872       gtk_check_menu_item_set_active(
 873         GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorWhite")), TRUE);
 874       break;
 875     default:
 876       gtk_check_menu_item_set_active(
 877         GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorOther")), TRUE);
 878   }
 879 }
 880
 881 void update_pen_props_menu(void)
 882 {
 883   switch(ui.brushes[0][TOOL_PEN].thickness_no) {
 884     case THICKNESS_VERYFINE:
 885       gtk_check_menu_item_set_active(
 886         GTK_CHECK_MENU_ITEM(GET_COMPONENT("penthicknessVeryFine")), TRUE);
 887       break;
 888     case THICKNESS_FINE:
 889       gtk_check_menu_item_set_active(
 890         GTK_CHECK_MENU_ITEM(GET_COMPONENT("penthicknessFine")), TRUE);
 891       break;
 892     case THICKNESS_MEDIUM:
 893       gtk_check_menu_item_set_active(
 894         GTK_CHECK_MENU_ITEM(GET_COMPONENT("penthicknessMedium")), TRUE);
 895       break;
 896     case THICKNESS_THICK:
 897       gtk_check_menu_item_set_active(
 898         GTK_CHECK_MENU_ITEM(GET_COMPONENT("penthicknessThick")), TRUE);
 899       break;
 900     case THICKNESS_VERYTHICK:
 901       gtk_check_menu_item_set_active(
 902         GTK_CHECK_MENU_ITEM(GET_COMPONENT("penthicknessVeryThick")), TRUE);
 903       break;
 904   }
 905 }
 906
 907 void update_eraser_props_menu(void)
 908 {
 909   switch (ui.brushes[0][TOOL_ERASER].thickness_no) {
 910     case THICKNESS_FINE:
 911       gtk_check_menu_item_set_active(
 912         GTK_CHECK_MENU_ITEM(GET_COMPONENT("eraserFine")), TRUE);
 913       break;
 914     case THICKNESS_MEDIUM:
 915       gtk_check_menu_item_set_active(
 916         GTK_CHECK_MENU_ITEM(GET_COMPONENT("eraserMedium")), TRUE);
 917       break;
 918     case THICKNESS_THICK:
 919       gtk_check_menu_item_set_active(
 920         GTK_CHECK_MENU_ITEM(GET_COMPONENT("eraserThick")), TRUE);
 921       break;
 922   }
 923
 924   gtk_check_menu_item_set_active(
 925     GTK_CHECK_MENU_ITEM(GET_COMPONENT("eraserStandard")),
 926     ui.brushes[0][TOOL_ERASER].tool_options == TOOLOPT_ERASER_STANDARD);
 927   gtk_check_menu_item_set_active(
 928     GTK_CHECK_MENU_ITEM(GET_COMPONENT("eraserWhiteout")),
 929     ui.brushes[0][TOOL_ERASER].tool_options == TOOLOPT_ERASER_WHITEOUT);
 930   gtk_check_menu_item_set_active(
 931     GTK_CHECK_MENU_ITEM(GET_COMPONENT("eraserDeleteStrokes")),
 932     ui.brushes[0][TOOL_ERASER].tool_options == TOOLOPT_ERASER_STROKES);
 933 }
 934
 935 void update_highlighter_props_menu(void)
 936 {
 937   switch (ui.brushes[0][TOOL_HIGHLIGHTER].thickness_no) {
 938     case THICKNESS_FINE:
 939       gtk_check_menu_item_set_active(
 940         GTK_CHECK_MENU_ITEM(GET_COMPONENT("highlighterFine")), TRUE);
 941       break;
 942     case THICKNESS_MEDIUM:
 943       gtk_check_menu_item_set_active(
 944         GTK_CHECK_MENU_ITEM(GET_COMPONENT("highlighterMedium")), TRUE);
 945       break;
 946     case THICKNESS_THICK:
 947       gtk_check_menu_item_set_active(
 948         GTK_CHECK_MENU_ITEM(GET_COMPONENT("highlighterThick")), TRUE);
 949       break;
 950   }
 951 }
 952
 953 void update_mappings_menu_linkings(void)
 954 {
 955   switch (ui.linked_brush[1]) {
 956     case BRUSH_LINKED:
 957       gtk_check_menu_item_set_active(
 958         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button2LinkBrush")), TRUE);
 959       break;
 960     case BRUSH_COPIED:
 961       gtk_check_menu_item_set_active(
 962         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button2CopyBrush")), TRUE);
 963       break;
 964     case BRUSH_STATIC:
 965       gtk_check_menu_item_set_active(
 966         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button2NABrush")), TRUE);
 967       break;
 968   }
 969   switch (ui.linked_brush[2]) {
 970     case BRUSH_LINKED:
 971       gtk_check_menu_item_set_active(
 972         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button3LinkBrush")), TRUE);
 973       break;
 974     case BRUSH_COPIED:
 975       gtk_check_menu_item_set_active(
 976         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button3CopyBrush")), TRUE);
 977       break;
 978     case BRUSH_STATIC:
 979       gtk_check_menu_item_set_active(
 980         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button3NABrush")), TRUE);
 981       break;
 982   }
 983 }
 984
 985 void update_mappings_menu(void)
 986 {
 987   gtk_widget_set_sensitive(GET_COMPONENT("optionsButtonMappings"), ui.use_xinput);
 988   gtk_widget_set_sensitive(GET_COMPONENT("optionsDiscardCoreEvents"),
 989     ui.use_xinput && (gtk_check_version(2, 11, 0)!=NULL));
 990   gtk_check_menu_item_set_active(
 991     GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsButtonMappings")), ui.use_erasertip);
 992   gtk_check_menu_item_set_active(
 993     GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsDiscardCoreEvents")), ui.discard_corepointer);
 994
 995   switch(ui.toolno[1]) {
 996     case TOOL_PEN:
 997       gtk_check_menu_item_set_active(
 998         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button2Pen")), TRUE);
 999       break;
1000     case TOOL_ERASER:
1001       gtk_check_menu_item_set_active(
1002         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button2Eraser")), TRUE);
1003       break;
1004     case TOOL_HIGHLIGHTER:
1005       gtk_check_menu_item_set_active(
1006         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button2Highlighter")), TRUE);
1007       break;
1008     case TOOL_TEXT:
1009       gtk_check_menu_item_set_active(
1010         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button2Text")), TRUE);
1011       break;
1012     case TOOL_SELECTREGION:
1013       gtk_check_menu_item_set_active(
1014         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button2SelectRegion")), TRUE);
1015       break;
1016     case TOOL_SELECTRECT:
1017       gtk_check_menu_item_set_active(
1018         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button2SelectRectangle")), TRUE);
1019       break;
1020     case TOOL_VERTSPACE:
1021       gtk_check_menu_item_set_active(
1022         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button2VerticalSpace")), TRUE);
1023       break;
1024   }
1025   switch(ui.toolno[2]) {
1026     case TOOL_PEN:
1027       gtk_check_menu_item_set_active(
1028         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button3Pen")), TRUE);
1029       break;
1030     case TOOL_ERASER:
1031       gtk_check_menu_item_set_active(
1032         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button3Eraser")), TRUE);
1033       break;
1034     case TOOL_HIGHLIGHTER:
1035       gtk_check_menu_item_set_active(
1036         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button3Highlighter")), TRUE);
1037       break;
1038     case TOOL_TEXT:
1039       gtk_check_menu_item_set_active(
1040         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button3Text")), TRUE);
1041       break;
1042     case TOOL_SELECTREGION:
1043       gtk_check_menu_item_set_active(
1044         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button3SelectRegion")), TRUE);
1045       break;
1046     case TOOL_SELECTRECT:
1047       gtk_check_menu_item_set_active(
1048         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button3SelectRectangle")), TRUE);
1049       break;
1050     case TOOL_VERTSPACE:
1051       gtk_check_menu_item_set_active(
1052         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button3VerticalSpace")), TRUE);
1053       break;
1054   }
1055   update_mappings_menu_linkings();
1056 }
1057
1058 void do_switch_page(int pg, gboolean rescroll, gboolean refresh_all)
1059 {
1060   int i, cx, cy;
1061   struct Layer *layer;
1062   GList *list;
1063
1064   ui.pageno = pg;
1065
1066   /* re-show all the layers of the old page */
1067   if (ui.cur_page != NULL)
1068     for (i=0, list = ui.cur_page->layers; list!=NULL; i++, list = list->next) {
1069       layer = (struct Layer *)list->data;
1070       if (layer->group!=NULL)
1071         gnome_canvas_item_show(GNOME_CANVAS_ITEM(layer->group));
1072     }
1073
1074   ui.cur_page = g_list_nth_data(journal.pages, ui.pageno);
1075   ui.layerno = ui.cur_page->nlayers-1;
1076   ui.cur_layer = (struct Layer *)(g_list_last(ui.cur_page->layers)->data);
1077   update_page_stuff();
1078   if (ui.progressive_bg) rescale_bg_pixmaps();
1079
1080   if (rescroll) { // scroll and force a refresh
1081 /* -- this seems to cause some display bugs ??
1082     gtk_adjustment_set_value(gtk_layout_get_vadjustment(GTK_LAYOUT(canvas)),
1083       ui.cur_page->voffset*ui.zoom);  */
1084     gnome_canvas_get_scroll_offsets(canvas, &cx, &cy);
1085     cy = ui.cur_page->voffset*ui.zoom;
1086     gnome_canvas_scroll_to(canvas, cx, cy);
1087
1088     if (refresh_all)
1089       gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
1090     else if (!ui.view_continuous)
1091       gnome_canvas_item_move(GNOME_CANVAS_ITEM(ui.cur_page->group), 0., 0.);
1092   }
1093 }
1094
1095 void update_page_stuff(void)
1096 {
1097   gchar tmp[10];
1098   GtkComboBox *layerbox;
1099   int i;
1100   GList *pglist;
1101   GtkSpinButton *spin;
1102   struct Page *pg;
1103   double vertpos, maxwidth;
1104   struct Layer *layer;
1105   int relscroll;
1106
1107   // move the page groups to their rightful locations or hide them
1108   if (ui.view_continuous) {
1109     vertpos = 0.;
1110     maxwidth = 0.;
1111     for (i=0, pglist = journal.pages; pglist!=NULL; i++, pglist = pglist->next) {
1112       pg = (struct Page *)pglist->data;
1113       if (pg->group!=NULL) {
1114         pg->hoffset = 0.; pg->voffset = vertpos;
1115         gnome_canvas_item_set(GNOME_CANVAS_ITEM(pg->group),
1116             "x", pg->hoffset, "y", pg->voffset, NULL);
1117         gnome_canvas_item_show(GNOME_CANVAS_ITEM(pg->group));
1118       }
1119       vertpos += pg->height + VIEW_CONTINUOUS_SKIP;
1120       if (pg->width > maxwidth) maxwidth = pg->width;
1121     }
1122     vertpos -= VIEW_CONTINUOUS_SKIP;
1123     gnome_canvas_set_scroll_region(canvas, 0, 0, maxwidth, vertpos);
1124   } else {
1125     for (pglist = journal.pages; pglist!=NULL; pglist = pglist->next) {
1126       pg = (struct Page *)pglist->data;
1127       if (pg == ui.cur_page && pg->group!=NULL) {
1128         pg->hoffset = 0.; pg->voffset = 0.;
1129         gnome_canvas_item_set(GNOME_CANVAS_ITEM(pg->group),
1130             "x", pg->hoffset, "y", pg->voffset, NULL);
1131         gnome_canvas_item_show(GNOME_CANVAS_ITEM(pg->group));
1132       } else {
1133         if (pg->group!=NULL) gnome_canvas_item_hide(GNOME_CANVAS_ITEM(pg->group));
1134       }
1135     }
1136     gnome_canvas_set_scroll_region(canvas, 0, 0, ui.cur_page->width, ui.cur_page->height);
1137   }
1138
1139   // update the page / layer info at bottom of screen
1140
1141   spin = GTK_SPIN_BUTTON(GET_COMPONENT("spinPageNo"));
1142   ui.in_update_page_stuff = TRUE; // avoid a bad retroaction
1143   gtk_spin_button_set_range(spin, 1, journal.npages+1);
1144     /* npages+1 will be used to create a new page at end */
1145   gtk_spin_button_set_value(spin, ui.pageno+1);
1146   g_snprintf(tmp, 10, " of %d", journal.npages);
1147   gtk_label_set_text(GTK_LABEL(GET_COMPONENT("labelNumpages")), tmp);
1148
1149   layerbox = GTK_COMBO_BOX(GET_COMPONENT("comboLayer"));
1150   if (ui.layerbox_length == 0) {
1151     gtk_combo_box_prepend_text(layerbox, "Background");
1152     ui.layerbox_length++;
1153   }
1154   while (ui.layerbox_length > ui.cur_page->nlayers+1) {
1155     gtk_combo_box_remove_text(layerbox, 0);
1156     ui.layerbox_length--;
1157   }
1158   while (ui.layerbox_length < ui.cur_page->nlayers+1) {
1159     g_snprintf(tmp, 10, "Layer %d", ui.layerbox_length++);
1160     gtk_combo_box_prepend_text(layerbox, tmp);
1161   }
1162   gtk_combo_box_set_active(layerbox, ui.cur_page->nlayers-1-ui.layerno);
1163   ui.in_update_page_stuff = FALSE;
1164
1165   // update the paper-style menu radio buttons
1166
1167   if (ui.view_continuous)
1168     gtk_check_menu_item_set_active(
1169        GTK_CHECK_MENU_ITEM(GET_COMPONENT("viewContinuous")), TRUE);
1170   else
1171     gtk_check_menu_item_set_active(
1172        GTK_CHECK_MENU_ITEM(GET_COMPONENT("viewOnePage")), TRUE);
1173
1174   if (ui.cur_page->bg->type == BG_SOLID && !ui.bg_apply_all_pages) {
1175     switch (ui.cur_page->bg->color_no) {
1176       case COLOR_WHITE:
1177         gtk_check_menu_item_set_active(
1178           GTK_CHECK_MENU_ITEM(GET_COMPONENT("papercolorWhite")), TRUE);
1179         break;
1180       case COLOR_YELLOW:
1181         gtk_check_menu_item_set_active(
1182           GTK_CHECK_MENU_ITEM(GET_COMPONENT("papercolorYellow")), TRUE);
1183         break;
1184       case COLOR_RED:
1185         gtk_check_menu_item_set_active(
1186           GTK_CHECK_MENU_ITEM(GET_COMPONENT("papercolorPink")), TRUE);
1187         break;
1188       case COLOR_ORANGE:
1189         gtk_check_menu_item_set_active(
1190           GTK_CHECK_MENU_ITEM(GET_COMPONENT("papercolorOrange")), TRUE);
1191         break;
1192       case COLOR_BLUE:
1193         gtk_check_menu_item_set_active(
1194           GTK_CHECK_MENU_ITEM(GET_COMPONENT("papercolorBlue")), TRUE);
1195         break;
1196       case COLOR_GREEN:
1197         gtk_check_menu_item_set_active(
1198           GTK_CHECK_MENU_ITEM(GET_COMPONENT("papercolorGreen")), TRUE);
1199         break;
1200       default:
1201         gtk_check_menu_item_set_active(
1202           GTK_CHECK_MENU_ITEM(GET_COMPONENT("papercolorOther")), TRUE);
1203         break;
1204     }
1205     switch (ui.cur_page->bg->ruling) {
1206       case RULING_NONE:
1207         gtk_check_menu_item_set_active(
1208           GTK_CHECK_MENU_ITEM(GET_COMPONENT("paperstylePlain")), TRUE);
1209         break;
1210       case RULING_LINED:
1211         gtk_check_menu_item_set_active(
1212           GTK_CHECK_MENU_ITEM(GET_COMPONENT("paperstyleLined")), TRUE);
1213         break;
1214       case RULING_RULED:
1215         gtk_check_menu_item_set_active(
1216           GTK_CHECK_MENU_ITEM(GET_COMPONENT("paperstyleRuled")), TRUE);
1217         break;
1218       case RULING_GRAPH:
1219         gtk_check_menu_item_set_active(
1220           GTK_CHECK_MENU_ITEM(GET_COMPONENT("paperstyleGraph")), TRUE);
1221         break;
1222     }
1223   } else {
1224     gtk_check_menu_item_set_active(
1225       GTK_CHECK_MENU_ITEM(GET_COMPONENT("papercolorNA")), TRUE);
1226     gtk_check_menu_item_set_active(
1227       GTK_CHECK_MENU_ITEM(GET_COMPONENT("paperstyleNA")), TRUE);
1228   }
1229
1230   // enable/disable the page/layer menu items and toolbar buttons
1231
1232   gtk_widget_set_sensitive(GET_COMPONENT("journalPaperColor"),
1233      ui.cur_page->bg->type == BG_SOLID || ui.bg_apply_all_pages);
1234   gtk_widget_set_sensitive(GET_COMPONENT("journalSetAsDefault"),
1235      ui.cur_page->bg->type == BG_SOLID);
1236
1237   gtk_widget_set_sensitive(GET_COMPONENT("viewFirstPage"), ui.pageno!=0);
1238   gtk_widget_set_sensitive(GET_COMPONENT("viewPreviousPage"), ui.pageno!=0);
1239   gtk_widget_set_sensitive(GET_COMPONENT("viewNextPage"), TRUE);
1240   gtk_widget_set_sensitive(GET_COMPONENT("viewLastPage"), ui.pageno!=journal.npages-1);
1241   gtk_widget_set_sensitive(GET_COMPONENT("buttonFirstPage"), ui.pageno!=0);
1242   gtk_widget_set_sensitive(GET_COMPONENT("buttonPreviousPage"), ui.pageno!=0);
1243   gtk_widget_set_sensitive(GET_COMPONENT("buttonNextPage"), TRUE);
1244   gtk_widget_set_sensitive(GET_COMPONENT("buttonLastPage"), ui.pageno!=journal.npages-1);
1245
1246   gtk_widget_set_sensitive(GET_COMPONENT("viewShowLayer"), ui.layerno!=ui.cur_page->nlayers-1);
1247   gtk_widget_set_sensitive(GET_COMPONENT("viewHideLayer"), ui.layerno>=0);
1248
1249   gtk_widget_set_sensitive(GET_COMPONENT("editPaste"), ui.cur_layer!=NULL);
1250   gtk_widget_set_sensitive(GET_COMPONENT("buttonPaste"), ui.cur_layer!=NULL);
1251 }
1252
1253 void update_toolbar_and_menu(void)
1254 {
1255   update_tool_buttons(); // takes care of other toolbar buttons as well
1256   update_tool_menu();
1257   update_color_menu();
1258   update_pen_props_menu();
1259   update_eraser_props_menu();
1260   update_highlighter_props_menu();
1261   update_mappings_menu();
1262
1263   gtk_toggle_tool_button_set_active(
1264     GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonFullscreen")), ui.fullscreen);
1265   gtk_check_menu_item_set_active(
1266     GTK_CHECK_MENU_ITEM(GET_COMPONENT("viewFullscreen")), ui.fullscreen);
1267 }
1268
1269 void update_file_name(char *filename)
1270 {
1271   gchar tmp[100], *p;
1272   if (ui.filename != NULL) g_free(ui.filename);
1273   ui.filename = filename;
1274   if (filename == NULL) {
1275     gtk_window_set_title(GTK_WINDOW (winMain), "Xournal");
1276     return;
1277   }
1278   p = g_utf8_strrchr(filename, -1, '/');
1279   if (p == NULL) p = filename;
1280   else p = g_utf8_next_char(p);
1281   g_snprintf(tmp, 100, "Xournal - %s", p);
1282   gtk_window_set_title(GTK_WINDOW (winMain), tmp);
1283   new_mru_entry(filename);
1284 }
1285
1286 void update_undo_redo_enabled(void)
1287 {
1288   gtk_widget_set_sensitive(GET_COMPONENT("editUndo"), undo!=NULL);
1289   gtk_widget_set_sensitive(GET_COMPONENT("editRedo"), redo!=NULL);
1290   gtk_widget_set_sensitive(GET_COMPONENT("buttonUndo"), undo!=NULL);
1291   gtk_widget_set_sensitive(GET_COMPONENT("buttonRedo"), redo!=NULL);
1292 }
1293
1294 void update_copy_paste_enabled(void)
1295 {
1296   gtk_widget_set_sensitive(GET_COMPONENT("editCut"), ui.selection!=NULL);
1297   gtk_widget_set_sensitive(GET_COMPONENT("editCopy"), ui.selection!=NULL);
1298   gtk_widget_set_sensitive(GET_COMPONENT("editPaste"), ui.cur_item_type!=ITEM_TEXT);
1299   gtk_widget_set_sensitive(GET_COMPONENT("editDelete"), ui.selection!=NULL);
1300   gtk_widget_set_sensitive(GET_COMPONENT("buttonCut"), ui.selection!=NULL);
1301   gtk_widget_set_sensitive(GET_COMPONENT("buttonCopy"), ui.selection!=NULL);
1302   gtk_widget_set_sensitive(GET_COMPONENT("buttonPaste"), ui.cur_item_type!=ITEM_TEXT);
1303 }
1304
1305 void update_mapping_linkings(int toolno)
1306 {
1307   int i;
1308
1309   for (i = 1; i<=NUM_BUTTONS; i++) {
1310     if (ui.linked_brush[i] == BRUSH_LINKED) {
1311       if (toolno >= 0 && toolno < NUM_STROKE_TOOLS)
1312         g_memmove(&(ui.brushes[i][toolno]), &(ui.brushes[0][toolno]), sizeof(struct Brush));
1313       ui.ruler[i] = ui.ruler[0];
1314       if (ui.toolno[i]!=TOOL_PEN && ui.toolno[i]!=TOOL_HIGHLIGHTER)
1315         ui.ruler[i] = FALSE;
1316     }
1317     if (ui.linked_brush[i] == BRUSH_COPIED && toolno == ui.toolno[i]) {
1318       ui.linked_brush[i] = BRUSH_STATIC;
1319       if (i==1 || i==2) update_mappings_menu_linkings();
1320     }
1321   }
1322 }
1323
1324 void set_cur_color(int color)
1325 {
1326   ui.cur_brush->color_no = color;
1327   if (ui.toolno[0] == TOOL_HIGHLIGHTER)
1328     ui.cur_brush->color_rgba = predef_colors_rgba[color] & ui.hiliter_alpha_mask;
1329   else
1330     ui.cur_brush->color_rgba = predef_colors_rgba[color];
1331   update_mapping_linkings(ui.toolno[0]);
1332 }
1333
1334 void recolor_temp_text(int color_no, guint color_rgba)
1335 {
1336   GdkColor gdkcolor;
1337
1338   if (ui.cur_item_type!=ITEM_TEXT) return;
1339   if (ui.cur_item->text!=NULL && ui.cur_item->brush.color_rgba != color_rgba) {
1340     prepare_new_undo();
1341     undo->type = ITEM_TEXT_ATTRIB;
1342     undo->item = ui.cur_item;
1343     undo->str = g_strdup(ui.cur_item->font_name);
1344     undo->val_x = ui.cur_item->font_size;
1345     undo->brush = (struct Brush *)g_memdup(&(ui.cur_item->brush), sizeof(struct Brush));
1346   }
1347   ui.cur_item->brush.color_no = color_no;
1348   ui.cur_item->brush.color_rgba = color_rgba;
1349   rgb_to_gdkcolor(color_rgba, &gdkcolor);
1350   gtk_widget_modify_text(ui.cur_item->widget, GTK_STATE_NORMAL, &gdkcolor);
1351   gtk_widget_grab_focus(ui.cur_item->widget);
1352 }
1353
1354 void process_color_activate(GtkMenuItem *menuitem, int color)
1355 {
1356   if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1357     if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1358       return;
1359   } else {
1360     if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1361       return;
1362   }
1363
1364   if (ui.cur_mapping != 0) return; // not user-generated
1365   reset_focus();
1366
1367   if (ui.cur_item_type == ITEM_TEXT)
1368     recolor_temp_text(color, predef_colors_rgba[color]);
1369
1370   if (ui.selection != NULL) {
1371     recolor_selection(color);
1372     update_color_buttons();
1373     update_color_menu();
1374   }
1375
1376   if (ui.toolno[0] != TOOL_PEN && ui.toolno[0] != TOOL_HIGHLIGHTER
1377       && ui.toolno[0] != TOOL_TEXT) {
1378     if (ui.selection != NULL) return;
1379     end_text();
1380     ui.toolno[0] = TOOL_PEN;
1381     ui.cur_brush = &(ui.brushes[0][TOOL_PEN]);
1382     update_tool_buttons();
1383     update_tool_menu();
1384   }
1385
1386   set_cur_color(color);
1387   update_color_buttons();
1388   update_color_menu();
1389   update_cursor();
1390 }
1391
1392 void process_thickness_activate(GtkMenuItem *menuitem, int tool, int val)
1393 {
1394   if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1395     if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1396       return;
1397   } else {
1398     if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1399       return;
1400   }
1401
1402   if (ui.cur_mapping != 0) return; // not user-generated
1403
1404   if (ui.selection != NULL && GTK_OBJECT_TYPE(menuitem) != GTK_TYPE_RADIO_MENU_ITEM) {
1405     reset_focus();
1406     rethicken_selection(val);
1407     update_thickness_buttons();
1408   }
1409
1410   if (tool >= NUM_STROKE_TOOLS) {
1411     update_thickness_buttons(); // undo illegal button selection
1412     return;
1413   }
1414
1415   if (ui.brushes[0][tool].thickness_no == val) return;
1416   reset_focus();
1417   end_text();
1418   ui.brushes[0][tool].thickness_no = val;
1419   ui.brushes[0][tool].thickness = predef_thickness[tool][val];
1420   update_mapping_linkings(tool);
1421
1422   update_thickness_buttons();
1423   if (tool == TOOL_PEN) update_pen_props_menu();
1424   if (tool == TOOL_ERASER) update_eraser_props_menu();
1425   if (tool == TOOL_HIGHLIGHTER) update_highlighter_props_menu();
1426   update_cursor();
1427 }
1428
1429 void process_papercolor_activate(GtkMenuItem *menuitem, int color)
1430 {
1431   struct Page *pg;
1432   GList *pglist;
1433   gboolean hasdone;
1434
1435   if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1436     return;
1437
1438   if ((ui.cur_page->bg->type != BG_SOLID) || ui.bg_apply_all_pages)
1439     gtk_check_menu_item_set_active(
1440       GTK_CHECK_MENU_ITEM(GET_COMPONENT("papercolorNA")), TRUE);
1441
1442   pg = ui.cur_page;
1443   hasdone = FALSE;
1444   for (pglist = journal.pages; pglist!=NULL; pglist = pglist->next) {
1445     if (ui.bg_apply_all_pages) pg = (struct Page *)pglist->data;
1446     if (pg->bg->type == BG_SOLID && pg->bg->color_no != color) {
1447       prepare_new_undo();
1448       if (hasdone) undo->multiop |= MULTIOP_CONT_UNDO;
1449       undo->multiop |= MULTIOP_CONT_REDO;
1450       hasdone = TRUE;
1451       undo->type = ITEM_NEW_BG_ONE;
1452       undo->page = pg;
1453       undo->bg = (struct Background *)g_memdup(pg->bg, sizeof(struct Background));
1454       undo->bg->canvas_item = NULL;
1455
1456       pg->bg->color_no = color;
1457       pg->bg->color_rgba = predef_bgcolors_rgba[color];
1458       update_canvas_bg(pg);
1459     }
1460     if (!ui.bg_apply_all_pages) break;
1461   }
1462   if (hasdone) undo->multiop -= MULTIOP_CONT_REDO;
1463 }
1464
1465 void process_paperstyle_activate(GtkMenuItem *menuitem, int style)
1466 {
1467   struct Page *pg;
1468   GList *pglist;
1469   gboolean hasdone, must_upd;
1470
1471   if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1472     return;
1473
1474   if (ui.bg_apply_all_pages)
1475     gtk_check_menu_item_set_active(
1476       GTK_CHECK_MENU_ITEM(GET_COMPONENT("paperstyleNA")), TRUE);
1477
1478   pg = ui.cur_page;
1479   hasdone = FALSE;
1480   must_upd = FALSE;
1481   for (pglist = journal.pages; pglist!=NULL; pglist = pglist->next) {
1482     if (ui.bg_apply_all_pages) pg = (struct Page *)pglist->data;
1483     if (pg->bg->type != BG_SOLID || pg->bg->ruling != style) {
1484       prepare_new_undo();
1485       undo->type = ITEM_NEW_BG_ONE;
1486       if (hasdone) undo->multiop |= MULTIOP_CONT_UNDO;
1487       undo->multiop |= MULTIOP_CONT_REDO;
1488       hasdone = TRUE;
1489       undo->page = pg;
1490       undo->bg = (struct Background *)g_memdup(pg->bg, sizeof(struct Background));
1491       undo->bg->canvas_item = NULL;
1492
1493       if (pg->bg->type != BG_SOLID) {
1494         pg->bg->type = BG_SOLID;
1495         pg->bg->color_no = COLOR_WHITE;
1496         pg->bg->color_rgba = predef_bgcolors_rgba[COLOR_WHITE];
1497         pg->bg->filename = NULL;
1498         pg->bg->pixbuf = NULL;
1499         must_upd = TRUE;
1500       }
1501       pg->bg->ruling = style;
1502       update_canvas_bg(pg);
1503     }
1504     if (!ui.bg_apply_all_pages) break;
1505   }
1506   if (hasdone) undo->multiop -= MULTIOP_CONT_REDO;
1507   if (must_upd) update_page_stuff();
1508 }
1509
1510 gboolean ok_to_close(void)
1511 {
1512   GtkWidget *dialog;
1513   GtkResponseType response;
1514   GList *pagelist;
1515
1516   if (ui.saved) return TRUE;
1517   dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
1518     GTK_MESSAGE_WARNING, GTK_BUTTONS_YES_NO, "Save changes to '%s'?",
1519     (ui.filename!=NULL) ? ui.filename:"Untitled");
1520   gtk_dialog_add_button(GTK_DIALOG (dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
1521   response = gtk_dialog_run(GTK_DIALOG (dialog));
1522   gtk_widget_destroy(dialog);
1523   if (response == GTK_RESPONSE_CANCEL || response == GTK_RESPONSE_DELETE_EVENT)
1524     return FALSE; // aborted
1525   if (response == GTK_RESPONSE_YES) {
1526     on_fileSave_activate(NULL, NULL);
1527     if (!ui.saved) return FALSE; // if save failed, then we abort
1528   }
1529   return TRUE;
1530 }
1531
1532 // test if we're still busy loading a PDF background file
1533 gboolean page_ops_forbidden(void)
1534 {
1535   return (bgpdf.status != STATUS_NOT_INIT && bgpdf.create_pages);
1536 }
1537
1538 // send the focus back to the appropriate widget
1539 void reset_focus(void)
1540 {
1541   if (ui.cur_item_type == ITEM_TEXT)
1542     gtk_widget_grab_focus(ui.cur_item->widget);
1543   else
1544     gtk_widget_grab_focus(GTK_WIDGET(canvas));
1545 }
1546
1547 // selection / clipboard stuff
1548
1549 void reset_selection(void)
1550 {
1551   if (ui.selection == NULL) return;
1552   if (ui.selection->canvas_item != NULL)
1553     gtk_object_destroy(GTK_OBJECT(ui.selection->canvas_item));
1554   g_list_free(ui.selection->items);
1555   g_free(ui.selection);
1556   ui.selection = NULL;
1557   update_copy_paste_enabled();
1558   update_color_menu();
1559   update_thickness_buttons();
1560   update_color_buttons();
1561   update_font_button();
1562 }
1563
1564 void move_journal_items_by(GList *itemlist, double dx, double dy,
1565                               struct Layer *l1, struct Layer *l2, GList *depths)
1566 {
1567   struct Item *item;
1568   GnomeCanvasItem *refitem;
1569   GList *link;
1570   int i;
1571   double *pt;
1572
1573   while (itemlist!=NULL) {
1574     item = (struct Item *)itemlist->data;
1575     if (item->type == ITEM_STROKE)
1576       for (pt=item->path->coords, i=0; i<item->path->num_points; i++, pt+=2)
1577         { pt[0] += dx; pt[1] += dy; }
1578     if (item->type == ITEM_STROKE || item->type == ITEM_TEXT || item->type == ITEM_TEMP_TEXT) {
1579       item->bbox.left += dx;
1580       item->bbox.right += dx;
1581       item->bbox.top += dy;
1582       item->bbox.bottom += dy;
1583     }
1584     if (l1 != l2) {
1585       // find out where to insert
1586       if (depths != NULL) {
1587         if (depths->data == NULL) link = l2->items;
1588         else {
1589           link = g_list_find(l2->items, depths->data);
1590           if (link != NULL) link = link->next;
1591         }
1592       } else link = NULL;
1593       l2->items = g_list_insert_before(l2->items, link, item);
1594       l2->nitems++;
1595       l1->items = g_list_remove(l1->items, item);
1596       l1->nitems--;
1597     }
1598     if (depths != NULL) { // also raise/lower the canvas items
1599       if (item->canvas_item!=NULL) {
1600         if (depths->data == NULL) link = NULL;
1601         else link = g_list_find(l2->items, depths->data);
1602         if (link != NULL) refitem = ((struct Item *)(link->data))->canvas_item;
1603         else refitem = NULL;
1604         lower_canvas_item_to(l2->group, item->canvas_item, refitem);
1605       }
1606       depths = depths->next;
1607     }
1608     itemlist = itemlist->next;
1609   }
1610 }
1611
1612 // Switch between button mappings
1613
1614 /* NOTE ABOUT BUTTON MAPPINGS: ui.cur_mapping is 0 except while a canvas
1615    click event is being processed ... */
1616
1617 void switch_mapping(int m)
1618 {
1619   if (ui.cur_mapping == m) return;
1620
1621   ui.cur_mapping = m;
1622   if (ui.toolno[m] < NUM_STROKE_TOOLS)
1623     ui.cur_brush = &(ui.brushes[m][ui.toolno[m]]);
1624   if (ui.toolno[m] == TOOL_TEXT)
1625     ui.cur_brush = &(ui.brushes[m][TOOL_PEN]);
1626   update_tool_buttons();
1627   update_color_menu();
1628   update_cursor();
1629 }
1630
1631 void process_mapping_activate(GtkMenuItem *menuitem, int m, int tool)
1632 {
1633   if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem))) return;
1634   if (ui.cur_mapping!=0) return;
1635   if (ui.toolno[m] == tool) return;
1636   end_text();
1637   reset_focus();
1638
1639   ui.toolno[m] = tool;
1640   ui.ruler[m] = FALSE;
1641   if (ui.linked_brush[m] == BRUSH_LINKED
1642        && (tool==TOOL_PEN || tool==TOOL_HIGHLIGHTER))
1643     ui.ruler[m] = ui.ruler[0];
1644   if (ui.linked_brush[m] == BRUSH_COPIED) {
1645     ui.linked_brush[m] = BRUSH_STATIC;
1646     update_mappings_menu_linkings();
1647   }
1648 }
1649
1650 // update the ordering of components in the main vbox
1651
1652 const char *vbox_component_names[VBOX_MAIN_NITEMS]=
1653  {"scrolledwindowMain", "menubar", "toolbarMain", "toolbarPen", "hbox1"};
1654
1655 void update_vbox_order(int *order)
1656 {
1657   int i, j;
1658   GtkWidget *child;
1659   GtkBox *vboxMain = GTK_BOX(GET_COMPONENT("vboxMain"));
1660   gboolean present[VBOX_MAIN_NITEMS];
1661
1662   for (i=0; i<VBOX_MAIN_NITEMS; i++) present[i] = FALSE;
1663   j=0;
1664   for (i=0; i<VBOX_MAIN_NITEMS; i++) {
1665     if (order[i]<0 || order[i]>=VBOX_MAIN_NITEMS) continue;
1666     present[order[i]] = TRUE;
1667     child = GET_COMPONENT(vbox_component_names[order[i]]);
1668     gtk_box_reorder_child(vboxMain, child, j++);
1669     gtk_widget_show(child);
1670   }
1671   for (i=1; i<VBOX_MAIN_NITEMS; i++) // hide others, but not the drawing area!
1672     if (!present[i]) gtk_widget_hide(GET_COMPONENT(vbox_component_names[i]));
1673 }
1674
1675 gchar *make_cur_font_name(void)
1676 {
1677   gchar *str;
1678   struct Item *it;
1679
1680   if (ui.cur_item_type == ITEM_TEXT)
1681     str = g_strdup_printf("%s %.1f", ui.cur_item->font_name, ui.cur_item->font_size);
1682   else if (ui.selection!=NULL && ui.selection->items!=NULL &&
1683            ui.selection->items->next==NULL &&
1684            (it=(struct Item*)ui.selection->items->data)->type == ITEM_TEXT)
1685     str = g_strdup_printf("%s %.1f", it->font_name, it->font_size);
1686   else
1687     str = g_strdup_printf("%s %.1f", ui.font_name, ui.font_size);
1688   return str;
1689 }
1690
1691 void update_font_button(void)
1692 {
1693   gchar *str;
1694
1695   str = make_cur_font_name();
1696   gtk_font_button_set_font_name(GTK_FONT_BUTTON(GET_COMPONENT("fontButton")), str);
1697   g_free(str);
1698 }
1699
1700 gboolean can_accel(GtkWidget *widget, guint id, gpointer data)
1701 {
1702   return GTK_WIDGET_SENSITIVE(widget);
1703 }
1704
1705 void allow_all_accels(void)
1706 {
1707   g_signal_connect((gpointer) GET_COMPONENT("fileNew"),
1708       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1709   g_signal_connect((gpointer) GET_COMPONENT("fileOpen"),
1710       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1711   g_signal_connect((gpointer) GET_COMPONENT("fileSave"),
1712       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1713   g_signal_connect((gpointer) GET_COMPONENT("filePrint"),
1714       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1715   g_signal_connect((gpointer) GET_COMPONENT("filePrintPDF"),
1716       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1717   g_signal_connect((gpointer) GET_COMPONENT("fileQuit"),
1718       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1719   g_signal_connect((gpointer) GET_COMPONENT("editUndo"),
1720       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1721   g_signal_connect((gpointer) GET_COMPONENT("editRedo"),
1722       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1723   g_signal_connect((gpointer) GET_COMPONENT("editCut"),
1724       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1725   g_signal_connect((gpointer) GET_COMPONENT("editCopy"),
1726       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1727   g_signal_connect((gpointer) GET_COMPONENT("editPaste"),
1728       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1729   g_signal_connect((gpointer) GET_COMPONENT("editDelete"),
1730       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1731   g_signal_connect((gpointer) GET_COMPONENT("viewFullscreen"),
1732       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1733   g_signal_connect((gpointer) GET_COMPONENT("viewZoomIn"),
1734       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1735   g_signal_connect((gpointer) GET_COMPONENT("viewZoomOut"),
1736       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1737   g_signal_connect((gpointer) GET_COMPONENT("viewNormalSize"),
1738       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1739   g_signal_connect((gpointer) GET_COMPONENT("viewPageWidth"),
1740       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1741   g_signal_connect((gpointer) GET_COMPONENT("viewFirstPage"),
1742       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1743   g_signal_connect((gpointer) GET_COMPONENT("viewPreviousPage"),
1744       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1745   g_signal_connect((gpointer) GET_COMPONENT("viewNextPage"),
1746       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1747   g_signal_connect((gpointer) GET_COMPONENT("viewLastPage"),
1748       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1749   g_signal_connect((gpointer) GET_COMPONENT("toolsPen"),
1750       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1751   g_signal_connect((gpointer) GET_COMPONENT("toolsEraser"),
1752       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1753   g_signal_connect((gpointer) GET_COMPONENT("toolsHighlighter"),
1754       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1755   g_signal_connect((gpointer) GET_COMPONENT("toolsText"),
1756       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1757 /*  g_signal_connect((gpointer) GET_COMPONENT("toolsSelectRegion"),
1758       "can-activate-accel", G_CALLBACK(can_accel), NULL);  */
1759   g_signal_connect((gpointer) GET_COMPONENT("toolsSelectRectangle"),
1760       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1761   g_signal_connect((gpointer) GET_COMPONENT("toolsVerticalSpace"),
1762       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1763   g_signal_connect((gpointer) GET_COMPONENT("toolsHand"),
1764       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1765   g_signal_connect((gpointer) GET_COMPONENT("toolsTextFont"),
1766       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1767   g_signal_connect((gpointer) GET_COMPONENT("toolsRuler"),
1768       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1769 }
1770
1771 void add_scroll_bindings(void)
1772 {
1773   GtkBindingSet *binding_set;
1774
1775   binding_set = gtk_binding_set_by_class(
1776      G_OBJECT_GET_CLASS(GET_COMPONENT("scrolledwindowMain")));
1777   gtk_binding_entry_add_signal(binding_set, GDK_Up, 0,
1778     "scroll_child", 2, GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_STEP_BACKWARD,
1779     G_TYPE_BOOLEAN, FALSE);
1780   gtk_binding_entry_add_signal(binding_set, GDK_KP_Up, 0,
1781     "scroll_child", 2, GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_STEP_BACKWARD,
1782     G_TYPE_BOOLEAN, FALSE);
1783   gtk_binding_entry_add_signal(binding_set, GDK_Down, 0,
1784     "scroll_child", 2, GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_STEP_FORWARD,
1785     G_TYPE_BOOLEAN, FALSE);
1786   gtk_binding_entry_add_signal(binding_set, GDK_KP_Down, 0,
1787     "scroll_child", 2, GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_STEP_FORWARD,
1788     G_TYPE_BOOLEAN, FALSE);
1789   gtk_binding_entry_add_signal(binding_set, GDK_Left, 0,
1790     "scroll_child", 2, GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_STEP_BACKWARD,
1791     G_TYPE_BOOLEAN, TRUE);
1792   gtk_binding_entry_add_signal(binding_set, GDK_KP_Left, 0,
1793     "scroll_child", 2, GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_STEP_BACKWARD,
1794     G_TYPE_BOOLEAN, TRUE);
1795   gtk_binding_entry_add_signal(binding_set, GDK_Right, 0,
1796     "scroll_child", 2, GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_STEP_FORWARD,
1797     G_TYPE_BOOLEAN, TRUE);
1798   gtk_binding_entry_add_signal(binding_set, GDK_KP_Right, 0,
1799     "scroll_child", 2, GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_STEP_FORWARD,
1800     G_TYPE_BOOLEAN, TRUE);
1801 }
1802
1803 gboolean is_event_within_textview(GdkEventButton *event)
1804 {
1805   double pt[2];
1806
1807   if (ui.cur_item_type!=ITEM_TEXT) return FALSE;
1808   get_pointer_coords((GdkEvent *)event, pt);
1809   if (pt[0]<ui.cur_item->bbox.left || pt[0]>ui.cur_item->bbox.right) return FALSE;
1810   if (pt[1]<ui.cur_item->bbox.top || pt[1]>ui.cur_item->bbox.bottom) return FALSE;
1811   return TRUE;
1812 }