kdeui Library API Documentation

kruler.cpp

00001 /* This file is part of the KDE libraries
00002     Copyright (C) 1998 Jörg Habenicht (j.habenicht@europemail.com)
00003 
00004     This library is free software; you can redistribute it and/or
00005     modify it under the terms of the GNU Library General Public
00006     License as published by the Free Software Foundation; either
00007     version 2 of the License, or (at your option) any later version.
00008 
00009     This library is distributed in the hope that it will be useful,
00010     but WITHOUT ANY WARRANTY; without even the implied warranty of
00011     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00012     Library General Public License for more details.
00013 
00014     You should have received a copy of the GNU Library General Public License
00015     along with this library; see the file COPYING.LIB.  If not, write to
00016     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
00017     Boston, MA 02111-1307, USA.
00018 */
00019 
00020 /*************************************************************************
00021  * $Id: kruler.cpp,v 1.17 2002/08/21 03:08:05 orlovich Exp $
00022  *
00023  * $Log: kruler.cpp,v $
00024  * Revision 1.17  2002/08/21 03:08:05  orlovich
00025  *
00026  * Cleanup:
00027  * 1. Don't read unitialized variables all over the place
00028  * 2. Make tiny mark distance setting actually matter.
00029  * 3. Remove dead code that did nothing other than read uninitialized variables and write out
00030  * somoe other ones noone actually used -- mark 3 methods with no effect as deprecated.
00031  *
00032  * Revision 1.16  2002/03/04 00:51:51  lunakl
00033  * Keep BC changes (the patch is almost 100KiB of boring stuff
00034  * ... anybody willing to review? ;) ).
00035  *
00036  * Revision 1.15  2000/11/29 11:52:59  mlaurent
00037  * Fix draw marker when kruler is horizontal
00038  *
00039  * Revision 1.14  2000/09/12 17:48:02  mueller
00040  * avoid compiler warning
00041  *
00042  * Revision 1.13  2000/06/05 21:31:45  gehrmab
00043  * QFrame's 4th argument is no more
00044  *
00045  * Revision 1.12  2000/06/03 23:09:02  gehrmab
00046  * Completely redesigned KRuler's API
00047  *
00048  * Revision 1.11  2000/04/15 16:16:56  habenich
00049  * fixed bug with disappearing vertical text
00050  * enabled offset drawing of begin and end marks
00051  * implemented fixed ruler width when resizing widget
00052  * implemented on/off switch for ruler pointer
00053  * ruler label moves with beginning of ruler
00054  *
00055  * Revision 1.10  2000/01/17 19:07:59  bieker
00056  * Made it more QT_NO_CAST_ASCII and QT_NO_ASCII_CAST safe (this is not 100 %
00057  * yet).
00058  *
00059  * Revision 1.9  1999/05/10 12:59:04  kulow
00060  * applied 90% of Hans's patch and tried to fix other stuff. Some classes
00061  * (KAccel is a good example - libkab is even worse) mix string types so
00062  * dramacticly, that I bet 70% of the runtime is spent in string conversion ;(
00063  *
00064  * Revision 1.8  1999/03/01 23:35:08  kulow
00065  * CVS_SILENT ported to Qt 2.0
00066  *
00067  * Revision 1.7  1999/02/19 08:52:45  habenich
00068  * ID und LOG tags included
00069  *
00070  *
00071  *************************************************************************/
00072 
00073 #include "kruler.h"
00074 
00075 #include <qpainter.h>
00076 #include <qfont.h>
00077 
00078 #define INIT_VALUE 0
00079 #define INIT_MIN_VALUE 0
00080 #define INIT_MAX_VALUE 100
00081 #define INIT_TINY_MARK_DISTANCE 1
00082 #define INIT_LITTLE_MARK_DISTANCE 5
00083 #define INIT_MIDDLE_MARK_DISTANCE (INIT_LITTLE_MARK_DISTANCE * 2)
00084 #define INIT_BIG_MARK_DISTANCE (INIT_LITTLE_MARK_DISTANCE * 10)
00085 #define INIT_SHOW_TINY_MARK false
00086 #define INIT_SHOW_LITTLE_MARK true
00087 #define INIT_SHOW_MEDIUM_MARK true
00088 #define INIT_SHOW_BIG_MARK true
00089 #define INIT_SHOW_END_MARK true
00090 #define INIT_SHOW_POINTER true
00091 #define INIT_SHOW_END_LABEL true
00092 
00093 #define INIT_PIXEL_PER_MARK (double)10.0 /* distance between 2 base marks in pixel */
00094 #define INIT_OFFSET (-20)
00095 #define INIT_LENGTH_FIX true
00096 #define INIT_END_OFFSET 0
00097 
00098 #define FIX_WIDTH 20 /* widget width in pixel */
00099 #define LINE_END (FIX_WIDTH - 3)
00100 #define END_MARK_LENGTH (FIX_WIDTH - 6)
00101 #define END_MARK_X2 LINE_END
00102 #define END_MARK_X1 (END_MARK_X2 - END_MARK_LENGTH)
00103 #define BIG_MARK_LENGTH (END_MARK_LENGTH*3/4)
00104 #define BIG_MARK_X2 LINE_END
00105 #define BIG_MARK_X1 (BIG_MARK_X2 - BIG_MARK_LENGTH)
00106 #define MIDDLE_MARK_LENGTH (END_MARK_LENGTH/2)
00107 #define MIDDLE_MARK_X2 LINE_END
00108 #define MIDDLE_MARK_X1 (MIDDLE_MARK_X2 - MIDDLE_MARK_LENGTH)
00109 #define LITTLE_MARK_LENGTH (MIDDLE_MARK_LENGTH/2)
00110 #define LITTLE_MARK_X2 LINE_END
00111 #define LITTLE_MARK_X1 (LITTLE_MARK_X2 - LITTLE_MARK_LENGTH)
00112 #define BASE_MARK_LENGTH (LITTLE_MARK_LENGTH/2)
00113 #define BASE_MARK_X2 LINE_END
00114 #define BASE_MARK_X1 (BASE_MARK_X2 - BASE_MARK_LENGTH)
00115 
00116 #define LABEL_SIZE 8
00117 #define END_LABEL_X 4
00118 #define END_LABEL_Y (END_LABEL_X + LABEL_SIZE - 2)
00119 
00120 #undef PROFILING
00121 
00122 #ifdef PROFILING
00123 # include <qdatetime.h>
00124 #endif
00125 
00126 class KRuler::KRulerPrivate
00127 {
00128 public:
00129   bool showpointer;
00130   bool showEndL;
00131   bool lengthFix;
00132   int  endOffset_length;  /* marks the offset at the end of the ruler
00133                            * i.e. right side at horizontal and down side
00134                            * at vertical rulers.
00135                            * the ruler end mark is moved endOffset_length
00136                            * ticks away from the widget end.
00137                            * positive offset moves end mark inside the ruler.
00138                            * if lengthFix is true, endOffset_length holds the
00139                            * length of the ruler.
00140                            */
00141   int fontWidth; // ONLY valid for vertical rulers
00142 };
00143 
00144 
00145 
00146 KRuler::KRuler(QWidget *parent, const char *name)
00147   : QFrame(parent, name),
00148     range(INIT_MIN_VALUE, INIT_MAX_VALUE, 1, 10, INIT_VALUE),
00149     dir(Horizontal)
00150 {
00151   init();
00152   setFixedHeight(FIX_WIDTH);
00153 }
00154 
00155 
00156 KRuler::KRuler(Orientation orient,
00157                QWidget *parent, const char *name, WFlags f)
00158   : QFrame(parent, name, f),
00159     range(INIT_MIN_VALUE, INIT_MAX_VALUE, 1, 10, INIT_VALUE),
00160     dir(orient)
00161 {
00162   init();
00163   if (orient == Horizontal)
00164     setFixedHeight(FIX_WIDTH);
00165   else
00166     setFixedWidth(FIX_WIDTH);
00167 }
00168 
00169 
00170 KRuler::KRuler(Orientation orient, int widgetWidth,
00171                QWidget *parent, const char *name, WFlags f)
00172   : QFrame(parent, name, f),
00173     range(INIT_MIN_VALUE, INIT_MAX_VALUE, 1, 10, INIT_VALUE),
00174     dir(orient)
00175 {
00176   init();
00177 
00178   if (orient == Horizontal)
00179     setFixedHeight(widgetWidth);
00180   else
00181     setFixedWidth(widgetWidth);
00182 }
00183 
00184 
00185 void KRuler::init()
00186 {
00187   setFrameStyle(WinPanel | Raised);
00188 
00189   tmDist = INIT_TINY_MARK_DISTANCE;
00190   lmDist = INIT_LITTLE_MARK_DISTANCE;
00191   mmDist = INIT_MIDDLE_MARK_DISTANCE;
00192   bmDist = INIT_BIG_MARK_DISTANCE;
00193   offset_= INIT_OFFSET;
00194   showtm = INIT_SHOW_TINY_MARK;
00195   showlm = INIT_SHOW_LITTLE_MARK;
00196   showmm = INIT_SHOW_MEDIUM_MARK;
00197   showbm = INIT_SHOW_BIG_MARK;
00198   showem = INIT_SHOW_END_MARK;
00199   ppm = INIT_PIXEL_PER_MARK;
00200 
00201   d = new KRuler::KRulerPrivate;
00202   d->showpointer = INIT_SHOW_POINTER;
00203   d->showEndL = INIT_SHOW_END_LABEL;
00204   d->lengthFix = INIT_LENGTH_FIX;
00205   d->endOffset_length = INIT_END_OFFSET;
00206 }
00207 
00208 
00209 KRuler::~KRuler()
00210 {
00211   delete d;
00212 }
00213 
00214 void
00215 KRuler::setMinValue(int value)
00216 {
00217   if (range.minValue() != value) {
00218     range.setRange( value, range.maxValue() );
00219     update(contentsRect());
00220   }
00221 }
00222 
00223 void
00224 KRuler::setMaxValue(int value)
00225 {
00226   if (range.maxValue() != value) {
00227     range.setRange( range.minValue(), value );
00228     update(contentsRect());
00229   }
00230 }
00231 
00232 void
00233 KRuler::setRange(int min, int max)
00234 {// debug("set range from %i to %i", min, max);
00235   if ((range.minValue() != min) || (range.maxValue() != max)) {
00236     range.setRange( min, max );
00237     update(contentsRect());
00238   }
00239 }
00240 
00241 void
00242 KRuler::setValue(int value)
00243 {
00244   range.setValue(value);
00245   update(contentsRect());
00246 }
00247 
00248 void
00249 KRuler::setTinyMarkDistance(int dist)
00250 {
00251   if (dist != tmDist) {
00252     tmDist = dist;
00253     update(contentsRect());
00254   }
00255 }
00256 
00257 void
00258 KRuler::setLittleMarkDistance(int dist)
00259 {
00260   if (dist != lmDist) {
00261     lmDist = dist;
00262     update(contentsRect());
00263   }
00264 }
00265 
00266 void
00267 KRuler::setMediumMarkDistance(int dist)
00268 {
00269   if (dist != mmDist) {
00270     mmDist = dist;
00271     update(contentsRect());
00272   }
00273 }
00274 
00275 void
00276 KRuler::setBigMarkDistance(int dist)
00277 {
00278   if (dist != bmDist) {
00279     bmDist = dist;
00280     update(contentsRect());
00281   }
00282 }
00283 
00284 void
00285 KRuler::setShowTinyMarks(bool show)
00286 {
00287   if (show != showtm) {
00288     showtm = show;
00289     update(contentsRect());
00290   }
00291 }
00292 
00293 bool
00294 KRuler::showTinyMarks() const
00295 {
00296   return showtm;
00297 }
00298 
00299 void
00300 KRuler::setShowLittleMarks(bool show)
00301 {
00302   if (show != showlm) {
00303     showlm = show;
00304     update(contentsRect());
00305   }
00306 }
00307 
00308 bool
00309 KRuler::showLittleMarks() const
00310 {
00311   return showlm;
00312 }
00313 
00314 void
00315 KRuler::setShowMediumMarks(bool show)
00316 {
00317   if (show != showmm) {
00318     showmm = show;
00319     update(contentsRect());
00320   }
00321 }
00322 
00323 bool
00324 KRuler::showMediumMarks() const
00325 {
00326   return showmm;
00327 }
00328 
00329 void
00330 KRuler::setShowBigMarks(bool show)
00331 {
00332   if (show != showbm) {
00333     showbm = show;
00334     update(contentsRect());
00335   }
00336 }
00337 
00338 
00339 bool
00340 KRuler::showBigMarks() const
00341 {
00342   return showbm;
00343 }
00344 
00345 void
00346 KRuler::setShowEndMarks(bool show)
00347 {
00348   if (show != showem) {
00349     showem = show;
00350     update(contentsRect());
00351   }
00352 }
00353 
00354 bool
00355 KRuler::showEndMarks() const
00356 {
00357   return showem;
00358 }
00359 
00360 void
00361 KRuler::setShowPointer(bool show)
00362 {
00363   if (show != d->showpointer) {
00364     d->showpointer = show;
00365     update(contentsRect());
00366   }
00367 }
00368 
00369 
00370 bool
00371 KRuler::showPointer() const
00372 {
00373   return d->showpointer;
00374 }
00375 
00376 void
00377 KRuler::setValuePerLittleMark(int)
00378 {
00379   update(contentsRect());
00380 }
00381 
00382 void
00383 KRuler::setValuePerMediumMark(int)
00384 {
00385    update(contentsRect());
00386 }
00387 
00388 void
00389 KRuler::setValuePerBigMark(int)
00390 {
00391  update(contentsRect());
00392 }
00393 
00394 void
00395 KRuler::setShowEndLabel(bool show)
00396 {
00397   if (d->showEndL != show) {
00398     d->showEndL = show;
00399     update(contentsRect());
00400   }
00401 }
00402 
00403 
00404 bool
00405 KRuler::showEndLabel() const
00406 {
00407     return d->showEndL;
00408 }
00409 
00410 
00411 void
00412 KRuler::setEndLabel(const QString& label)
00413 {
00414   endlabel = label;
00415 
00416   // premeasure the fontwidth and save it
00417   if (dir == Vertical) {
00418     QFont font = this->font();
00419     font.setPointSize(LABEL_SIZE);
00420     QFontMetrics fm(font);
00421     d->fontWidth = fm.width(endlabel);
00422   }
00423   update(contentsRect());
00424 }
00425 
00426 QString KRuler::endLabel() const
00427 {
00428   return endlabel;
00429 }
00430 
00431 void
00432 KRuler::setRulerMetricStyle(KRuler::MetricStyle style)
00433 {
00434   switch (style) {
00435   default: /* fall through */
00436   case Custom:
00437     return;
00438   case Pixel:
00439     setLittleMarkDistance(1);
00440     setMediumMarkDistance(5);
00441     setBigMarkDistance(10);
00442 
00443     setShowTinyMarks(false);
00444     setShowLittleMarks(true);
00445     setShowMediumMarks(true);
00446     setShowBigMarks(true);
00447     setShowEndMarks(true);
00448 
00449     setValuePerMediumMark(50);
00450     setPixelPerMark(10.0);
00451 
00452     break;
00453   case Inch:
00454     setTinyMarkDistance(1);
00455     setLittleMarkDistance(2);
00456     setMediumMarkDistance(4);
00457     setBigMarkDistance(8);
00458 
00459     setShowTinyMarks(true);
00460     setShowLittleMarks(true);
00461     setShowMediumMarks(true);
00462     setShowBigMarks(true);
00463     setShowEndMarks(true);
00464 
00465     setValuePerBigMark(1);
00466     setPixelPerMark(9.0);
00467 
00468     break;
00469   case Millimetres: /* fall through */
00470   case Centimetres: /* fall through */
00471   case Metres:
00472     setLittleMarkDistance(1);
00473     setMediumMarkDistance(5);
00474     setBigMarkDistance(10);
00475 
00476     setShowTinyMarks(false);
00477     setShowLittleMarks(true);
00478     setShowMediumMarks(true);
00479     setShowBigMarks(true);
00480     setShowEndMarks(true);
00481 
00482     setValuePerBigMark(10);
00483     setPixelPerMark(3.0);
00484   }
00485   switch (style) {
00486   case Pixel:
00487     setEndLabel(QString::fromLatin1("pixel"));
00488     break;
00489   case Inch:
00490     setEndLabel(QString::fromLatin1("inch"));
00491     break;
00492   case Millimetres:
00493     setEndLabel(QString::fromLatin1("mm"));
00494     break;
00495   case Centimetres:
00496     setEndLabel(QString::fromLatin1("cm"));
00497     break;
00498   case Metres:
00499     setEndLabel(QString::fromLatin1("m"));
00500   default: /* never reached, see above switch */
00501     /* empty command */;
00502   }
00503   // if the style changes one of the values,
00504   // update would have been called inside the methods
00505   // -> no update() call needed here !
00506 }
00507 
00508 void
00509 KRuler::setPixelPerMark(double rate)
00510 { // never compare floats against each other :)
00511   ppm = rate;
00512   update(contentsRect());
00513 }
00514 
00515 
00516 void
00517 KRuler::setLength(int length)
00518 {
00519   int tmp;
00520   if (d->lengthFix) {
00521     tmp = length;
00522   }
00523   else {
00524     tmp = this->width() - length;
00525   }
00526   if (tmp != d->endOffset_length) {
00527     d->endOffset_length = tmp;
00528     update(contentsRect());
00529   }
00530 }
00531 
00532 int
00533 KRuler::length() const
00534 {
00535   if (d->lengthFix) {
00536     return d->endOffset_length;
00537   }
00538   return (this->width() - d->endOffset_length);
00539 }
00540 
00541 
00542 void
00543 KRuler::setLengthFixed(bool fix)
00544 {
00545   d->lengthFix = fix;
00546 }
00547 
00548 bool
00549 KRuler::lengthFixed() const
00550 {
00551   return d->lengthFix;
00552 }
00553 
00554 void
00555 KRuler::setOffset(int _offset)
00556 {// debug("set offset %i", _offset);
00557   if (offset_ != _offset) {
00558     offset_ = _offset;
00559     update(contentsRect());
00560   }
00561 }
00562 
00563 int
00564 KRuler::endOffset() const
00565 {
00566   if (d->lengthFix) {
00567     return (this->width() - d->endOffset_length);
00568   }
00569   return d->endOffset_length;
00570 }
00571 
00572 
00573 void
00574 KRuler::slideUp(int count)
00575 {
00576   if (count) {
00577     offset_ += count;
00578     update(contentsRect());
00579   }
00580 }
00581 
00582 void
00583 KRuler::slideDown(int count)
00584 {
00585   if (count) {
00586     offset_ -= count;
00587     update(contentsRect());
00588   }
00589 }
00590 
00591 
00592 void
00593 KRuler::slotNewValue(int _value)
00594 {
00595   int oldvalue = range.value();
00596   if (oldvalue == _value) {
00597     return;
00598   }
00599   //    setValue(_value);
00600   range.setValue(_value);
00601   if (range.value() == oldvalue) {
00602     return;
00603   }
00604   // get the rectangular of the old and the new ruler pointer
00605   // and repaint only him
00606   if (dir == Horizontal) {
00607     QRect oldrec(-5+oldvalue,10, 11,6);
00608     QRect newrec(-5+_value,10, 11,6);
00609     repaint( oldrec.unite(newrec) );
00610   }
00611   else {
00612     QRect oldrec(10,-5+oldvalue, 6,11);
00613     QRect newrec(10,-5+_value, 6,11);
00614     repaint( oldrec.unite(newrec) );
00615   }
00616 }
00617 
00618 void
00619 KRuler::slotNewOffset(int _offset)
00620 {
00621   if (offset_ != _offset) {
00622     //setOffset(_offset);
00623     offset_ = _offset;
00624     repaint(contentsRect());
00625   }
00626 }
00627 
00628 
00629 void
00630 KRuler::slotEndOffset(int offset)
00631 {
00632   int tmp;
00633   if (d->lengthFix) {
00634     tmp = this->width() - offset;
00635   }
00636   else {
00637     tmp = offset;
00638   }
00639   if (d->endOffset_length != tmp) {
00640     d->endOffset_length = tmp;
00641     repaint(contentsRect());
00642   }
00643 }
00644 
00645 void
00646 KRuler::drawContents(QPainter *p)
00647 {
00648   //  debug ("KRuler::drawContents, %s",(horizontal==dir)?"horizontal":"vertical");
00649 
00650 #ifdef PROFILING
00651   QTime time;
00652   time.start();
00653   for (int profile=0; profile<10; profile++) {
00654 #endif
00655 
00656   int value  = range.value(),
00657     minval = range.minValue(),
00658     maxval;
00659     if (dir == Horizontal) {
00660     maxval = range.maxValue()
00661     + offset_
00662     - (d->lengthFix?(height()-d->endOffset_length):d->endOffset_length);
00663     }
00664     else
00665     {
00666     maxval = range.maxValue()
00667     + offset_
00668     - (d->lengthFix?(width()-d->endOffset_length):d->endOffset_length);
00669     }
00670     //ioffsetval = value-offset;
00671     //    pixelpm = (int)ppm;
00672   //    left  = clip.left(),
00673   //    right = clip.right();
00674   double f, fend,
00675     offsetmin=(double)(minval-offset_),
00676     offsetmax=(double)(maxval-offset_),
00677     fontOffset = (((double)minval)>offsetmin)?(double)minval:offsetmin;
00678 
00679   // draw labels
00680   QFont font = p->font();
00681   font.setPointSize(LABEL_SIZE);
00682   p->setFont( font );
00683   // draw littlemarklabel
00684 
00685   // draw mediummarklabel
00686 
00687   // draw bigmarklabel
00688 
00689   // draw endlabel
00690   if (d->showEndL) {
00691     if (dir == Horizontal) {
00692       p->translate( fontOffset, 0 );
00693       p->drawText( END_LABEL_X, END_LABEL_Y, endlabel );
00694     }
00695     else { // rotate text +pi/2 and move down a bit
00696       //QFontMetrics fm(font);
00697 #ifdef KRULER_ROTATE_TEST
00698       p->rotate( -90.0 + rotate );
00699       p->translate( -8.0 - fontOffset - d->fontWidth + xtrans,
00700                     ytrans );
00701 #else
00702       p->rotate( -90.0 );
00703       p->translate( -8.0 - fontOffset - d->fontWidth, 0.0 );
00704 #endif
00705       p->drawText( END_LABEL_X, END_LABEL_Y, endlabel );
00706     }
00707     p->resetXForm();
00708   }
00709 
00710   // draw the tiny marks
00711   if (showtm) {
00712     fend = ppm*tmDist;
00713     for ( f=offsetmin; f<offsetmax; f+=fend ) {
00714       if (dir == Horizontal) {
00715         p->drawLine((int)f, BASE_MARK_X1, (int)f, BASE_MARK_X2);
00716       }
00717       else {
00718         p->drawLine(BASE_MARK_X1, (int)f, BASE_MARK_X2, (int)f);
00719       }
00720     }
00721   }
00722   if (showlm) {
00723     // draw the little marks
00724     fend = ppm*lmDist;
00725     for ( f=offsetmin; f<offsetmax; f+=fend ) {
00726       if (dir == Horizontal) {
00727         p->drawLine((int)f, LITTLE_MARK_X1, (int)f, LITTLE_MARK_X2);
00728       }
00729       else {
00730         p->drawLine(LITTLE_MARK_X1, (int)f, LITTLE_MARK_X2, (int)f);
00731       }
00732     }
00733   }
00734   if (showmm) {
00735     // draw medium marks
00736     fend = ppm*mmDist;
00737     for ( f=offsetmin; f<offsetmax; f+=fend ) {
00738       if (dir == Horizontal) {
00739         p->drawLine((int)f, MIDDLE_MARK_X1, (int)f, MIDDLE_MARK_X2);
00740       }
00741       else {
00742         p->drawLine(MIDDLE_MARK_X1, (int)f, MIDDLE_MARK_X2, (int)f);
00743       }
00744     }
00745   }
00746   if (showbm) {
00747     // draw big marks
00748     fend = ppm*bmDist;
00749     for ( f=offsetmin; f<offsetmax; f+=fend ) {
00750       if (dir == Horizontal) {
00751         p->drawLine((int)f, BIG_MARK_X1, (int)f, BIG_MARK_X2);
00752       }
00753       else {
00754         p->drawLine(BIG_MARK_X1, (int)f, BIG_MARK_X2, (int)f);
00755       }
00756     }
00757   }
00758   if (showem) {
00759     // draw end marks
00760     if (dir == Horizontal) {
00761       p->drawLine(minval-offset_, END_MARK_X1, minval-offset_, END_MARK_X2);
00762       p->drawLine(maxval-offset_, END_MARK_X1, maxval-offset_, END_MARK_X2);
00763     }
00764     else {
00765       p->drawLine(END_MARK_X1, minval-offset_, END_MARK_X2, minval-offset_);
00766       p->drawLine(END_MARK_X1, maxval-offset_, END_MARK_X2, maxval-offset_);
00767     }
00768   }
00769 
00770   // draw pointer
00771   if (d->showpointer) {
00772     QPointArray pa(4);
00773     if (dir == Horizontal) {
00774       pa.setPoints(3, value-5, 10, value+5, 10, value/*+0*/,15);
00775     }
00776     else {
00777       pa.setPoints(3, 10, value-5, 10, value+5, 15, value/*+0*/);
00778     }
00779     p->setBrush( p->backgroundColor() );
00780     p->drawPolygon( pa );
00781   }
00782 
00783 #ifdef PROFILING
00784   }
00785   int elapsed = time.elapsed();
00786   debug("paint time %i",elapsed);
00787 #endif
00788 
00789 }
00790 
00791 void KRuler::virtual_hook( int, void* )
00792 { /*BASE::virtual_hook( id, data );*/ }
00793 
00794 #include "kruler.moc"
KDE Logo
This file is part of the documentation for kdelibs Version 3.1.5.
Documentation copyright © 1996-2002 the KDE developers.
Generated on Wed Jan 28 12:57:37 2004 by doxygen 1.3.4 written by Dimitri van Heesch, © 1997-2001