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