← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/kde4libs/gutsy

« back to all changes in this revision

Viewing changes to kdeui/widgets/kruler.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Jonathan Riddell
  • Date: 2007-02-21 11:00:12 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20070221110012-6kw8khr9knv6lmg1
Tags: 3.80.3-0ubuntu1
New upstream unstable release

Show diffs side-by-side

added added

removed removed

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