• Skip to content
  • Skip to link menu
Trinity API Reference
  • Trinity API Reference
  • tdeui
 

tdeui

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

tdeui

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

tdeui

Skip menu "tdeui"
  • arts
  • dcop
  • dnssd
  • interfaces
  •   kspeech
  •     interface
  •     library
  •   tdetexteditor
  • kate
  • kded
  • kdoctools
  • kimgio
  • kjs
  • libtdemid
  • libtdescreensaver
  •     tdecore
  • tdeabc
  • tdecmshell
  • tdecore
  • tdefx
  • tdehtml
  • tdeinit
  • tdeio
  •   bookmarks
  •   httpfilter
  •   kpasswdserver
  •   kssl
  • tdeioslave
  •   http
  •   tdefile
  •   tdeio
  •   tdeioexec
  • tdemdi
  •   tdemdi
  • tdenewstuff
  • tdeparts
  • tdeprint
  • tderandr
  • tderesources
  • tdespell2
  • tdesu
  • tdeui
  • tdeunittest
  • tdeutils
  • tdewallet
Generated for tdeui by doxygen 1.8.8
This website is maintained by Timothy Pearson.