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   // 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);
 355
 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;
 359
 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;
 363 #endif
 364 }
 365
 366 void update_item_bbox(struct Item *item)
 367 {
 368   int i;
 369   gdouble *p, h, w;
 370
 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)
 375     {
 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];
 380     }
 381   }
 382   if (item->type == ITEM_TEXT && item->canvas_item!=NULL) {
 383     h=0.; w=0.;
 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;
 387   }
 388 }
 389
 390 void make_page_clipbox(struct Page *pg)
 391 {
 392   GnomeCanvasPathDef *pg_clip;
 393
 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);
 402 }
 403
 404 void make_canvas_item_one(GnomeCanvasGroup *group, struct Item *item)
 405 {
 406   GnomeCanvasItem *i;
 407   PangoFontDescription *font_desc;
 408
 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);
 425   }
 426 }
 427
 428 void make_canvas_items(void)
 429 {
 430   struct Page *pg;
 431   struct Layer *l;
 432   struct Item *item;
 433   GList *pagelist, *layerlist, *itemlist;
 434
 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);
 441     }
 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);
 452       }
 453     }
 454   }
 455 }
 456
 457 void update_canvas_bg(struct Page *pg)
 458 {
 459   GnomeCanvasGroup *group;
 460   GnomeCanvasPoints *seg;
 461   GdkPixbuf *scaled_pix;
 462   double *pt;
 463   double x, y;
 464   int w, h;
 465
 466   if (pg->bg->canvas_item != NULL)
 467     gtk_object_destroy(GTK_OBJECT(pg->bg->canvas_item));
 468   pg->bg->canvas_item = NULL;
 469
 470   if (pg->bg->type == BG_SOLID)
 471   {
 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);
 481     pt = seg->coords;
 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) {
 485         pt[0] = pt[2] = x;
 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);
 489       }
 490       pt[0] = 0; pt[2] = pg->width;
 491       for (y=RULING_GRAPHSPACING; y<pg->height-1; y+=RULING_GRAPHSPACING) {
 492         pt[1] = pt[3] = y;
 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);
 496       }
 497       gnome_canvas_points_free(seg);
 498       return;
 499     }
 500     pt[0] = 0; pt[2] = pg->width;
 501     for (y=RULING_TOPMARGIN; y<pg->height-1; y+=RULING_SPACING) {
 502       pt[1] = pt[3] = y;
 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);
 506     }
 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);
 513     }
 514     gnome_canvas_points_free(seg);
 515     return;
 516   }
 517
 518   if (pg->bg->type == BG_PIXMAP)
 519   {
 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);
 527       else
 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);
 531     }
 532     else {
 533       scaled_pix = gdk_pixbuf_ref(pg->bg->pixbuf);
 534       pg->bg->pixbuf_scale = 0;
 535     }
 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,
 541         NULL);
 542     gdk_pixbuf_unref(scaled_pix);
 543     lower_canvas_item_to(pg->group, pg->bg->canvas_item, NULL);
 544   }
 545
 546   if (pg->bg->type == BG_PDF)
 547   {
 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,
 554         NULL);
 555     lower_canvas_item_to(pg->group, pg->bg->canvas_item, NULL);
 556   }
 557
 558 }
 559
 560 gboolean is_visible(struct Page *pg)
 561 {
 562   GtkAdjustment *v_adj;
 563   double ytop, ybot;
 564
 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));
 570 }
 571
 572 void rescale_bg_pixmaps(void)
 573 {
 574   GList *pglist;
 575   struct Page *pg;
 576   GdkPixbuf *pix;
 577
 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;
 582
 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);
 594       } else
 595       {
 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;
 600       }
 601     }
 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;
 606     }
 607   }
 608 }
 609
 610 gboolean have_intersect(struct BBox *a, struct BBox *b)
 611 {
 612   return (MAX(a->top, b->top) <= MIN(a->bottom, b->bottom)) &&
 613          (MAX(a->left, b->left) <= MIN(a->right, b->right));
 614 }
 615
 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 !! */
 619
 620 void lower_canvas_item_to(GnomeCanvasGroup *g, GnomeCanvasItem *item, GnomeCanvasItem *after)
 621 {
 622   int i1, i2;
 623
 624   i1 = g_list_index(g->item_list, item);
 625   if (i1 == -1) return;
 626
 627   if (after == NULL) i2 = -1;
 628   else i2 = g_list_index(g->item_list, after);
 629
 630   if (i1 < i2) gnome_canvas_item_raise(item, i2-i1);
 631   if (i1 > i2+1) gnome_canvas_item_lower(item, i1-i2-1);
 632
 633   // BUGFIX for libgnomecanvas
 634   g->item_list_end = g_list_last(g->item_list);
 635 }
 636
 637 void rgb_to_gdkcolor(guint rgba, GdkColor *color)
 638 {
 639   color->pixel = 0;
 640   color->red = ((rgba>>24)&0xff)*0x101;
 641   color->green = ((rgba>>16)&0xff)*0x101;
 642   color->blue = ((rgba>>8)&0xff)*0x101;
 643 }
 644
 645 // some interface functions
 646
 647 void update_thickness_buttons(void)
 648 {
 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);
 652   } else
 653   switch (ui.cur_brush->thickness_no) {
 654     case THICKNESS_FINE:
 655       gtk_toggle_tool_button_set_active(
 656         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonFine")), TRUE);
 657       break;
 658     case THICKNESS_MEDIUM:
 659       gtk_toggle_tool_button_set_active(
 660         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonMedium")), TRUE);
 661       break;
 662     case THICKNESS_THICK:
 663       gtk_toggle_tool_button_set_active(
 664         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonThick")), TRUE);
 665       break;
 666     default:
 667       gtk_toggle_tool_button_set_active(
 668         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonThicknessOther")), TRUE);
 669   }
 670 }
 671
 672 void update_color_buttons(void)
 673 {
 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);
 678   } else
 679   switch (ui.cur_brush->color_no) {
 680     case COLOR_BLACK:
 681       gtk_toggle_tool_button_set_active(
 682         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonBlack")), TRUE);
 683       break;
 684     case COLOR_BLUE:
 685       gtk_toggle_tool_button_set_active(
 686         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonBlue")), TRUE);
 687       break;
 688     case COLOR_RED:
 689       gtk_toggle_tool_button_set_active(
 690         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonRed")), TRUE);
 691       break;
 692     case COLOR_GREEN:
 693       gtk_toggle_tool_button_set_active(
 694         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonGreen")), TRUE);
 695       break;
 696     case COLOR_GRAY:
 697       gtk_toggle_tool_button_set_active(
 698         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonGray")), TRUE);
 699       break;
 700     case COLOR_LIGHTBLUE:
 701       gtk_toggle_tool_button_set_active(
 702         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonLightBlue")), TRUE);
 703       break;
 704     case COLOR_LIGHTGREEN:
 705       gtk_toggle_tool_button_set_active(
 706         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonLightGreen")), TRUE);
 707       break;
 708     case COLOR_MAGENTA:
 709       gtk_toggle_tool_button_set_active(
 710         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonMagenta")), TRUE);
 711       break;
 712     case COLOR_ORANGE:
 713       gtk_toggle_tool_button_set_active(
 714         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonOrange")), TRUE);
 715       break;
 716     case COLOR_YELLOW:
 717       gtk_toggle_tool_button_set_active(
 718         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonYellow")), TRUE);
 719       break;
 720     case COLOR_WHITE:
 721       gtk_toggle_tool_button_set_active(
 722         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonWhite")), TRUE);
 723       break;
 724     default:
 725       gtk_toggle_tool_button_set_active(
 726         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonColorOther")), TRUE);
 727   }
 728 }
 729
 730 void update_tool_buttons(void)
 731 {
 732   switch(ui.toolno[ui.cur_mapping]) {
 733     case TOOL_PEN:
 734       gtk_toggle_tool_button_set_active(
 735         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonPen")), TRUE);
 736       break;
 737     case TOOL_ERASER:
 738       gtk_toggle_tool_button_set_active(
 739         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonEraser")), TRUE);
 740       break;
 741     case TOOL_HIGHLIGHTER:
 742       gtk_toggle_tool_button_set_active(
 743         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonHighlighter")), TRUE);
 744       break;
 745     case TOOL_TEXT:
 746       gtk_toggle_tool_button_set_active(
 747         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonText")), TRUE);
 748       break;
 749     case TOOL_SELECTREGION:
 750       gtk_toggle_tool_button_set_active(
 751         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonSelectRegion")), TRUE);
 752       break;
 753     case TOOL_SELECTRECT:
 754       gtk_toggle_tool_button_set_active(
 755         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonSelectRectangle")), TRUE);
 756       break;
 757     case TOOL_VERTSPACE:
 758       gtk_toggle_tool_button_set_active(
 759         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonVerticalSpace")), TRUE);
 760       break;
 761     case TOOL_HAND:
 762       gtk_toggle_tool_button_set_active(
 763         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonHand")), TRUE);
 764       break;
 765   }
 766
 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();
 771 }
 772
 773 void update_tool_menu(void)
 774 {
 775   switch(ui.toolno[0]) {
 776     case TOOL_PEN:
 777       gtk_check_menu_item_set_active(
 778         GTK_CHECK_MENU_ITEM(GET_COMPONENT("toolsPen")), TRUE);
 779       break;
 780     case TOOL_ERASER:
 781       gtk_check_menu_item_set_active(
 782         GTK_CHECK_MENU_ITEM(GET_COMPONENT("toolsEraser")), TRUE);
 783       break;
 784     case TOOL_HIGHLIGHTER:
 785       gtk_check_menu_item_set_active(
 786         GTK_CHECK_MENU_ITEM(GET_COMPONENT("toolsHighlighter")), TRUE);
 787       break;
 788     case TOOL_TEXT:
 789       gtk_check_menu_item_set_active(
 790         GTK_CHECK_MENU_ITEM(GET_COMPONENT("toolsText")), TRUE);
 791       break;
 792     case TOOL_SELECTREGION:
 793       gtk_check_menu_item_set_active(
 794         GTK_CHECK_MENU_ITEM(GET_COMPONENT("toolsSelectRegion")), TRUE);
 795       break;
 796     case TOOL_SELECTRECT:
 797       gtk_check_menu_item_set_active(
 798         GTK_CHECK_MENU_ITEM(GET_COMPONENT("toolsSelectRectangle")), TRUE);
 799       break;
 800     case TOOL_VERTSPACE:
 801       gtk_check_menu_item_set_active(
 802         GTK_CHECK_MENU_ITEM(GET_COMPONENT("toolsVerticalSpace")), TRUE);
 803       break;
 804     case TOOL_HAND:
 805       gtk_check_menu_item_set_active(
 806         GTK_CHECK_MENU_ITEM(GET_COMPONENT("toolsHand")), TRUE);
 807       break;
 808   }
 809
 810   gtk_check_menu_item_set_active(
 811     GTK_CHECK_MENU_ITEM(GET_COMPONENT("toolsRuler")), ui.ruler[0]);
 812 }
 813
 814 void update_ruler_indicator(void)
 815 {
 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]);
 820 }
 821
 822 void update_color_menu(void)
 823 {
 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);
 828   } else
 829   switch (ui.cur_brush->color_no) {
 830     case COLOR_BLACK:
 831       gtk_check_menu_item_set_active(
 832         GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorBlack")), TRUE);
 833       break;
 834     case COLOR_BLUE:
 835       gtk_check_menu_item_set_active(
 836         GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorBlue")), TRUE);
 837       break;
 838     case COLOR_RED:
 839       gtk_check_menu_item_set_active(
 840         GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorRed")), TRUE);
 841       break;
 842     case COLOR_GREEN:
 843       gtk_check_menu_item_set_active(
 844         GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorGreen")), TRUE);
 845       break;
 846     case COLOR_GRAY:
 847       gtk_check_menu_item_set_active(
 848         GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorGray")), TRUE);
 849       break;
 850     case COLOR_LIGHTBLUE:
 851       gtk_check_menu_item_set_active(
 852         GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorLightBlue")), TRUE);
 853       break;
 854     case COLOR_LIGHTGREEN:
 855       gtk_check_menu_item_set_active(
 856         GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorLightGreen")), TRUE);
 857       break;
 858     case COLOR_MAGENTA:
 859       gtk_check_menu_item_set_active(
 860         GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorMagenta")), TRUE);
 861       break;
 862     case COLOR_ORANGE:
 863       gtk_check_menu_item_set_active(
 864         GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorOrange")), TRUE);
 865       break;
 866     case COLOR_YELLOW:
 867       gtk_check_menu_item_set_active(
 868         GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorYellow")), TRUE);
 869       break;
 870     case COLOR_WHITE:
 871       gtk_check_menu_item_set_active(
 872         GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorWhite")), TRUE);
 873       break;
 874     default:
 875       gtk_check_menu_item_set_active(
 876         GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorOther")), TRUE);
 877   }
 878 }
 879
 880 void update_pen_props_menu(void)
 881 {
 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);
 886       break;
 887     case THICKNESS_FINE:
 888       gtk_check_menu_item_set_active(
 889         GTK_CHECK_MENU_ITEM(GET_COMPONENT("penthicknessFine")), TRUE);
 890       break;
 891     case THICKNESS_MEDIUM:
 892       gtk_check_menu_item_set_active(
 893         GTK_CHECK_MENU_ITEM(GET_COMPONENT("penthicknessMedium")), TRUE);
 894       break;
 895     case THICKNESS_THICK:
 896       gtk_check_menu_item_set_active(
 897         GTK_CHECK_MENU_ITEM(GET_COMPONENT("penthicknessThick")), TRUE);
 898       break;
 899     case THICKNESS_VERYTHICK:
 900       gtk_check_menu_item_set_active(
 901         GTK_CHECK_MENU_ITEM(GET_COMPONENT("penthicknessVeryThick")), TRUE);
 902       break;
 903   }
 904 }
 905
 906 void update_eraser_props_menu(void)
 907 {
 908   switch (ui.brushes[0][TOOL_ERASER].thickness_no) {
 909     case THICKNESS_FINE:
 910       gtk_check_menu_item_set_active(
 911         GTK_CHECK_MENU_ITEM(GET_COMPONENT("eraserFine")), TRUE);
 912       break;
 913     case THICKNESS_MEDIUM:
 914       gtk_check_menu_item_set_active(
 915         GTK_CHECK_MENU_ITEM(GET_COMPONENT("eraserMedium")), TRUE);
 916       break;
 917     case THICKNESS_THICK:
 918       gtk_check_menu_item_set_active(
 919         GTK_CHECK_MENU_ITEM(GET_COMPONENT("eraserThick")), TRUE);
 920       break;
 921   }
 922
 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);
 932 }
 933
 934 void update_highlighter_props_menu(void)
 935 {
 936   switch (ui.brushes[0][TOOL_HIGHLIGHTER].thickness_no) {
 937     case THICKNESS_FINE:
 938       gtk_check_menu_item_set_active(
 939         GTK_CHECK_MENU_ITEM(GET_COMPONENT("highlighterFine")), TRUE);
 940       break;
 941     case THICKNESS_MEDIUM:
 942       gtk_check_menu_item_set_active(
 943         GTK_CHECK_MENU_ITEM(GET_COMPONENT("highlighterMedium")), TRUE);
 944       break;
 945     case THICKNESS_THICK:
 946       gtk_check_menu_item_set_active(
 947         GTK_CHECK_MENU_ITEM(GET_COMPONENT("highlighterThick")), TRUE);
 948       break;
 949   }
 950 }
 951
 952 void update_mappings_menu_linkings(void)
 953 {
 954   switch (ui.linked_brush[1]) {
 955     case BRUSH_LINKED:
 956       gtk_check_menu_item_set_active(
 957         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button2LinkBrush")), TRUE);
 958       break;
 959     case BRUSH_COPIED:
 960       gtk_check_menu_item_set_active(
 961         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button2CopyBrush")), TRUE);
 962       break;
 963     case BRUSH_STATIC:
 964       gtk_check_menu_item_set_active(
 965         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button2NABrush")), TRUE);
 966       break;
 967   }
 968   switch (ui.linked_brush[2]) {
 969     case BRUSH_LINKED:
 970       gtk_check_menu_item_set_active(
 971         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button3LinkBrush")), TRUE);
 972       break;
 973     case BRUSH_COPIED:
 974       gtk_check_menu_item_set_active(
 975         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button3CopyBrush")), TRUE);
 976       break;
 977     case BRUSH_STATIC:
 978       gtk_check_menu_item_set_active(
 979         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button3NABrush")), TRUE);
 980       break;
 981   }
 982 }
 983
 984 void update_mappings_menu(void)
 985 {
 986   gtk_widget_set_sensitive(GET_COMPONENT("optionsButtonMappings"), ui.use_xinput);
 987   gtk_widget_set_sensitive(GET_COMPONENT("optionsDiscardCoreEvents"),
 988     ui.use_xinput && (gtk_check_version(2, 11, 0)!=NULL));
 989   gtk_check_menu_item_set_active(
 990     GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsButtonMappings")), ui.use_erasertip);
 991   gtk_check_menu_item_set_active(
 992     GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsDiscardCoreEvents")), ui.discard_corepointer);
 993
 994   switch(ui.toolno[1]) {
 995     case TOOL_PEN:
 996       gtk_check_menu_item_set_active(
 997         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button2Pen")), TRUE);
 998       break;
 999     case TOOL_ERASER:
1000       gtk_check_menu_item_set_active(
1001         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button2Eraser")), TRUE);
1002       break;
1003     case TOOL_HIGHLIGHTER:
1004       gtk_check_menu_item_set_active(
1005         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button2Highlighter")), TRUE);
1006       break;
1007     case TOOL_TEXT:
1008       gtk_check_menu_item_set_active(
1009         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button2Text")), TRUE);
1010       break;
1011     case TOOL_SELECTREGION:
1012       gtk_check_menu_item_set_active(
1013         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button2SelectRegion")), TRUE);
1014       break;
1015     case TOOL_SELECTRECT:
1016       gtk_check_menu_item_set_active(
1017         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button2SelectRectangle")), TRUE);
1018       break;
1019     case TOOL_VERTSPACE:
1020       gtk_check_menu_item_set_active(
1021         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button2VerticalSpace")), TRUE);
1022       break;
1023   }
1024   switch(ui.toolno[2]) {
1025     case TOOL_PEN:
1026       gtk_check_menu_item_set_active(
1027         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button3Pen")), TRUE);
1028       break;
1029     case TOOL_ERASER:
1030       gtk_check_menu_item_set_active(
1031         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button3Eraser")), TRUE);
1032       break;
1033     case TOOL_HIGHLIGHTER:
1034       gtk_check_menu_item_set_active(
1035         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button3Highlighter")), TRUE);
1036       break;
1037     case TOOL_TEXT:
1038       gtk_check_menu_item_set_active(
1039         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button3Text")), TRUE);
1040       break;
1041     case TOOL_SELECTREGION:
1042       gtk_check_menu_item_set_active(
1043         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button3SelectRegion")), TRUE);
1044       break;
1045     case TOOL_SELECTRECT:
1046       gtk_check_menu_item_set_active(
1047         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button3SelectRectangle")), TRUE);
1048       break;
1049     case TOOL_VERTSPACE:
1050       gtk_check_menu_item_set_active(
1051         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button3VerticalSpace")), TRUE);
1052       break;
1053   }
1054   update_mappings_menu_linkings();
1055 }
1056
1057 void do_switch_page(int pg, gboolean rescroll, gboolean refresh_all)
1058 {
1059   int i, cx, cy;
1060   struct Layer *layer;
1061   GList *list;
1062
1063   ui.pageno = pg;
1064
1065   /* re-show all the layers of the old page */
1066   if (ui.cur_page != NULL)
1067     for (i=0, list = ui.cur_page->layers; list!=NULL; i++, list = list->next) {
1068       layer = (struct Layer *)list->data;
1069       if (layer->group!=NULL)
1070         gnome_canvas_item_show(GNOME_CANVAS_ITEM(layer->group));
1071     }
1072
1073   ui.cur_page = g_list_nth_data(journal.pages, ui.pageno);
1074   ui.layerno = ui.cur_page->nlayers-1;
1075   ui.cur_layer = (struct Layer *)(g_list_last(ui.cur_page->layers)->data);
1076   update_page_stuff();
1077   if (ui.progressive_bg) rescale_bg_pixmaps();
1078
1079   if (rescroll) { // scroll and force a refresh
1080 /* -- this seems to cause some display bugs ??
1081     gtk_adjustment_set_value(gtk_layout_get_vadjustment(GTK_LAYOUT(canvas)),
1082       ui.cur_page->voffset*ui.zoom);  */
1083     gnome_canvas_get_scroll_offsets(canvas, &cx, &cy);
1084     cy = ui.cur_page->voffset*ui.zoom;
1085     gnome_canvas_scroll_to(canvas, cx, cy);
1086
1087     if (refresh_all)
1088       gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
1089     else if (!ui.view_continuous)
1090       gnome_canvas_item_move(GNOME_CANVAS_ITEM(ui.cur_page->group), 0., 0.);
1091   }
1092 }
1093
1094 void update_page_stuff(void)
1095 {
1096   gchar tmp[10];
1097   GtkComboBox *layerbox;
1098   int i;
1099   GList *pglist;
1100   GtkSpinButton *spin;
1101   struct Page *pg;
1102   double vertpos, maxwidth;
1103   struct Layer *layer;
1104   int relscroll;
1105
1106   // move the page groups to their rightful locations or hide them
1107   if (ui.view_continuous) {
1108     vertpos = 0.;
1109     maxwidth = 0.;
1110     for (i=0, pglist = journal.pages; pglist!=NULL; i++, pglist = pglist->next) {
1111       pg = (struct Page *)pglist->data;
1112       if (pg->group!=NULL) {
1113         pg->hoffset = 0.; pg->voffset = vertpos;
1114         gnome_canvas_item_set(GNOME_CANVAS_ITEM(pg->group),
1115             "x", pg->hoffset, "y", pg->voffset, NULL);
1116         gnome_canvas_item_show(GNOME_CANVAS_ITEM(pg->group));
1117       }
1118       vertpos += pg->height + VIEW_CONTINUOUS_SKIP;
1119       if (pg->width > maxwidth) maxwidth = pg->width;
1120     }
1121     vertpos -= VIEW_CONTINUOUS_SKIP;
1122     gnome_canvas_set_scroll_region(canvas, 0, 0, maxwidth, vertpos);
1123   } else {
1124     for (pglist = journal.pages; pglist!=NULL; pglist = pglist->next) {
1125       pg = (struct Page *)pglist->data;
1126       if (pg == ui.cur_page && pg->group!=NULL) {
1127         pg->hoffset = 0.; pg->voffset = 0.;
1128         gnome_canvas_item_set(GNOME_CANVAS_ITEM(pg->group),
1129             "x", pg->hoffset, "y", pg->voffset, NULL);
1130         gnome_canvas_item_show(GNOME_CANVAS_ITEM(pg->group));
1131       } else {
1132         if (pg->group!=NULL) gnome_canvas_item_hide(GNOME_CANVAS_ITEM(pg->group));
1133       }
1134     }
1135     gnome_canvas_set_scroll_region(canvas, 0, 0, ui.cur_page->width, ui.cur_page->height);
1136   }
1137
1138   // update the page / layer info at bottom of screen
1139
1140   spin = GTK_SPIN_BUTTON(GET_COMPONENT("spinPageNo"));
1141   ui.in_update_page_stuff = TRUE; // avoid a bad retroaction
1142   gtk_spin_button_set_range(spin, 1, journal.npages+1);
1143     /* npages+1 will be used to create a new page at end */
1144   gtk_spin_button_set_value(spin, ui.pageno+1);
1145   g_snprintf(tmp, 10, " of %d", journal.npages);
1146   gtk_label_set_text(GTK_LABEL(GET_COMPONENT("labelNumpages")), tmp);
1147
1148   layerbox = GTK_COMBO_BOX(GET_COMPONENT("comboLayer"));
1149   if (ui.layerbox_length == 0) {
1150     gtk_combo_box_prepend_text(layerbox, "Background");
1151     ui.layerbox_length++;
1152   }
1153   while (ui.layerbox_length > ui.cur_page->nlayers+1) {
1154     gtk_combo_box_remove_text(layerbox, 0);
1155     ui.layerbox_length--;
1156   }
1157   while (ui.layerbox_length < ui.cur_page->nlayers+1) {
1158     g_snprintf(tmp, 10, "Layer %d", ui.layerbox_length++);
1159     gtk_combo_box_prepend_text(layerbox, tmp);
1160   }
1161   gtk_combo_box_set_active(layerbox, ui.cur_page->nlayers-1-ui.layerno);
1162   ui.in_update_page_stuff = FALSE;
1163
1164   // update the paper-style menu radio buttons
1165
1166   if (ui.view_continuous)
1167     gtk_check_menu_item_set_active(
1168        GTK_CHECK_MENU_ITEM(GET_COMPONENT("viewContinuous")), TRUE);
1169   else
1170     gtk_check_menu_item_set_active(
1171        GTK_CHECK_MENU_ITEM(GET_COMPONENT("viewOnePage")), TRUE);
1172
1173   if (ui.cur_page->bg->type == BG_SOLID && !ui.bg_apply_all_pages) {
1174     switch (ui.cur_page->bg->color_no) {
1175       case COLOR_WHITE:
1176         gtk_check_menu_item_set_active(
1177           GTK_CHECK_MENU_ITEM(GET_COMPONENT("papercolorWhite")), TRUE);
1178         break;
1179       case COLOR_YELLOW:
1180         gtk_check_menu_item_set_active(
1181           GTK_CHECK_MENU_ITEM(GET_COMPONENT("papercolorYellow")), TRUE);
1182         break;
1183       case COLOR_RED:
1184         gtk_check_menu_item_set_active(
1185           GTK_CHECK_MENU_ITEM(GET_COMPONENT("papercolorPink")), TRUE);
1186         break;
1187       case COLOR_ORANGE:
1188         gtk_check_menu_item_set_active(
1189           GTK_CHECK_MENU_ITEM(GET_COMPONENT("papercolorOrange")), TRUE);
1190         break;
1191       case COLOR_BLUE:
1192         gtk_check_menu_item_set_active(
1193           GTK_CHECK_MENU_ITEM(GET_COMPONENT("papercolorBlue")), TRUE);
1194         break;
1195       case COLOR_GREEN:
1196         gtk_check_menu_item_set_active(
1197           GTK_CHECK_MENU_ITEM(GET_COMPONENT("papercolorGreen")), TRUE);
1198         break;
1199       default:
1200         gtk_check_menu_item_set_active(
1201           GTK_CHECK_MENU_ITEM(GET_COMPONENT("papercolorOther")), TRUE);
1202         break;
1203     }
1204     switch (ui.cur_page->bg->ruling) {
1205       case RULING_NONE:
1206         gtk_check_menu_item_set_active(
1207           GTK_CHECK_MENU_ITEM(GET_COMPONENT("paperstylePlain")), TRUE);
1208         break;
1209       case RULING_LINED:
1210         gtk_check_menu_item_set_active(
1211           GTK_CHECK_MENU_ITEM(GET_COMPONENT("paperstyleLined")), TRUE);
1212         break;
1213       case RULING_RULED:
1214         gtk_check_menu_item_set_active(
1215           GTK_CHECK_MENU_ITEM(GET_COMPONENT("paperstyleRuled")), TRUE);
1216         break;
1217       case RULING_GRAPH:
1218         gtk_check_menu_item_set_active(
1219           GTK_CHECK_MENU_ITEM(GET_COMPONENT("paperstyleGraph")), TRUE);
1220         break;
1221     }
1222   } else {
1223     gtk_check_menu_item_set_active(
1224       GTK_CHECK_MENU_ITEM(GET_COMPONENT("papercolorNA")), TRUE);
1225     gtk_check_menu_item_set_active(
1226       GTK_CHECK_MENU_ITEM(GET_COMPONENT("paperstyleNA")), TRUE);
1227   }
1228
1229   // enable/disable the page/layer menu items and toolbar buttons
1230
1231   gtk_widget_set_sensitive(GET_COMPONENT("journalPaperColor"),
1232      ui.cur_page->bg->type == BG_SOLID || ui.bg_apply_all_pages);
1233   gtk_widget_set_sensitive(GET_COMPONENT("journalSetAsDefault"),
1234      ui.cur_page->bg->type == BG_SOLID);
1235
1236   gtk_widget_set_sensitive(GET_COMPONENT("viewFirstPage"), ui.pageno!=0);
1237   gtk_widget_set_sensitive(GET_COMPONENT("viewPreviousPage"), ui.pageno!=0);
1238   gtk_widget_set_sensitive(GET_COMPONENT("viewNextPage"), TRUE);
1239   gtk_widget_set_sensitive(GET_COMPONENT("viewLastPage"), ui.pageno!=journal.npages-1);
1240   gtk_widget_set_sensitive(GET_COMPONENT("buttonFirstPage"), ui.pageno!=0);
1241   gtk_widget_set_sensitive(GET_COMPONENT("buttonPreviousPage"), ui.pageno!=0);
1242   gtk_widget_set_sensitive(GET_COMPONENT("buttonNextPage"), TRUE);
1243   gtk_widget_set_sensitive(GET_COMPONENT("buttonLastPage"), ui.pageno!=journal.npages-1);
1244
1245   gtk_widget_set_sensitive(GET_COMPONENT("viewShowLayer"), ui.layerno!=ui.cur_page->nlayers-1);
1246   gtk_widget_set_sensitive(GET_COMPONENT("viewHideLayer"), ui.layerno>=0);
1247
1248   gtk_widget_set_sensitive(GET_COMPONENT("editPaste"), ui.cur_layer!=NULL);
1249   gtk_widget_set_sensitive(GET_COMPONENT("buttonPaste"), ui.cur_layer!=NULL);
1250 }
1251
1252 void update_toolbar_and_menu(void)
1253 {
1254   update_tool_buttons(); // takes care of other toolbar buttons as well
1255   update_tool_menu();
1256   update_color_menu();
1257   update_pen_props_menu();
1258   update_eraser_props_menu();
1259   update_highlighter_props_menu();
1260   update_mappings_menu();
1261
1262   gtk_toggle_tool_button_set_active(
1263     GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonFullscreen")), ui.fullscreen);
1264   gtk_check_menu_item_set_active(
1265     GTK_CHECK_MENU_ITEM(GET_COMPONENT("viewFullscreen")), ui.fullscreen);
1266 }
1267
1268 void update_file_name(char *filename)
1269 {
1270   gchar tmp[100], *p;
1271   if (ui.filename != NULL) g_free(ui.filename);
1272   ui.filename = filename;
1273   if (filename == NULL) {
1274     gtk_window_set_title(GTK_WINDOW (winMain), "Xournal");
1275     return;
1276   }
1277   p = g_utf8_strrchr(filename, -1, '/');
1278   if (p == NULL) p = filename;
1279   else p = g_utf8_next_char(p);
1280   g_snprintf(tmp, 100, "Xournal - %s", p);
1281   gtk_window_set_title(GTK_WINDOW (winMain), tmp);
1282   new_mru_entry(filename);
1283 }
1284
1285 void update_undo_redo_enabled(void)
1286 {
1287   gtk_widget_set_sensitive(GET_COMPONENT("editUndo"), undo!=NULL);
1288   gtk_widget_set_sensitive(GET_COMPONENT("editRedo"), redo!=NULL);
1289   gtk_widget_set_sensitive(GET_COMPONENT("buttonUndo"), undo!=NULL);
1290   gtk_widget_set_sensitive(GET_COMPONENT("buttonRedo"), redo!=NULL);
1291 }
1292
1293 void update_copy_paste_enabled(void)
1294 {
1295   gtk_widget_set_sensitive(GET_COMPONENT("editCut"), ui.selection!=NULL);
1296   gtk_widget_set_sensitive(GET_COMPONENT("editCopy"), ui.selection!=NULL);
1297   gtk_widget_set_sensitive(GET_COMPONENT("editPaste"), ui.cur_item_type!=ITEM_TEXT);
1298   gtk_widget_set_sensitive(GET_COMPONENT("editDelete"), ui.selection!=NULL);
1299   gtk_widget_set_sensitive(GET_COMPONENT("buttonCut"), ui.selection!=NULL);
1300   gtk_widget_set_sensitive(GET_COMPONENT("buttonCopy"), ui.selection!=NULL);
1301   gtk_widget_set_sensitive(GET_COMPONENT("buttonPaste"), ui.cur_item_type!=ITEM_TEXT);
1302 }
1303
1304 void update_mapping_linkings(int toolno)
1305 {
1306   int i;
1307
1308   for (i = 1; i<=NUM_BUTTONS; i++) {
1309     if (ui.linked_brush[i] == BRUSH_LINKED) {
1310       if (toolno >= 0 && toolno < NUM_STROKE_TOOLS)
1311         g_memmove(&(ui.brushes[i][toolno]), &(ui.brushes[0][toolno]), sizeof(struct Brush));
1312       ui.ruler[i] = ui.ruler[0];
1313       if (ui.toolno[i]!=TOOL_PEN && ui.toolno[i]!=TOOL_HIGHLIGHTER)
1314         ui.ruler[i] = FALSE;
1315     }
1316     if (ui.linked_brush[i] == BRUSH_COPIED && toolno == ui.toolno[i]) {
1317       ui.linked_brush[i] = BRUSH_STATIC;
1318       if (i==1 || i==2) update_mappings_menu_linkings();
1319     }
1320   }
1321 }
1322
1323 void set_cur_color(int color)
1324 {
1325   ui.cur_brush->color_no = color;
1326   if (ui.toolno[0] == TOOL_HIGHLIGHTER)
1327     ui.cur_brush->color_rgba = predef_colors_rgba[color] & ui.hiliter_alpha_mask;
1328   else
1329     ui.cur_brush->color_rgba = predef_colors_rgba[color];
1330   update_mapping_linkings(ui.toolno[0]);
1331 }
1332
1333 void recolor_temp_text(int color_no, guint color_rgba)
1334 {
1335   GdkColor gdkcolor;
1336
1337   if (ui.cur_item_type!=ITEM_TEXT) return;
1338   if (ui.cur_item->text!=NULL && ui.cur_item->brush.color_rgba != color_rgba) {
1339     prepare_new_undo();
1340     undo->type = ITEM_TEXT_ATTRIB;
1341     undo->item = ui.cur_item;
1342     undo->str = g_strdup(ui.cur_item->font_name);
1343     undo->val_x = ui.cur_item->font_size;
1344     undo->brush = (struct Brush *)g_memdup(&(ui.cur_item->brush), sizeof(struct Brush));
1345   }
1346   ui.cur_item->brush.color_no = color_no;
1347   ui.cur_item->brush.color_rgba = color_rgba;
1348   rgb_to_gdkcolor(color_rgba, &gdkcolor);
1349   gtk_widget_modify_text(ui.cur_item->widget, GTK_STATE_NORMAL, &gdkcolor);
1350   gtk_widget_grab_focus(ui.cur_item->widget);
1351 }
1352
1353 void process_color_activate(GtkMenuItem *menuitem, int color)
1354 {
1355   if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1356     if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1357       return;
1358   } else {
1359     if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1360       return;
1361   }
1362
1363   if (ui.cur_mapping != 0) return; // not user-generated
1364   reset_focus();
1365
1366   if (ui.cur_item_type == ITEM_TEXT)
1367     recolor_temp_text(color, predef_colors_rgba[color]);
1368
1369   if (ui.selection != NULL) {
1370     recolor_selection(color);
1371     update_color_buttons();
1372     update_color_menu();
1373   }
1374
1375   if (ui.toolno[0] != TOOL_PEN && ui.toolno[0] != TOOL_HIGHLIGHTER
1376       && ui.toolno[0] != TOOL_TEXT) {
1377     if (ui.selection != NULL) return;
1378     end_text();
1379     ui.toolno[0] = TOOL_PEN;
1380     ui.cur_brush = &(ui.brushes[0][TOOL_PEN]);
1381     update_tool_buttons();
1382     update_tool_menu();
1383   }
1384
1385   set_cur_color(color);
1386   update_color_buttons();
1387   update_color_menu();
1388   update_cursor();
1389 }
1390
1391 void process_thickness_activate(GtkMenuItem *menuitem, int tool, int val)
1392 {
1393   if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1394     if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1395       return;
1396   } else {
1397     if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1398       return;
1399   }
1400
1401   if (ui.cur_mapping != 0) return; // not user-generated
1402
1403   if (ui.selection != NULL && GTK_OBJECT_TYPE(menuitem) != GTK_TYPE_RADIO_MENU_ITEM) {
1404     reset_focus();
1405     rethicken_selection(val);
1406     update_thickness_buttons();
1407   }
1408
1409   if (tool >= NUM_STROKE_TOOLS) {
1410     update_thickness_buttons(); // undo illegal button selection
1411     return;
1412   }
1413
1414   if (ui.brushes[0][tool].thickness_no == val) return;
1415   reset_focus();
1416   end_text();
1417   ui.brushes[0][tool].thickness_no = val;
1418   ui.brushes[0][tool].thickness = predef_thickness[tool][val];
1419   update_mapping_linkings(tool);
1420
1421   update_thickness_buttons();
1422   if (tool == TOOL_PEN) update_pen_props_menu();
1423   if (tool == TOOL_ERASER) update_eraser_props_menu();
1424   if (tool == TOOL_HIGHLIGHTER) update_highlighter_props_menu();
1425   update_cursor();
1426 }
1427
1428 void process_papercolor_activate(GtkMenuItem *menuitem, int color)
1429 {
1430   struct Page *pg;
1431   GList *pglist;
1432   gboolean hasdone;
1433
1434   if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1435     return;
1436
1437   if ((ui.cur_page->bg->type != BG_SOLID) || ui.bg_apply_all_pages)
1438     gtk_check_menu_item_set_active(
1439       GTK_CHECK_MENU_ITEM(GET_COMPONENT("papercolorNA")), TRUE);
1440
1441   pg = ui.cur_page;
1442   hasdone = FALSE;
1443   for (pglist = journal.pages; pglist!=NULL; pglist = pglist->next) {
1444     if (ui.bg_apply_all_pages) pg = (struct Page *)pglist->data;
1445     if (pg->bg->type == BG_SOLID && pg->bg->color_no != color) {
1446       prepare_new_undo();
1447       if (hasdone) undo->multiop |= MULTIOP_CONT_UNDO;
1448       undo->multiop |= MULTIOP_CONT_REDO;
1449       hasdone = TRUE;
1450       undo->type = ITEM_NEW_BG_ONE;
1451       undo->page = pg;
1452       undo->bg = (struct Background *)g_memdup(pg->bg, sizeof(struct Background));
1453       undo->bg->canvas_item = NULL;
1454
1455       pg->bg->color_no = color;
1456       pg->bg->color_rgba = predef_bgcolors_rgba[color];
1457       update_canvas_bg(pg);
1458     }
1459     if (!ui.bg_apply_all_pages) break;
1460   }
1461   if (hasdone) undo->multiop -= MULTIOP_CONT_REDO;
1462 }
1463
1464 void process_paperstyle_activate(GtkMenuItem *menuitem, int style)
1465 {
1466   struct Page *pg;
1467   GList *pglist;
1468   gboolean hasdone, must_upd;
1469
1470   if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1471     return;
1472
1473   if (ui.bg_apply_all_pages)
1474     gtk_check_menu_item_set_active(
1475       GTK_CHECK_MENU_ITEM(GET_COMPONENT("paperstyleNA")), TRUE);
1476
1477   pg = ui.cur_page;
1478   hasdone = FALSE;
1479   must_upd = FALSE;
1480   for (pglist = journal.pages; pglist!=NULL; pglist = pglist->next) {
1481     if (ui.bg_apply_all_pages) pg = (struct Page *)pglist->data;
1482     if (pg->bg->type != BG_SOLID || pg->bg->ruling != style) {
1483       prepare_new_undo();
1484       undo->type = ITEM_NEW_BG_ONE;
1485       if (hasdone) undo->multiop |= MULTIOP_CONT_UNDO;
1486       undo->multiop |= MULTIOP_CONT_REDO;
1487       hasdone = TRUE;
1488       undo->page = pg;
1489       undo->bg = (struct Background *)g_memdup(pg->bg, sizeof(struct Background));
1490       undo->bg->canvas_item = NULL;
1491
1492       if (pg->bg->type != BG_SOLID) {
1493         pg->bg->type = BG_SOLID;
1494         pg->bg->color_no = COLOR_WHITE;
1495         pg->bg->color_rgba = predef_bgcolors_rgba[COLOR_WHITE];
1496         pg->bg->filename = NULL;
1497         pg->bg->pixbuf = NULL;
1498         must_upd = TRUE;
1499       }
1500       pg->bg->ruling = style;
1501       update_canvas_bg(pg);
1502     }
1503     if (!ui.bg_apply_all_pages) break;
1504   }
1505   if (hasdone) undo->multiop -= MULTIOP_CONT_REDO;
1506   if (must_upd) update_page_stuff();
1507 }
1508
1509 gboolean ok_to_close(void)
1510 {
1511   GtkWidget *dialog;
1512   GtkResponseType response;
1513   GList *pagelist;
1514
1515   if (ui.saved) return TRUE;
1516   dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
1517     GTK_MESSAGE_WARNING, GTK_BUTTONS_YES_NO, "Save changes to '%s'?",
1518     (ui.filename!=NULL) ? ui.filename:"Untitled");
1519   gtk_dialog_add_button(GTK_DIALOG (dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
1520   response = gtk_dialog_run(GTK_DIALOG (dialog));
1521   gtk_widget_destroy(dialog);
1522   if (response == GTK_RESPONSE_CANCEL || response == GTK_RESPONSE_DELETE_EVENT)
1523     return FALSE; // aborted
1524   if (response == GTK_RESPONSE_YES) {
1525     on_fileSave_activate(NULL, NULL);
1526     if (!ui.saved) return FALSE; // if save failed, then we abort
1527   }
1528   return TRUE;
1529 }
1530
1531 // test if we're still busy loading a PDF background file
1532 gboolean page_ops_forbidden(void)
1533 {
1534   return (bgpdf.status != STATUS_NOT_INIT && bgpdf.create_pages);
1535 }
1536
1537 // send the focus back to the appropriate widget
1538 void reset_focus(void)
1539 {
1540   if (ui.cur_item_type == ITEM_TEXT)
1541     gtk_widget_grab_focus(ui.cur_item->widget);
1542   else
1543     gtk_widget_grab_focus(GTK_WIDGET(canvas));
1544 }
1545
1546 // selection / clipboard stuff
1547
1548 void reset_selection(void)
1549 {
1550   if (ui.selection == NULL) return;
1551   if (ui.selection->canvas_item != NULL)
1552     gtk_object_destroy(GTK_OBJECT(ui.selection->canvas_item));
1553   g_list_free(ui.selection->items);
1554   g_free(ui.selection);
1555   ui.selection = NULL;
1556   update_copy_paste_enabled();
1557   update_color_menu();
1558   update_thickness_buttons();
1559   update_color_buttons();
1560   update_font_button();
1561 }
1562
1563 void move_journal_items_by(GList *itemlist, double dx, double dy,
1564                               struct Layer *l1, struct Layer *l2, GList *depths)
1565 {
1566   struct Item *item;
1567   GnomeCanvasItem *refitem;
1568   GList *link;
1569   int i;
1570   double *pt;
1571
1572   while (itemlist!=NULL) {
1573     item = (struct Item *)itemlist->data;
1574     if (item->type == ITEM_STROKE)
1575       for (pt=item->path->coords, i=0; i<item->path->num_points; i++, pt+=2)
1576         { pt[0] += dx; pt[1] += dy; }
1577     if (item->type == ITEM_STROKE || item->type == ITEM_TEXT || item->type == ITEM_TEMP_TEXT) {
1578       item->bbox.left += dx;
1579       item->bbox.right += dx;
1580       item->bbox.top += dy;
1581       item->bbox.bottom += dy;
1582     }
1583     if (l1 != l2) {
1584       // find out where to insert
1585       if (depths != NULL) {
1586         if (depths->data == NULL) link = l2->items;
1587         else {
1588           link = g_list_find(l2->items, depths->data);
1589           if (link != NULL) link = link->next;
1590         }
1591       } else link = NULL;
1592       l2->items = g_list_insert_before(l2->items, link, item);
1593       l2->nitems++;
1594       l1->items = g_list_remove(l1->items, item);
1595       l1->nitems--;
1596     }
1597     if (depths != NULL) { // also raise/lower the canvas items
1598       if (item->canvas_item!=NULL) {
1599         if (depths->data == NULL) link = NULL;
1600         else link = g_list_find(l2->items, depths->data);
1601         if (link != NULL) refitem = ((struct Item *)(link->data))->canvas_item;
1602         else refitem = NULL;
1603         lower_canvas_item_to(l2->group, item->canvas_item, refitem);
1604       }
1605       depths = depths->next;
1606     }
1607     itemlist = itemlist->next;
1608   }
1609 }
1610
1611 // Switch between button mappings
1612
1613 /* NOTE ABOUT BUTTON MAPPINGS: ui.cur_mapping is 0 except while a canvas
1614    click event is being processed ... */
1615
1616 void switch_mapping(int m)
1617 {
1618   if (ui.cur_mapping == m) return;
1619
1620   ui.cur_mapping = m;
1621   if (ui.toolno[m] < NUM_STROKE_TOOLS)
1622     ui.cur_brush = &(ui.brushes[m][ui.toolno[m]]);
1623   if (ui.toolno[m] == TOOL_TEXT)
1624     ui.cur_brush = &(ui.brushes[m][TOOL_PEN]);
1625   update_tool_buttons();
1626   update_color_menu();
1627   update_cursor();
1628 }
1629
1630 void process_mapping_activate(GtkMenuItem *menuitem, int m, int tool)
1631 {
1632   if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem))) return;
1633   if (ui.cur_mapping!=0) return;
1634   if (ui.toolno[m] == tool) return;
1635   end_text();
1636   reset_focus();
1637
1638   ui.toolno[m] = tool;
1639   ui.ruler[m] = FALSE;
1640   if (ui.linked_brush[m] == BRUSH_LINKED
1641        && (tool==TOOL_PEN || tool==TOOL_HIGHLIGHTER))
1642     ui.ruler[m] = ui.ruler[0];
1643   if (ui.linked_brush[m] == BRUSH_COPIED) {
1644     ui.linked_brush[m] = BRUSH_STATIC;
1645     update_mappings_menu_linkings();
1646   }
1647 }
1648
1649 // update the ordering of components in the main vbox
1650
1651 const char *vbox_component_names[VBOX_MAIN_NITEMS]=
1652  {"scrolledwindowMain", "menubar", "toolbarMain", "toolbarPen", "hbox1"};
1653
1654 void update_vbox_order(int *order)
1655 {
1656   int i, j;
1657   GtkWidget *child;
1658   GtkBox *vboxMain = GTK_BOX(GET_COMPONENT("vboxMain"));
1659   gboolean present[VBOX_MAIN_NITEMS];
1660
1661   for (i=0; i<VBOX_MAIN_NITEMS; i++) present[i] = FALSE;
1662   j=0;
1663   for (i=0; i<VBOX_MAIN_NITEMS; i++) {
1664     if (order[i]<0 || order[i]>=VBOX_MAIN_NITEMS) continue;
1665     present[order[i]] = TRUE;
1666     child = GET_COMPONENT(vbox_component_names[order[i]]);
1667     gtk_box_reorder_child(vboxMain, child, j++);
1668     gtk_widget_show(child);
1669   }
1670   for (i=1; i<VBOX_MAIN_NITEMS; i++) // hide others, but not the drawing area!
1671     if (!present[i]) gtk_widget_hide(GET_COMPONENT(vbox_component_names[i]));
1672 }
1673
1674 gchar *make_cur_font_name(void)
1675 {
1676   gchar *str;
1677   struct Item *it;
1678
1679   if (ui.cur_item_type == ITEM_TEXT)
1680     str = g_strdup_printf("%s %.1f", ui.cur_item->font_name, ui.cur_item->font_size);
1681   else if (ui.selection!=NULL && ui.selection->items!=NULL &&
1682            ui.selection->items->next==NULL &&
1683            (it=(struct Item*)ui.selection->items->data)->type == ITEM_TEXT)
1684     str = g_strdup_printf("%s %.1f", it->font_name, it->font_size);
1685   else
1686     str = g_strdup_printf("%s %.1f", ui.font_name, ui.font_size);
1687   return str;
1688 }
1689
1690 void update_font_button(void)
1691 {
1692   gchar *str;
1693
1694   str = make_cur_font_name();
1695   gtk_font_button_set_font_name(GTK_FONT_BUTTON(GET_COMPONENT("fontButton")), str);
1696   g_free(str);
1697 }
1698
1699 gboolean can_accel(GtkWidget *widget, guint id, gpointer data)
1700 {
1701   return GTK_WIDGET_SENSITIVE(widget);
1702 }
1703
1704 void allow_all_accels(void)
1705 {
1706   g_signal_connect((gpointer) GET_COMPONENT("fileNew"),
1707       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1708   g_signal_connect((gpointer) GET_COMPONENT("fileOpen"),
1709       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1710   g_signal_connect((gpointer) GET_COMPONENT("fileSave"),
1711       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1712   g_signal_connect((gpointer) GET_COMPONENT("filePrint"),
1713       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1714   g_signal_connect((gpointer) GET_COMPONENT("filePrintPDF"),
1715       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1716   g_signal_connect((gpointer) GET_COMPONENT("fileQuit"),
1717       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1718   g_signal_connect((gpointer) GET_COMPONENT("editUndo"),
1719       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1720   g_signal_connect((gpointer) GET_COMPONENT("editRedo"),
1721       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1722   g_signal_connect((gpointer) GET_COMPONENT("editCut"),
1723       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1724   g_signal_connect((gpointer) GET_COMPONENT("editCopy"),
1725       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1726   g_signal_connect((gpointer) GET_COMPONENT("editPaste"),
1727       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1728   g_signal_connect((gpointer) GET_COMPONENT("editDelete"),
1729       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1730   g_signal_connect((gpointer) GET_COMPONENT("viewFullscreen"),
1731       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1732   g_signal_connect((gpointer) GET_COMPONENT("viewZoomIn"),
1733       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1734   g_signal_connect((gpointer) GET_COMPONENT("viewZoomOut"),
1735       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1736   g_signal_connect((gpointer) GET_COMPONENT("viewNormalSize"),
1737       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1738   g_signal_connect((gpointer) GET_COMPONENT("viewPageWidth"),
1739       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1740   g_signal_connect((gpointer) GET_COMPONENT("viewFirstPage"),
1741       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1742   g_signal_connect((gpointer) GET_COMPONENT("viewPreviousPage"),
1743       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1744   g_signal_connect((gpointer) GET_COMPONENT("viewNextPage"),
1745       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1746   g_signal_connect((gpointer) GET_COMPONENT("viewLastPage"),
1747       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1748   g_signal_connect((gpointer) GET_COMPONENT("toolsPen"),
1749       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1750   g_signal_connect((gpointer) GET_COMPONENT("toolsEraser"),
1751       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1752   g_signal_connect((gpointer) GET_COMPONENT("toolsHighlighter"),
1753       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1754   g_signal_connect((gpointer) GET_COMPONENT("toolsText"),
1755       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1756 /*  g_signal_connect((gpointer) GET_COMPONENT("toolsSelectRegion"),
1757       "can-activate-accel", G_CALLBACK(can_accel), NULL);  */
1758   g_signal_connect((gpointer) GET_COMPONENT("toolsSelectRectangle"),
1759       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1760   g_signal_connect((gpointer) GET_COMPONENT("toolsVerticalSpace"),
1761       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1762   g_signal_connect((gpointer) GET_COMPONENT("toolsHand"),
1763       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1764   g_signal_connect((gpointer) GET_COMPONENT("toolsTextFont"),
1765       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1766   g_signal_connect((gpointer) GET_COMPONENT("toolsRuler"),
1767       "can-activate-accel", G_CALLBACK(can_accel), NULL);
1768 }
1769
1770 void add_scroll_bindings(void)
1771 {
1772   GtkBindingSet *binding_set;
1773
1774   binding_set = gtk_binding_set_by_class(
1775      G_OBJECT_GET_CLASS(GET_COMPONENT("scrolledwindowMain")));
1776   gtk_binding_entry_add_signal(binding_set, GDK_Up, 0,
1777     "scroll_child", 2, GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_STEP_BACKWARD,
1778     G_TYPE_BOOLEAN, FALSE);
1779   gtk_binding_entry_add_signal(binding_set, GDK_KP_Up, 0,
1780     "scroll_child", 2, GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_STEP_BACKWARD,
1781     G_TYPE_BOOLEAN, FALSE);
1782   gtk_binding_entry_add_signal(binding_set, GDK_Down, 0,
1783     "scroll_child", 2, GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_STEP_FORWARD,
1784     G_TYPE_BOOLEAN, FALSE);
1785   gtk_binding_entry_add_signal(binding_set, GDK_KP_Down, 0,
1786     "scroll_child", 2, GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_STEP_FORWARD,
1787     G_TYPE_BOOLEAN, FALSE);
1788   gtk_binding_entry_add_signal(binding_set, GDK_Left, 0,
1789     "scroll_child", 2, GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_STEP_BACKWARD,
1790     G_TYPE_BOOLEAN, TRUE);
1791   gtk_binding_entry_add_signal(binding_set, GDK_KP_Left, 0,
1792     "scroll_child", 2, GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_STEP_BACKWARD,
1793     G_TYPE_BOOLEAN, TRUE);
1794   gtk_binding_entry_add_signal(binding_set, GDK_Right, 0,
1795     "scroll_child", 2, GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_STEP_FORWARD,
1796     G_TYPE_BOOLEAN, TRUE);
1797   gtk_binding_entry_add_signal(binding_set, GDK_KP_Right, 0,
1798     "scroll_child", 2, GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_STEP_FORWARD,
1799     G_TYPE_BOOLEAN, TRUE);
1800 }
1801
1802 gboolean is_event_within_textview(GdkEventButton *event)
1803 {
1804   double pt[2];
1805
1806   if (ui.cur_item_type!=ITEM_TEXT) return FALSE;
1807   get_pointer_coords((GdkEvent *)event, pt);
1808   if (pt[0]<ui.cur_item->bbox.left || pt[0]>ui.cur_item->bbox.right) return FALSE;
1809   if (pt[1]<ui.cur_item->bbox.top || pt[1]>ui.cur_item->bbox.bottom) return FALSE;
1810   return TRUE;
1811 }