KWidgetsAddons

kruler.cpp
1 /*
2  This file is part of the KDE libraries
3  SPDX-FileCopyrightText: 1998 Jörg Habenicht <[email protected]>
4 
5  SPDX-License-Identifier: LGPL-2.0-or-later
6 */
7 
8 #include "kruler.h"
9 
10 #include <QFont>
11 #include <QPolygon>
12 #include <QStylePainter>
13 
14 #define INIT_VALUE 0
15 #define INIT_MIN_VALUE 0
16 #define INIT_MAX_VALUE 100
17 #define INIT_TINY_MARK_DISTANCE 1
18 #define INIT_LITTLE_MARK_DISTANCE 5
19 #define INIT_MIDDLE_MARK_DISTANCE (INIT_LITTLE_MARK_DISTANCE * 2)
20 #define INIT_BIG_MARK_DISTANCE (INIT_LITTLE_MARK_DISTANCE * 10)
21 #define INIT_SHOW_TINY_MARK false
22 #define INIT_SHOW_LITTLE_MARK true
23 #define INIT_SHOW_MEDIUM_MARK true
24 #define INIT_SHOW_BIG_MARK true
25 #define INIT_SHOW_END_MARK true
26 #define INIT_SHOW_POINTER true
27 #define INIT_SHOW_END_LABEL true
28 
29 #define INIT_PIXEL_PER_MARK (double)10.0 /* distance between 2 base marks in pixel */
30 #define INIT_OFFSET (-20)
31 #define INIT_LENGTH_FIX true
32 #define INIT_END_OFFSET 0
33 
34 #define FIX_WIDTH 20 /* widget width in pixel */
35 #define LINE_END (FIX_WIDTH - 3)
36 #define END_MARK_LENGTH (FIX_WIDTH - 6)
37 #define END_MARK_X2 LINE_END
38 #define END_MARK_X1 (END_MARK_X2 - END_MARK_LENGTH)
39 #define BIG_MARK_LENGTH (END_MARK_LENGTH*3/4)
40 #define BIG_MARK_X2 LINE_END
41 #define BIG_MARK_X1 (BIG_MARK_X2 - BIG_MARK_LENGTH)
42 #define MIDDLE_MARK_LENGTH (END_MARK_LENGTH/2)
43 #define MIDDLE_MARK_X2 LINE_END
44 #define MIDDLE_MARK_X1 (MIDDLE_MARK_X2 - MIDDLE_MARK_LENGTH)
45 #define LITTLE_MARK_LENGTH (MIDDLE_MARK_LENGTH/2)
46 #define LITTLE_MARK_X2 LINE_END
47 #define LITTLE_MARK_X1 (LITTLE_MARK_X2 - LITTLE_MARK_LENGTH)
48 #define BASE_MARK_LENGTH (LITTLE_MARK_LENGTH/2)
49 #define BASE_MARK_X2 LINE_END
50 #define BASE_MARK_X1 (BASE_MARK_X2 - BASE_MARK_LENGTH)
51 
52 #define LABEL_SIZE 8
53 #define END_LABEL_X 4
54 #define END_LABEL_Y (END_LABEL_X + LABEL_SIZE - 2)
55 
56 #undef PROFILING
57 
58 #ifdef PROFILING
59 # include <qdatetime.h>
60 #endif
61 
62 class Q_DECL_HIDDEN KRuler::KRulerPrivate
63 {
64 public:
65  int endOffset_length; /* marks the offset at the end of the ruler
66  * i.e. right side at horizontal and down side
67  * at vertical rulers.
68  * the ruler end mark is moved endOffset_length
69  * ticks away from the widget end.
70  * positive offset moves end mark inside the ruler.
71  * if lengthFix is true, endOffset_length holds the
72  * length of the ruler.
73  */
74  int fontWidth; // ONLY valid for vertical rulers
75 
76  QAbstractSlider range;
78  int tmDist;
79  int lmDist;
80  int mmDist;
81  int bmDist;
82  int offset;
83  bool showtm : 1; /* show tiny, little, medium, big, endmarks */
84  bool showlm : 1;
85  bool showmm : 1;
86  bool showbm : 1;
87  bool showem : 1;
88 
89  bool showpointer : 1;
90  bool showEndL : 1;
91  bool lengthFix : 1;
92 
93  double ppm; /* pixel per mark */
94 
95  QString endlabel;
96 };
97 
99  : QAbstractSlider(parent)
100  , d(new KRulerPrivate)
101 {
102  setRange(INIT_MIN_VALUE, INIT_MAX_VALUE);
103  setPageStep(10);
104  setValue(INIT_VALUE);
105  initWidget(Qt::Horizontal);
106  setFixedHeight(FIX_WIDTH);
107 }
108 
111  : QAbstractSlider(parent)
112  , d(new KRulerPrivate)
113 {
114  setRange(INIT_MIN_VALUE, INIT_MAX_VALUE);
115  setPageStep(10);
116  setValue(INIT_VALUE);
117  setWindowFlags(f);
118  initWidget(orient);
119  if (orient == Qt::Horizontal) {
120  setFixedHeight(FIX_WIDTH);
121  } else {
122  setFixedWidth(FIX_WIDTH);
123  }
124 }
125 
126 KRuler::KRuler(Qt::Orientation orient, int widgetWidth,
128  : QAbstractSlider(parent)
129  , d(new KRulerPrivate)
130 {
131  setRange(INIT_MIN_VALUE, INIT_MAX_VALUE);
132  setPageStep(10);
133  setValue(INIT_VALUE);
134  setWindowFlags(f);
135  initWidget(orient);
136  if (orient == Qt::Horizontal) {
137  setFixedHeight(widgetWidth);
138  } else {
139  setFixedWidth(widgetWidth);
140  }
141 }
142 
143 void KRuler::initWidget(Qt::Orientation orientation)
144 {
145  d->showpointer = INIT_SHOW_POINTER;
146  d->showEndL = INIT_SHOW_END_LABEL;
147  d->lengthFix = INIT_LENGTH_FIX;
148  d->endOffset_length = INIT_END_OFFSET;
149 
150  d->tmDist = INIT_TINY_MARK_DISTANCE;
151  d->lmDist = INIT_LITTLE_MARK_DISTANCE;
152  d->mmDist = INIT_MIDDLE_MARK_DISTANCE;
153  d->bmDist = INIT_BIG_MARK_DISTANCE;
154  d->offset = INIT_OFFSET;
155  d->showtm = INIT_SHOW_TINY_MARK;
156  d->showlm = INIT_SHOW_LITTLE_MARK;
157  d->showmm = INIT_SHOW_MEDIUM_MARK;
158  d->showbm = INIT_SHOW_BIG_MARK;
159  d->showem = INIT_SHOW_END_MARK;
160  d->ppm = INIT_PIXEL_PER_MARK;
161  d->dir = orientation;
162 }
163 
165 {
166  delete d;
167 }
168 
169 #if KWIDGETSADDONS_BUILD_DEPRECATED_SINCE(5, 0)
170 void
172 {
173  setMinimum(value);
174 }
175 #endif
176 
177 #if KWIDGETSADDONS_BUILD_DEPRECATED_SINCE(5, 0)
178 int
180 {
181  return minimum();
182 }
183 #endif
184 
185 #if KWIDGETSADDONS_BUILD_DEPRECATED_SINCE(5, 0)
186 void
188 {
189  setMaximum(value);
190 }
191 #endif
192 
193 #if KWIDGETSADDONS_BUILD_DEPRECATED_SINCE(5, 0)
194 int
196 {
197  return maximum();
198 }
199 #endif
200 
201 void
203 {
204  if (dist != d->tmDist) {
205  d->tmDist = dist;
206  update(contentsRect());
207  }
208 }
209 
210 int
212 {
213  return d->tmDist;
214 }
215 
216 void
218 {
219  if (dist != d->lmDist) {
220  d->lmDist = dist;
221  update(contentsRect());
222  }
223 }
224 
225 int
227 {
228  return d->lmDist;
229 }
230 
231 void
233 {
234  if (dist != d->mmDist) {
235  d->mmDist = dist;
236  update(contentsRect());
237  }
238 }
239 
240 int
241 KRuler::mediumMarkDistance() const
242 {
243  return d->mmDist;
244 }
245 
246 void
248 {
249  if (dist != d->bmDist) {
250  d->bmDist = dist;
251  update(contentsRect());
252  }
253 }
254 
255 int
257 {
258  return d->bmDist;
259 }
260 
261 void
263 {
264  if (show != d->showtm) {
265  d->showtm = show;
266  update(contentsRect());
267  }
268 }
269 
270 bool
271 KRuler::showTinyMarks() const
272 {
273  return d->showtm;
274 }
275 
276 void
278 {
279  if (show != d->showlm) {
280  d->showlm = show;
281  update(contentsRect());
282  }
283 }
284 
285 bool
286 KRuler::showLittleMarks() const
287 {
288  return d->showlm;
289 }
290 
291 void
293 {
294  if (show != d->showmm) {
295  d->showmm = show;
296  update(contentsRect());
297  }
298 }
299 
300 bool
301 KRuler::showMediumMarks() const
302 {
303  return d->showmm;
304 }
305 
306 void
308 {
309  if (show != d->showbm) {
310  d->showbm = show;
311  update(contentsRect());
312  }
313 }
314 
315 bool
316 KRuler::showBigMarks() const
317 {
318  return d->showbm;
319 }
320 
321 void
323 {
324  if (show != d->showem) {
325  d->showem = show;
326  update(contentsRect());
327  }
328 }
329 
330 bool
331 KRuler::showEndMarks() const
332 {
333  return d->showem;
334 }
335 
336 void
338 {
339  if (show != d->showpointer) {
340  d->showpointer = show;
341  update(contentsRect());
342  }
343 }
344 
345 bool
346 KRuler::showPointer() const
347 {
348  return d->showpointer;
349 }
350 
351 #if KWIDGETSADDONS_BUILD_DEPRECATED_SINCE(5, 0)
352 void
354 {
355 }
356 #endif
357 
358 void
360 {
361  if (d->showEndL != show) {
362  d->showEndL = show;
363  update(contentsRect());
364  }
365 }
366 
367 bool
368 KRuler::showEndLabel() const
369 {
370  return d->showEndL;
371 }
372 
373 void
375 {
376  d->endlabel = label;
377 
378  // premeasure the fontwidth and save it
379  if (d->dir == Qt::Vertical) {
380  QFont font = this->font();
381  font.setPointSize(LABEL_SIZE);
382  QFontMetrics fm(font);
383  d->fontWidth = fm.horizontalAdvance(d->endlabel);
384  }
385  update(contentsRect());
386 }
387 
388 QString KRuler::endLabel() const
389 {
390  return d->endlabel;
391 }
392 
393 void
395 {
396  switch (style) {
397  default: /* fall through */
398  case Custom:
399  return;
400  case Pixel:
403  setBigMarkDistance(10);
404 
405  setShowTinyMarks(false);
406  setShowLittleMarks(true);
407  setShowMediumMarks(true);
408  setShowBigMarks(true);
409  setShowEndMarks(true);
410 
411  update(contentsRect());
412  setPixelPerMark(10.0);
413 
414  break;
415  case Inch:
420 
421  setShowTinyMarks(true);
422  setShowLittleMarks(true);
423  setShowMediumMarks(true);
424  setShowBigMarks(true);
425  setShowEndMarks(true);
426 
427  update(contentsRect());
428  setPixelPerMark(9.0);
429 
430  break;
431  case Millimetres: /* fall through */
432  case Centimetres: /* fall through */
433  case Metres:
436  setBigMarkDistance(10);
437 
438  setShowTinyMarks(false);
439  setShowLittleMarks(true);
440  setShowMediumMarks(true);
441  setShowBigMarks(true);
442  setShowEndMarks(true);
443 
444  update(contentsRect());
445  setPixelPerMark(3.0);
446  }
447  switch (style) {
448  case Pixel:
449  setEndLabel(QStringLiteral("pixel"));
450  break;
451  case Inch:
452  setEndLabel(QStringLiteral("inch"));
453  break;
454  case Millimetres:
455  setEndLabel(QStringLiteral("mm"));
456  break;
457  case Centimetres:
458  setEndLabel(QStringLiteral("cm"));
459  break;
460  case Metres:
461  setEndLabel(QStringLiteral("m"));
462  default: /* never reached, see above switch */
463  /* empty command */;
464  }
465  // if the style changes one of the values,
466  // update would have been called inside the methods
467  // -> no update() call needed here !
468 }
469 
470 void
472 {
473  // never compare floats against each other :)
474  d->ppm = rate;
475  update(contentsRect());
476 }
477 
478 double
479 KRuler::pixelPerMark() const
480 {
481  return d->ppm;
482 }
483 
484 void
485 KRuler::setLength(int length)
486 {
487  int tmp;
488  if (d->lengthFix) {
489  tmp = length;
490  } else {
491  tmp = width() - length;
492  }
493  if (tmp != d->endOffset_length) {
494  d->endOffset_length = tmp;
495  update(contentsRect());
496  }
497 }
498 
499 int
500 KRuler::length() const
501 {
502  if (d->lengthFix) {
503  return d->endOffset_length;
504  }
505  return (width() - d->endOffset_length);
506 }
507 
508 void
510 {
511  d->lengthFix = fix;
512 }
513 
514 bool
515 KRuler::lengthFixed() const
516 {
517  return d->lengthFix;
518 }
519 
520 void
521 KRuler::setOffset(int _offset)
522 {
523  // debug("set offset %i", _offset);
524  if (d->offset != _offset) {
525  d->offset = _offset;
526  update(contentsRect());
527  }
528 }
529 
530 int
531 KRuler::offset() const
532 {
533  return d->offset;
534 }
535 
536 int
537 KRuler::endOffset() const
538 {
539  if (d->lengthFix) {
540  return (width() - d->endOffset_length);
541  }
542  return d->endOffset_length;
543 }
544 
545 void
546 KRuler::slideUp(int count)
547 {
548  if (count) {
549  d->offset += count;
550  update(contentsRect());
551  }
552 }
553 
554 void
556 {
557  if (count) {
558  d->offset -= count;
559  update(contentsRect());
560  }
561 }
562 
563 void
565 {
566  int oldvalue = value();
567  if (oldvalue == _value) {
568  return;
569  }
570  // setValue(_value);
571  setValue(_value);
572  if (value() == oldvalue) {
573  return;
574  }
575  // get the rectangular of the old and the new ruler pointer
576  // and repaint only him
577  if (d->dir == Qt::Horizontal) {
578  QRect oldrec(-5 + oldvalue, 10, 11, 6);
579  QRect newrec(-5 + _value, 10, 11, 6);
580  repaint(oldrec.united(newrec));
581  } else {
582  QRect oldrec(10, -5 + oldvalue, 6, 11);
583  QRect newrec(10, -5 + _value, 6, 11);
584  repaint(oldrec.united(newrec));
585  }
586 }
587 
588 void
590 {
591  if (d->offset != _offset) {
592  //setOffset(_offset);
593  d->offset = _offset;
595  }
596 }
597 
598 void
599 KRuler::slotEndOffset(int offset)
600 {
601  int tmp;
602  if (d->lengthFix) {
603  tmp = width() - offset;
604  } else {
605  tmp = offset;
606  }
607  if (d->endOffset_length != tmp) {
608  d->endOffset_length = tmp;
610  }
611 }
612 
613 void
614 KRuler::paintEvent(QPaintEvent * /*e*/)
615 {
616  // debug ("KRuler::drawContents, %s",(horizontal==dir)?"horizontal":"vertical");
617 
618  QStylePainter p(this);
619 #ifdef PROFILING
620  QTime time;
621  time.start();
622  for (int profile = 0; profile < 10; profile++) {
623 #endif
624 
625  int value = this->value(),
626  minval = minimum(),
627  maxval;
628  if (d->dir == Qt::Horizontal) {
629  maxval = maximum()
630  + d->offset
631  - (d->lengthFix ? (height() - d->endOffset_length) : d->endOffset_length);
632  } else {
633  maxval = maximum()
634  + d->offset
635  - (d->lengthFix ? (width() - d->endOffset_length) : d->endOffset_length);
636  }
637  //ioffsetval = value-offset;
638  // pixelpm = (int)ppm;
639  // left = clip.left(),
640  // right = clip.right();
641  double f, fend,
642  offsetmin = (double)(minval - d->offset),
643  offsetmax = (double)(maxval - d->offset),
644  fontOffset = (((double)minval) > offsetmin) ? (double)minval : offsetmin;
645 
646  // draw labels
647  QFont font = p.font();
648  font.setPointSize(LABEL_SIZE);
649  p.setFont(font);
650  // draw littlemarklabel
651 
652  // draw mediummarklabel
653 
654  // draw bigmarklabel
655 
656  // draw endlabel
657  if (d->showEndL) {
658  if (d->dir == Qt::Horizontal) {
659  p.translate(fontOffset, 0);
660  p.drawText(END_LABEL_X, END_LABEL_Y, d->endlabel);
661  } else { // rotate text +pi/2 and move down a bit
662  //QFontMetrics fm(font);
663 #ifdef KRULER_ROTATE_TEST
664  p.rotate(-90.0 + rotate);
665  p.translate(-8.0 - fontOffset - d->fontWidth + xtrans,
666  ytrans);
667 #else
668  p.rotate(-90.0);
669  p.translate(-8.0 - fontOffset - d->fontWidth, 0.0);
670 #endif
671  p.drawText(END_LABEL_X, END_LABEL_Y, d->endlabel);
672  }
673  p.resetTransform();
674  }
675 
676  // draw the tiny marks
677  if (d->showtm) {
678  fend = d->ppm * d->tmDist;
679  for (f = offsetmin; f < offsetmax; f += fend) {
680  if (d->dir == Qt::Horizontal) {
681  p.drawLine((int)f, BASE_MARK_X1, (int)f, BASE_MARK_X2);
682  } else {
683  p.drawLine(BASE_MARK_X1, (int)f, BASE_MARK_X2, (int)f);
684  }
685  }
686  }
687  if (d->showlm) {
688  // draw the little marks
689  fend = d->ppm * d->lmDist;
690  for (f = offsetmin; f < offsetmax; f += fend) {
691  if (d->dir == Qt::Horizontal) {
692  p.drawLine((int)f, LITTLE_MARK_X1, (int)f, LITTLE_MARK_X2);
693  } else {
694  p.drawLine(LITTLE_MARK_X1, (int)f, LITTLE_MARK_X2, (int)f);
695  }
696  }
697  }
698  if (d->showmm) {
699  // draw medium marks
700  fend = d->ppm * d->mmDist;
701  for (f = offsetmin; f < offsetmax; f += fend) {
702  if (d->dir == Qt::Horizontal) {
703  p.drawLine((int)f, MIDDLE_MARK_X1, (int)f, MIDDLE_MARK_X2);
704  } else {
705  p.drawLine(MIDDLE_MARK_X1, (int)f, MIDDLE_MARK_X2, (int)f);
706  }
707  }
708  }
709  if (d->showbm) {
710  // draw big marks
711  fend = d->ppm * d->bmDist;
712  for (f = offsetmin; f < offsetmax; f += fend) {
713  if (d->dir == Qt::Horizontal) {
714  p.drawLine((int)f, BIG_MARK_X1, (int)f, BIG_MARK_X2);
715  } else {
716  p.drawLine(BIG_MARK_X1, (int)f, BIG_MARK_X2, (int)f);
717  }
718  }
719  }
720  if (d->showem) {
721  // draw end marks
722  if (d->dir == Qt::Horizontal) {
723  p.drawLine(minval - d->offset, END_MARK_X1, minval - d->offset, END_MARK_X2);
724  p.drawLine(maxval - d->offset, END_MARK_X1, maxval - d->offset, END_MARK_X2);
725  } else {
726  p.drawLine(END_MARK_X1, minval - d->offset, END_MARK_X2, minval - d->offset);
727  p.drawLine(END_MARK_X1, maxval - d->offset, END_MARK_X2, maxval - d->offset);
728  }
729  }
730 
731  // draw pointer
732  if (d->showpointer) {
733  QPolygon pa(4);
734  if (d->dir == Qt::Horizontal) {
735  pa.setPoints(3, value - 5, 10, value + 5, 10, value/*+0*/, 15);
736  } else {
737  pa.setPoints(3, 10, value - 5, 10, value + 5, 15, value/*+0*/);
738  }
739  p.setBrush(p.background().color());
740  p.drawPolygon(pa);
741  }
742 
743 #ifdef PROFILING
744  }
745  int elapsed = time.elapsed();
746  debug("paint time %i", elapsed);
747 #endif
748 
749 }
750 
int maxValue() const
Returns the maximal value of the ruler pointer.
Definition: kruler.cpp:195
void slotNewOffset(int)
Sets the ruler marks to a new position.
Definition: kruler.cpp:589
void setPointSize(int pointSize)
double pixelPerMark() const
Returns the number of pixels between two base marks.
int tinyMarkDistance() const
Returns the distance between tiny marks.
const QBrush & background() const const
int littleMarkDistance() const
Returns the distance between little marks.
void setFixedWidth(int w)
void setRange(int min, int max)
QRect contentsRect() const const
const QFont & font() const const
void setShowEndLabel(bool)
Show/hide number values of the end marks.
Definition: kruler.cpp:359
QStyle * style() const const
void setShowTinyMarks(bool)
Shows/hides tiny marks.
Definition: kruler.cpp:262
void setMaxValue(int)
Sets the maximum value of the ruler pointer (default is 100).
Definition: kruler.cpp:187
void drawPolygon(const QPointF *points, int pointCount, Qt::FillRule fillRule)
void setPageStep(int)
void rotate(qreal angle)
void drawLine(const QLineF &line)
void update()
int width() const const
const QColor & color() const const
void resetTransform()
void setShowEndMarks(bool)
Shows/hides end marks.
Definition: kruler.cpp:322
void setFont(const QFont &font)
int elapsed() const const
void setLengthFixed(bool fix)
Locks the length of the ruler, i.e.
Definition: kruler.cpp:509
Qt::Orientation orientation() const const
~KRuler()
Destructor.
Definition: kruler.cpp:164
void setPixelPerMark(double rate)
Sets the number of pixels between two base marks.
Definition: kruler.cpp:471
A ruler widget.
Definition: kruler.h:52
void setBrush(const QBrush &brush)
void drawText(const QPointF &position, const QString &text)
void setMinimum(int)
int bigMarkDistance() const
Returns the distance between big marks.
void slotNewValue(int)
Sets the pointer to a new position.
Definition: kruler.cpp:564
int minValue() const
Returns the minimal value of the ruler pointer.
Definition: kruler.cpp:179
const QFont & font() const const
void setValue(int)
void setTinyMarkDistance(int)
Sets the distance between tiny marks.
Definition: kruler.cpp:202
KRuler(QWidget *parent=nullptr)
Constructs a horizontal ruler.
Definition: kruler.cpp:98
void setMediumMarkDistance(int)
Sets the distance between medium marks.
Definition: kruler.cpp:232
int horizontalAdvance(const QString &text, int len) const const
void setMinValue(int)
Sets the minimal value of the ruler pointer (default is 0).
Definition: kruler.cpp:171
void repaint()
void setWindowFlags(Qt::WindowFlags type)
void setLength(int)
Sets the length of the ruler, i.e.
Definition: kruler.cpp:485
void setBigMarkDistance(int)
Sets distance between big marks.
Definition: kruler.cpp:247
KIOFILEWIDGETS_EXPORT QString dir(const QString &fileClass)
void setShowLittleMarks(bool)
Shows/hides little marks.
Definition: kruler.cpp:277
void setFixedHeight(int h)
int offset() const
Returns the current ruler offset.
void slideDown(int count=1)
Sets the number of pixels by which the ruler may slide down or right.
Definition: kruler.cpp:555
void translate(const QPointF &offset)
void setFrameStyle(int)
Is a no-op.
Definition: kruler.cpp:353
void start()
void show()
Orientation
void setPoints(int nPoints, const int *points)
void setRulerMetricStyle(KRuler::MetricStyle)
Sets up the necessary tasks for the provided styles.
Definition: kruler.cpp:394
void setShowBigMarks(bool)
Shows/hides big marks.
Definition: kruler.cpp:307
void setLittleMarkDistance(int)
Sets the distance between little marks.
Definition: kruler.cpp:217
void slideUp(int count=1)
Sets the number of pixels by which the ruler may slide up or left.
Definition: kruler.cpp:546
void setMaximum(int)
QObject * parent() const const
void setShowPointer(bool)
Shows/hides the pointer.
Definition: kruler.cpp:337
void setOffset(int offset)
Sets the ruler slide offset.
Definition: kruler.cpp:521
QRect united(const QRect &rectangle) const const
typedef WindowFlags
MetricStyle
The types of units used.
Definition: kruler.h:76
int height() const const
void setShowMediumMarks(bool)
Shows/hides medium marks.
Definition: kruler.cpp:292
void setEndLabel(const QString &)
Sets the label this is drawn at the beginning of the visible part of the ruler to label...
Definition: kruler.cpp:374
This file is part of the KDE documentation.
Documentation copyright © 1996-2020 The KDE developers.
Generated on Fri Aug 7 2020 22:42:22 by doxygen 1.8.11 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.