src/xo-misc.c

   1 // comment out the line below if you want the thickness settings of v 0.2
   2 #define NEW_THICKNESS
   3
   4 #ifdef HAVE_CONFIG_H
   5 #  include <config.h>
   6 #endif
   7
   8 #include <math.h>
   9 #include <string.h>
  10 #include <gtk/gtk.h>
  11 #include <libgnomecanvas/libgnomecanvas.h>
  12
  13 #include "xournal.h"
  14 #include "xo-interface.h"
  15 #include "xo-support.h"
  16 #include "xo-callbacks.h"
  17 #include "xo-misc.h"
  18 #include "xo-file.h"
  19 #include "xo-paint.h"
  20
  21 // some global constants
  22
  23 guint predef_colors_rgba[COLOR_MAX] =
  24   { 0x000000ff, 0x3333ccff, 0xff0000ff, 0x008000ff,
  25     0x808080ff, 0x00c0ffff, 0x00ff00ff, 0xff00ffff,
  26     0xff8000ff, 0xffff00ff, 0xffffffff };
  27
  28 guint predef_bgcolors_rgba[COLOR_MAX] = // meaningless ones set to white
  29   { 0xffffffff, 0xa0e8ffff, 0xffc0d4ff, 0x80ffc0ff,
  30     0xffffffff, 0xa0e8ffff, 0x80ffc0ff, 0xffc0d4ff,
  31     0xffc080ff, 0xffff80ff, 0xffffffff };
  32
  33 #ifdef NEW_THICKNESS
  34 double predef_thickness[NUM_STROKE_TOOLS][THICKNESS_MAX] =
  35   { { 0.42, 0.85, 1.41,  2.26, 5.67 }, // pen thicknesses = 0.15, 0.3, 0.5, 0.8, 2 mm
  36     { 2.83, 2.83, 8.50, 19.84, 19.84 }, // eraser thicknesses = 1, 2.5, 5 mm
  37     { 2.83, 2.83, 8.50, 19.84, 19.84 }, // highlighter thicknesses = 1, 2.5, 5 mm
  38   };
  39 #else
  40 double predef_thickness[NUM_STROKE_TOOLS][THICKNESS_MAX] =
  41   { { 0.42, 0.85, 1.41,  2.26, 5.67 }, // pen thicknesses = 0.15, 0.3, 0.5, 0.8, 2 mm
  42     { 2.83, 2.83, 7.08, 14.17, 14.17 }, // eraser thicknesses = 1, 2.5, 5 mm
  43     { 2.83, 2.83, 7.08, 14.17, 14.17 }, // highlighter thicknesses = 1, 2.5, 5 mm
  44   };
  45 #endif
  46
  47 // some manipulation functions
  48
  49 struct Page *new_page(struct Page *template)
  50 {
  51   struct Page *pg = (struct Page *) g_memdup(template, sizeof(struct Page));
  52   struct Layer *l = g_new(struct Layer, 1);
  53
  54   l->items = NULL;
  55   l->nitems = 0;
  56   pg->layers = g_list_append(NULL, l);
  57   pg->nlayers = 1;
  58   pg->bg = (struct Background *)g_memdup(template->bg, sizeof(struct Background));
  59   pg->bg->canvas_item = NULL;
  60   if (pg->bg->type == BG_PIXMAP || pg->bg->type == BG_PDF) {
  61     gdk_pixbuf_ref(pg->bg->pixbuf);
  62     refstring_ref(pg->bg->filename);
  63   }
  64   pg->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
  65       gnome_canvas_root(canvas), gnome_canvas_clipgroup_get_type(), NULL);
  66   make_page_clipbox(pg);
  67   update_canvas_bg(pg);
  68   l->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
  69       pg->group, gnome_canvas_group_get_type(), NULL);
  70
  71   return pg;
  72 }
  73
  74 /* Create a page from a background.
  75    Note: bg should be an UNREFERENCED background.
  76    If needed, first duplicate it and increase the refcount of the pixbuf.
  77 */
  78 struct Page *new_page_with_bg(struct Background *bg, double width, double height)
  79 {
  80   struct Page *pg = g_new(struct Page, 1);
  81   struct Layer *l = g_new(struct Layer, 1);
  82
  83   l->items = NULL;
  84   l->nitems = 0;
  85   pg->layers = g_list_append(NULL, l);
  86   pg->nlayers = 1;
  87   pg->bg = bg;
  88   pg->bg->canvas_item = NULL;
  89   pg->height = height;
  90   pg->width = width;
  91   pg->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
  92       gnome_canvas_root(canvas), gnome_canvas_clipgroup_get_type(), NULL);
  93   make_page_clipbox(pg);
  94   update_canvas_bg(pg);
  95   l->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
  96       pg->group, gnome_canvas_group_get_type(), NULL);
  97
  98   return pg;
  99 }
 100
 101 void realloc_cur_path(int n)
 102 {
 103   if (n <= ui.cur_path_storage_alloc) return;
 104   ui.cur_path_storage_alloc = n+10;
 105   ui.cur_path.coords = g_realloc(ui.cur_path.coords, 2*(n+10)*sizeof(double));
 106 }
 107
 108 // undo utility functions
 109
 110 void prepare_new_undo(void)
 111 {
 112   struct UndoItem *u;
 113   // add a new UndoItem on the stack
 114   u = (struct UndoItem *)g_malloc(sizeof(struct UndoItem));
 115   u->next = undo;
 116   u->multiop = 0;
 117   undo = u;
 118   ui.saved = FALSE;
 119   clear_redo_stack();
 120 }
 121
 122 void clear_redo_stack(void)
 123 {
 124   struct UndoItem *u;
 125   GList *list, *repl;
 126   struct UndoErasureData *erasure;
 127   struct Item *it;
 128
 129   /* Warning: the redo items might reference items from past redo entries,
 130      which have been destroyed before them. Be careful! As a rule, it's
 131      safe to destroy data which has been created at the current history step,
 132      it's unsafe to refer to any data from previous history steps */
 133
 134   while (redo!=NULL) {
 135     if (redo->type == ITEM_STROKE) {
 136       gnome_canvas_points_free(redo->item->path);
 137       g_free(redo->item);
 138       /* the strokes are unmapped, so there are no associated canvas items */
 139     }
 140     else if (redo->type == ITEM_ERASURE) {
 141       for (list = redo->erasurelist; list!=NULL; list=list->next) {
 142         erasure = (struct UndoErasureData *)list->data;
 143         for (repl = erasure->replacement_items; repl!=NULL; repl=repl->next) {
 144           it = (struct Item *)repl->data;
 145           gnome_canvas_points_free(it->path);
 146           g_free(it);
 147         }
 148         g_list_free(erasure->replacement_items);
 149         g_free(erasure);
 150       }
 151       g_list_free(redo->erasurelist);
 152     }
 153     else if (redo->type == ITEM_NEW_BG_ONE || redo->type == ITEM_NEW_BG_RESIZE
 154           || redo->type == ITEM_NEW_DEFAULT_BG) {
 155       if (redo->bg->type == BG_PIXMAP || redo->bg->type == BG_PDF) {
 156         if (redo->bg->pixbuf!=NULL) gdk_pixbuf_unref(redo->bg->pixbuf);
 157         refstring_unref(redo->bg->filename);
 158       }
 159       g_free(redo->bg);
 160     }
 161     else if (redo->type == ITEM_NEW_PAGE) {
 162       redo->page->group = NULL;
 163       delete_page(redo->page);
 164     }
 165     else if (redo->type == ITEM_MOVESEL || redo->type == ITEM_REPAINTSEL) {
 166       g_list_free(redo->itemlist); g_list_free(redo->auxlist);
 167     }
 168     else if (redo->type == ITEM_PASTE) {
 169       for (list = redo->itemlist; list!=NULL; list=list->next) {
 170         it = (struct Item *)list->data;
 171         if (it->type == ITEM_STROKE) gnome_canvas_points_free(it->path);
 172         g_free(it);
 173       }
 174       g_list_free(redo->itemlist);
 175     }
 176     else if (redo->type == ITEM_NEW_LAYER) {
 177       g_free(redo->layer);
 178     }
 179
 180     u = redo;
 181     redo = redo->next;
 182     g_free(u);
 183   }
 184   update_undo_redo_enabled();
 185 }
 186
 187 void clear_undo_stack(void)
 188 {
 189   struct UndoItem *u;
 190   GList *list;
 191   struct UndoErasureData *erasure;
 192
 193   while (undo!=NULL) {
 194     // for strokes, items are already in the journal, so we don't free them
 195     // for erasures, we need to free the dead items
 196     if (undo->type == ITEM_ERASURE) {
 197       for (list = undo->erasurelist; list!=NULL; list=list->next) {
 198         erasure = (struct UndoErasureData *)list->data;
 199         gnome_canvas_points_free(erasure->item->path);
 200         g_free(erasure->item);
 201         g_list_free(erasure->replacement_items);
 202         g_free(erasure);
 203       }
 204       g_list_free(undo->erasurelist);
 205     }
 206     else if (undo->type == ITEM_NEW_BG_ONE || undo->type == ITEM_NEW_BG_RESIZE
 207           || undo->type == ITEM_NEW_DEFAULT_BG) {
 208       if (undo->bg->type == BG_PIXMAP || undo->bg->type == BG_PDF) {
 209         if (undo->bg->pixbuf!=NULL) gdk_pixbuf_unref(undo->bg->pixbuf);
 210         refstring_unref(undo->bg->filename);
 211       }
 212       g_free(undo->bg);
 213     }
 214     else if (undo->type == ITEM_MOVESEL || undo->type == ITEM_REPAINTSEL) {
 215       g_list_free(undo->itemlist); g_list_free(undo->auxlist);
 216     }
 217     else if (undo->type == ITEM_PASTE) {
 218       g_list_free(undo->itemlist);
 219     }
 220     else if (undo->type == ITEM_DELETE_LAYER) {
 221       undo->layer->group = NULL;
 222       delete_layer(undo->layer);
 223     }
 224     else if (undo->type == ITEM_DELETE_PAGE) {
 225       undo->page->group = NULL;
 226       delete_page(undo->page);
 227     }
 228
 229     u = undo;
 230     undo = undo->next;
 231     g_free(u);
 232   }
 233   update_undo_redo_enabled();
 234 }
 235
 236 // free data structures
 237
 238 void delete_journal(struct Journal *j)
 239 {
 240   while (j->pages!=NULL) {
 241     delete_page((struct Page *)j->pages->data);
 242     j->pages = g_list_delete_link(j->pages, j->pages);
 243   }
 244 }
 245
 246 void delete_page(struct Page *pg)
 247 {
 248   struct Layer *l;
 249
 250   while (pg->layers!=NULL) {
 251     l = (struct Layer *)pg->layers->data;
 252     l->group = NULL;
 253     delete_layer(l);
 254     pg->layers = g_list_delete_link(pg->layers, pg->layers);
 255   }
 256   if (pg->group!=NULL) gtk_object_destroy(GTK_OBJECT(pg->group));
 257               // this also destroys the background's canvas items
 258   if (pg->bg->type == BG_PIXMAP || pg->bg->type == BG_PDF) {
 259     if (pg->bg->pixbuf != NULL) gdk_pixbuf_unref(pg->bg->pixbuf);
 260     if (pg->bg->filename != NULL) refstring_unref(pg->bg->filename);
 261   }
 262   g_free(pg->bg);
 263   g_free(pg);
 264 }
 265
 266 void delete_layer(struct Layer *l)
 267 {
 268   struct Item *item;
 269
 270   while (l->items!=NULL) {
 271     item = (struct Item *)l->items->data;
 272     if (item->type == ITEM_STROKE && item->path != NULL)
 273       gnome_canvas_points_free(item->path);
 274     // don't need to delete the canvas_item, as it's part of the group destroyed below
 275     g_free(item);
 276     l->items = g_list_delete_link(l->items, l->items);
 277   }
 278   if (l->group!= NULL) gtk_object_destroy(GTK_OBJECT(l->group));
 279   g_free(l);
 280 }
 281
 282 // referenced strings
 283
 284 struct Refstring *new_refstring(const char *s)
 285 {
 286   struct Refstring *rs = g_new(struct Refstring, 1);
 287   rs->nref = 1;
 288   if (s!=NULL) rs->s = g_strdup(s);
 289   else rs->s = NULL;
 290   rs->aux = NULL;
 291   return rs;
 292 }
 293
 294 struct Refstring *refstring_ref(struct Refstring *rs)
 295 {
 296   rs->nref++;
 297   return rs;
 298 }
 299
 300 void refstring_unref(struct Refstring *rs)
 301 {
 302   rs->nref--;
 303   if (rs->nref == 0) {
 304     if (rs->s!=NULL) g_free(rs->s);
 305     if (rs->aux!=NULL) g_free(rs->aux);
 306     g_free(rs);
 307   }
 308 }
 309
 310
 311 // some helper functions
 312
 313 void get_pointer_coords(GdkEvent *event, gdouble *ret)
 314 {
 315   double x, y;
 316   gdk_event_get_coords(event, &x, &y);
 317   gnome_canvas_window_to_world(canvas, x, y, ret, ret+1);
 318   ret[0] -= ui.cur_page->hoffset;
 319   ret[1] -= ui.cur_page->voffset;
 320 }
 321
 322 void fix_xinput_coords(GdkEvent *event)
 323 {
 324   double *axes, *px, *py, axis_width;
 325   GdkDevice *device;
 326   int wx, wy, sx, sy;
 327
 328   if (event->type == GDK_BUTTON_PRESS || event->type == GDK_BUTTON_RELEASE) {
 329     axes = event->button.axes;
 330     px = &(event->button.x);
 331     py = &(event->button.y);
 332     device = event->button.device;
 333   }
 334   else if (event->type == GDK_MOTION_NOTIFY) {
 335     axes = event->motion.axes;
 336     px = &(event->motion.x);
 337     py = &(event->motion.y);
 338     device = event->motion.device;
 339   }
 340   else return; // nothing we know how to do
 341
 342   gdk_window_get_origin(event->any.window, &wx, &wy);
 343   gnome_canvas_get_scroll_offsets(canvas, &sx, &sy);
 344
 345   axis_width = device->axes[0].max - device->axes[0].min;
 346   if (axis_width>EPSILON)
 347     *px = (axes[0]/axis_width)*ui.screen_width + sx - wx;
 348
 349   axis_width = device->axes[1].max - device->axes[1].min;
 350   if (axis_width>EPSILON)
 351     *py = (axes[1]/axis_width)*ui.screen_height + sy - wy;
 352 }
 353
 354 void update_item_bbox(struct Item *item)
 355 {
 356   int i;
 357   double *p;
 358
 359   if (item->type == ITEM_STROKE) {
 360     item->bbox.left = item->bbox.right = item->path->coords[0];
 361     item->bbox.top = item->bbox.bottom = item->path->coords[1];
 362     for (i=1, p=item->path->coords+2; i<item->path->num_points; i++, p+=2)
 363     {
 364       if (p[0] < item->bbox.left) item->bbox.left = p[0];
 365       if (p[0] > item->bbox.right) item->bbox.right = p[0];
 366       if (p[1] < item->bbox.top) item->bbox.top = p[1];
 367       if (p[1] > item->bbox.bottom) item->bbox.bottom = p[1];
 368     }
 369   }
 370 }
 371
 372 void make_page_clipbox(struct Page *pg)
 373 {
 374   GnomeCanvasPathDef *pg_clip;
 375
 376   pg_clip = gnome_canvas_path_def_new_sized(4);
 377   gnome_canvas_path_def_moveto(pg_clip, 0., 0.);
 378   gnome_canvas_path_def_lineto(pg_clip, 0., pg->height);
 379   gnome_canvas_path_def_lineto(pg_clip, pg->width, pg->height);
 380   gnome_canvas_path_def_lineto(pg_clip, pg->width, 0.);
 381   gnome_canvas_path_def_closepath(pg_clip);
 382   gnome_canvas_item_set(GNOME_CANVAS_ITEM(pg->group), "path", pg_clip, NULL);
 383   gnome_canvas_path_def_unref(pg_clip);
 384 }
 385
 386 void make_canvas_items(void)
 387 {
 388   struct Page *pg;
 389   struct Layer *l;
 390   struct Item *item;
 391   GList *pagelist, *layerlist, *itemlist;
 392
 393   for (pagelist = journal.pages; pagelist!=NULL; pagelist = pagelist->next) {
 394     pg = (struct Page *)pagelist->data;
 395     if (pg->group == NULL) {
 396       pg->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
 397          gnome_canvas_root(canvas), gnome_canvas_clipgroup_get_type(), NULL);
 398       make_page_clipbox(pg);
 399     }
 400     if (pg->bg->canvas_item == NULL) update_canvas_bg(pg);
 401     for (layerlist = pg->layers; layerlist!=NULL; layerlist = layerlist->next) {
 402       l = (struct Layer *)layerlist->data;
 403       if (l->group == NULL)
 404         l->group = (GnomeCanvasGroup *) gnome_canvas_item_new(
 405            pg->group, gnome_canvas_group_get_type(), NULL);
 406       for (itemlist = l->items; itemlist!=NULL; itemlist = itemlist->next) {
 407         item = (struct Item *)itemlist->data;
 408         if (item->type == ITEM_STROKE && item->canvas_item == NULL) {
 409           item->canvas_item = gnome_canvas_item_new(l->group,
 410               gnome_canvas_line_get_type(), "points", item->path,
 411               "cap-style", GDK_CAP_ROUND, "join-style", GDK_JOIN_ROUND,
 412               "fill-color-rgba", item->brush.color_rgba,
 413               "width-units", item->brush.thickness, NULL);
 414         }
 415       }
 416     }
 417   }
 418 }
 419
 420 void update_canvas_bg(struct Page *pg)
 421 {
 422   GnomeCanvasGroup *group;
 423   GnomeCanvasPoints *seg;
 424   GdkPixbuf *scaled_pix;
 425   double *pt;
 426   double x, y;
 427   int w, h;
 428
 429   if (pg->bg->canvas_item != NULL)
 430     gtk_object_destroy(GTK_OBJECT(pg->bg->canvas_item));
 431   pg->bg->canvas_item = NULL;
 432
 433   if (pg->bg->type == BG_SOLID)
 434   {
 435     pg->bg->canvas_item = gnome_canvas_item_new(pg->group,
 436                                gnome_canvas_group_get_type(), NULL);
 437     group = GNOME_CANVAS_GROUP(pg->bg->canvas_item);
 438     lower_canvas_item_to(pg->group, pg->bg->canvas_item, NULL);
 439     gnome_canvas_item_new(group, gnome_canvas_rect_get_type(),
 440       "x1", 0., "x2", pg->width, "y1", 0., "y2", pg->height,
 441       "fill-color-rgba", pg->bg->color_rgba, NULL);
 442     if (pg->bg->ruling == RULING_NONE) return;
 443     seg = gnome_canvas_points_new(2);
 444     pt = seg->coords;
 445     if (pg->bg->ruling == RULING_GRAPH) {
 446       pt[1] = 0; pt[3] = pg->height;
 447       for (x=RULING_GRAPHSPACING; x<pg->width-1; x+=RULING_GRAPHSPACING) {
 448         pt[0] = pt[2] = x;
 449         gnome_canvas_item_new(group, gnome_canvas_line_get_type(),
 450            "points", seg, "fill-color-rgba", RULING_COLOR,
 451            "width-units", RULING_THICKNESS, NULL);
 452       }
 453       pt[0] = 0; pt[2] = pg->width;
 454       for (y=RULING_GRAPHSPACING; y<pg->height-1; y+=RULING_GRAPHSPACING) {
 455         pt[1] = pt[3] = y;
 456         gnome_canvas_item_new(group, gnome_canvas_line_get_type(),
 457            "points", seg, "fill-color-rgba", RULING_COLOR,
 458            "width-units", RULING_THICKNESS, NULL);
 459       }
 460       gnome_canvas_points_free(seg);
 461       return;
 462     }
 463     pt[0] = 0; pt[2] = pg->width;
 464     for (y=RULING_TOPMARGIN; y<pg->height-1; y+=RULING_SPACING) {
 465       pt[1] = pt[3] = y;
 466       gnome_canvas_item_new(group, gnome_canvas_line_get_type(),
 467          "points", seg, "fill-color-rgba", RULING_COLOR,
 468          "width-units", RULING_THICKNESS, NULL);
 469     }
 470     if (pg->bg->ruling == RULING_LINED) {
 471       pt[0] = pt[2] = RULING_LEFTMARGIN;
 472       pt[1] = 0; pt[3] = pg->height;
 473       gnome_canvas_item_new(group, gnome_canvas_line_get_type(),
 474          "points", seg, "fill-color-rgba", RULING_MARGIN_COLOR,
 475          "width-units", RULING_THICKNESS, NULL);
 476     }
 477     gnome_canvas_points_free(seg);
 478     return;
 479   }
 480
 481   if (pg->bg->type == BG_PIXMAP)
 482   {
 483     if (ui.antialias_bg) {
 484       set_cursor_busy(TRUE);
 485       w = (int)floor(pg->width*ui.zoom+0.5);
 486       h = (int)floor(pg->height*ui.zoom+0.5);
 487       if (w == gdk_pixbuf_get_width(pg->bg->pixbuf) &&
 488           h == gdk_pixbuf_get_height(pg->bg->pixbuf))
 489         scaled_pix = gdk_pixbuf_ref(pg->bg->pixbuf);
 490       else
 491         scaled_pix = gdk_pixbuf_scale_simple(pg->bg->pixbuf, w, h, GDK_INTERP_BILINEAR);
 492       pg->bg->pixbuf_scale = ui.zoom;
 493       set_cursor_busy(FALSE);
 494     }
 495     else {
 496       scaled_pix = gdk_pixbuf_ref(pg->bg->pixbuf);
 497       pg->bg->pixbuf_scale = 0;
 498     }
 499     pg->bg->canvas_item = gnome_canvas_item_new(pg->group,
 500         gnome_canvas_pixbuf_get_type(),
 501         "pixbuf", scaled_pix,
 502         "width", pg->width, "height", pg->height,
 503         "width-set", TRUE, "height-set", TRUE,
 504         NULL);
 505     gdk_pixbuf_unref(scaled_pix);
 506     lower_canvas_item_to(pg->group, pg->bg->canvas_item, NULL);
 507   }
 508
 509   if (pg->bg->type == BG_PDF)
 510   {
 511     if (pg->bg->pixbuf == NULL) return;
 512     pg->bg->canvas_item = gnome_canvas_item_new(pg->group,
 513         gnome_canvas_pixbuf_get_type(),
 514         "pixbuf", pg->bg->pixbuf,
 515         "width", pg->width, "height", pg->height,
 516         "width-set", TRUE, "height-set", TRUE,
 517         NULL);
 518     lower_canvas_item_to(pg->group, pg->bg->canvas_item, NULL);
 519   }
 520
 521 }
 522
 523 gboolean is_visible(struct Page *pg)
 524 {
 525   GtkAdjustment *v_adj;
 526   double ytop, ybot;
 527
 528   if (!ui.view_continuous) return (pg == ui.cur_page);
 529   v_adj = gtk_layout_get_vadjustment(GTK_LAYOUT(canvas));
 530   ytop = v_adj->value/ui.zoom;
 531   ybot = (v_adj->value + v_adj->page_size) / ui.zoom;
 532   return (MAX(ytop, pg->voffset) < MIN(ybot, pg->voffset+pg->height));
 533 }
 534
 535 void rescale_bg_pixmaps(void)
 536 {
 537   GList *pglist;
 538   struct Page *pg;
 539   GdkPixbuf *pix;
 540
 541   for (pglist = journal.pages; pglist!=NULL; pglist = pglist->next) {
 542     pg = (struct Page *)pglist->data;
 543     // in progressive mode we scale only visible pages
 544     if (ui.progressive_bg && !is_visible(pg)) continue;
 545
 546     if (pg->bg->type == BG_PIXMAP) { // do the rescaling ourselves
 547       if (ui.antialias_bg) {
 548         if (pg->bg->pixbuf_scale == ui.zoom) continue;
 549         set_cursor_busy(TRUE);
 550         pix = gdk_pixbuf_scale_simple(pg->bg->pixbuf,
 551           (int)floor(pg->width*ui.zoom+0.5), (int)floor(pg->height*ui.zoom+0.5),
 552           GDK_INTERP_BILINEAR);
 553         gnome_canvas_item_set(pg->bg->canvas_item, "pixbuf", pix, NULL);
 554         gdk_pixbuf_unref(pix);
 555         pg->bg->pixbuf_scale = ui.zoom;
 556         set_cursor_busy(FALSE);
 557       } else
 558       {
 559         pix = GDK_PIXBUF(g_object_get_data(G_OBJECT(pg->bg->canvas_item), "pixbuf"));
 560         if (pix!=pg->bg->pixbuf)
 561           gnome_canvas_item_set(pg->bg->canvas_item, "pixbuf", pg->bg->pixbuf, NULL);
 562         pg->bg->pixbuf_scale = 0;
 563       }
 564     }
 565     if (pg->bg->type == BG_PDF) { // request an asynchronous update
 566       if (pg->bg->pixbuf_scale == ui.zoom) continue;
 567       add_bgpdf_request(pg->bg->file_page_seq, ui.zoom, FALSE);
 568       pg->bg->pixbuf_scale = ui.zoom;
 569     }
 570   }
 571 }
 572
 573 gboolean have_intersect(struct BBox *a, struct BBox *b)
 574 {
 575   return (MAX(a->top, b->top) <= MIN(a->bottom, b->bottom)) &&
 576          (MAX(a->left, b->left) <= MIN(a->right, b->right));
 577 }
 578
 579 /* In libgnomecanvas 2.10.0, the lower/raise functions fail to update
 580    correctly the end of the group's item list. We try to work around this.
 581    DON'T USE gnome_canvas_item_raise/lower directly !! */
 582
 583 void lower_canvas_item_to(GnomeCanvasGroup *g, GnomeCanvasItem *item, GnomeCanvasItem *after)
 584 {
 585   int i1, i2;
 586
 587   i1 = g_list_index(g->item_list, item);
 588   if (i1 == -1) return;
 589
 590   if (after == NULL) i2 = -1;
 591   else i2 = g_list_index(g->item_list, after);
 592
 593   if (i1 < i2) gnome_canvas_item_raise(item, i2-i1);
 594   if (i1 > i2+1) gnome_canvas_item_lower(item, i1-i2-1);
 595
 596   // BUGFIX for libgnomecanvas
 597   g->item_list_end = g_list_last(g->item_list);
 598 }
 599
 600 // some interface functions
 601
 602 void update_thickness_buttons(void)
 603 {
 604   if (ui.selection!=NULL || ui.toolno[ui.cur_mapping] >= NUM_STROKE_TOOLS) {
 605     gtk_toggle_tool_button_set_active(
 606       GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonThicknessOther")), TRUE);
 607   } else
 608   switch (ui.cur_brush->thickness_no) {
 609     case THICKNESS_FINE:
 610       gtk_toggle_tool_button_set_active(
 611         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonFine")), TRUE);
 612       break;
 613     case THICKNESS_MEDIUM:
 614       gtk_toggle_tool_button_set_active(
 615         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonMedium")), TRUE);
 616       break;
 617     case THICKNESS_THICK:
 618       gtk_toggle_tool_button_set_active(
 619         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonThick")), TRUE);
 620       break;
 621     default:
 622       gtk_toggle_tool_button_set_active(
 623         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonThicknessOther")), TRUE);
 624   }
 625 }
 626
 627 void update_color_buttons(void)
 628 {
 629   if (ui.selection!=NULL || (ui.toolno[ui.cur_mapping] != TOOL_PEN
 630                           && ui.toolno[ui.cur_mapping] != TOOL_HIGHLIGHTER)) {
 631     gtk_toggle_tool_button_set_active(
 632       GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonColorOther")), TRUE);
 633   } else
 634   switch (ui.cur_brush->color_no) {
 635     case COLOR_BLACK:
 636       gtk_toggle_tool_button_set_active(
 637         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonBlack")), TRUE);
 638       break;
 639     case COLOR_BLUE:
 640       gtk_toggle_tool_button_set_active(
 641         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonBlue")), TRUE);
 642       break;
 643     case COLOR_RED:
 644       gtk_toggle_tool_button_set_active(
 645         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonRed")), TRUE);
 646       break;
 647     case COLOR_GREEN:
 648       gtk_toggle_tool_button_set_active(
 649         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonGreen")), TRUE);
 650       break;
 651     case COLOR_GRAY:
 652       gtk_toggle_tool_button_set_active(
 653         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonGray")), TRUE);
 654       break;
 655     case COLOR_LIGHTBLUE:
 656       gtk_toggle_tool_button_set_active(
 657         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonLightBlue")), TRUE);
 658       break;
 659     case COLOR_LIGHTGREEN:
 660       gtk_toggle_tool_button_set_active(
 661         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonLightGreen")), TRUE);
 662       break;
 663     case COLOR_MAGENTA:
 664       gtk_toggle_tool_button_set_active(
 665         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonMagenta")), TRUE);
 666       break;
 667     case COLOR_ORANGE:
 668       gtk_toggle_tool_button_set_active(
 669         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonOrange")), TRUE);
 670       break;
 671     case COLOR_YELLOW:
 672       gtk_toggle_tool_button_set_active(
 673         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonYellow")), TRUE);
 674       break;
 675     case COLOR_WHITE:
 676       gtk_toggle_tool_button_set_active(
 677         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonWhite")), TRUE);
 678       break;
 679     default:
 680       gtk_toggle_tool_button_set_active(
 681         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonColorOther")), TRUE);
 682   }
 683 }
 684
 685 void update_tool_buttons(void)
 686 {
 687   switch(ui.toolno[ui.cur_mapping]) {
 688     case TOOL_PEN:
 689       gtk_toggle_tool_button_set_active(
 690         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonPen")), TRUE);
 691       break;
 692     case TOOL_ERASER:
 693       gtk_toggle_tool_button_set_active(
 694         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonEraser")), TRUE);
 695       break;
 696     case TOOL_HIGHLIGHTER:
 697       gtk_toggle_tool_button_set_active(
 698         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonHighlighter")), TRUE);
 699       break;
 700     case TOOL_TEXT:
 701       gtk_toggle_tool_button_set_active(
 702         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonText")), TRUE);
 703       break;
 704     case TOOL_SELECTREGION:
 705       gtk_toggle_tool_button_set_active(
 706         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonSelectRegion")), TRUE);
 707       break;
 708     case TOOL_SELECTRECT:
 709       gtk_toggle_tool_button_set_active(
 710         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonSelectRectangle")), TRUE);
 711       break;
 712     case TOOL_VERTSPACE:
 713       gtk_toggle_tool_button_set_active(
 714         GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonVerticalSpace")), TRUE);
 715       break;
 716   }
 717
 718   gtk_toggle_tool_button_set_active(
 719     GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonRuler")), ui.ruler[ui.cur_mapping]);
 720   update_thickness_buttons();
 721   update_color_buttons();
 722 }
 723
 724 void update_tool_menu(void)
 725 {
 726   switch(ui.toolno[0]) {
 727     case TOOL_PEN:
 728       gtk_check_menu_item_set_active(
 729         GTK_CHECK_MENU_ITEM(GET_COMPONENT("toolsPen")), TRUE);
 730       break;
 731     case TOOL_ERASER:
 732       gtk_check_menu_item_set_active(
 733         GTK_CHECK_MENU_ITEM(GET_COMPONENT("toolsEraser")), TRUE);
 734       break;
 735     case TOOL_HIGHLIGHTER:
 736       gtk_check_menu_item_set_active(
 737         GTK_CHECK_MENU_ITEM(GET_COMPONENT("toolsHighlighter")), TRUE);
 738       break;
 739     case TOOL_TEXT:
 740       gtk_check_menu_item_set_active(
 741         GTK_CHECK_MENU_ITEM(GET_COMPONENT("toolsText")), TRUE);
 742       break;
 743     case TOOL_SELECTREGION:
 744       gtk_check_menu_item_set_active(
 745         GTK_CHECK_MENU_ITEM(GET_COMPONENT("toolsSelectRegion")), TRUE);
 746       break;
 747     case TOOL_SELECTRECT:
 748       gtk_check_menu_item_set_active(
 749         GTK_CHECK_MENU_ITEM(GET_COMPONENT("toolsSelectRectangle")), TRUE);
 750       break;
 751     case TOOL_VERTSPACE:
 752       gtk_check_menu_item_set_active(
 753         GTK_CHECK_MENU_ITEM(GET_COMPONENT("toolsVerticalSpace")), TRUE);
 754       break;
 755   }
 756
 757   gtk_check_menu_item_set_active(
 758     GTK_CHECK_MENU_ITEM(GET_COMPONENT("toolsRuler")), ui.ruler[0]);
 759 }
 760
 761 void update_ruler_indicator(void)
 762 {
 763   gtk_toggle_tool_button_set_active(
 764     GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonRuler")), ui.ruler[ui.cur_mapping]);
 765   gtk_check_menu_item_set_active(
 766     GTK_CHECK_MENU_ITEM(GET_COMPONENT("toolsRuler")), ui.ruler[0]);
 767 }
 768
 769 void update_color_menu(void)
 770 {
 771   if (ui.selection!=NULL || (ui.toolno[ui.cur_mapping] != TOOL_PEN
 772                           && ui.toolno[ui.cur_mapping] != TOOL_HIGHLIGHTER)) {
 773     gtk_check_menu_item_set_active(
 774       GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorNA")), TRUE);
 775   } else
 776   switch (ui.cur_brush->color_no) {
 777     case COLOR_BLACK:
 778       gtk_check_menu_item_set_active(
 779         GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorBlack")), TRUE);
 780       break;
 781     case COLOR_BLUE:
 782       gtk_check_menu_item_set_active(
 783         GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorBlue")), TRUE);
 784       break;
 785     case COLOR_RED:
 786       gtk_check_menu_item_set_active(
 787         GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorRed")), TRUE);
 788       break;
 789     case COLOR_GREEN:
 790       gtk_check_menu_item_set_active(
 791         GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorGreen")), TRUE);
 792       break;
 793     case COLOR_GRAY:
 794       gtk_check_menu_item_set_active(
 795         GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorGray")), TRUE);
 796       break;
 797     case COLOR_LIGHTBLUE:
 798       gtk_check_menu_item_set_active(
 799         GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorLightBlue")), TRUE);
 800       break;
 801     case COLOR_LIGHTGREEN:
 802       gtk_check_menu_item_set_active(
 803         GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorLightGreen")), TRUE);
 804       break;
 805     case COLOR_MAGENTA:
 806       gtk_check_menu_item_set_active(
 807         GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorMagenta")), TRUE);
 808       break;
 809     case COLOR_ORANGE:
 810       gtk_check_menu_item_set_active(
 811         GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorOrange")), TRUE);
 812       break;
 813     case COLOR_YELLOW:
 814       gtk_check_menu_item_set_active(
 815         GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorYellow")), TRUE);
 816       break;
 817     case COLOR_WHITE:
 818       gtk_check_menu_item_set_active(
 819         GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorWhite")), TRUE);
 820       break;
 821     default:
 822       gtk_check_menu_item_set_active(
 823         GTK_CHECK_MENU_ITEM(GET_COMPONENT("colorOther")), TRUE);
 824   }
 825 }
 826
 827 void update_pen_props_menu(void)
 828 {
 829   switch(ui.brushes[0][TOOL_PEN].thickness_no) {
 830     case THICKNESS_VERYFINE:
 831       gtk_check_menu_item_set_active(
 832         GTK_CHECK_MENU_ITEM(GET_COMPONENT("penthicknessVeryFine")), TRUE);
 833       break;
 834     case THICKNESS_FINE:
 835       gtk_check_menu_item_set_active(
 836         GTK_CHECK_MENU_ITEM(GET_COMPONENT("penthicknessFine")), TRUE);
 837       break;
 838     case THICKNESS_MEDIUM:
 839       gtk_check_menu_item_set_active(
 840         GTK_CHECK_MENU_ITEM(GET_COMPONENT("penthicknessMedium")), TRUE);
 841       break;
 842     case THICKNESS_THICK:
 843       gtk_check_menu_item_set_active(
 844         GTK_CHECK_MENU_ITEM(GET_COMPONENT("penthicknessThick")), TRUE);
 845       break;
 846     case THICKNESS_VERYTHICK:
 847       gtk_check_menu_item_set_active(
 848         GTK_CHECK_MENU_ITEM(GET_COMPONENT("penthicknessVeryThick")), TRUE);
 849       break;
 850   }
 851 }
 852
 853 void update_eraser_props_menu(void)
 854 {
 855   switch (ui.brushes[0][TOOL_ERASER].thickness_no) {
 856     case THICKNESS_FINE:
 857       gtk_check_menu_item_set_active(
 858         GTK_CHECK_MENU_ITEM(GET_COMPONENT("eraserFine")), TRUE);
 859       break;
 860     case THICKNESS_MEDIUM:
 861       gtk_check_menu_item_set_active(
 862         GTK_CHECK_MENU_ITEM(GET_COMPONENT("eraserMedium")), TRUE);
 863       break;
 864     case THICKNESS_THICK:
 865       gtk_check_menu_item_set_active(
 866         GTK_CHECK_MENU_ITEM(GET_COMPONENT("eraserThick")), TRUE);
 867       break;
 868   }
 869
 870   gtk_check_menu_item_set_active(
 871     GTK_CHECK_MENU_ITEM(GET_COMPONENT("eraserStandard")),
 872     ui.brushes[0][TOOL_ERASER].tool_options == TOOLOPT_ERASER_STANDARD);
 873   gtk_check_menu_item_set_active(
 874     GTK_CHECK_MENU_ITEM(GET_COMPONENT("eraserWhiteout")),
 875     ui.brushes[0][TOOL_ERASER].tool_options == TOOLOPT_ERASER_WHITEOUT);
 876   gtk_check_menu_item_set_active(
 877     GTK_CHECK_MENU_ITEM(GET_COMPONENT("eraserDeleteStrokes")),
 878     ui.brushes[0][TOOL_ERASER].tool_options == TOOLOPT_ERASER_STROKES);
 879 }
 880
 881 void update_highlighter_props_menu(void)
 882 {
 883   switch (ui.brushes[0][TOOL_HIGHLIGHTER].thickness_no) {
 884     case THICKNESS_FINE:
 885       gtk_check_menu_item_set_active(
 886         GTK_CHECK_MENU_ITEM(GET_COMPONENT("highlighterFine")), TRUE);
 887       break;
 888     case THICKNESS_MEDIUM:
 889       gtk_check_menu_item_set_active(
 890         GTK_CHECK_MENU_ITEM(GET_COMPONENT("highlighterMedium")), TRUE);
 891       break;
 892     case THICKNESS_THICK:
 893       gtk_check_menu_item_set_active(
 894         GTK_CHECK_MENU_ITEM(GET_COMPONENT("highlighterThick")), TRUE);
 895       break;
 896   }
 897 }
 898
 899 void update_mappings_menu_linkings(void)
 900 {
 901   switch (ui.linked_brush[1]) {
 902     case BRUSH_LINKED:
 903       gtk_check_menu_item_set_active(
 904         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button2LinkBrush")), TRUE);
 905       break;
 906     case BRUSH_COPIED:
 907       gtk_check_menu_item_set_active(
 908         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button2CopyBrush")), TRUE);
 909       break;
 910     case BRUSH_STATIC:
 911       gtk_check_menu_item_set_active(
 912         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button2NABrush")), TRUE);
 913       break;
 914   }
 915   switch (ui.linked_brush[2]) {
 916     case BRUSH_LINKED:
 917       gtk_check_menu_item_set_active(
 918         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button3LinkBrush")), TRUE);
 919       break;
 920     case BRUSH_COPIED:
 921       gtk_check_menu_item_set_active(
 922         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button3CopyBrush")), TRUE);
 923       break;
 924     case BRUSH_STATIC:
 925       gtk_check_menu_item_set_active(
 926         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button3NABrush")), TRUE);
 927       break;
 928   }
 929 }
 930
 931 void update_mappings_menu(void)
 932 {
 933   gtk_check_menu_item_set_active(
 934     GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsButtonMappings")), ui.use_erasertip);
 935
 936   switch(ui.toolno[1]) {
 937     case TOOL_PEN:
 938       gtk_check_menu_item_set_active(
 939         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button2Pen")), TRUE);
 940       break;
 941     case TOOL_ERASER:
 942       gtk_check_menu_item_set_active(
 943         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button2Eraser")), TRUE);
 944       break;
 945     case TOOL_HIGHLIGHTER:
 946       gtk_check_menu_item_set_active(
 947         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button2Highlighter")), TRUE);
 948       break;
 949     case TOOL_TEXT:
 950       gtk_check_menu_item_set_active(
 951         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button2Text")), TRUE);
 952       break;
 953     case TOOL_SELECTREGION:
 954       gtk_check_menu_item_set_active(
 955         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button2SelectRegion")), TRUE);
 956       break;
 957     case TOOL_SELECTRECT:
 958       gtk_check_menu_item_set_active(
 959         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button2SelectRectangle")), TRUE);
 960       break;
 961     case TOOL_VERTSPACE:
 962       gtk_check_menu_item_set_active(
 963         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button2VerticalSpace")), TRUE);
 964       break;
 965   }
 966   switch(ui.toolno[2]) {
 967     case TOOL_PEN:
 968       gtk_check_menu_item_set_active(
 969         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button3Pen")), TRUE);
 970       break;
 971     case TOOL_ERASER:
 972       gtk_check_menu_item_set_active(
 973         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button3Eraser")), TRUE);
 974       break;
 975     case TOOL_HIGHLIGHTER:
 976       gtk_check_menu_item_set_active(
 977         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button3Highlighter")), TRUE);
 978       break;
 979     case TOOL_TEXT:
 980       gtk_check_menu_item_set_active(
 981         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button3Text")), TRUE);
 982       break;
 983     case TOOL_SELECTREGION:
 984       gtk_check_menu_item_set_active(
 985         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button3SelectRegion")), TRUE);
 986       break;
 987     case TOOL_SELECTRECT:
 988       gtk_check_menu_item_set_active(
 989         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button3SelectRectangle")), TRUE);
 990       break;
 991     case TOOL_VERTSPACE:
 992       gtk_check_menu_item_set_active(
 993         GTK_CHECK_MENU_ITEM(GET_COMPONENT("button3VerticalSpace")), TRUE);
 994       break;
 995   }
 996   update_mappings_menu_linkings();
 997 }
 998
 999 void do_switch_page(int pg, gboolean rescroll, gboolean refresh_all)
1000 {
1001   int i;
1002   struct Layer *layer;
1003   GList *list;
1004
1005   ui.pageno = pg;
1006
1007   /* re-show all the layers of the old page */
1008   if (ui.cur_page != NULL)
1009     for (i=0, list = ui.cur_page->layers; list!=NULL; i++, list = list->next) {
1010       layer = (struct Layer *)list->data;
1011       if (layer->group!=NULL)
1012         gnome_canvas_item_show(GNOME_CANVAS_ITEM(layer->group));
1013     }
1014
1015   ui.cur_page = g_list_nth_data(journal.pages, ui.pageno);
1016   ui.layerno = ui.cur_page->nlayers-1;
1017   ui.cur_layer = (struct Layer *)(g_list_last(ui.cur_page->layers)->data);
1018   update_page_stuff();
1019   if (ui.progressive_bg) rescale_bg_pixmaps();
1020
1021   if (rescroll) { // scroll and force a refresh
1022     gtk_adjustment_set_value(gtk_layout_get_vadjustment(GTK_LAYOUT(canvas)),
1023       ui.cur_page->voffset*ui.zoom);
1024     if (refresh_all)
1025       gnome_canvas_set_pixels_per_unit(canvas, ui.zoom);
1026     else if (!ui.view_continuous)
1027       gnome_canvas_item_move(GNOME_CANVAS_ITEM(ui.cur_page->group), 0., 0.);
1028   }
1029 }
1030
1031 void update_page_stuff(void)
1032 {
1033   gchar tmp[10];
1034   GtkComboBox *layerbox;
1035   int i;
1036   GList *pglist;
1037   GtkSpinButton *spin;
1038   struct Page *pg;
1039   double vertpos, maxwidth;
1040   struct Layer *layer;
1041   int relscroll;
1042
1043   // move the page groups to their rightful locations or hide them
1044   if (ui.view_continuous) {
1045     vertpos = 0.;
1046     maxwidth = 0.;
1047     for (i=0, pglist = journal.pages; pglist!=NULL; i++, pglist = pglist->next) {
1048       pg = (struct Page *)pglist->data;
1049       if (pg->group!=NULL) {
1050         pg->hoffset = 0.; pg->voffset = vertpos;
1051         gnome_canvas_item_set(GNOME_CANVAS_ITEM(pg->group),
1052             "x", pg->hoffset, "y", pg->voffset, NULL);
1053         gnome_canvas_item_show(GNOME_CANVAS_ITEM(pg->group));
1054       }
1055       vertpos += pg->height + VIEW_CONTINUOUS_SKIP;
1056       if (pg->width > maxwidth) maxwidth = pg->width;
1057     }
1058     vertpos -= VIEW_CONTINUOUS_SKIP;
1059     gnome_canvas_set_scroll_region(canvas, 0, 0, maxwidth, vertpos);
1060   } else {
1061     for (pglist = journal.pages; pglist!=NULL; pglist = pglist->next) {
1062       pg = (struct Page *)pglist->data;
1063       if (pg == ui.cur_page && pg->group!=NULL) {
1064         pg->hoffset = 0.; pg->voffset = 0.;
1065         gnome_canvas_item_set(GNOME_CANVAS_ITEM(pg->group),
1066             "x", pg->hoffset, "y", pg->voffset, NULL);
1067         gnome_canvas_item_show(GNOME_CANVAS_ITEM(pg->group));
1068       } else {
1069         if (pg->group!=NULL) gnome_canvas_item_hide(GNOME_CANVAS_ITEM(pg->group));
1070       }
1071     }
1072     gnome_canvas_set_scroll_region(canvas, 0, 0, ui.cur_page->width, ui.cur_page->height);
1073   }
1074
1075   // update the page / layer info at bottom of screen
1076
1077   spin = GTK_SPIN_BUTTON(GET_COMPONENT("spinPageNo"));
1078   ui.in_update_page_stuff = TRUE; // avoid a bad retroaction
1079   gtk_spin_button_set_range(spin, 1, journal.npages+1);
1080     /* npages+1 will be used to create a new page at end */
1081   gtk_spin_button_set_value(spin, ui.pageno+1);
1082   g_snprintf(tmp, 10, " of %d", journal.npages);
1083   gtk_label_set_text(GTK_LABEL(GET_COMPONENT("labelNumpages")), tmp);
1084
1085   layerbox = GTK_COMBO_BOX(GET_COMPONENT("comboLayer"));
1086   if (ui.layerbox_length == 0) {
1087     gtk_combo_box_prepend_text(layerbox, "Background");
1088     ui.layerbox_length++;
1089   }
1090   while (ui.layerbox_length > ui.cur_page->nlayers+1) {
1091     gtk_combo_box_remove_text(layerbox, 0);
1092     ui.layerbox_length--;
1093   }
1094   while (ui.layerbox_length < ui.cur_page->nlayers+1) {
1095     g_snprintf(tmp, 10, "Layer %d", ui.layerbox_length++);
1096     gtk_combo_box_prepend_text(layerbox, tmp);
1097   }
1098   gtk_combo_box_set_active(layerbox, ui.cur_page->nlayers-1-ui.layerno);
1099   ui.in_update_page_stuff = FALSE;
1100
1101   // update the paper-style menu radio buttons
1102
1103   if (ui.view_continuous)
1104     gtk_check_menu_item_set_active(
1105        GTK_CHECK_MENU_ITEM(GET_COMPONENT("viewContinuous")), TRUE);
1106   else
1107     gtk_check_menu_item_set_active(
1108        GTK_CHECK_MENU_ITEM(GET_COMPONENT("viewOnePage")), TRUE);
1109
1110   if (ui.cur_page->bg->type == BG_SOLID && !ui.bg_apply_all_pages) {
1111     switch (ui.cur_page->bg->color_no) {
1112       case COLOR_WHITE:
1113         gtk_check_menu_item_set_active(
1114           GTK_CHECK_MENU_ITEM(GET_COMPONENT("papercolorWhite")), TRUE);
1115         break;
1116       case COLOR_YELLOW:
1117         gtk_check_menu_item_set_active(
1118           GTK_CHECK_MENU_ITEM(GET_COMPONENT("papercolorYellow")), TRUE);
1119         break;
1120       case COLOR_RED:
1121         gtk_check_menu_item_set_active(
1122           GTK_CHECK_MENU_ITEM(GET_COMPONENT("papercolorPink")), TRUE);
1123         break;
1124       case COLOR_ORANGE:
1125         gtk_check_menu_item_set_active(
1126           GTK_CHECK_MENU_ITEM(GET_COMPONENT("papercolorOrange")), TRUE);
1127         break;
1128       case COLOR_BLUE:
1129         gtk_check_menu_item_set_active(
1130           GTK_CHECK_MENU_ITEM(GET_COMPONENT("papercolorBlue")), TRUE);
1131         break;
1132       case COLOR_GREEN:
1133         gtk_check_menu_item_set_active(
1134           GTK_CHECK_MENU_ITEM(GET_COMPONENT("papercolorGreen")), TRUE);
1135         break;
1136       default:
1137         gtk_check_menu_item_set_active(
1138           GTK_CHECK_MENU_ITEM(GET_COMPONENT("papercolorOther")), TRUE);
1139         break;
1140     }
1141     switch (ui.cur_page->bg->ruling) {
1142       case RULING_NONE:
1143         gtk_check_menu_item_set_active(
1144           GTK_CHECK_MENU_ITEM(GET_COMPONENT("paperstylePlain")), TRUE);
1145         break;
1146       case RULING_LINED:
1147         gtk_check_menu_item_set_active(
1148           GTK_CHECK_MENU_ITEM(GET_COMPONENT("paperstyleLined")), TRUE);
1149         break;
1150       case RULING_RULED:
1151         gtk_check_menu_item_set_active(
1152           GTK_CHECK_MENU_ITEM(GET_COMPONENT("paperstyleRuled")), TRUE);
1153         break;
1154       case RULING_GRAPH:
1155         gtk_check_menu_item_set_active(
1156           GTK_CHECK_MENU_ITEM(GET_COMPONENT("paperstyleGraph")), TRUE);
1157         break;
1158     }
1159   } else {
1160     gtk_check_menu_item_set_active(
1161       GTK_CHECK_MENU_ITEM(GET_COMPONENT("papercolorNA")), TRUE);
1162     gtk_check_menu_item_set_active(
1163       GTK_CHECK_MENU_ITEM(GET_COMPONENT("paperstyleNA")), TRUE);
1164   }
1165
1166   // enable/disable the page/layer menu items and toolbar buttons
1167
1168   gtk_widget_set_sensitive(GET_COMPONENT("journalPaperColor"),
1169      ui.cur_page->bg->type == BG_SOLID || ui.bg_apply_all_pages);
1170   gtk_widget_set_sensitive(GET_COMPONENT("journalSetAsDefault"),
1171      ui.cur_page->bg->type == BG_SOLID);
1172
1173   gtk_widget_set_sensitive(GET_COMPONENT("viewFirstPage"), ui.pageno!=0);
1174   gtk_widget_set_sensitive(GET_COMPONENT("viewPreviousPage"), ui.pageno!=0);
1175   gtk_widget_set_sensitive(GET_COMPONENT("viewNextPage"), TRUE);
1176   gtk_widget_set_sensitive(GET_COMPONENT("viewLastPage"), ui.pageno!=journal.npages-1);
1177   gtk_widget_set_sensitive(GET_COMPONENT("buttonFirstPage"), ui.pageno!=0);
1178   gtk_widget_set_sensitive(GET_COMPONENT("buttonPreviousPage"), ui.pageno!=0);
1179   gtk_widget_set_sensitive(GET_COMPONENT("buttonNextPage"), TRUE);
1180   gtk_widget_set_sensitive(GET_COMPONENT("buttonLastPage"), ui.pageno!=journal.npages-1);
1181
1182   gtk_widget_set_sensitive(GET_COMPONENT("viewShowLayer"), ui.layerno!=ui.cur_page->nlayers-1);
1183   gtk_widget_set_sensitive(GET_COMPONENT("viewHideLayer"), ui.layerno>=0);
1184
1185   gtk_widget_set_sensitive(GET_COMPONENT("editPaste"), ui.cur_layer!=NULL);
1186   gtk_widget_set_sensitive(GET_COMPONENT("buttonPaste"), ui.cur_layer!=NULL);
1187 }
1188
1189 void update_toolbar_and_menu(void)
1190 {
1191   update_tool_buttons(); // takes care of other toolbar buttons as well
1192   update_tool_menu();
1193   update_color_menu();
1194   update_pen_props_menu();
1195   update_eraser_props_menu();
1196   update_highlighter_props_menu();
1197   update_mappings_menu();
1198
1199   gtk_toggle_tool_button_set_active(
1200     GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonFullscreen")), ui.fullscreen);
1201   gtk_check_menu_item_set_active(
1202     GTK_CHECK_MENU_ITEM(GET_COMPONENT("viewFullscreen")), ui.fullscreen);
1203 }
1204
1205 void update_file_name(char *filename)
1206 {
1207   gchar tmp[100], *p;
1208   if (ui.filename != NULL) g_free(ui.filename);
1209   ui.filename = filename;
1210   if (filename == NULL) {
1211     gtk_window_set_title(GTK_WINDOW (winMain), "Xournal");
1212     return;
1213   }
1214   p = g_utf8_strrchr(filename, -1, '/');
1215   if (p == NULL) p = filename;
1216   else p = g_utf8_next_char(p);
1217   g_snprintf(tmp, 100, "Xournal - %s", p);
1218   gtk_window_set_title(GTK_WINDOW (winMain), tmp);
1219   new_mru_entry(filename);
1220 }
1221
1222 void update_undo_redo_enabled(void)
1223 {
1224   gtk_widget_set_sensitive(GET_COMPONENT("editUndo"), undo!=NULL);
1225   gtk_widget_set_sensitive(GET_COMPONENT("editRedo"), redo!=NULL);
1226   gtk_widget_set_sensitive(GET_COMPONENT("buttonUndo"), undo!=NULL);
1227   gtk_widget_set_sensitive(GET_COMPONENT("buttonRedo"), redo!=NULL);
1228 }
1229
1230 void update_copy_paste_enabled(void)
1231 {
1232   gtk_widget_set_sensitive(GET_COMPONENT("editCut"), ui.selection!=NULL);
1233   gtk_widget_set_sensitive(GET_COMPONENT("editCopy"), ui.selection!=NULL);
1234   gtk_widget_set_sensitive(GET_COMPONENT("editDelete"), ui.selection!=NULL);
1235   gtk_widget_set_sensitive(GET_COMPONENT("buttonCut"), ui.selection!=NULL);
1236   gtk_widget_set_sensitive(GET_COMPONENT("buttonCopy"), ui.selection!=NULL);
1237 }
1238
1239 void update_mapping_linkings(int toolno)
1240 {
1241   int i;
1242
1243   for (i = 1; i<=NUM_BUTTONS; i++) {
1244     if (ui.linked_brush[i] == BRUSH_LINKED) {
1245       if (toolno >= 0 && toolno < NUM_STROKE_TOOLS)
1246         g_memmove(&(ui.brushes[i][toolno]), &(ui.brushes[0][toolno]), sizeof(struct Brush));
1247       ui.ruler[i] = ui.ruler[0];
1248       if (ui.toolno[i]!=TOOL_PEN && ui.toolno[i]!=TOOL_HIGHLIGHTER)
1249         ui.ruler[i] = FALSE;
1250     }
1251     if (ui.linked_brush[i] == BRUSH_COPIED && toolno == ui.toolno[i]) {
1252       ui.linked_brush[i] = BRUSH_STATIC;
1253       if (i==1 || i==2) update_mappings_menu_linkings();
1254     }
1255   }
1256 }
1257
1258 void set_cur_color(int color)
1259 {
1260   ui.cur_brush->color_no = color;
1261   if (ui.toolno[0] == TOOL_HIGHLIGHTER)
1262     ui.cur_brush->color_rgba = predef_colors_rgba[color] & HILITER_ALPHA_MASK;
1263   else
1264     ui.cur_brush->color_rgba = predef_colors_rgba[color];
1265   update_mapping_linkings(ui.toolno[0]);
1266 }
1267
1268 void process_color_activate(GtkMenuItem *menuitem, int color)
1269 {
1270   if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1271     if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1272       return;
1273   } else {
1274     if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1275       return;
1276   }
1277
1278   if (ui.cur_mapping != 0) return; // not user-generated
1279
1280   if (ui.selection != NULL) {
1281     recolor_selection(color);
1282     update_color_buttons();
1283     update_color_menu();
1284   }
1285
1286   if (ui.toolno[0] != TOOL_PEN && ui.toolno[0] != TOOL_HIGHLIGHTER) {
1287     if (ui.selection != NULL) return;
1288     ui.toolno[0] = TOOL_PEN;
1289     ui.cur_brush = &(ui.brushes[0][TOOL_PEN]);
1290     update_tool_buttons();
1291     update_tool_menu();
1292   }
1293
1294   set_cur_color(color);
1295   update_color_buttons();
1296   update_color_menu();
1297   update_cursor();
1298 }
1299
1300 void process_thickness_activate(GtkMenuItem *menuitem, int tool, int val)
1301 {
1302   if (GTK_OBJECT_TYPE(menuitem) == GTK_TYPE_RADIO_MENU_ITEM) {
1303     if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1304       return;
1305   } else {
1306     if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON (menuitem)))
1307       return;
1308   }
1309
1310   if (ui.cur_mapping != 0) return; // not user-generated
1311
1312   if (ui.selection != NULL && GTK_OBJECT_TYPE(menuitem) != GTK_TYPE_RADIO_MENU_ITEM) {
1313     rethicken_selection(val);
1314     update_thickness_buttons();
1315   }
1316
1317   if (tool >= NUM_STROKE_TOOLS) {
1318     update_thickness_buttons(); // undo illegal button selection
1319     return;
1320   }
1321
1322   ui.brushes[0][tool].thickness_no = val;
1323   ui.brushes[0][tool].thickness = predef_thickness[tool][val];
1324   update_mapping_linkings(tool);
1325
1326   update_thickness_buttons();
1327   if (tool == TOOL_PEN) update_pen_props_menu();
1328   if (tool == TOOL_ERASER) update_eraser_props_menu();
1329   if (tool == TOOL_HIGHLIGHTER) update_highlighter_props_menu();
1330   update_cursor();
1331 }
1332
1333 void process_papercolor_activate(GtkMenuItem *menuitem, int color)
1334 {
1335   struct Page *pg;
1336   GList *pglist;
1337   gboolean hasdone;
1338
1339   if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1340     return;
1341
1342   if ((ui.cur_page->bg->type != BG_SOLID) || ui.bg_apply_all_pages)
1343     gtk_check_menu_item_set_active(
1344       GTK_CHECK_MENU_ITEM(GET_COMPONENT("papercolorNA")), TRUE);
1345
1346   pg = ui.cur_page;
1347   hasdone = FALSE;
1348   for (pglist = journal.pages; pglist!=NULL; pglist = pglist->next) {
1349     if (ui.bg_apply_all_pages) pg = (struct Page *)pglist->data;
1350     if (pg->bg->type == BG_SOLID && pg->bg->color_no != color) {
1351       prepare_new_undo();
1352       if (hasdone) undo->multiop |= MULTIOP_CONT_UNDO;
1353       undo->multiop |= MULTIOP_CONT_REDO;
1354       hasdone = TRUE;
1355       undo->type = ITEM_NEW_BG_ONE;
1356       undo->page = pg;
1357       undo->bg = (struct Background *)g_memdup(pg->bg, sizeof(struct Background));
1358       undo->bg->canvas_item = NULL;
1359
1360       pg->bg->color_no = color;
1361       pg->bg->color_rgba = predef_bgcolors_rgba[color];
1362       update_canvas_bg(pg);
1363     }
1364     if (!ui.bg_apply_all_pages) break;
1365   }
1366   if (hasdone) undo->multiop -= MULTIOP_CONT_REDO;
1367 }
1368
1369 void process_paperstyle_activate(GtkMenuItem *menuitem, int style)
1370 {
1371   struct Page *pg;
1372   GList *pglist;
1373   gboolean hasdone, must_upd;
1374
1375   if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (menuitem)))
1376     return;
1377
1378   if (ui.bg_apply_all_pages)
1379     gtk_check_menu_item_set_active(
1380       GTK_CHECK_MENU_ITEM(GET_COMPONENT("paperstyleNA")), TRUE);
1381
1382   pg = ui.cur_page;
1383   hasdone = FALSE;
1384   must_upd = FALSE;
1385   for (pglist = journal.pages; pglist!=NULL; pglist = pglist->next) {
1386     if (ui.bg_apply_all_pages) pg = (struct Page *)pglist->data;
1387     if (pg->bg->type != BG_SOLID || pg->bg->ruling != style) {
1388       prepare_new_undo();
1389       undo->type = ITEM_NEW_BG_ONE;
1390       if (hasdone) undo->multiop |= MULTIOP_CONT_UNDO;
1391       undo->multiop |= MULTIOP_CONT_REDO;
1392       hasdone = TRUE;
1393       undo->page = pg;
1394       undo->bg = (struct Background *)g_memdup(pg->bg, sizeof(struct Background));
1395       undo->bg->canvas_item = NULL;
1396
1397       if (pg->bg->type != BG_SOLID) {
1398         pg->bg->type = BG_SOLID;
1399         pg->bg->color_no = COLOR_WHITE;
1400         pg->bg->color_rgba = predef_bgcolors_rgba[COLOR_WHITE];
1401         pg->bg->filename = NULL;
1402         pg->bg->pixbuf = NULL;
1403         must_upd = TRUE;
1404       }
1405       pg->bg->ruling = style;
1406       update_canvas_bg(pg);
1407     }
1408     if (!ui.bg_apply_all_pages) break;
1409   }
1410   if (hasdone) undo->multiop -= MULTIOP_CONT_REDO;
1411   if (must_upd) update_page_stuff();
1412 }
1413
1414 gboolean ok_to_close(void)
1415 {
1416   GtkWidget *dialog;
1417   GtkResponseType response;
1418   GList *pagelist;
1419
1420   if (ui.saved) return TRUE;
1421   dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT,
1422     GTK_MESSAGE_WARNING, GTK_BUTTONS_YES_NO, "Save changes to '%s'?",
1423     (ui.filename!=NULL) ? ui.filename:"Untitled");
1424   gtk_dialog_add_button(GTK_DIALOG (dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
1425   response = gtk_dialog_run(GTK_DIALOG (dialog));
1426   gtk_widget_destroy(dialog);
1427   if (response == GTK_RESPONSE_CANCEL || response == GTK_RESPONSE_DELETE_EVENT)
1428     return FALSE; // aborted
1429   if (response == GTK_RESPONSE_YES) {
1430     on_fileSave_activate(NULL, NULL);
1431     if (!ui.saved) return FALSE; // if save failed, then we abort
1432   }
1433   return TRUE;
1434 }
1435
1436 // test if we're still busy loading a PDF background file
1437 gboolean page_ops_forbidden(void)
1438 {
1439   return (bgpdf.status != STATUS_NOT_INIT && bgpdf.create_pages);
1440 }
1441
1442 // selection / clipboard stuff
1443
1444 void reset_selection(void)
1445 {
1446   if (ui.selection == NULL) return;
1447   if (ui.selection->canvas_item != NULL)
1448     gtk_object_destroy(GTK_OBJECT(ui.selection->canvas_item));
1449   g_list_free(ui.selection->items);
1450   g_free(ui.selection);
1451   ui.selection = NULL;
1452   update_copy_paste_enabled();
1453   update_color_menu();
1454   update_thickness_buttons();
1455   update_color_buttons();
1456 }
1457
1458 void move_journal_items_by(GList *itemlist, double dx, double dy,
1459                               struct Layer *l1, struct Layer *l2, GList *depths)
1460 {
1461   struct Item *item;
1462   GnomeCanvasItem *refitem;
1463   GList *link;
1464   int i;
1465   double *pt;
1466
1467   while (itemlist!=NULL) {
1468     item = (struct Item *)itemlist->data;
1469     if (item->type == ITEM_STROKE) {
1470       for (pt=item->path->coords, i=0; i<item->path->num_points; i++, pt+=2)
1471         { pt[0] += dx; pt[1] += dy; }
1472       item->bbox.left += dx;
1473       item->bbox.right += dx;
1474       item->bbox.top += dy;
1475       item->bbox.bottom += dy;
1476     }
1477     if (l1 != l2) {
1478       // find out where to insert
1479       if (depths != NULL) {
1480         if (depths->data == NULL) link = l2->items;
1481         else {
1482           link = g_list_find(l2->items, depths->data);
1483           if (link != NULL) link = link->next;
1484         }
1485       } else link = NULL;
1486       l2->items = g_list_insert_before(l2->items, link, item);
1487       l2->nitems++;
1488       l1->items = g_list_remove(l1->items, item);
1489       l1->nitems--;
1490     }
1491     if (depths != NULL) { // also raise/lower the canvas items
1492       if (item->canvas_item!=NULL) {
1493         if (depths->data == NULL) link = NULL;
1494         else link = g_list_find(l2->items, depths->data);
1495         if (link != NULL) refitem = ((struct Item *)(link->data))->canvas_item;
1496         else refitem = NULL;
1497         lower_canvas_item_to(l2->group, item->canvas_item, refitem);
1498       }
1499       depths = depths->next;
1500     }
1501     itemlist = itemlist->next;
1502   }
1503 }
1504
1505 // Switch between button mappings
1506
1507 /* NOTE ABOUT BUTTON MAPPINGS: ui.cur_mapping is 0 except while a canvas
1508    click event is being processed ... */
1509
1510 void switch_mapping(int m)
1511 {
1512   if (ui.cur_mapping == m) return;
1513
1514   ui.cur_mapping = m;
1515   if (ui.toolno[m] < NUM_STROKE_TOOLS)
1516     ui.cur_brush = &(ui.brushes[m][ui.toolno[m]]);
1517   update_tool_buttons();
1518   update_color_menu();
1519   update_cursor();
1520 }
1521
1522 void process_mapping_activate(GtkMenuItem *menuitem, int m, int tool)
1523 {
1524   if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem))) return;
1525   if (ui.cur_mapping!=0) return;
1526   if (ui.toolno[m] == tool) return;
1527   ui.toolno[m] = tool;
1528   ui.ruler[m] = FALSE;
1529   if (ui.linked_brush[m] == BRUSH_LINKED
1530        && (tool==TOOL_PEN || tool==TOOL_HIGHLIGHTER))
1531     ui.ruler[m] = ui.ruler[0];
1532   if (ui.linked_brush[m] == BRUSH_COPIED) {
1533     ui.linked_brush[m] = BRUSH_STATIC;
1534     update_mappings_menu_linkings();
1535   }
1536 }