• Skip to content
  • Skip to link menu
KDE API Reference
  • KDE API Reference
  • kdelibs API Reference
  • KDE Home
  • Contact Us
 

KDEUI

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

KDE's Doxygen guidelines are available online.

KDEUI

Skip menu "KDEUI"
  • Main Page
  • Namespace List
  • Namespace Members
  • Alphabetical List
  • Class List
  • Class Hierarchy
  • Class Members
  • File List
  • File Members
  • Modules
  • Related Pages

kdelibs API Reference

Skip menu "kdelibs API Reference"
  • DNSSD
  • Interfaces
  •   KHexEdit
  •   KMediaPlayer
  •   KSpeech
  •   KTextEditor
  • kconf_update
  • KDE3Support
  •   KUnitTest
  • KDECore
  • KDED
  • KDEsu
  • KDEUI
  • KDEWebKit
  • KDocTools
  • KFile
  • KHTML
  • KImgIO
  • KInit
  • kio
  • KIOSlave
  • KJS
  •   KJS-API
  • kjsembed
  •   WTF
  • KNewStuff
  • KParts
  • KPty
  • Kross
  • KUnitConversion
  • KUtils
  • Nepomuk
  • Nepomuk-Core
  • Nepomuk
  • Plasma
  • Solid
  • Sonnet
  • ThreadWeaver

Search



Report problems with this website to our bug tracking system.
Contact the specific authors with questions and comments about the page contents.

KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal