5eb752377851cbc8dba1438a281774fdbbfc9c67
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 x = (int)event->x;
109 ruler->position = ruler->lower + ((ruler->upper - ruler->lower) * x) / widget->allocation.width;
111 /* Make sure the ruler has been allocated already */
112 if (ruler->backing_store != NULL)
113 gtk_ruler_draw_pos (ruler);
115 return FALSE;
116 }
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;
141 g_return_if_fail (ruler != NULL);
142 g_return_if_fail (SP_IS_HRULER (ruler));
144 if (!GTK_WIDGET_DRAWABLE (ruler))
145 return;
147 widget = GTK_WIDGET (ruler);
149 gc = widget->style->fg_gc[GTK_STATE_NORMAL];
150 bg_gc = widget->style->bg_gc[GTK_STATE_NORMAL];
152 pango_desc = widget->style->font_desc;
154 // Create the pango layout
155 pango_context = gtk_widget_get_pango_context (widget);
157 pango_layout = pango_layout_new (pango_context);
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);
164 digit_height = (int) floor (RULER_FONT_SIZE * RULER_FONT_VERTICAL_SPACING / PANGO_SCALE + 0.5);
166 xthickness = widget->style->xthickness;
167 ythickness = widget->style->ythickness;
169 width = widget->allocation.width;
170 height = widget->allocation.height;// - ythickness * 2;
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);
178 upper = ruler->upper / ruler->metric->pixels_per_unit;
179 lower = ruler->lower / ruler->metric->pixels_per_unit;
181 if ((upper - lower) == 0)
182 return;
183 increment = (double) width / (upper - lower);
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;
194 for (scale = 0; scale < MAXIMUM_SCALES; scale++)
195 if (ruler->metric->ruler_scale[scale] * fabs(increment) > 2 * text_width)
196 break;
198 if (scale == MAXIMUM_SCALES)
199 scale = MAXIMUM_SCALES - 1;
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;
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;
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 }
228 tick_index = 0;
229 cur = start;
231 while (cur <= end)
232 {
233 pos = ROUND ((cur - lower) * increment);
235 gdk_draw_line (ruler->backing_store, gc,
236 pos, height + ythickness,
237 pos, height - length + ythickness);
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);
250 pango_layout_set_text (pango_layout, unit_str, -1);
252 gdk_draw_layout (ruler->backing_store, gc,
253 pos + 2, 0, pango_layout);
254 }
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 }
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;
279 g_return_if_fail (ruler != NULL);
280 g_return_if_fail (SP_IS_HRULER (ruler));
282 if (GTK_WIDGET_DRAWABLE (ruler))
283 {
284 widget = GTK_WIDGET (ruler);
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;
292 bs_width = height / 2;
293 bs_width |= 1; /* make sure it's odd */
294 bs_height = bs_width / 2 + 1;
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);
307 increment = (gfloat) width / (ruler->upper - ruler->lower);
309 x = ROUND ((ruler->position - ruler->lower) * increment) + (xthickness - bs_width) / 2 - 1;
310 y = (height + bs_height) / 2 + ythickness;
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);
318 ruler->xsrc = x;
319 ruler->ysrc = y;
320 }
321 }
322 }
328 // vruler
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);
338 GtkType
339 sp_vruler_get_type (void)
340 {
341 static GtkType vruler_type = 0;
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 };
357 vruler_type = gtk_type_unique (gtk_ruler_get_type (), &vruler_info);
358 }
360 return vruler_type;
361 }
363 static void
364 sp_vruler_class_init (SPVRulerClass *klass)
365 {
366 GtkWidgetClass *widget_class;
367 GtkRulerClass *ruler_class;
369 widget_class = (GtkWidgetClass*) klass;
370 ruler_class = (GtkRulerClass*) klass;
372 widget_class->motion_notify_event = sp_vruler_motion_notify;
374 ruler_class->draw_ticks = sp_vruler_draw_ticks;
375 ruler_class->draw_pos = sp_vruler_draw_pos;
376 }
378 static void
379 sp_vruler_init (SPVRuler *vruler)
380 {
381 GtkWidget *widget;
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 }
388 GtkWidget*
389 sp_vruler_new (void)
390 {
391 return GTK_WIDGET (gtk_type_new (sp_vruler_get_type ()));
392 }
395 static gint
396 sp_vruler_motion_notify (GtkWidget *widget,
397 GdkEventMotion *event)
398 {
399 GtkRuler *ruler;
400 gint y;
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);
406 ruler = GTK_RULER (widget);
408 y = (int)event->y;
410 ruler->position = ruler->lower + ((ruler->upper - ruler->lower) * y) / widget->allocation.height;
412 /* Make sure the ruler has been allocated already */
413 if (ruler->backing_store != NULL)
414 gtk_ruler_draw_pos (ruler);
416 return FALSE;
417 }
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;
443 g_return_if_fail (ruler != NULL);
444 g_return_if_fail (SP_IS_VRULER (ruler));
446 if (!GTK_WIDGET_DRAWABLE (ruler))
447 return;
449 widget = GTK_WIDGET (ruler);
451 gc = widget->style->fg_gc[GTK_STATE_NORMAL];
452 bg_gc = widget->style->bg_gc[GTK_STATE_NORMAL];
454 pango_desc = widget->style->font_desc;
456 // Create the pango layout
457 pango_context = gtk_widget_get_pango_context (widget);
459 pango_layout = pango_layout_new (pango_context);
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);
466 digit_height = (int) floor (RULER_FONT_SIZE * RULER_FONT_VERTICAL_SPACING / PANGO_SCALE + 0.5);
468 xthickness = widget->style->xthickness;
469 ythickness = widget->style->ythickness;
471 width = widget->allocation.height;
472 height = widget->allocation.width;// - ythickness * 2;
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);
480 upper = ruler->upper / ruler->metric->pixels_per_unit;
481 lower = ruler->lower / ruler->metric->pixels_per_unit;
483 if ((upper - lower) == 0)
484 return;
485 increment = (double) width / (upper - lower);
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;
497 for (scale = 0; scale < MAXIMUM_SCALES; scale++)
498 if (ruler->metric->ruler_scale[scale] * fabs(increment) > 2 * text_height)
499 break;
501 if (scale == MAXIMUM_SCALES)
502 scale = MAXIMUM_SCALES - 1;
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;
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;
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 }
530 tick_index = 0;
531 cur = start;
533 while (cur < end) {
534 pos = ROUND ((cur - lower) * increment);
536 gdk_draw_line (ruler->backing_store, gc,
537 height + xthickness - length, pos,
538 height + xthickness, pos);
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];
554 pango_layout_set_text (pango_layout, digit_str, 1);
556 gdk_draw_layout (ruler->backing_store, gc,
557 xthickness + 1,
558 pos + digit_height * (j) + 1,
559 pango_layout);
560 }
561 }
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 }
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;
586 g_return_if_fail (ruler != NULL);
587 g_return_if_fail (SP_IS_VRULER (ruler));
589 if (GTK_WIDGET_DRAWABLE (ruler))
590 {
591 widget = GTK_WIDGET (ruler);
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;
599 bs_height = width / 2;
600 bs_height |= 1; /* make sure it's odd */
601 bs_width = bs_height / 2 + 1;
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);
614 increment = (gfloat) height / (ruler->upper - ruler->lower);
616 x = (width + bs_width) / 2 + xthickness;
617 y = ROUND ((ruler->position - ruler->lower) * increment) + (ythickness - bs_height) / 2 - 1;
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);
624 ruler->xsrc = x;
625 ruler->ysrc = y;
626 }
627 }
628 }
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 };
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));
650 if (metric == 0)
651 return;
653 ruler->metric = const_cast<GtkRulerMetric *>(&sp_ruler_metrics[metric]);
655 if (GTK_WIDGET_DRAWABLE (ruler))
656 gtk_widget_queue_draw (GTK_WIDGET (ruler));
657 }