1 #define __SP_RULER_C__
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 */
16 #include <cmath>
17 #include <string.h>
18 #include "widget-sizes.h"
19 #include "ruler.h"
20 #include "unit-constants.h"
22 #define MINIMUM_INCR 5
23 #define MAXIMUM_SUBDIVIDE 5
24 #define MAXIMUM_SCALES 10
26 #define ROUND(x) int (std::floor ((x) + 0.5000000001))
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);
37 GtkType
38 sp_hruler_get_type (void)
39 {
40 static GtkType hruler_type = 0;
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 };
56 hruler_type = gtk_type_unique (gtk_ruler_get_type (), &hruler_info);
57 }
59 return hruler_type;
60 }
62 static void
63 sp_hruler_class_init (SPHRulerClass *klass)
64 {
65 GtkWidgetClass *widget_class;
66 GtkRulerClass *ruler_class;
68 widget_class = (GtkWidgetClass*) klass;
69 ruler_class = (GtkRulerClass*) klass;
71 widget_class->motion_notify_event = sp_hruler_motion_notify;
73 ruler_class->draw_ticks = sp_hruler_draw_ticks;
74 ruler_class->draw_pos = sp_hruler_draw_pos;
75 }
77 static void
78 sp_hruler_init (SPHRuler *hruler)
79 {
80 GtkWidget *widget;
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 }
88 GtkWidget*
89 sp_hruler_new (void)
90 {
91 return GTK_WIDGET (gtk_type_new (sp_hruler_get_type ()));
92 }
94 static gint
95 sp_hruler_motion_notify (GtkWidget *widget,
96 GdkEventMotion *event)
97 {
98 GtkRuler *ruler;
99 gint x;
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);
105 ruler = GTK_RULER (widget);
107 if (event->is_hint)
108 gdk_window_get_pointer (widget->window, &x, NULL, NULL);
109 else
110 x = (int)event->x;
112 ruler->position = ruler->lower + ((ruler->upper - ruler->lower) * x) / widget->allocation.width;
114 /* Make sure the ruler has been allocated already */
115 if (ruler->backing_store != NULL)
116 gtk_ruler_draw_pos (ruler);
118 return FALSE;
119 }
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;
144 g_return_if_fail (ruler != NULL);
145 g_return_if_fail (SP_IS_HRULER (ruler));
147 if (!GTK_WIDGET_DRAWABLE (ruler))
148 return;
150 widget = GTK_WIDGET (ruler);
152 gc = widget->style->fg_gc[GTK_STATE_NORMAL];
153 bg_gc = widget->style->bg_gc[GTK_STATE_NORMAL];
155 pango_desc = widget->style->font_desc;
157 // Create the pango layout
158 pango_context = gtk_widget_get_pango_context (widget);
160 pango_layout = pango_layout_new (pango_context);
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);
167 digit_height = (int) floor (RULER_FONT_SIZE * RULER_FONT_VERTICAL_SPACING / PANGO_SCALE + 0.5);
169 xthickness = widget->style->xthickness;
170 ythickness = widget->style->ythickness;
172 width = widget->allocation.width;
173 height = widget->allocation.height;// - ythickness * 2;
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);
181 upper = ruler->upper / ruler->metric->pixels_per_unit;
182 lower = ruler->lower / ruler->metric->pixels_per_unit;
184 if ((upper - lower) == 0)
185 return;
186 increment = (double) width / (upper - lower);
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;
197 for (scale = 0; scale < MAXIMUM_SCALES; scale++)
198 if (ruler->metric->ruler_scale[scale] * fabs(increment) > 2 * text_width)
199 break;
201 if (scale == MAXIMUM_SCALES)
202 scale = MAXIMUM_SCALES - 1;
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;
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;
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 }
231 tick_index = 0;
232 cur = start;
234 while (cur <= end)
235 {
236 pos = ROUND ((cur - lower) * increment);
238 gdk_draw_line (ruler->backing_store, gc,
239 pos, height + ythickness,
240 pos, height - length + ythickness);
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);
253 pango_layout_set_text (pango_layout, unit_str, -1);
255 gdk_draw_layout (ruler->backing_store, gc,
256 pos + 2, 0, pango_layout);
257 }
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 }
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;
282 g_return_if_fail (ruler != NULL);
283 g_return_if_fail (SP_IS_HRULER (ruler));
285 if (GTK_WIDGET_DRAWABLE (ruler))
286 {
287 widget = GTK_WIDGET (ruler);
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;
295 bs_width = height / 2;
296 bs_width |= 1; /* make sure it's odd */
297 bs_height = bs_width / 2 + 1;
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);
310 increment = (gfloat) width / (ruler->upper - ruler->lower);
312 x = ROUND ((ruler->position - ruler->lower) * increment) + (xthickness - bs_width) / 2 - 1;
313 y = (height + bs_height) / 2 + ythickness;
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);
321 ruler->xsrc = x;
322 ruler->ysrc = y;
323 }
324 }
325 }
331 // vruler
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);
341 GtkType
342 sp_vruler_get_type (void)
343 {
344 static GtkType vruler_type = 0;
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 };
360 vruler_type = gtk_type_unique (gtk_ruler_get_type (), &vruler_info);
361 }
363 return vruler_type;
364 }
366 static void
367 sp_vruler_class_init (SPVRulerClass *klass)
368 {
369 GtkWidgetClass *widget_class;
370 GtkRulerClass *ruler_class;
372 widget_class = (GtkWidgetClass*) klass;
373 ruler_class = (GtkRulerClass*) klass;
375 widget_class->motion_notify_event = sp_vruler_motion_notify;
377 ruler_class->draw_ticks = sp_vruler_draw_ticks;
378 ruler_class->draw_pos = sp_vruler_draw_pos;
379 }
381 static void
382 sp_vruler_init (SPVRuler *vruler)
383 {
384 GtkWidget *widget;
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 }
391 GtkWidget*
392 sp_vruler_new (void)
393 {
394 return GTK_WIDGET (gtk_type_new (sp_vruler_get_type ()));
395 }
398 static gint
399 sp_vruler_motion_notify (GtkWidget *widget,
400 GdkEventMotion *event)
401 {
402 GtkRuler *ruler;
403 gint y;
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);
409 ruler = GTK_RULER (widget);
411 if (event->is_hint)
412 gdk_window_get_pointer (widget->window, NULL, &y, NULL);
413 else
414 y = (int)event->y;
416 ruler->position = ruler->lower + ((ruler->upper - ruler->lower) * y) / widget->allocation.height;
418 /* Make sure the ruler has been allocated already */
419 if (ruler->backing_store != NULL)
420 gtk_ruler_draw_pos (ruler);
422 return FALSE;
423 }
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;
449 g_return_if_fail (ruler != NULL);
450 g_return_if_fail (SP_IS_VRULER (ruler));
452 if (!GTK_WIDGET_DRAWABLE (ruler))
453 return;
455 widget = GTK_WIDGET (ruler);
457 gc = widget->style->fg_gc[GTK_STATE_NORMAL];
458 bg_gc = widget->style->bg_gc[GTK_STATE_NORMAL];
460 pango_desc = widget->style->font_desc;
462 // Create the pango layout
463 pango_context = gtk_widget_get_pango_context (widget);
465 pango_layout = pango_layout_new (pango_context);
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);
472 digit_height = (int) floor (RULER_FONT_SIZE * RULER_FONT_VERTICAL_SPACING / PANGO_SCALE + 0.5);
474 xthickness = widget->style->xthickness;
475 ythickness = widget->style->ythickness;
477 width = widget->allocation.height;
478 height = widget->allocation.width;// - ythickness * 2;
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);
486 upper = ruler->upper / ruler->metric->pixels_per_unit;
487 lower = ruler->lower / ruler->metric->pixels_per_unit;
489 if ((upper - lower) == 0)
490 return;
491 increment = (double) width / (upper - lower);
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;
503 for (scale = 0; scale < MAXIMUM_SCALES; scale++)
504 if (ruler->metric->ruler_scale[scale] * fabs(increment) > 2 * text_height)
505 break;
507 if (scale == MAXIMUM_SCALES)
508 scale = MAXIMUM_SCALES - 1;
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;
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;
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 }
536 tick_index = 0;
537 cur = start;
539 while (cur < end) {
540 pos = ROUND ((cur - lower) * increment);
542 gdk_draw_line (ruler->backing_store, gc,
543 height + xthickness - length, pos,
544 height + xthickness, pos);
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];
560 pango_layout_set_text (pango_layout, digit_str, 1);
562 gdk_draw_layout (ruler->backing_store, gc,
563 xthickness + 1,
564 pos + digit_height * (j) + 1,
565 pango_layout);
566 }
567 }
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 }
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;
592 g_return_if_fail (ruler != NULL);
593 g_return_if_fail (SP_IS_VRULER (ruler));
595 if (GTK_WIDGET_DRAWABLE (ruler))
596 {
597 widget = GTK_WIDGET (ruler);
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;
605 bs_height = width / 2;
606 bs_height |= 1; /* make sure it's odd */
607 bs_width = bs_height / 2 + 1;
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);
620 increment = (gfloat) height / (ruler->upper - ruler->lower);
622 x = (width + bs_width) / 2 + xthickness;
623 y = ROUND ((ruler->position - ruler->lower) * increment) + (ythickness - bs_height) / 2 - 1;
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);
630 ruler->xsrc = x;
631 ruler->ysrc = y;
632 }
633 }
634 }
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 };
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));
656 if (metric == 0)
657 return;
659 ruler->metric = const_cast<GtkRulerMetric *>(&sp_ruler_metrics[metric]);
661 if (GTK_WIDGET_DRAWABLE (ruler))
662 gtk_widget_queue_draw (GTK_WIDGET (ruler));
663 }