00001
00002
00003
00004
00005
00006
00007
00008
00009
00010 #include <math.h>
00011 #include <qpainter.h>
00012 #if QT_VERSION >= 0x040000
00013 #include <qbitmap.h>
00014 #include <qpalette.h>
00015 #endif
00016 #include <qpixmap.h>
00017 #include <qevent.h>
00018 #include "qwt_math.h"
00019 #include "qwt_scale_engine.h"
00020 #include "qwt_scale_map.h"
00021 #include "qwt_paint_buffer.h"
00022 #include "qwt_painter.h"
00023 #include "qwt_dial_needle.h"
00024 #include "qwt_dial.h"
00025
00026 class QwtDial::PrivateData
00027 {
00028 public:
00029 PrivateData():
00030 visibleBackground(true),
00031 frameShadow(Sunken),
00032 lineWidth(0),
00033 mode(RotateNeedle),
00034 origin(90.0),
00035 minScaleArc(0.0),
00036 maxScaleArc(0.0),
00037 scaleDraw(0),
00038 maxMajIntv(36),
00039 maxMinIntv(10),
00040 scaleStep(0.0),
00041 needle(0)
00042 {
00043 }
00044
00045 ~PrivateData()
00046 {
00047 delete scaleDraw;
00048 delete needle;
00049 }
00050 bool visibleBackground;
00051 Shadow frameShadow;
00052 int lineWidth;
00053
00054 QwtDial::Mode mode;
00055
00056 double origin;
00057 double minScaleArc;
00058 double maxScaleArc;
00059
00060 QwtDialScaleDraw *scaleDraw;
00061 int maxMajIntv;
00062 int maxMinIntv;
00063 double scaleStep;
00064
00065 QwtDialNeedle *needle;
00066
00067 static double previousDir;
00068 };
00069
00070 double QwtDial::PrivateData::previousDir = -1.0;
00071
00077 QwtDialScaleDraw::QwtDialScaleDraw(QwtDial *parent):
00078 d_parent(parent),
00079 d_penWidth(1)
00080 {
00081 }
00082
00090 void QwtDialScaleDraw::setPenWidth(uint penWidth)
00091 {
00092 d_penWidth = penWidth;
00093 }
00094
00099 uint QwtDialScaleDraw::penWidth() const
00100 {
00101 return d_penWidth;
00102 }
00103
00111 QwtText QwtDialScaleDraw::label(double value) const
00112 {
00113 if ( d_parent == NULL )
00114 return QwtRoundScaleDraw::label(value);
00115
00116 return d_parent->scaleLabel(value);
00117 }
00118
00129 QwtDial::QwtDial(QWidget* parent):
00130 QwtAbstractSlider(Qt::Horizontal, parent)
00131 {
00132 initDial();
00133 }
00134
00135 #if QT_VERSION < 0x040000
00136
00146 QwtDial::QwtDial(QWidget* parent, const char *name):
00147 QwtAbstractSlider(Qt::Horizontal, parent)
00148 {
00149 setName(name);
00150 initDial();
00151 }
00152 #endif
00153
00154 void QwtDial::initDial()
00155 {
00156 d_data = new PrivateData;
00157
00158 #if QT_VERSION < 0x040000
00159 setWFlags(Qt::WNoAutoErase);
00160 #endif
00161
00162 #if QT_VERSION >= 0x040000
00163 using namespace Qt;
00164 #endif
00165 setFocusPolicy(TabFocus);
00166
00167 QPalette p = palette();
00168 for ( int i = 0; i < QPalette::NColorGroups; i++ )
00169 {
00170 const QPalette::ColorGroup cg = (QPalette::ColorGroup)i;
00171
00172
00173
00174
00175 #if QT_VERSION < 0x040000
00176 p.setColor(cg, QColorGroup::Foreground,
00177 p.color(cg, QColorGroup::Base));
00178 #else
00179 p.setColor(cg, QPalette::Foreground,
00180 p.color(cg, QPalette::Base));
00181 #endif
00182 }
00183 setPalette(p);
00184
00185 d_data->scaleDraw = new QwtDialScaleDraw(this);
00186 d_data->scaleDraw->setRadius(0);
00187
00188 setScaleArc(0.0, 360.0);
00189 setRange(0.0, 360.0, 1.0, 10);
00190 }
00191
00193 QwtDial::~QwtDial()
00194 {
00195 delete d_data;
00196 }
00197
00206 void QwtDial::showBackground(bool show)
00207 {
00208 if ( d_data->visibleBackground != show )
00209 {
00210 d_data->visibleBackground = show;
00211 updateMask();
00212 }
00213 }
00214
00220 bool QwtDial::hasVisibleBackground() const
00221 {
00222 return d_data->visibleBackground;
00223 }
00224
00230 void QwtDial::setFrameShadow(Shadow shadow)
00231 {
00232 if ( shadow != d_data->frameShadow )
00233 {
00234 d_data->frameShadow = shadow;
00235 if ( lineWidth() > 0 )
00236 update();
00237 }
00238 }
00239
00244 QwtDial::Shadow QwtDial::frameShadow() const
00245 {
00246 return d_data->frameShadow;
00247 }
00248
00255 void QwtDial::setLineWidth(int lineWidth)
00256 {
00257 if ( lineWidth < 0 )
00258 lineWidth = 0;
00259
00260 if ( d_data->lineWidth != lineWidth )
00261 {
00262 d_data->lineWidth = lineWidth;
00263 update();
00264 }
00265 }
00266
00271 int QwtDial::lineWidth() const
00272 {
00273 return d_data->lineWidth;
00274 }
00275
00280 QRect QwtDial::contentsRect() const
00281 {
00282 const int lw = lineWidth();
00283
00284 QRect r = boundingRect();
00285 if ( lw > 0 )
00286 {
00287 r.setRect(r.x() + lw, r.y() + lw,
00288 r.width() - 2 * lw, r.height() - 2 * lw);
00289 }
00290 return r;
00291 }
00292
00297 QRect QwtDial::boundingRect() const
00298 {
00299 const int radius = qwtMin(width(), height()) / 2;
00300
00301 QRect r(0, 0, 2 * radius, 2 * radius);
00302 r.moveCenter(rect().center());
00303 return r;
00304 }
00305
00310 QRect QwtDial::scaleContentsRect() const
00311 {
00312 #if QT_VERSION < 0x040000
00313 const QPen scalePen(colorGroup().text(), 0, Qt::NoPen);
00314 #else
00315 const QPen scalePen(palette().text(), 0, Qt::NoPen);
00316 #endif
00317
00318 int scaleDist = 0;
00319 if ( d_data->scaleDraw )
00320 {
00321 scaleDist = d_data->scaleDraw->extent(scalePen, font());
00322 scaleDist++;
00323 }
00324
00325 const QRect rect = contentsRect();
00326 return QRect(rect.x() + scaleDist, rect.y() + scaleDist,
00327 rect.width() - 2 * scaleDist, rect.height() - 2 * scaleDist);
00328 }
00329
00345 void QwtDial::setMode(Mode mode)
00346 {
00347 if ( mode != d_data->mode )
00348 {
00349 d_data->mode = mode;
00350 update();
00351 }
00352 }
00353
00368 QwtDial::Mode QwtDial::mode() const
00369 {
00370 return d_data->mode;
00371 }
00372
00383 void QwtDial::setWrapping(bool wrapping)
00384 {
00385 setPeriodic(wrapping);
00386 }
00387
00396 bool QwtDial::wrapping() const
00397 {
00398 return periodic();
00399 }
00400
00405 void QwtDial::resizeEvent(QResizeEvent *e)
00406 {
00407 QWidget::resizeEvent(e);
00408
00409 if ( !hasVisibleBackground() )
00410 updateMask();
00411 }
00412
00417 void QwtDial::paintEvent(QPaintEvent *e)
00418 {
00419 const QRect &ur = e->rect();
00420 if ( ur.isValid() )
00421 {
00422 #if QT_VERSION < 0x040000
00423 QwtPaintBuffer paintBuffer(this, ur);
00424 QPainter &painter = *paintBuffer.painter();
00425 #else
00426 QPainter painter(this);
00427 painter.setRenderHint(QPainter::Antialiasing, true);
00428 #endif
00429
00430 painter.save();
00431 drawContents(&painter);
00432 painter.restore();
00433
00434 painter.save();
00435 drawFrame(&painter);
00436 painter.restore();
00437
00438 if ( hasFocus() )
00439 drawFocusIndicator(&painter);
00440 }
00441 }
00442
00448 void QwtDial::drawFocusIndicator(QPainter *painter) const
00449 {
00450 if ( !isReadOnly() )
00451 {
00452 QRect focusRect = contentsRect();
00453
00454 const int margin = 2;
00455 focusRect.setRect(
00456 focusRect.x() + margin,
00457 focusRect.y() + margin,
00458 focusRect.width() - 2 * margin,
00459 focusRect.height() - 2 * margin);
00460
00461 #if QT_VERSION < 0x040000
00462 QColor color = colorGroup().color(QColorGroup::Base);
00463 #else
00464 QColor color = palette().color(QPalette::Base);
00465 #endif
00466 if (color.isValid())
00467 {
00468 const QColor gray(Qt::gray);
00469
00470 int h, s, v;
00471 #if QT_VERSION < 0x040000
00472 color.hsv(&h, &s, &v);
00473 #else
00474 color.getHsv(&h, &s, &v);
00475 #endif
00476 color = (v > 128) ? gray.dark(120) : gray.light(120);
00477 }
00478 else
00479 color = Qt::darkGray;
00480
00481 painter->save();
00482 painter->setBrush(Qt::NoBrush);
00483 painter->setPen(QPen(color, 0, Qt::DotLine));
00484 painter->drawEllipse(focusRect);
00485 painter->restore();
00486 }
00487 }
00488
00495 void QwtDial::drawFrame(QPainter *painter)
00496 {
00497 const int lw = lineWidth();
00498 const int off = (lw + 1) % 2;
00499
00500 QRect r = boundingRect();
00501 r.setRect(r.x() + lw / 2 - off, r.y() + lw / 2 - off,
00502 r.width() - lw + off + 1, r.height() - lw + off + 1);
00503 #if QT_VERSION >= 0x040000
00504 #ifdef __GNUC__
00505 #endif
00506 r.setX(r.x() + 1);
00507 r.setY(r.y() + 1);
00508 r.setWidth(r.width() - 2);
00509 r.setHeight(r.height() - 2);
00510 #endif
00511
00512 if ( lw > 0 )
00513 {
00514 switch(d_data->frameShadow)
00515 {
00516 case QwtDial::Raised:
00517 #if QT_VERSION < 0x040000
00518 QwtPainter::drawRoundFrame(painter, r,
00519 lw, colorGroup(), false);
00520 #else
00521 QwtPainter::drawRoundFrame(painter, r,
00522 lw, palette(), false);
00523 #endif
00524 break;
00525 case QwtDial::Sunken:
00526 #if QT_VERSION < 0x040000
00527 QwtPainter::drawRoundFrame(painter, r,
00528 lw, colorGroup(), true);
00529 #else
00530 QwtPainter::drawRoundFrame(painter, r,
00531 lw, palette(), true);
00532 #endif
00533 break;
00534 default:
00535 {
00536 painter->save();
00537 painter->setPen(QPen(Qt::black, lw));
00538 painter->setBrush(Qt::NoBrush);
00539 painter->drawEllipse(r);
00540 painter->restore();
00541 }
00542 }
00543 }
00544 }
00545
00557 void QwtDial::drawContents(QPainter *painter) const
00558 {
00559 #if QT_VERSION < 0x040000
00560 if ( backgroundMode() == Qt::NoBackground ||
00561 colorGroup().brush(QColorGroup::Base) !=
00562 colorGroup().brush(QColorGroup::Background) )
00563 #else
00564 if ( testAttribute(Qt::WA_NoSystemBackground) ||
00565 palette().brush(QPalette::Base) !=
00566 palette().brush(QPalette::Background) )
00567 #endif
00568 {
00569
00570 const QRect br = boundingRect();
00571
00572 painter->save();
00573 painter->setPen(Qt::NoPen);
00574
00575 #if QT_VERSION < 0x040000
00576 painter->setBrush(colorGroup().brush(QColorGroup::Base));
00577 #else
00578 painter->setBrush(palette().brush(QPalette::Base));
00579 #endif
00580
00581 painter->drawEllipse(br);
00582 painter->restore();
00583 }
00584
00585
00586 const QRect insideScaleRect = scaleContentsRect();
00587 #if QT_VERSION < 0x040000
00588 if ( colorGroup().brush(QColorGroup::Foreground) !=
00589 colorGroup().brush(QColorGroup::Base) )
00590 #else
00591 if ( palette().brush(QPalette::Foreground) !=
00592 palette().brush(QPalette::Base) )
00593 #endif
00594 {
00595 painter->save();
00596 painter->setPen(Qt::NoPen);
00597
00598 #if QT_VERSION < 0x040000
00599 painter->setBrush(colorGroup().brush(QColorGroup::Foreground));
00600 #else
00601 painter->setBrush(palette().brush(QPalette::Foreground));
00602 #endif
00603
00604 painter->drawEllipse(insideScaleRect.x() - 1, insideScaleRect.y() - 1,
00605 insideScaleRect.width(), insideScaleRect.height() );
00606
00607 painter->restore();
00608 }
00609
00610 const QPoint center = insideScaleRect.center();
00611 const int radius = insideScaleRect.width() / 2;
00612
00613 painter->save();
00614 drawScaleContents(painter, center, radius);
00615 painter->restore();
00616
00617 double direction = d_data->origin;
00618
00619 if (isValid())
00620 {
00621 direction = d_data->origin + d_data->minScaleArc;
00622 if ( maxValue() > minValue() && d_data->maxScaleArc > d_data->minScaleArc )
00623 {
00624 const double ratio =
00625 (value() - minValue()) / (maxValue() - minValue());
00626 direction += ratio * (d_data->maxScaleArc - d_data->minScaleArc);
00627 }
00628
00629 if ( direction >= 360.0 )
00630 direction -= 360.0;
00631 }
00632
00633 double origin = d_data->origin;
00634 if ( mode() == RotateScale )
00635 {
00636 origin -= direction - d_data->origin;
00637 direction = d_data->origin;
00638 }
00639
00640 painter->save();
00641 drawScale(painter, center, radius, origin, d_data->minScaleArc, d_data->maxScaleArc);
00642 painter->restore();
00643
00644 if ( isValid() )
00645 {
00646 QPalette::ColorGroup cg;
00647 if ( isEnabled() )
00648 cg = hasFocus() ? QPalette::Active : QPalette::Inactive;
00649 else
00650 cg = QPalette::Disabled;
00651
00652 painter->save();
00653 drawNeedle(painter, center, radius, direction, cg);
00654 painter->restore();
00655 }
00656 }
00657
00667 void QwtDial::drawNeedle(QPainter *painter, const QPoint ¢er,
00668 int radius, double direction, QPalette::ColorGroup cg) const
00669 {
00670 if ( d_data->needle )
00671 {
00672 direction = 360.0 - direction;
00673 d_data->needle->draw(painter, center, radius, direction, cg);
00674 }
00675 }
00676
00689 void QwtDial::drawScale(QPainter *painter, const QPoint ¢er,
00690 int radius, double origin, double minArc, double maxArc) const
00691 {
00692 if ( d_data->scaleDraw == NULL )
00693 return;
00694
00695 origin -= 270.0;
00696
00697 double angle = maxArc - minArc;
00698 if ( angle > 360.0 )
00699 angle = fmod(angle, 360.0);
00700
00701 minArc += origin;
00702 if ( minArc < -360.0 )
00703 minArc = fmod(minArc, 360.0);
00704
00705 maxArc = minArc + angle;
00706 if ( maxArc > 360.0 )
00707 {
00708
00709
00710 minArc -= 360.0;
00711 maxArc -= 360.0;
00712 }
00713
00714 painter->setFont(font());
00715
00716 d_data->scaleDraw->setAngleRange(minArc, maxArc);
00717 d_data->scaleDraw->setRadius(radius);
00718 d_data->scaleDraw->moveCenter(center);
00719
00720 #if QT_VERSION < 0x040000
00721 QColorGroup cg = colorGroup();
00722
00723 const QColor textColor = cg.color(QColorGroup::Text);
00724 cg.setColor(QColorGroup::Foreground, textColor);
00725 painter->setPen(QPen(textColor, d_data->scaleDraw->penWidth()));
00726
00727 d_data->scaleDraw->draw(painter, cg);
00728 #else
00729 QPalette pal = palette();
00730
00731 const QColor textColor = pal.color(QPalette::Text);
00732 pal.setColor(QPalette::Foreground, textColor);
00733
00734 painter->setPen(QPen(textColor, d_data->scaleDraw->penWidth()));
00735
00736 d_data->scaleDraw->draw(painter, pal);
00737 #endif
00738 }
00739
00740 void QwtDial::drawScaleContents(QPainter *,
00741 const QPoint &, int) const
00742 {
00743
00744 }
00745
00756 void QwtDial::setNeedle(QwtDialNeedle *needle)
00757 {
00758 if ( needle != d_data->needle )
00759 {
00760 if ( d_data->needle )
00761 delete d_data->needle;
00762
00763 d_data->needle = needle;
00764 update();
00765 }
00766 }
00767
00772 const QwtDialNeedle *QwtDial::needle() const
00773 {
00774 return d_data->needle;
00775 }
00776
00781 QwtDialNeedle *QwtDial::needle()
00782 {
00783 return d_data->needle;
00784 }
00785
00787 void QwtDial::rangeChange()
00788 {
00789 updateScale();
00790 }
00791
00796 void QwtDial::updateScale()
00797 {
00798 if ( d_data->scaleDraw )
00799 {
00800 QwtLinearScaleEngine scaleEngine;
00801
00802 const QwtScaleDiv scaleDiv = scaleEngine.divideScale(
00803 minValue(), maxValue(),
00804 d_data->maxMajIntv, d_data->maxMinIntv, d_data->scaleStep);
00805
00806 d_data->scaleDraw->setTransformation(scaleEngine.transformation());
00807 d_data->scaleDraw->setScaleDiv(scaleDiv);
00808 }
00809 }
00810
00812 QwtDialScaleDraw *QwtDial::scaleDraw()
00813 {
00814 return d_data->scaleDraw;
00815 }
00816
00818 const QwtDialScaleDraw *QwtDial::scaleDraw() const
00819 {
00820 return d_data->scaleDraw;
00821 }
00822
00829 void QwtDial::setScaleDraw(QwtDialScaleDraw *scaleDraw)
00830 {
00831 if ( scaleDraw != d_data->scaleDraw )
00832 {
00833 if ( d_data->scaleDraw )
00834 delete d_data->scaleDraw;
00835
00836 d_data->scaleDraw = scaleDraw;
00837 updateScale();
00838 update();
00839 }
00840 }
00841
00846 void QwtDial::setScale(int maxMajIntv, int maxMinIntv, double step)
00847 {
00848 d_data->maxMajIntv = maxMajIntv;
00849 d_data->maxMinIntv = maxMinIntv;
00850 d_data->scaleStep = step;
00851
00852 updateScale();
00853 }
00854
00869 void QwtDial::setScaleOptions(int options)
00870 {
00871 if ( options == 0 )
00872 setScaleDraw(NULL);
00873
00874 QwtDialScaleDraw *sd = d_data->scaleDraw;
00875 if ( sd == NULL )
00876 return;
00877
00878 sd->enableComponent(QwtAbstractScaleDraw::Backbone,
00879 options & ScaleBackbone);
00880
00881 sd->enableComponent(QwtAbstractScaleDraw::Ticks,
00882 options & ScaleTicks);
00883
00884 sd->enableComponent(QwtAbstractScaleDraw::Labels,
00885 options & ScaleLabel);
00886 }
00887
00889 void QwtDial::setScaleTicks(int minLen, int medLen,
00890 int majLen, int penWidth)
00891 {
00892 QwtDialScaleDraw *sd = d_data->scaleDraw;
00893 if ( sd )
00894 {
00895 sd->setTickLength(QwtScaleDiv::MinorTick, minLen);
00896 sd->setTickLength(QwtScaleDiv::MediumTick, medLen);
00897 sd->setTickLength(QwtScaleDiv::MajorTick, majLen);
00898 sd->setPenWidth(penWidth);
00899 }
00900 }
00901
00908 QwtText QwtDial::scaleLabel(double value) const
00909 {
00910 #if 1
00911 if ( value == -0 )
00912 value = 0;
00913 #endif
00914
00915 return QString::number(value);
00916 }
00917
00919 double QwtDial::minScaleArc() const
00920 {
00921 return d_data->minScaleArc;
00922 }
00923
00925 double QwtDial::maxScaleArc() const
00926 {
00927 return d_data->maxScaleArc;
00928 }
00929
00938 void QwtDial::setOrigin(double origin)
00939 {
00940 d_data->origin = origin;
00941 update();
00942 }
00943
00950 double QwtDial::origin() const
00951 {
00952 return d_data->origin;
00953 }
00954
00961 void QwtDial::setScaleArc(double minArc, double maxArc)
00962 {
00963 if ( minArc != 360.0 && minArc != -360.0 )
00964 minArc = fmod(minArc, 360.0);
00965 if ( maxArc != 360.0 && maxArc != -360.0 )
00966 maxArc = fmod(maxArc, 360.0);
00967
00968 d_data->minScaleArc = qwtMin(minArc, maxArc);
00969 d_data->maxScaleArc = qwtMax(minArc, maxArc);
00970 if ( d_data->maxScaleArc - d_data->minScaleArc > 360.0 )
00971 d_data->maxScaleArc = d_data->minScaleArc + 360.0;
00972
00973 update();
00974 }
00975
00977 void QwtDial::valueChange()
00978 {
00979 update();
00980 QwtAbstractSlider::valueChange();
00981 }
00982
00986 QSize QwtDial::sizeHint() const
00987 {
00988 int sh = 0;
00989 if ( d_data->scaleDraw )
00990 sh = d_data->scaleDraw->extent( QPen(), font() );
00991
00992 const int d = 6 * sh + 2 * lineWidth();
00993
00994 return QSize( d, d );
00995 }
00996
01002 QSize QwtDial::minimumSizeHint() const
01003 {
01004 int sh = 0;
01005 if ( d_data->scaleDraw )
01006 sh = d_data->scaleDraw->extent(QPen(), font() );
01007
01008 const int d = 3 * sh + 2 * lineWidth();
01009
01010 return QSize( d, d );
01011 }
01012
01013 static double line2Radians(const QPoint &p1, const QPoint &p2)
01014 {
01015 const QPoint p = p2 - p1;
01016
01017 double angle;
01018 if ( p.x() == 0 )
01019 angle = ( p.y() <= 0 ) ? M_PI_2 : 3 * M_PI_2;
01020 else
01021 {
01022 angle = atan(double(-p.y()) / double(p.x()));
01023 if ( p.x() < 0 )
01024 angle += M_PI;
01025 if ( angle < 0.0 )
01026 angle += 2 * M_PI;
01027 }
01028 return 360.0 - angle * 180.0 / M_PI;
01029 }
01030
01037 double QwtDial::getValue(const QPoint &pos)
01038 {
01039 if ( d_data->maxScaleArc == d_data->minScaleArc || maxValue() == minValue() )
01040 return minValue();
01041
01042 double dir = line2Radians(rect().center(), pos) - d_data->origin;
01043 if ( dir < 0.0 )
01044 dir += 360.0;
01045
01046 if ( mode() == RotateScale )
01047 dir = 360.0 - dir;
01048
01049
01050
01051
01052 const double completeCircle = 360.0 / (d_data->maxScaleArc - d_data->minScaleArc)
01053 * (maxValue() - minValue());
01054
01055 double posValue = minValue() + completeCircle * dir / 360.0;
01056
01057 if ( scrollMode() == ScrMouse )
01058 {
01059 if ( d_data->previousDir >= 0.0 )
01060 {
01061
01062
01063
01064 bool clockWise = false;
01065
01066 const double angle = dir - d_data->previousDir;
01067 if ( (angle >= 0.0 && angle <= 180.0) || angle < -180.0 )
01068 clockWise = true;
01069
01070 if ( clockWise )
01071 {
01072 if ( dir < d_data->previousDir && mouseOffset() > 0.0 )
01073 {
01074
01075 setMouseOffset(mouseOffset() - completeCircle);
01076 }
01077
01078 if ( wrapping() )
01079 {
01080 if ( posValue - mouseOffset() > maxValue() )
01081 {
01082
01083
01084
01085 setMouseOffset(posValue - minValue());
01086 }
01087 }
01088 else
01089 {
01090 if ( posValue - mouseOffset() > maxValue() ||
01091 value() == maxValue() )
01092 {
01093
01094
01095
01096 setMouseOffset(posValue - maxValue());
01097 }
01098 }
01099 }
01100 else
01101 {
01102 if ( dir > d_data->previousDir && mouseOffset() < 0.0 )
01103 {
01104
01105 setMouseOffset(mouseOffset() + completeCircle);
01106 }
01107
01108 if ( wrapping() )
01109 {
01110 if ( posValue - mouseOffset() < minValue() )
01111 {
01112
01113
01114
01115 setMouseOffset(posValue - maxValue());
01116 }
01117 }
01118 else
01119 {
01120 if ( posValue - mouseOffset() < minValue() ||
01121 value() == minValue() )
01122 {
01123
01124
01125
01126 setMouseOffset(posValue - minValue());
01127 }
01128 }
01129 }
01130 }
01131 d_data->previousDir = dir;
01132 }
01133
01134 return posValue;
01135 }
01136
01140 void QwtDial::getScrollMode(const QPoint &p, int &scrollMode, int &direction)
01141 {
01142 direction = 0;
01143 scrollMode = ScrNone;
01144
01145 const QRegion region(contentsRect(), QRegion::Ellipse);
01146 if ( region.contains(p) && p != rect().center() )
01147 {
01148 scrollMode = ScrMouse;
01149 d_data->previousDir = -1.0;
01150 }
01151 }
01152
01172 void QwtDial::keyPressEvent(QKeyEvent *e)
01173 {
01174 if ( isReadOnly() )
01175 {
01176 e->ignore();
01177 return;
01178 }
01179
01180 if ( !isValid() )
01181 return;
01182
01183 double previous = prevValue();
01184 switch ( e->key() )
01185 {
01186 case Qt::Key_Down:
01187 case Qt::Key_Left:
01188 QwtDoubleRange::incValue(-1);
01189 break;
01190 #if QT_VERSION < 0x040000
01191 case Qt::Key_Prior:
01192 #else
01193 case Qt::Key_PageUp:
01194 #endif
01195 QwtDoubleRange::incValue(-pageSize());
01196 break;
01197 case Qt::Key_Home:
01198 setValue(minValue());
01199 break;
01200
01201 case Qt::Key_Up:
01202 case Qt::Key_Right:
01203 QwtDoubleRange::incValue(1);
01204 break;
01205 #if QT_VERSION < 0x040000
01206 case Qt::Key_Next:
01207 #else
01208 case Qt::Key_PageDown:
01209 #endif
01210 QwtDoubleRange::incValue(pageSize());
01211 break;
01212 case Qt::Key_End:
01213 setValue(maxValue());
01214 break;
01215 default:;
01216 e->ignore();
01217 }
01218
01219 if (value() != previous)
01220 emit sliderMoved(value());
01221 }
01222
01231 void QwtDial::updateMask()
01232 {
01233 if ( d_data->visibleBackground )
01234 clearMask();
01235 else
01236 setMask(QRegion(boundingRect(), QRegion::Ellipse));
01237 }