src/widgets/ruler.cpp

   1 #define __SP_RULER_C__
   2
   3 /*
   4  * Customized ruler class for inkscape
   5  *
   6  * Authors:
   7  *   Lauris Kaplinski <lauris@kaplinski.com>
   8  *   Frank Felfe <innerspace@iname.com>
   9  *   bulia byak <buliabyak@users.sf.net>
  10  *
  11  * Copyright (C) 1999-2005 authors
  12  *
  13  * Released under GNU GPL, read the file 'COPYING' for more information
  14  */
  15
  16 #include <cmath>
  17 #include <string.h>
  18 #include "widget-sizes.h"
  19 #include "ruler.h"
  20 #include "unit-constants.h"
  21
  22 #define MINIMUM_INCR          5
  23 #define MAXIMUM_SUBDIVIDE     5
  24 #define MAXIMUM_SCALES        10
  25
  26 #define ROUND(x) int (std::floor ((x) + 0.5000000001))
  27
  28
  29 static void sp_hruler_class_init    (SPHRulerClass *klass);
  30 static void sp_hruler_init          (SPHRuler      *hruler);
  31 static gint sp_hruler_motion_notify (GtkWidget      *widget,
  32                                       GdkEventMotion *event);
  33 static void sp_hruler_draw_ticks    (GtkRuler       *ruler);
  34 static void sp_hruler_draw_pos      (GtkRuler       *ruler);
  35
  36
  37 GtkType
  38 sp_hruler_get_type (void)
  39 {
  40   static GtkType hruler_type = 0;
  41
  42   if (!hruler_type)
  43     {
  44       static const GtkTypeInfo hruler_info =
  45       {
  46         "SPHRuler",
  47         sizeof (SPHRuler),
  48         sizeof (SPHRulerClass),
  49         (GtkClassInitFunc) sp_hruler_class_init,
  50         (GtkObjectInitFunc) sp_hruler_init,
  51         /* reserved_1 */ NULL,
  52         /* reserved_2 */ NULL,
  53         (GtkClassInitFunc) NULL,
  54       };
  55
  56       hruler_type = gtk_type_unique (gtk_ruler_get_type (), &hruler_info);
  57     }
  58
  59   return hruler_type;
  60 }
  61
  62 static void
  63 sp_hruler_class_init (SPHRulerClass *klass)
  64 {
  65   GtkWidgetClass *widget_class;
  66   GtkRulerClass *ruler_class;
  67
  68   widget_class = (GtkWidgetClass*) klass;
  69   ruler_class = (GtkRulerClass*) klass;
  70
  71   widget_class->motion_notify_event = sp_hruler_motion_notify;
  72
  73   ruler_class->draw_ticks = sp_hruler_draw_ticks;
  74   ruler_class->draw_pos = sp_hruler_draw_pos;
  75 }
  76
  77 static void
  78 sp_hruler_init (SPHRuler *hruler)
  79 {
  80   GtkWidget *widget;
  81
  82   widget = GTK_WIDGET (hruler);
  83   widget->requisition.width = widget->style->xthickness * 2 + 1;
  84   widget->requisition.height = widget->style->ythickness * 2 + RULER_HEIGHT;
  85 }
  86
  87
  88 GtkWidget*
  89 sp_hruler_new (void)
  90 {
  91   return GTK_WIDGET (gtk_type_new (sp_hruler_get_type ()));
  92 }
  93
  94 static gint
  95 sp_hruler_motion_notify (GtkWidget      *widget,
  96                           GdkEventMotion *event)
  97 {
  98   GtkRuler *ruler;
  99   gint x;
 100
 101   g_return_val_if_fail (widget != NULL, FALSE);
 102   g_return_val_if_fail (SP_IS_HRULER (widget), FALSE);
 103   g_return_val_if_fail (event != NULL, FALSE);
 104
 105   ruler = GTK_RULER (widget);
 106
 107   if (event->is_hint)
 108     gdk_window_get_pointer (widget->window, &x, NULL, NULL);
 109   else
 110     x = (int)event->x;
 111
 112   ruler->position = ruler->lower + ((ruler->upper - ruler->lower) * x) / widget->allocation.width;
 113
 114   /*  Make sure the ruler has been allocated already  */
 115   if (ruler->backing_store != NULL)
 116     gtk_ruler_draw_pos (ruler);
 117
 118   return FALSE;
 119 }
 120
 121 static void
 122 sp_hruler_draw_ticks (GtkRuler *ruler)
 123 {
 124   GtkWidget *widget;
 125   GdkGC *gc, *bg_gc;
 126   PangoFontDescription *pango_desc;
 127   PangoContext *pango_context;
 128   PangoLayout *pango_layout;
 129   gint i, tick_index;
 130   gint width, height;
 131   gint xthickness;
 132   gint ythickness;
 133   gint length, ideal_length;
 134   double lower, upper;          /* Upper and lower limits, in ruler units */
 135   double increment;             /* Number of pixels per unit */
 136   gint scale;                   /* Number of units per major unit */
 137   double subd_incr;
 138   double start, end, cur;
 139   gchar unit_str[32];
 140   gint digit_height;
 141   gint text_width;
 142   gint pos;
 143
 144   g_return_if_fail (ruler != NULL);
 145   g_return_if_fail (SP_IS_HRULER (ruler));
 146
 147   if (!GTK_WIDGET_DRAWABLE (ruler))
 148     return;
 149
 150   widget = GTK_WIDGET (ruler);
 151
 152   gc = widget->style->fg_gc[GTK_STATE_NORMAL];
 153   bg_gc = widget->style->bg_gc[GTK_STATE_NORMAL];
 154
 155   pango_desc = widget->style->font_desc;
 156
 157   // Create the pango layout
 158   pango_context = gtk_widget_get_pango_context (widget);
 159
 160   pango_layout = pango_layout_new (pango_context);
 161
 162   PangoFontDescription *fs = pango_font_description_new ();
 163   pango_font_description_set_size (fs, RULER_FONT_SIZE);
 164   pango_layout_set_font_description (pango_layout, fs);
 165   pango_font_description_free (fs);
 166
 167   digit_height = (int) floor (RULER_FONT_SIZE * RULER_FONT_VERTICAL_SPACING / PANGO_SCALE + 0.5);
 168
 169   xthickness = widget->style->xthickness;
 170   ythickness = widget->style->ythickness;
 171
 172   width = widget->allocation.width;
 173   height = widget->allocation.height;// - ythickness * 2;
 174
 175   gtk_paint_box (widget->style, ruler->backing_store,
 176                  GTK_STATE_NORMAL, GTK_SHADOW_NONE,
 177                  NULL, widget, "hruler",
 178                  0, 0,
 179                  widget->allocation.width, widget->allocation.height);
 180
 181   upper = ruler->upper / ruler->metric->pixels_per_unit;
 182   lower = ruler->lower / ruler->metric->pixels_per_unit;
 183
 184   if ((upper - lower) == 0)
 185     return;
 186   increment = (double) width / (upper - lower);
 187
 188   /* determine the scale
 189    *  We calculate the text size as for the vruler instead of using
 190    *  text_width = gdk_string_width(font, unit_str), so that the result
 191    *  for the scale looks consistent with an accompanying vruler
 192    */
 193   scale = (int)(ceil (ruler->max_size / ruler->metric->pixels_per_unit));
 194   sprintf (unit_str, "%d", scale);
 195   text_width = strlen (unit_str) * digit_height + 1;
 196
 197   for (scale = 0; scale < MAXIMUM_SCALES; scale++)
 198     if (ruler->metric->ruler_scale[scale] * fabs(increment) > 2 * text_width)
 199       break;
 200
 201   if (scale == MAXIMUM_SCALES)
 202     scale = MAXIMUM_SCALES - 1;
 203
 204   /* drawing starts here */
 205   length = 0;
 206   for (i = MAXIMUM_SUBDIVIDE - 1; i >= 0; i--)
 207     {
 208       subd_incr = ruler->metric->ruler_scale[scale] /
 209                   ruler->metric->subdivide[i];
 210       if (subd_incr * fabs(increment) <= MINIMUM_INCR)
 211         continue;
 212
 213       /* Calculate the length of the tickmarks. Make sure that
 214        * this length increases for each set of ticks
 215        */
 216       ideal_length = height / (i + 1) - 1;
 217       if (ideal_length > ++length)
 218         length = ideal_length;
 219
 220       if (lower < upper)
 221         {
 222           start = floor (lower / subd_incr) * subd_incr;
 223           end   = ceil  (upper / subd_incr) * subd_incr;
 224         }
 225       else
 226         {
 227           start = floor (upper / subd_incr) * subd_incr;
 228           end   = ceil  (lower / subd_incr) * subd_incr;
 229         }
 230
 231     tick_index = 0;
 232     cur = start;
 233
 234         while (cur <= end)
 235         {
 236           pos = ROUND ((cur - lower) * increment);
 237
 238           gdk_draw_line (ruler->backing_store, gc,
 239                          pos, height + ythickness,
 240                          pos, height - length + ythickness);
 241
 242           /* draw label */
 243         double label_spacing_px = (increment*(double)ruler->metric->ruler_scale[scale])/ruler->metric->subdivide[i];
 244           if (i == 0 &&
 245                                 (label_spacing_px > 6*digit_height || tick_index%2 == 0 || cur == 0) &&
 246                                 (label_spacing_px > 3*digit_height || tick_index%4 == 0 ||  cur == 0))
 247             {
 248                                 if (fabs((int)cur) >= 2000 && (((int) cur)/1000)*1000 == ((int) cur))
 249                                         sprintf (unit_str, "%dk", ((int) cur)/1000);
 250                                 else
 251                                         sprintf (unit_str, "%d", (int) cur);
 252
 253                                 pango_layout_set_text (pango_layout, unit_str, -1);
 254
 255                                 gdk_draw_layout (ruler->backing_store, gc,
 256                                pos + 2, 0, pango_layout);
 257             }
 258
 259       /* Calculate cur from start rather than incrementing by subd_incr
 260        * in each iteration. This is to avoid propagation of floating point
 261        * errors in subd_incr.
 262        */
 263       ++tick_index;
 264       cur = start + (((double)tick_index) * (double)ruler->metric->ruler_scale[scale])/ ruler->metric->subdivide[i];
 265         }
 266     }
 267 }
 268
 269 static void
 270 sp_hruler_draw_pos (GtkRuler *ruler)
 271 {
 272   GtkWidget *widget;
 273   GdkGC *gc;
 274   int i;
 275   gint x, y;
 276   gint width, height;
 277   gint bs_width, bs_height;
 278   gint xthickness;
 279   gint ythickness;
 280   gfloat increment;
 281
 282   g_return_if_fail (ruler != NULL);
 283   g_return_if_fail (SP_IS_HRULER (ruler));
 284
 285   if (GTK_WIDGET_DRAWABLE (ruler))
 286     {
 287       widget = GTK_WIDGET (ruler);
 288
 289       gc = widget->style->fg_gc[GTK_STATE_NORMAL];
 290       xthickness = widget->style->xthickness;
 291       ythickness = widget->style->ythickness;
 292       width = widget->allocation.width;
 293       height = widget->allocation.height - ythickness * 2;
 294
 295       bs_width = height / 2;
 296       bs_width |= 1;  /* make sure it's odd */
 297       bs_height = bs_width / 2 + 1;
 298
 299       if ((bs_width > 0) && (bs_height > 0))
 300         {
 301           /*  If a backing store exists, restore the ruler  */
 302           if (ruler->backing_store && ruler->non_gr_exp_gc)
 303             gdk_draw_pixmap (ruler->widget.window,
 304                              ruler->non_gr_exp_gc,
 305                              ruler->backing_store,
 306                              ruler->xsrc, ruler->ysrc,
 307                              ruler->xsrc, ruler->ysrc,
 308                              bs_width, bs_height);
 309
 310           increment = (gfloat) width / (ruler->upper - ruler->lower);
 311
 312           x = ROUND ((ruler->position - ruler->lower) * increment) + (xthickness - bs_width) / 2 - 1;
 313           y = (height + bs_height) / 2 + ythickness;
 314
 315           for (i = 0; i < bs_height; i++)
 316             gdk_draw_line (widget->window, gc,
 317                            x + i, y + i,
 318                            x + bs_width - 1 - i, y + i);
 319
 320
 321           ruler->xsrc = x;
 322           ruler->ysrc = y;
 323         }
 324     }
 325 }
 326
 327
 328
 329
 330
 331 // vruler
 332
 333 static void sp_vruler_class_init    (SPVRulerClass *klass);
 334 static void sp_vruler_init          (SPVRuler      *vruler);
 335 static gint sp_vruler_motion_notify (GtkWidget      *widget,
 336                                       GdkEventMotion *event);
 337 static void sp_vruler_draw_ticks    (GtkRuler       *ruler);
 338 static void sp_vruler_draw_pos      (GtkRuler       *ruler);
 339
 340
 341 GtkType
 342 sp_vruler_get_type (void)
 343 {
 344   static GtkType vruler_type = 0;
 345
 346   if (!vruler_type)
 347     {
 348       static const GtkTypeInfo vruler_info =
 349       {
 350         "SPVRuler",
 351         sizeof (SPVRuler),
 352         sizeof (SPVRulerClass),
 353         (GtkClassInitFunc) sp_vruler_class_init,
 354         (GtkObjectInitFunc) sp_vruler_init,
 355         /* reserved_1 */ NULL,
 356         /* reserved_2 */ NULL,
 357         (GtkClassInitFunc) NULL,
 358       };
 359
 360       vruler_type = gtk_type_unique (gtk_ruler_get_type (), &vruler_info);
 361     }
 362
 363   return vruler_type;
 364 }
 365
 366 static void
 367 sp_vruler_class_init (SPVRulerClass *klass)
 368 {
 369   GtkWidgetClass *widget_class;
 370   GtkRulerClass *ruler_class;
 371
 372   widget_class = (GtkWidgetClass*) klass;
 373   ruler_class = (GtkRulerClass*) klass;
 374
 375   widget_class->motion_notify_event = sp_vruler_motion_notify;
 376
 377   ruler_class->draw_ticks = sp_vruler_draw_ticks;
 378   ruler_class->draw_pos = sp_vruler_draw_pos;
 379 }
 380
 381 static void
 382 sp_vruler_init (SPVRuler *vruler)
 383 {
 384   GtkWidget *widget;
 385
 386   widget = GTK_WIDGET (vruler);
 387   widget->requisition.width = widget->style->xthickness * 2 + RULER_WIDTH;
 388   widget->requisition.height = widget->style->ythickness * 2 + 1;
 389 }
 390
 391 GtkWidget*
 392 sp_vruler_new (void)
 393 {
 394   return GTK_WIDGET (gtk_type_new (sp_vruler_get_type ()));
 395 }
 396
 397
 398 static gint
 399 sp_vruler_motion_notify (GtkWidget      *widget,
 400                           GdkEventMotion *event)
 401 {
 402   GtkRuler *ruler;
 403   gint y;
 404
 405   g_return_val_if_fail (widget != NULL, FALSE);
 406   g_return_val_if_fail (SP_IS_VRULER (widget), FALSE);
 407   g_return_val_if_fail (event != NULL, FALSE);
 408
 409   ruler = GTK_RULER (widget);
 410
 411   if (event->is_hint)
 412     gdk_window_get_pointer (widget->window, NULL, &y, NULL);
 413   else
 414     y = (int)event->y;
 415
 416   ruler->position = ruler->lower + ((ruler->upper - ruler->lower) * y) / widget->allocation.height;
 417
 418   /*  Make sure the ruler has been allocated already  */
 419   if (ruler->backing_store != NULL)
 420     gtk_ruler_draw_pos (ruler);
 421
 422   return FALSE;
 423 }
 424
 425 static void
 426 sp_vruler_draw_ticks (GtkRuler *ruler)
 427 {
 428   GtkWidget *widget;
 429   GdkGC *gc, *bg_gc;
 430   PangoFontDescription *pango_desc;
 431   PangoContext *pango_context;
 432   PangoLayout *pango_layout;
 433   gint i, j, tick_index;
 434   gint width, height;
 435   gint xthickness;
 436   gint ythickness;
 437   gint length, ideal_length;
 438   double lower, upper;          /* Upper and lower limits, in ruler units */
 439   double increment;             /* Number of pixels per unit */
 440   gint scale;                   /* Number of units per major unit */
 441   double subd_incr;
 442   double start, end, cur;
 443   gchar unit_str[32];
 444   gchar digit_str[2] = { '\0', '\0' };
 445   gint digit_height;
 446   gint text_height;
 447   gint pos;
 448
 449   g_return_if_fail (ruler != NULL);
 450   g_return_if_fail (SP_IS_VRULER (ruler));
 451
 452   if (!GTK_WIDGET_DRAWABLE (ruler))
 453     return;
 454
 455   widget = GTK_WIDGET (ruler);
 456
 457   gc = widget->style->fg_gc[GTK_STATE_NORMAL];
 458   bg_gc = widget->style->bg_gc[GTK_STATE_NORMAL];
 459
 460   pango_desc = widget->style->font_desc;
 461
 462   // Create the pango layout
 463   pango_context = gtk_widget_get_pango_context (widget);
 464
 465   pango_layout = pango_layout_new (pango_context);
 466
 467   PangoFontDescription *fs = pango_font_description_new ();
 468   pango_font_description_set_size (fs, RULER_FONT_SIZE);
 469   pango_layout_set_font_description (pango_layout, fs);
 470   pango_font_description_free (fs);
 471
 472   digit_height = (int) floor (RULER_FONT_SIZE * RULER_FONT_VERTICAL_SPACING / PANGO_SCALE + 0.5);
 473
 474   xthickness = widget->style->xthickness;
 475   ythickness = widget->style->ythickness;
 476
 477   width = widget->allocation.height;
 478   height = widget->allocation.width;// - ythickness * 2;
 479
 480   gtk_paint_box (widget->style, ruler->backing_store,
 481                  GTK_STATE_NORMAL, GTK_SHADOW_NONE,
 482                  NULL, widget, "vruler",
 483                  0, 0,
 484                  widget->allocation.width, widget->allocation.height);
 485
 486   upper = ruler->upper / ruler->metric->pixels_per_unit;
 487   lower = ruler->lower / ruler->metric->pixels_per_unit;
 488
 489   if ((upper - lower) == 0)
 490     return;
 491   increment = (double) width / (upper - lower);
 492
 493   /* determine the scale
 494    *   use the maximum extents of the ruler to determine the largest
 495    *   possible number to be displayed.  Calculate the height in pixels
 496    *   of this displayed text. Use this height to find a scale which
 497    *   leaves sufficient room for drawing the ruler.
 498    */
 499   scale = (int)ceil (ruler->max_size / ruler->metric->pixels_per_unit);
 500   sprintf (unit_str, "%d", scale);
 501   text_height = strlen (unit_str) * digit_height + 1;
 502
 503   for (scale = 0; scale < MAXIMUM_SCALES; scale++)
 504     if (ruler->metric->ruler_scale[scale] * fabs(increment) > 2 * text_height)
 505       break;
 506
 507   if (scale == MAXIMUM_SCALES)
 508     scale = MAXIMUM_SCALES - 1;
 509
 510   /* drawing starts here */
 511   length = 0;
 512   for (i = MAXIMUM_SUBDIVIDE - 1; i >= 0; i--) {
 513                 subd_incr = (double) ruler->metric->ruler_scale[scale] /
 514                         (double) ruler->metric->subdivide[i];
 515                 if (subd_incr * fabs(increment) <= MINIMUM_INCR)
 516                         continue;
 517
 518                 /* Calculate the length of the tickmarks. Make sure that
 519                  * this length increases for each set of ticks
 520                  */
 521                 ideal_length = height / (i + 1) - 1;
 522                 if (ideal_length > ++length)
 523                         length = ideal_length;
 524
 525                 if (lower < upper)
 526                         {
 527                                 start = floor (lower / subd_incr) * subd_incr;
 528                                 end   = ceil  (upper / subd_incr) * subd_incr;
 529                         }
 530                 else
 531                         {
 532                                 start = floor (upper / subd_incr) * subd_incr;
 533                                 end   = ceil  (lower / subd_incr) * subd_incr;
 534                         }
 535
 536     tick_index = 0;
 537     cur = start;
 538
 539     while (cur < end) {
 540                         pos = ROUND ((cur - lower) * increment);
 541
 542                         gdk_draw_line (ruler->backing_store, gc,
 543                                                                                  height + xthickness - length, pos,
 544                                                                                  height + xthickness, pos);
 545
 546                         /* draw label */
 547                         double label_spacing_px = fabs((increment*(double)ruler->metric->ruler_scale[scale])/ruler->metric->subdivide[i]);
 548                         if (i == 0 &&
 549                                         (label_spacing_px > 6*digit_height || tick_index%2 == 0 || cur == 0) &&
 550                                         (label_spacing_px > 3*digit_height || tick_index%4 == 0 || cur == 0))
 551                                 {
 552                                         if (fabs((int)cur) >= 2000 && (((int) cur)/1000)*1000 == ((int) cur))
 553                                                 sprintf (unit_str, "%dk", ((int) cur)/1000);
 554                                         else
 555                                                 sprintf (unit_str, "%d", (int) cur);
 556                                         for (j = 0; j < (int) strlen (unit_str); j++)
 557                                                 {
 558                                                         digit_str[0] = unit_str[j];
 559
 560                                                         pango_layout_set_text (pango_layout, digit_str, 1);
 561
 562                                                         gdk_draw_layout (ruler->backing_store, gc,
 563                                                                                                                          xthickness + 1,
 564                                                                                                                          pos + digit_height * (j) + 1,
 565                                                                                                                          pango_layout);
 566                                                 }
 567                                 }
 568
 569                         /* Calculate cur from start rather than incrementing by subd_incr
 570                          * in each iteration. This is to avoid propagation of floating point
 571                          * errors in subd_incr.
 572                          */
 573                         ++tick_index;
 574                         cur = start + (((double)tick_index) * (double)ruler->metric->ruler_scale[scale])/ ruler->metric->subdivide[i];
 575                 }
 576         }
 577 }
 578
 579 static void
 580 sp_vruler_draw_pos (GtkRuler *ruler)
 581 {
 582   GtkWidget *widget;
 583   GdkGC *gc;
 584   int i;
 585   gint x, y;
 586   gint width, height;
 587   gint bs_width, bs_height;
 588   gint xthickness;
 589   gint ythickness;
 590   gfloat increment;
 591
 592   g_return_if_fail (ruler != NULL);
 593   g_return_if_fail (SP_IS_VRULER (ruler));
 594
 595   if (GTK_WIDGET_DRAWABLE (ruler))
 596     {
 597       widget = GTK_WIDGET (ruler);
 598
 599       gc = widget->style->fg_gc[GTK_STATE_NORMAL];
 600       xthickness = widget->style->xthickness;
 601       ythickness = widget->style->ythickness;
 602       width = widget->allocation.width - xthickness * 2;
 603       height = widget->allocation.height;
 604
 605       bs_height = width / 2;
 606       bs_height |= 1;  /* make sure it's odd */
 607       bs_width = bs_height / 2 + 1;
 608
 609       if ((bs_width > 0) && (bs_height > 0))
 610         {
 611           /*  If a backing store exists, restore the ruler  */
 612           if (ruler->backing_store && ruler->non_gr_exp_gc)
 613             gdk_draw_pixmap (ruler->widget.window,
 614                              ruler->non_gr_exp_gc,
 615                              ruler->backing_store,
 616                              ruler->xsrc, ruler->ysrc,
 617                              ruler->xsrc, ruler->ysrc,
 618                              bs_width, bs_height);
 619
 620           increment = (gfloat) height / (ruler->upper - ruler->lower);
 621
 622           x = (width + bs_width) / 2 + xthickness;
 623           y = ROUND ((ruler->position - ruler->lower) * increment) + (ythickness - bs_height) / 2 - 1;
 624
 625           for (i = 0; i < bs_width; i++)
 626             gdk_draw_line (widget->window, gc,
 627                            x + i, y + i,
 628                            x + i, y + bs_height - 1 - i);
 629
 630           ruler->xsrc = x;
 631           ruler->ysrc = y;
 632         }
 633     }
 634 }
 635
 636 /// Ruler metrics.
 637 static GtkRulerMetric const sp_ruler_metrics[] = {
 638   // NOTE: the order of records in this struct must correspond to the SPMetric enum.
 639   {"NONE",  "", 1, { 1, 2, 5, 10, 25, 50, 100, 250, 500, 1000 }, { 1, 5, 10, 50, 100 }},
 640   {"millimeters",  "mm", PX_PER_MM, { 1, 2, 5, 10, 25, 50, 100, 250, 500, 1000 }, { 1, 5, 10, 50, 100 }},
 641   {"centimeters", "cm", PX_PER_CM, { 1, 2, 5, 10, 25, 50, 100, 250, 500, 1000 }, { 1, 5, 10, 50, 100 }},
 642   {"inches",      "in", PX_PER_IN, { 1, 2, 4, 8, 16, 32, 64, 128, 256, 512 }, { 1, 2, 4, 8, 16 }},
 643   {"points",      "pt", PX_PER_PT, { 1, 2, 5, 10, 25, 50, 100, 250, 500, 1000 }, { 1, 5, 10, 50, 100 }},
 644   {"pixels",      "px", PX_PER_PX, { 1, 2, 5, 10, 25, 50, 100, 250, 500, 1000 }, { 1, 5, 10, 50, 100 }},
 645   {"meters",      "m", PX_PER_M, { 1, 2, 5, 10, 25, 50, 100, 250, 500, 1000 }, { 1, 5, 10, 50, 100 }},
 646 };
 647
 648 void
 649 sp_ruler_set_metric (GtkRuler *ruler,
 650                      SPMetric  metric)
 651 {
 652   g_return_if_fail (ruler != NULL);
 653   g_return_if_fail (GTK_IS_RULER (ruler));
 654   g_return_if_fail((unsigned) metric < G_N_ELEMENTS(sp_ruler_metrics));
 655
 656   if (metric == 0)
 657         return;
 658
 659   ruler->metric = const_cast<GtkRulerMetric *>(&sp_ruler_metrics[metric]);
 660
 661   if (GTK_WIDGET_DRAWABLE (ruler))
 662     gtk_widget_queue_draw (GTK_WIDGET (ruler));
 663 }