Pileus Git - ~andy/gtk/blob - gtk/gtkruler.c

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 /*
  21  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  22  * file for a list of people on the GTK+ Team.  See the ChangeLog
  23  * files for a list of changes.  These files are distributed with
  24  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  25  */
  26
  27 #include "config.h"
  28
  29 #include <math.h>
  30 #include <string.h>
  31
  32 #include "gtkorientable.h"
  33 #include "gtkruler.h"
  34 #include "gtkprivate.h"
  35 #include "gtkintl.h"
  36 #include "gtkalias.h"
  37
  38
  39 #define RULER_WIDTH           14
  40 #define MINIMUM_INCR          5
  41 #define MAXIMUM_SUBDIVIDE     5
  42 #define MAXIMUM_SCALES        10
  43
  44 #define ROUND(x) ((int) ((x) + 0.5))
  45
  46 enum {
  47   PROP_0,
  48   PROP_ORIENTATION,
  49   PROP_LOWER,
  50   PROP_UPPER,
  51   PROP_POSITION,
  52   PROP_MAX_SIZE,
  53   PROP_METRIC
  54 };
  55
  56 typedef struct _GtkRulerPrivate GtkRulerPrivate;
  57
  58 struct _GtkRulerPrivate
  59 {
  60   GtkOrientation orientation;
  61 };
  62
  63 #define GTK_RULER_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_RULER, GtkRulerPrivate))
  64
  65
  66 static void     gtk_ruler_set_property    (GObject        *object,
  67                                            guint            prop_id,
  68                                            const GValue   *value,
  69                                            GParamSpec     *pspec);
  70 static void     gtk_ruler_get_property    (GObject        *object,
  71                                            guint           prop_id,
  72                                            GValue         *value,
  73                                            GParamSpec     *pspec);
  74 static void     gtk_ruler_realize         (GtkWidget      *widget);
  75 static void     gtk_ruler_unrealize       (GtkWidget      *widget);
  76 static void     gtk_ruler_size_request    (GtkWidget      *widget,
  77                                            GtkRequisition *requisition);
  78 static void     gtk_ruler_size_allocate   (GtkWidget      *widget,
  79                                            GtkAllocation  *allocation);
  80 static gboolean gtk_ruler_motion_notify   (GtkWidget      *widget,
  81                                            GdkEventMotion *event);
  82 static gboolean gtk_ruler_expose          (GtkWidget      *widget,
  83                                            GdkEventExpose *event);
  84 static void     gtk_ruler_make_pixmap     (GtkRuler       *ruler);
  85 static void     gtk_ruler_real_draw_ticks (GtkRuler       *ruler);
  86 static void     gtk_ruler_real_draw_pos   (GtkRuler       *ruler);
  87
  88
  89 static const GtkRulerMetric ruler_metrics[] =
  90 {
  91   { "Pixel", "Pi", 1.0, { 1, 2, 5, 10, 25, 50, 100, 250, 500, 1000 }, { 1, 5, 10, 50, 100 }},
  92   { "Inches", "In", 72.0, { 1, 2, 4, 8, 16, 32, 64, 128, 256, 512 }, { 1, 2, 4, 8, 16 }},
  93   { "Centimeters", "Cn", 28.35, { 1, 2, 5, 10, 25, 50, 100, 250, 500, 1000 }, { 1, 5, 10, 50, 100 }},
  94 };
  95
  96
  97 G_DEFINE_TYPE_WITH_CODE (GtkRuler, gtk_ruler, GTK_TYPE_WIDGET,
  98                          G_IMPLEMENT_INTERFACE (GTK_TYPE_ORIENTABLE,
  99                                                 NULL))
 100
 101
 102 static void
 103 gtk_ruler_class_init (GtkRulerClass *class)
 104 {
 105   GObjectClass   *gobject_class = G_OBJECT_CLASS (class);
 106   GtkWidgetClass *widget_class  = GTK_WIDGET_CLASS (class);
 107
 108   gobject_class->set_property = gtk_ruler_set_property;
 109   gobject_class->get_property = gtk_ruler_get_property;
 110
 111   widget_class->realize = gtk_ruler_realize;
 112   widget_class->unrealize = gtk_ruler_unrealize;
 113   widget_class->size_request = gtk_ruler_size_request;
 114   widget_class->size_allocate = gtk_ruler_size_allocate;
 115   widget_class->motion_notify_event = gtk_ruler_motion_notify;
 116   widget_class->expose_event = gtk_ruler_expose;
 117
 118   class->draw_ticks = gtk_ruler_real_draw_ticks;
 119   class->draw_pos = gtk_ruler_real_draw_pos;
 120
 121   g_object_class_override_property (gobject_class,
 122                                     PROP_ORIENTATION,
 123                                     "orientation");
 124
 125   g_object_class_install_property (gobject_class,
 126                                    PROP_LOWER,
 127                                    g_param_spec_double ("lower",
 128                                                         P_("Lower"),
 129                                                         P_("Lower limit of ruler"),
 130                                                         -G_MAXDOUBLE,
 131                                                         G_MAXDOUBLE,
 132                                                         0.0,
 133                                                         GTK_PARAM_READWRITE));
 134
 135   g_object_class_install_property (gobject_class,
 136                                    PROP_UPPER,
 137                                    g_param_spec_double ("upper",
 138                                                         P_("Upper"),
 139                                                         P_("Upper limit of ruler"),
 140                                                         -G_MAXDOUBLE,
 141                                                         G_MAXDOUBLE,
 142                                                         0.0,
 143                                                         GTK_PARAM_READWRITE));
 144
 145   g_object_class_install_property (gobject_class,
 146                                    PROP_POSITION,
 147                                    g_param_spec_double ("position",
 148                                                         P_("Position"),
 149                                                         P_("Position of mark on the ruler"),
 150                                                         -G_MAXDOUBLE,
 151                                                         G_MAXDOUBLE,
 152                                                         0.0,
 153                                                         GTK_PARAM_READWRITE));
 154
 155   g_object_class_install_property (gobject_class,
 156                                    PROP_MAX_SIZE,
 157                                    g_param_spec_double ("max-size",
 158                                                         P_("Max Size"),
 159                                                         P_("Maximum size of the ruler"),
 160                                                         -G_MAXDOUBLE,
 161                                                         G_MAXDOUBLE,
 162                                                         0.0,
 163                                                         GTK_PARAM_READWRITE));
 164   /**
 165    * GtkRuler:metric:
 166    *
 167    * The metric used for the ruler.
 168    *
 169    * Since: 2.8
 170    */
 171   g_object_class_install_property (gobject_class,
 172                                    PROP_METRIC,
 173                                    g_param_spec_enum ("metric",
 174                                                       P_("Metric"),
 175                                                       P_("The metric used for the ruler"),
 176                                                       GTK_TYPE_METRIC_TYPE,
 177                                                       GTK_PIXELS,
 178                                                       GTK_PARAM_READWRITE));
 179
 180   g_type_class_add_private (gobject_class, sizeof (GtkRulerPrivate));
 181 }
 182
 183 static void
 184 gtk_ruler_init (GtkRuler *ruler)
 185 {
 186   GtkWidget *widget = GTK_WIDGET (ruler);
 187   GtkRulerPrivate *private = GTK_RULER_GET_PRIVATE (ruler);
 188
 189   private->orientation = GTK_ORIENTATION_HORIZONTAL;
 190
 191   widget->requisition.width  = widget->style->xthickness * 2 + 1;
 192   widget->requisition.height = widget->style->ythickness * 2 + RULER_WIDTH;
 193
 194   ruler->backing_store = NULL;
 195   ruler->xsrc = 0;
 196   ruler->ysrc = 0;
 197   ruler->slider_size = 0;
 198   ruler->lower = 0;
 199   ruler->upper = 0;
 200   ruler->position = 0;
 201   ruler->max_size = 0;
 202
 203   gtk_ruler_set_metric (ruler, GTK_PIXELS);
 204 }
 205
 206 static void
 207 gtk_ruler_set_property (GObject      *object,
 208                         guint         prop_id,
 209                         const GValue *value,
 210                         GParamSpec   *pspec)
 211 {
 212   GtkRuler *ruler = GTK_RULER (object);
 213   GtkRulerPrivate *private = GTK_RULER_GET_PRIVATE (ruler);
 214
 215   switch (prop_id)
 216     {
 217     case PROP_ORIENTATION:
 218       private->orientation = g_value_get_enum (value);
 219       gtk_widget_queue_resize (GTK_WIDGET (ruler));
 220       break;
 221     case PROP_LOWER:
 222       gtk_ruler_set_range (ruler, g_value_get_double (value), ruler->upper,
 223                            ruler->position, ruler->max_size);
 224       break;
 225     case PROP_UPPER:
 226       gtk_ruler_set_range (ruler, ruler->lower, g_value_get_double (value),
 227                            ruler->position, ruler->max_size);
 228       break;
 229     case PROP_POSITION:
 230       gtk_ruler_set_range (ruler, ruler->lower, ruler->upper,
 231                            g_value_get_double (value), ruler->max_size);
 232       break;
 233     case PROP_MAX_SIZE:
 234       gtk_ruler_set_range (ruler, ruler->lower, ruler->upper,
 235                            ruler->position,  g_value_get_double (value));
 236       break;
 237     case PROP_METRIC:
 238       gtk_ruler_set_metric (ruler, g_value_get_enum (value));
 239       break;
 240     default:
 241       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 242       break;
 243     }
 244 }
 245
 246 static void
 247 gtk_ruler_get_property (GObject      *object,
 248                         guint         prop_id,
 249                         GValue       *value,
 250                         GParamSpec   *pspec)
 251 {
 252   GtkRuler *ruler = GTK_RULER (object);
 253   GtkRulerPrivate *private = GTK_RULER_GET_PRIVATE (ruler);
 254
 255   switch (prop_id)
 256     {
 257     case PROP_ORIENTATION:
 258       g_value_set_enum (value, private->orientation);
 259       break;
 260     case PROP_LOWER:
 261       g_value_set_double (value, ruler->lower);
 262       break;
 263     case PROP_UPPER:
 264       g_value_set_double (value, ruler->upper);
 265       break;
 266     case PROP_POSITION:
 267       g_value_set_double (value, ruler->position);
 268       break;
 269     case PROP_MAX_SIZE:
 270       g_value_set_double (value, ruler->max_size);
 271       break;
 272     case PROP_METRIC:
 273       g_value_set_enum (value, gtk_ruler_get_metric (ruler));
 274       break;
 275     default:
 276       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 277       break;
 278     }
 279 }
 280
 281 #if 0
 282 /**
 283  * gtk_ruler_new:
 284  * @orientation: the ruler's orientation.
 285  *
 286  * Creates a new #GtkRuler with the given orientation.
 287  *
 288  * Return value: a new #GtkRuler.
 289  *
 290  * Since: 2.16
 291  **/
 292 GtkWidget *
 293 gtk_ruler_new (GtkOrientation orientation)
 294 {
 295   return g_object_new (GTK_TYPE_RULER,
 296                        "orientation", orientation,
 297                        NULL);
 298 }
 299 #endif
 300
 301 void
 302 gtk_ruler_set_metric (GtkRuler      *ruler,
 303                       GtkMetricType  metric)
 304 {
 305   g_return_if_fail (GTK_IS_RULER (ruler));
 306
 307   ruler->metric = (GtkRulerMetric *) &ruler_metrics[metric];
 308
 309   if (GTK_WIDGET_DRAWABLE (ruler))
 310     gtk_widget_queue_draw (GTK_WIDGET (ruler));
 311
 312   g_object_notify (G_OBJECT (ruler), "metric");
 313 }
 314
 315 /**
 316  * gtk_ruler_get_metric:
 317  * @ruler: a #GtkRuler
 318  *
 319  * Gets the units used for a #GtkRuler. See gtk_ruler_set_metric().
 320  *
 321  * Return value: the units currently used for @ruler
 322  **/
 323 GtkMetricType
 324 gtk_ruler_get_metric (GtkRuler *ruler)
 325 {
 326   gint i;
 327
 328   g_return_val_if_fail (GTK_IS_RULER (ruler), 0);
 329
 330   for (i = 0; i < G_N_ELEMENTS (ruler_metrics); i++)
 331     if (ruler->metric == &ruler_metrics[i])
 332       return i;
 333
 334   g_assert_not_reached ();
 335
 336   return 0;
 337 }
 338
 339 /**
 340  * gtk_ruler_set_range:
 341  * @ruler: the gtkruler
 342  * @lower: the lower limit of the ruler
 343  * @upper: the upper limit of the ruler
 344  * @position: the mark on the ruler
 345  * @max_size: the maximum size of the ruler used when calculating the space to
 346  * leave for the text
 347  *
 348  * This sets the range of the ruler.
 349  */
 350 void
 351 gtk_ruler_set_range (GtkRuler *ruler,
 352                      gdouble   lower,
 353                      gdouble   upper,
 354                      gdouble   position,
 355                      gdouble   max_size)
 356 {
 357   g_return_if_fail (GTK_IS_RULER (ruler));
 358
 359   g_object_freeze_notify (G_OBJECT (ruler));
 360   if (ruler->lower != lower)
 361     {
 362       ruler->lower = lower;
 363       g_object_notify (G_OBJECT (ruler), "lower");
 364     }
 365   if (ruler->upper != upper)
 366     {
 367       ruler->upper = upper;
 368       g_object_notify (G_OBJECT (ruler), "upper");
 369     }
 370   if (ruler->position != position)
 371     {
 372       ruler->position = position;
 373       g_object_notify (G_OBJECT (ruler), "position");
 374     }
 375   if (ruler->max_size != max_size)
 376     {
 377       ruler->max_size = max_size;
 378       g_object_notify (G_OBJECT (ruler), "max-size");
 379     }
 380   g_object_thaw_notify (G_OBJECT (ruler));
 381
 382   if (GTK_WIDGET_DRAWABLE (ruler))
 383     gtk_widget_queue_draw (GTK_WIDGET (ruler));
 384 }
 385
 386 /**
 387  * gtk_ruler_get_range:
 388  * @ruler: a #GtkRuler
 389  * @lower: location to store lower limit of the ruler, or %NULL
 390  * @upper: location to store upper limit of the ruler, or %NULL
 391  * @position: location to store the current position of the mark on the ruler, or %NULL
 392  * @max_size: location to store the maximum size of the ruler used when calculating
 393  *            the space to leave for the text, or %NULL.
 394  *
 395  * Retrieves values indicating the range and current position of a #GtkRuler.
 396  * See gtk_ruler_set_range().
 397  **/
 398 void
 399 gtk_ruler_get_range (GtkRuler *ruler,
 400                      gdouble  *lower,
 401                      gdouble  *upper,
 402                      gdouble  *position,
 403                      gdouble  *max_size)
 404 {
 405   g_return_if_fail (GTK_IS_RULER (ruler));
 406
 407   if (lower)
 408     *lower = ruler->lower;
 409   if (upper)
 410     *upper = ruler->upper;
 411   if (position)
 412     *position = ruler->position;
 413   if (max_size)
 414     *max_size = ruler->max_size;
 415 }
 416
 417 void
 418 gtk_ruler_draw_ticks (GtkRuler *ruler)
 419 {
 420   g_return_if_fail (GTK_IS_RULER (ruler));
 421
 422   if (GTK_RULER_GET_CLASS (ruler)->draw_ticks)
 423     GTK_RULER_GET_CLASS (ruler)->draw_ticks (ruler);
 424 }
 425
 426 void
 427 gtk_ruler_draw_pos (GtkRuler *ruler)
 428 {
 429   g_return_if_fail (GTK_IS_RULER (ruler));
 430
 431   if (GTK_RULER_GET_CLASS (ruler)->draw_pos)
 432      GTK_RULER_GET_CLASS (ruler)->draw_pos (ruler);
 433 }
 434
 435
 436 static void
 437 gtk_ruler_realize (GtkWidget *widget)
 438 {
 439   GtkRuler *ruler;
 440   GdkWindowAttr attributes;
 441   gint attributes_mask;
 442
 443   ruler = GTK_RULER (widget);
 444   GTK_WIDGET_SET_FLAGS (ruler, GTK_REALIZED);
 445
 446   attributes.window_type = GDK_WINDOW_CHILD;
 447   attributes.x = widget->allocation.x;
 448   attributes.y = widget->allocation.y;
 449   attributes.width = widget->allocation.width;
 450   attributes.height = widget->allocation.height;
 451   attributes.wclass = GDK_INPUT_OUTPUT;
 452   attributes.visual = gtk_widget_get_visual (widget);
 453   attributes.colormap = gtk_widget_get_colormap (widget);
 454   attributes.event_mask = gtk_widget_get_events (widget);
 455   attributes.event_mask |= (GDK_EXPOSURE_MASK |
 456                             GDK_POINTER_MOTION_MASK |
 457                             GDK_POINTER_MOTION_HINT_MASK);
 458
 459   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
 460
 461   widget->window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attributes_mask);
 462   gdk_window_set_user_data (widget->window, ruler);
 463
 464   widget->style = gtk_style_attach (widget->style, widget->window);
 465   gtk_style_set_background (widget->style, widget->window, GTK_STATE_ACTIVE);
 466
 467   gtk_ruler_make_pixmap (ruler);
 468 }
 469
 470 static void
 471 gtk_ruler_unrealize (GtkWidget *widget)
 472 {
 473   GtkRuler *ruler = GTK_RULER (widget);
 474
 475   if (ruler->backing_store)
 476     {
 477       g_object_unref (ruler->backing_store);
 478       ruler->backing_store = NULL;
 479     }
 480
 481   if (ruler->non_gr_exp_gc)
 482     {
 483       g_object_unref (ruler->non_gr_exp_gc);
 484       ruler->non_gr_exp_gc = NULL;
 485     }
 486
 487   GTK_WIDGET_CLASS (gtk_ruler_parent_class)->unrealize (widget);
 488 }
 489
 490 static void
 491 gtk_ruler_size_request (GtkWidget      *widget,
 492                         GtkRequisition *requisition)
 493 {
 494   GtkRulerPrivate *private = GTK_RULER_GET_PRIVATE (widget);
 495
 496   if (private->orientation == GTK_ORIENTATION_HORIZONTAL)
 497     {
 498       requisition->width  = widget->style->xthickness * 2 + 1;
 499       requisition->height = widget->style->ythickness * 2 + RULER_WIDTH;
 500     }
 501   else
 502     {
 503       requisition->width  = widget->style->xthickness * 2 + RULER_WIDTH;
 504       requisition->height = widget->style->ythickness * 2 + 1;
 505     }
 506 }
 507
 508 static void
 509 gtk_ruler_size_allocate (GtkWidget     *widget,
 510                          GtkAllocation *allocation)
 511 {
 512   GtkRuler *ruler = GTK_RULER (widget);
 513
 514   widget->allocation = *allocation;
 515
 516   if (GTK_WIDGET_REALIZED (widget))
 517     {
 518       gdk_window_move_resize (widget->window,
 519                               allocation->x, allocation->y,
 520                               allocation->width, allocation->height);
 521
 522       gtk_ruler_make_pixmap (ruler);
 523     }
 524 }
 525
 526 static gboolean
 527 gtk_ruler_motion_notify (GtkWidget      *widget,
 528                          GdkEventMotion *event)
 529 {
 530   GtkRuler *ruler = GTK_RULER (widget);
 531   GtkRulerPrivate *private = GTK_RULER_GET_PRIVATE (widget);
 532   gint x;
 533   gint y;
 534
 535   gdk_event_request_motions (event);
 536   x = event->x;
 537   y = event->y;
 538
 539   if (private->orientation == GTK_ORIENTATION_HORIZONTAL)
 540     ruler->position = ruler->lower + ((ruler->upper - ruler->lower) * x) / widget->allocation.width;
 541   else
 542     ruler->position = ruler->lower + ((ruler->upper - ruler->lower) * y) / widget->allocation.height;
 543
 544   g_object_notify (G_OBJECT (ruler), "position");
 545
 546   /*  Make sure the ruler has been allocated already  */
 547   if (ruler->backing_store != NULL)
 548     gtk_ruler_draw_pos (ruler);
 549
 550   return FALSE;
 551 }
 552
 553 static gboolean
 554 gtk_ruler_expose (GtkWidget      *widget,
 555                   GdkEventExpose *event)
 556 {
 557   if (GTK_WIDGET_DRAWABLE (widget))
 558     {
 559       GtkRuler *ruler = GTK_RULER (widget);
 560
 561       gtk_ruler_draw_ticks (ruler);
 562
 563       gdk_draw_drawable (widget->window,
 564                          ruler->non_gr_exp_gc,
 565                          ruler->backing_store,
 566                          0, 0, 0, 0,
 567                          widget->allocation.width,
 568                          widget->allocation.height);
 569
 570       gtk_ruler_draw_pos (ruler);
 571     }
 572
 573   return FALSE;
 574 }
 575
 576 static void
 577 gtk_ruler_make_pixmap (GtkRuler *ruler)
 578 {
 579   GtkWidget *widget;
 580   gint width;
 581   gint height;
 582
 583   widget = GTK_WIDGET (ruler);
 584
 585   if (ruler->backing_store)
 586     {
 587       gdk_drawable_get_size (ruler->backing_store, &width, &height);
 588       if ((width == widget->allocation.width) &&
 589           (height == widget->allocation.height))
 590         return;
 591
 592       g_object_unref (ruler->backing_store);
 593     }
 594
 595   ruler->backing_store = gdk_pixmap_new (widget->window,
 596                                          widget->allocation.width,
 597                                          widget->allocation.height,
 598                                          -1);
 599
 600   ruler->xsrc = 0;
 601   ruler->ysrc = 0;
 602
 603   if (!ruler->non_gr_exp_gc)
 604     {
 605       ruler->non_gr_exp_gc = gdk_gc_new (widget->window);
 606       gdk_gc_set_exposures (ruler->non_gr_exp_gc, FALSE);
 607     }
 608 }
 609
 610 static void
 611 gtk_ruler_real_draw_ticks (GtkRuler *ruler)
 612 {
 613   GtkWidget *widget = GTK_WIDGET (ruler);
 614   GtkRulerPrivate *private = GTK_RULER_GET_PRIVATE (ruler);
 615   cairo_t *cr;
 616   gint i, j;
 617   gint width, height;
 618   gint xthickness;
 619   gint ythickness;
 620   gint length, ideal_length;
 621   gdouble lower, upper;         /* Upper and lower limits, in ruler units */
 622   gdouble increment;            /* Number of pixels per unit */
 623   gint scale;                   /* Number of units per major unit */
 624   gdouble subd_incr;
 625   gdouble start, end, cur;
 626   gchar unit_str[32];
 627   gint digit_height;
 628   gint digit_offset;
 629   gint text_width;
 630   gint text_height;
 631   gint pos;
 632   PangoLayout *layout;
 633   PangoRectangle logical_rect, ink_rect;
 634
 635   if (!GTK_WIDGET_DRAWABLE (ruler))
 636     return;
 637
 638   xthickness = widget->style->xthickness;
 639   ythickness = widget->style->ythickness;
 640
 641   layout = gtk_widget_create_pango_layout (widget, "012456789");
 642   pango_layout_get_extents (layout, &ink_rect, &logical_rect);
 643
 644   digit_height = PANGO_PIXELS (ink_rect.height) + 2;
 645   digit_offset = ink_rect.y;
 646
 647   if (private->orientation == GTK_ORIENTATION_HORIZONTAL)
 648     {
 649       width = widget->allocation.width;
 650       height = widget->allocation.height - ythickness * 2;
 651     }
 652   else
 653     {
 654       width = widget->allocation.height;
 655       height = widget->allocation.width - ythickness * 2;
 656     }
 657
 658 #define DETAILE(private) (private->orientation == GTK_ORIENTATION_HORIZONTAL ? "hruler" : "vruler");
 659
 660   gtk_paint_box (widget->style, ruler->backing_store,
 661                  GTK_STATE_NORMAL, GTK_SHADOW_OUT,
 662                  NULL, widget,
 663                  private->orientation == GTK_ORIENTATION_HORIZONTAL ?
 664                  "hruler" : "vruler",
 665                  0, 0,
 666                  widget->allocation.width, widget->allocation.height);
 667
 668   cr = gdk_cairo_create (ruler->backing_store);
 669   gdk_cairo_set_source_color (cr, &widget->style->fg[widget->state]);
 670
 671   if (private->orientation == GTK_ORIENTATION_HORIZONTAL)
 672     {
 673       cairo_rectangle (cr,
 674                        xthickness,
 675                        height + ythickness,
 676                        widget->allocation.width - 2 * xthickness,
 677                        1);
 678     }
 679   else
 680     {
 681       cairo_rectangle (cr,
 682                        height + xthickness,
 683                        ythickness,
 684                        1,
 685                        widget->allocation.height - 2 * ythickness);
 686     }
 687
 688   upper = ruler->upper / ruler->metric->pixels_per_unit;
 689   lower = ruler->lower / ruler->metric->pixels_per_unit;
 690
 691   if ((upper - lower) == 0)
 692     goto out;
 693
 694   increment = (gdouble) width / (upper - lower);
 695
 696   /* determine the scale H
 697    *  We calculate the text size as for the vruler instead of using
 698    *  text_width = gdk_string_width(font, unit_str), so that the result
 699    *  for the scale looks consistent with an accompanying vruler
 700    */
 701   /* determine the scale V
 702    *   use the maximum extents of the ruler to determine the largest
 703    *   possible number to be displayed.  Calculate the height in pixels
 704    *   of this displayed text. Use this height to find a scale which
 705    *   leaves sufficient room for drawing the ruler.
 706    */
 707   scale = ceil (ruler->max_size / ruler->metric->pixels_per_unit);
 708   g_snprintf (unit_str, sizeof (unit_str), "%d", scale);
 709
 710   if (private->orientation == GTK_ORIENTATION_HORIZONTAL)
 711     {
 712       text_width = strlen (unit_str) * digit_height + 1;
 713
 714       for (scale = 0; scale < MAXIMUM_SCALES; scale++)
 715         if (ruler->metric->ruler_scale[scale] * fabs(increment) > 2 * text_width)
 716           break;
 717     }
 718   else
 719     {
 720       text_height = strlen (unit_str) * digit_height + 1;
 721
 722       for (scale = 0; scale < MAXIMUM_SCALES; scale++)
 723         if (ruler->metric->ruler_scale[scale] * fabs(increment) > 2 * text_height)
 724           break;
 725     }
 726
 727   if (scale == MAXIMUM_SCALES)
 728     scale = MAXIMUM_SCALES - 1;
 729
 730   /* drawing starts here */
 731   length = 0;
 732   for (i = MAXIMUM_SUBDIVIDE - 1; i >= 0; i--)
 733     {
 734       subd_incr = (gdouble) ruler->metric->ruler_scale[scale] /
 735                   (gdouble) ruler->metric->subdivide[i];
 736       if (subd_incr * fabs(increment) <= MINIMUM_INCR)
 737         continue;
 738
 739       /* Calculate the length of the tickmarks. Make sure that
 740        * this length increases for each set of ticks
 741        */
 742       ideal_length = height / (i + 1) - 1;
 743       if (ideal_length > ++length)
 744         length = ideal_length;
 745
 746       if (lower < upper)
 747         {
 748           start = floor (lower / subd_incr) * subd_incr;
 749           end   = ceil  (upper / subd_incr) * subd_incr;
 750         }
 751       else
 752         {
 753           start = floor (upper / subd_incr) * subd_incr;
 754           end   = ceil  (lower / subd_incr) * subd_incr;
 755         }
 756
 757       for (cur = start; cur <= end; cur += subd_incr)
 758         {
 759           pos = ROUND ((cur - lower) * increment);
 760
 761           if (private->orientation == GTK_ORIENTATION_HORIZONTAL)
 762             {
 763               cairo_rectangle (cr,
 764                                pos, height + ythickness - length,
 765                                1,   length);
 766             }
 767           else
 768             {
 769               cairo_rectangle (cr,
 770                                height + xthickness - length, pos,
 771                                length,                       1);
 772             }
 773
 774           /* draw label */
 775           if (i == 0)
 776             {
 777               g_snprintf (unit_str, sizeof (unit_str), "%d", (int) cur);
 778
 779               if (private->orientation == GTK_ORIENTATION_HORIZONTAL)
 780                 {
 781                   pango_layout_set_text (layout, unit_str, -1);
 782                   pango_layout_get_extents (layout, &logical_rect, NULL);
 783
 784                   gtk_paint_layout (widget->style,
 785                                     ruler->backing_store,
 786                                     GTK_WIDGET_STATE (widget),
 787                                     FALSE,
 788                                     NULL,
 789                                     widget,
 790                                     "hruler",
 791                                     pos + 2, ythickness + PANGO_PIXELS (logical_rect.y - digit_offset),
 792                                     layout);
 793                 }
 794               else
 795                 {
 796                   for (j = 0; j < (int) strlen (unit_str); j++)
 797                     {
 798                       pango_layout_set_text (layout, unit_str + j, 1);
 799                       pango_layout_get_extents (layout, NULL, &logical_rect);
 800
 801                       gtk_paint_layout (widget->style,
 802                                         ruler->backing_store,
 803                                         GTK_WIDGET_STATE (widget),
 804                                         FALSE,
 805                                         NULL,
 806                                         widget,
 807                                         "vruler",
 808                                         xthickness + 1,
 809                                         pos + digit_height * j + 2 + PANGO_PIXELS (logical_rect.y - digit_offset),
 810                                         layout);
 811                     }
 812                 }
 813             }
 814         }
 815     }
 816
 817   cairo_fill (cr);
 818 out:
 819   cairo_destroy (cr);
 820
 821   g_object_unref (layout);
 822 }
 823
 824 static void
 825 gtk_ruler_real_draw_pos (GtkRuler *ruler)
 826 {
 827   GtkWidget *widget = GTK_WIDGET (ruler);
 828   GtkRulerPrivate *private = GTK_RULER_GET_PRIVATE (ruler);
 829   gint x, y;
 830   gint width, height;
 831   gint bs_width, bs_height;
 832   gint xthickness;
 833   gint ythickness;
 834   gdouble increment;
 835
 836   if (GTK_WIDGET_DRAWABLE (ruler))
 837     {
 838       xthickness = widget->style->xthickness;
 839       ythickness = widget->style->ythickness;
 840       width = widget->allocation.width;
 841       height = widget->allocation.height;
 842
 843       if (private->orientation == GTK_ORIENTATION_HORIZONTAL)
 844         {
 845           height -= ythickness * 2;
 846
 847           bs_width = height / 2 + 2;
 848           bs_width |= 1;  /* make sure it's odd */
 849           bs_height = bs_width / 2 + 1;
 850         }
 851       else
 852         {
 853           width -= xthickness * 2;
 854
 855           bs_height = width / 2 + 2;
 856           bs_height |= 1;  /* make sure it's odd */
 857           bs_width = bs_height / 2 + 1;
 858         }
 859
 860       if ((bs_width > 0) && (bs_height > 0))
 861         {
 862           cairo_t *cr = gdk_cairo_create (widget->window);
 863
 864           /*  If a backing store exists, restore the ruler  */
 865           if (ruler->backing_store)
 866             gdk_draw_drawable (widget->window,
 867                                widget->style->black_gc,
 868                                ruler->backing_store,
 869                                ruler->xsrc, ruler->ysrc,
 870                                ruler->xsrc, ruler->ysrc,
 871                                bs_width, bs_height);
 872
 873           if (private->orientation == GTK_ORIENTATION_HORIZONTAL)
 874             {
 875               increment = (gdouble) width / (ruler->upper - ruler->lower);
 876
 877               x = ROUND ((ruler->position - ruler->lower) * increment) + (xthickness - bs_width) / 2 - 1;
 878               y = (height + bs_height) / 2 + ythickness;
 879             }
 880           else
 881             {
 882               increment = (gdouble) height / (ruler->upper - ruler->lower);
 883
 884               x = (width + bs_width) / 2 + xthickness;
 885               y = ROUND ((ruler->position - ruler->lower) * increment) + (ythickness - bs_height) / 2 - 1;
 886             }
 887
 888           gdk_cairo_set_source_color (cr, &widget->style->fg[widget->state]);
 889
 890           cairo_move_to (cr, x, y);
 891
 892           if (private->orientation == GTK_ORIENTATION_HORIZONTAL)
 893             {
 894               cairo_line_to (cr, x + bs_width / 2.0, y + bs_height);
 895               cairo_line_to (cr, x + bs_width,       y);
 896             }
 897           else
 898             {
 899               cairo_line_to (cr, x + bs_width, y + bs_height / 2.0);
 900               cairo_line_to (cr, x,            y + bs_height);
 901             }
 902
 903           cairo_fill (cr);
 904
 905           cairo_destroy (cr);
 906
 907           ruler->xsrc = x;
 908           ruler->ysrc = y;
 909         }
 910     }
 911 }
 912
 913 #define __GTK_RULER_C__
 914 #include "gtkaliasdef.c"