00001
00002
00003
00004
00005
00006
00007
00008
00009
00010 #include <math.h>
00011 #include <qpainter.h>
00012 #if QT_VERSION >= 0x040000
00013 #include <qpaintengine.h>
00014 #include <qbitmap.h>
00015 #include <qpalette.h>
00016 #endif
00017 #include <qpixmap.h>
00018 #include <qevent.h>
00019 #include "qwt_math.h"
00020 #include "qwt_scale_engine.h"
00021 #include "qwt_scale_map.h"
00022 #include "qwt_paint_buffer.h"
00023 #include "qwt_painter.h"
00024 #include "qwt_dial_needle.h"
00025 #include "qwt_dial.h"
00026
00027 #if QT_VERSION >= 0x040000
00028 static void setAntialiasing(QPainter *painter, bool on)
00029 {
00030 QPaintEngine *engine = painter->paintEngine();
00031 if ( engine && engine->hasFeature(QPaintEngine::Antialiasing) )
00032 painter->setRenderHint(QPainter::Antialiasing, on);
00033 }
00034 #else
00035 static void setAntialiasing(QPainter *, bool)
00036 {
00037 }
00038 #endif
00039
00040 class QwtDial::PrivateData
00041 {
00042 public:
00043 PrivateData():
00044 visibleBackground(true),
00045 frameShadow(Sunken),
00046 lineWidth(0),
00047 mode(RotateNeedle),
00048 origin(90.0),
00049 minScaleArc(0.0),
00050 maxScaleArc(0.0),
00051 scaleDraw(0),
00052 maxMajIntv(36),
00053 maxMinIntv(10),
00054 scaleStep(0.0),
00055 needle(0)
00056 {
00057 }
00058
00059 ~PrivateData()
00060 {
00061 delete scaleDraw;
00062 delete needle;
00063 }
00064 bool visibleBackground;
00065 Shadow frameShadow;
00066 int lineWidth;
00067
00068 QwtDial::Mode mode;
00069
00070 double origin;
00071 double minScaleArc;
00072 double maxScaleArc;
00073
00074 QwtDialScaleDraw *scaleDraw;
00075 int maxMajIntv;
00076 int maxMinIntv;
00077 double scaleStep;
00078
00079 QwtDialNeedle *needle;
00080
00081 static double previousDir;
00082 };
00083
00084 double QwtDial::PrivateData::previousDir = -1.0;
00085
00091 QwtDialScaleDraw::QwtDialScaleDraw(QwtDial *parent):
00092 d_parent(parent),
00093 d_penWidth(1)
00094 {
00095 }
00096
00104 void QwtDialScaleDraw::setPenWidth(uint penWidth)
00105 {
00106 d_penWidth = penWidth;
00107 }
00108
00113 uint QwtDialScaleDraw::penWidth() const
00114 {
00115 return d_penWidth;
00116 }
00117
00125 QwtText QwtDialScaleDraw::label(double value) const
00126 {
00127 if ( d_parent == NULL )
00128 return QwtRoundScaleDraw::label(value);
00129
00130 return d_parent->scaleLabel(value);
00131 }
00132
00143 QwtDial::QwtDial(QWidget* parent):
00144 QwtAbstractSlider(Qt::Horizontal, parent)
00145 {
00146 initDial();
00147 }
00148
00149 #if QT_VERSION < 0x040000
00150
00160 QwtDial::QwtDial(QWidget* parent, const char *name):
00161 QwtAbstractSlider(Qt::Horizontal, parent)
00162 {
00163 setName(name);
00164 initDial();
00165 }
00166 #endif
00167
00168 void QwtDial::initDial()
00169 {
00170 d_data = new PrivateData;
00171
00172 #if QT_VERSION < 0x040000
00173 setWFlags(Qt::WNoAutoErase);
00174 #endif
00175
00176 #if QT_VERSION >= 0x040000
00177 using namespace Qt;
00178 #endif
00179 setFocusPolicy(TabFocus);
00180
00181 QPalette p = palette();
00182 for ( int i = 0; i < QPalette::NColorGroups; i++ )
00183 {
00184 const QPalette::ColorGroup cg = (QPalette::ColorGroup)i;
00185
00186
00187
00188
00189 #if QT_VERSION < 0x040000
00190 p.setColor(cg, QColorGroup::Foreground,
00191 p.color(cg, QColorGroup::Base));
00192 #else
00193 p.setColor(cg, QPalette::Foreground,
00194 p.color(cg, QPalette::Base));
00195 #endif
00196 }
00197 setPalette(p);
00198
00199 d_data->scaleDraw = new QwtDialScaleDraw(this);
00200 d_data->scaleDraw->setRadius(0);
00201
00202 setScaleArc(0.0, 360.0);
00203 setRange(0.0, 360.0, 1.0, 10);
00204 }
00205
00207 QwtDial::~QwtDial()
00208 {
00209 delete d_data;
00210 }
00211
00220 void QwtDial::showBackground(bool show)
00221 {
00222 if ( d_data->visibleBackground != show )
00223 {
00224 d_data->visibleBackground = show;
00225 updateMask();
00226 }
00227 }
00228
00234 bool QwtDial::hasVisibleBackground() const
00235 {
00236 return d_data->visibleBackground;
00237 }
00238
00244 void QwtDial::setFrameShadow(Shadow shadow)
00245 {
00246 if ( shadow != d_data->frameShadow )
00247 {
00248 d_data->frameShadow = shadow;
00249 if ( lineWidth() > 0 )
00250 update();
00251 }
00252 }
00253
00258 QwtDial::Shadow QwtDial::frameShadow() const
00259 {
00260 return d_data->frameShadow;
00261 }
00262
00269 void QwtDial::setLineWidth(int lineWidth)
00270 {
00271 if ( lineWidth < 0 )
00272 lineWidth = 0;
00273
00274 if ( d_data->lineWidth != lineWidth )
00275 {
00276 d_data->lineWidth = lineWidth;
00277 update();
00278 }
00279 }
00280
00285 int QwtDial::lineWidth() const
00286 {
00287 return d_data->lineWidth;
00288 }
00289
00294 QRect QwtDial::contentsRect() const
00295 {
00296 const int lw = lineWidth();
00297
00298 QRect r = boundingRect();
00299 if ( lw > 0 )
00300 {
00301 r.setRect(r.x() + lw, r.y() + lw,
00302 r.width() - 2 * lw, r.height() - 2 * lw);
00303 }
00304 return r;
00305 }
00306
00311 QRect QwtDial::boundingRect() const
00312 {
00313 const int radius = qwtMin(width(), height()) / 2;
00314
00315 QRect r(0, 0, 2 * radius, 2 * radius);
00316 r.moveCenter(rect().center());
00317 return r;
00318 }
00319
00324 QRect QwtDial::scaleContentsRect() const
00325 {
00326 #if QT_VERSION < 0x040000
00327 const QPen scalePen(colorGroup().text(), 0, Qt::NoPen);
00328 #else
00329 const QPen scalePen(palette().text(), 0, Qt::NoPen);
00330 #endif
00331
00332 int scaleDist = 0;
00333 if ( d_data->scaleDraw )
00334 {
00335 scaleDist = d_data->scaleDraw->extent(scalePen, font());
00336 scaleDist++;
00337 }
00338
00339 const QRect rect = contentsRect();
00340 return QRect(rect.x() + scaleDist, rect.y() + scaleDist,
00341 rect.width() - 2 * scaleDist, rect.height() - 2 * scaleDist);
00342 }
00343
00359 void QwtDial::setMode(Mode mode)
00360 {
00361 if ( mode != d_data->mode )
00362 {
00363 d_data->mode = mode;
00364 update();
00365 }
00366 }
00367
00382 QwtDial::Mode QwtDial::mode() const
00383 {
00384 return d_data->mode;
00385 }
00386
00397 void QwtDial::setWrapping(bool wrapping)
00398 {
00399 setPeriodic(wrapping);
00400 }
00401
00410 bool QwtDial::wrapping() const
00411 {
00412 return periodic();
00413 }
00414
00419 void QwtDial::resizeEvent(QResizeEvent *e)
00420 {
00421 QWidget::resizeEvent(e);
00422
00423 if ( !hasVisibleBackground() )
00424 updateMask();
00425 }
00426
00431 void QwtDial::paintEvent(QPaintEvent *e)
00432 {
00433 const QRect &ur = e->rect();
00434 if ( ur.isValid() )
00435 {
00436 #if QT_VERSION < 0x040000
00437 QwtPaintBuffer paintBuffer(this, ur);
00438 QPainter &painter = *paintBuffer.painter();
00439 #else
00440 QPainter painter(this);
00441 #endif
00442
00443 setAntialiasing(&painter, true);
00444
00445 painter.save();
00446 drawContents(&painter);
00447 painter.restore();
00448
00449 painter.save();
00450 drawFrame(&painter);
00451 painter.restore();
00452
00453 if ( hasFocus() )
00454 drawFocusIndicator(&painter);
00455 }
00456 }
00457
00463 void QwtDial::drawFocusIndicator(QPainter *painter) const
00464 {
00465 if ( !isReadOnly() )
00466 {
00467 QRect focusRect = contentsRect();
00468
00469 const int margin = 2;
00470 focusRect.setRect(
00471 focusRect.x() + margin,
00472 focusRect.y() + margin,
00473 focusRect.width() - 2 * margin,
00474 focusRect.height() - 2 * margin);
00475
00476 #if QT_VERSION < 0x040000
00477 QColor color = colorGroup().color(QColorGroup::Base);
00478 #else
00479 QColor color = palette().color(QPalette::Base);
00480 #endif
00481 if (color.isValid())
00482 {
00483 const QColor gray(Qt::gray);
00484
00485 int h, s, v;
00486 #if QT_VERSION < 0x040000
00487 color.hsv(&h, &s, &v);
00488 #else
00489 color.getHsv(&h, &s, &v);
00490 #endif
00491 color = (v > 128) ? gray.dark(120) : gray.light(120);
00492 }
00493 else
00494 color = Qt::darkGray;
00495
00496 painter->save();
00497 painter->setBrush(Qt::NoBrush);
00498 painter->setPen(QPen(color, 0, Qt::DotLine));
00499 painter->drawEllipse(focusRect);
00500 painter->restore();
00501 }
00502 }
00503
00510 void QwtDial::drawFrame(QPainter *painter)
00511 {
00512 const int lw = lineWidth();
00513 const int off = (lw + 1) % 2;
00514
00515 QRect r = boundingRect();
00516 r.setRect(r.x() + lw / 2 - off, r.y() + lw / 2 - off,
00517 r.width() - lw + off + 1, r.height() - lw + off + 1);
00518 #if QT_VERSION >= 0x040000
00519 #ifdef __GNUC__
00520 #endif
00521 r.setX(r.x() + 1);
00522 r.setY(r.y() + 1);
00523 r.setWidth(r.width() - 2);
00524 r.setHeight(r.height() - 2);
00525 #endif
00526
00527 if ( lw > 0 )
00528 {
00529 switch(d_data->frameShadow)
00530 {
00531 case QwtDial::Raised:
00532 #if QT_VERSION < 0x040000
00533 QwtPainter::drawRoundFrame(painter, r,
00534 lw, colorGroup(), false);
00535 #else
00536 QwtPainter::drawRoundFrame(painter, r,
00537 lw, palette(), false);
00538 #endif
00539 break;
00540 case QwtDial::Sunken:
00541 #if QT_VERSION < 0x040000
00542 QwtPainter::drawRoundFrame(painter, r,
00543 lw, colorGroup(), true);
00544 #else
00545 QwtPainter::drawRoundFrame(painter, r,
00546 lw, palette(), true);
00547 #endif
00548 break;
00549 default:
00550 {
00551 painter->save();
00552 painter->setPen(QPen(Qt::black, lw));
00553 painter->setBrush(Qt::NoBrush);
00554 painter->drawEllipse(r);
00555 painter->restore();
00556 }
00557 }
00558 }
00559 }
00560
00572 void QwtDial::drawContents(QPainter *painter) const
00573 {
00574 #if QT_VERSION < 0x040000
00575 if ( backgroundMode() == Qt::NoBackground ||
00576 colorGroup().brush(QColorGroup::Base) !=
00577 colorGroup().brush(QColorGroup::Background) )
00578 #else
00579 if ( testAttribute(Qt::WA_NoSystemBackground) ||
00580 palette().brush(QPalette::Base) !=
00581 palette().brush(QPalette::Background) )
00582 #endif
00583 {
00584
00585 const QRect br = boundingRect();
00586
00587 painter->save();
00588 painter->setPen(Qt::NoPen);
00589
00590 #if QT_VERSION < 0x040000
00591 painter->setBrush(colorGroup().brush(QColorGroup::Base));
00592 #else
00593 painter->setBrush(palette().brush(QPalette::Base));
00594 #endif
00595
00596 painter->drawEllipse(br);
00597 painter->restore();
00598 }
00599
00600
00601 const QRect insideScaleRect = scaleContentsRect();
00602 #if QT_VERSION < 0x040000
00603 if ( colorGroup().brush(QColorGroup::Foreground) !=
00604 colorGroup().brush(QColorGroup::Base) )
00605 #else
00606 if ( palette().brush(QPalette::Foreground) !=
00607 palette().brush(QPalette::Base) )
00608 #endif
00609 {
00610 painter->save();
00611 painter->setPen(Qt::NoPen);
00612
00613 #if QT_VERSION < 0x040000
00614 painter->setBrush(colorGroup().brush(QColorGroup::Foreground));
00615 #else
00616 painter->setBrush(palette().brush(QPalette::Foreground));
00617 #endif
00618
00619 painter->drawEllipse(insideScaleRect.x() - 1, insideScaleRect.y() - 1,
00620 insideScaleRect.width(), insideScaleRect.height() );
00621
00622 painter->restore();
00623 }
00624
00625 const QPoint center = insideScaleRect.center();
00626 const int radius = insideScaleRect.width() / 2;
00627
00628 painter->save();
00629 drawScaleContents(painter, center, radius);
00630 painter->restore();
00631
00632 double direction = d_data->origin;
00633
00634 if (isValid())
00635 {
00636 direction = d_data->origin + d_data->minScaleArc;
00637 if ( maxValue() > minValue() && d_data->maxScaleArc > d_data->minScaleArc )
00638 {
00639 const double ratio =
00640 (value() - minValue()) / (maxValue() - minValue());
00641 direction += ratio * (d_data->maxScaleArc - d_data->minScaleArc);
00642 }
00643
00644 if ( direction >= 360.0 )
00645 direction -= 360.0;
00646 }
00647
00648 double origin = d_data->origin;
00649 if ( mode() == RotateScale )
00650 {
00651 origin -= direction - d_data->origin;
00652 direction = d_data->origin;
00653 }
00654
00655 painter->save();
00656 drawScale(painter, center, radius, origin, d_data->minScaleArc, d_data->maxScaleArc);
00657 painter->restore();
00658
00659 if ( isValid() )
00660 {
00661 QPalette::ColorGroup cg;
00662 if ( isEnabled() )
00663 cg = hasFocus() ? QPalette::Active : QPalette::Inactive;
00664 else
00665 cg = QPalette::Disabled;
00666
00667 painter->save();
00668 drawNeedle(painter, center, radius, direction, cg);
00669 painter->restore();
00670 }
00671 }
00672
00682 void QwtDial::drawNeedle(QPainter *painter, const QPoint ¢er,
00683 int radius, double direction, QPalette::ColorGroup cg) const
00684 {
00685 if ( d_data->needle )
00686 {
00687 direction = 360.0 - direction;
00688 d_data->needle->draw(painter, center, radius, direction, cg);
00689 }
00690 }
00691
00704 void QwtDial::drawScale(QPainter *painter, const QPoint ¢er,
00705 int radius, double origin, double minArc, double maxArc) const
00706 {
00707 if ( d_data->scaleDraw == NULL )
00708 return;
00709
00710 origin -= 270.0;
00711
00712 double angle = maxArc - minArc;
00713 if ( angle > 360.0 )
00714 angle = fmod(angle, 360.0);
00715
00716 minArc += origin;
00717 if ( minArc < -360.0 )
00718 minArc = fmod(minArc, 360.0);
00719
00720 maxArc = minArc + angle;
00721 if ( maxArc > 360.0 )
00722 {
00723
00724
00725 minArc -= 360.0;
00726 maxArc -= 360.0;
00727 }
00728
00729 painter->setFont(font());
00730
00731 d_data->scaleDraw->setAngleRange(minArc, maxArc);
00732 d_data->scaleDraw->setRadius(radius);
00733 d_data->scaleDraw->moveCenter(center);
00734
00735 #if QT_VERSION < 0x040000
00736 QColorGroup cg = colorGroup();
00737
00738 const QColor textColor = cg.color(QColorGroup::Text);
00739 cg.setColor(QColorGroup::Foreground, textColor);
00740 painter->setPen(QPen(textColor, d_data->scaleDraw->penWidth()));
00741
00742 d_data->scaleDraw->draw(painter, cg);
00743 #else
00744 QPalette pal = palette();
00745
00746 const QColor textColor = pal.color(QPalette::Text);
00747 pal.setColor(QPalette::Foreground, textColor);
00748
00749 painter->setPen(QPen(textColor, d_data->scaleDraw->penWidth()));
00750
00751 d_data->scaleDraw->draw(painter, pal);
00752 #endif
00753 }
00754
00755 void QwtDial::drawScaleContents(QPainter *,
00756 const QPoint &, int) const
00757 {
00758
00759 }
00760
00771 void QwtDial::setNeedle(QwtDialNeedle *needle)
00772 {
00773 if ( needle != d_data->needle )
00774 {
00775 if ( d_data->needle )
00776 delete d_data->needle;
00777
00778 d_data->needle = needle;
00779 update();
00780 }
00781 }
00782
00787 const QwtDialNeedle *QwtDial::needle() const
00788 {
00789 return d_data->needle;
00790 }
00791
00796 QwtDialNeedle *QwtDial::needle()
00797 {
00798 return d_data->needle;
00799 }
00800
00802 void QwtDial::rangeChange()
00803 {
00804 updateScale();
00805 }
00806
00811 void QwtDial::updateScale()
00812 {
00813 if ( d_data->scaleDraw )
00814 {
00815 QwtLinearScaleEngine scaleEngine;
00816
00817 const QwtScaleDiv scaleDiv = scaleEngine.divideScale(
00818 minValue(), maxValue(),
00819 d_data->maxMajIntv, d_data->maxMinIntv, d_data->scaleStep);
00820
00821 d_data->scaleDraw->setTransformation(scaleEngine.transformation());
00822 d_data->scaleDraw->setScaleDiv(scaleDiv);
00823 }
00824 }
00825
00827 QwtDialScaleDraw *QwtDial::scaleDraw()
00828 {
00829 return d_data->scaleDraw;
00830 }
00831
00833 const QwtDialScaleDraw *QwtDial::scaleDraw() const
00834 {
00835 return d_data->scaleDraw;
00836 }
00837
00844 void QwtDial::setScaleDraw(QwtDialScaleDraw *scaleDraw)
00845 {
00846 if ( scaleDraw != d_data->scaleDraw )
00847 {
00848 if ( d_data->scaleDraw )
00849 delete d_data->scaleDraw;
00850
00851 d_data->scaleDraw = scaleDraw;
00852 updateScale();
00853 update();
00854 }
00855 }
00856
00861 void QwtDial::setScale(int maxMajIntv, int maxMinIntv, double step)
00862 {
00863 d_data->maxMajIntv = maxMajIntv;
00864 d_data->maxMinIntv = maxMinIntv;
00865 d_data->scaleStep = step;
00866
00867 updateScale();
00868 }
00869
00884 void QwtDial::setScaleOptions(int options)
00885 {
00886 if ( options == 0 )
00887 setScaleDraw(NULL);
00888
00889 QwtDialScaleDraw *sd = d_data->scaleDraw;
00890 if ( sd == NULL )
00891 return;
00892
00893 sd->enableComponent(QwtAbstractScaleDraw::Backbone,
00894 options & ScaleBackbone);
00895
00896 sd->enableComponent(QwtAbstractScaleDraw::Ticks,
00897 options & ScaleTicks);
00898
00899 sd->enableComponent(QwtAbstractScaleDraw::Labels,
00900 options & ScaleLabel);
00901 }
00902
00904 void QwtDial::setScaleTicks(int minLen, int medLen,
00905 int majLen, int penWidth)
00906 {
00907 QwtDialScaleDraw *sd = d_data->scaleDraw;
00908 if ( sd )
00909 {
00910 sd->setTickLength(QwtScaleDiv::MinorTick, minLen);
00911 sd->setTickLength(QwtScaleDiv::MediumTick, medLen);
00912 sd->setTickLength(QwtScaleDiv::MajorTick, majLen);
00913 sd->setPenWidth(penWidth);
00914 }
00915 }
00916
00923 QwtText QwtDial::scaleLabel(double value) const
00924 {
00925 #if 1
00926 if ( value == -0 )
00927 value = 0;
00928 #endif
00929
00930 return QString::number(value);
00931 }
00932
00934 double QwtDial::minScaleArc() const
00935 {
00936 return d_data->minScaleArc;
00937 }
00938
00940 double QwtDial::maxScaleArc() const
00941 {
00942 return d_data->maxScaleArc;
00943 }
00944
00953 void QwtDial::setOrigin(double origin)
00954 {
00955 d_data->origin = origin;
00956 update();
00957 }
00958
00965 double QwtDial::origin() const
00966 {
00967 return d_data->origin;
00968 }
00969
00976 void QwtDial::setScaleArc(double minArc, double maxArc)
00977 {
00978 if ( minArc != 360.0 && minArc != -360.0 )
00979 minArc = fmod(minArc, 360.0);
00980 if ( maxArc != 360.0 && maxArc != -360.0 )
00981 maxArc = fmod(maxArc, 360.0);
00982
00983 d_data->minScaleArc = qwtMin(minArc, maxArc);
00984 d_data->maxScaleArc = qwtMax(minArc, maxArc);
00985 if ( d_data->maxScaleArc - d_data->minScaleArc > 360.0 )
00986 d_data->maxScaleArc = d_data->minScaleArc + 360.0;
00987
00988 update();
00989 }
00990
00992 void QwtDial::valueChange()
00993 {
00994 update();
00995 QwtAbstractSlider::valueChange();
00996 }
00997
01001 QSize QwtDial::sizeHint() const
01002 {
01003 int sh = 0;
01004 if ( d_data->scaleDraw )
01005 sh = d_data->scaleDraw->extent( QPen(), font() );
01006
01007 const int d = 6 * sh + 2 * lineWidth();
01008
01009 return QSize( d, d );
01010 }
01011
01017 QSize QwtDial::minimumSizeHint() const
01018 {
01019 int sh = 0;
01020 if ( d_data->scaleDraw )
01021 sh = d_data->scaleDraw->extent(QPen(), font() );
01022
01023 const int d = 3 * sh + 2 * lineWidth();
01024
01025 return QSize( d, d );
01026 }
01027
01028 static double line2Radians(const QPoint &p1, const QPoint &p2)
01029 {
01030 const QPoint p = p2 - p1;
01031
01032 double angle;
01033 if ( p.x() == 0 )
01034 angle = ( p.y() <= 0 ) ? M_PI_2 : 3 * M_PI_2;
01035 else
01036 {
01037 angle = atan(double(-p.y()) / double(p.x()));
01038 if ( p.x() < 0 )
01039 angle += M_PI;
01040 if ( angle < 0.0 )
01041 angle += 2 * M_PI;
01042 }
01043 return 360.0 - angle * 180.0 / M_PI;
01044 }
01045
01052 double QwtDial::getValue(const QPoint &pos)
01053 {
01054 if ( d_data->maxScaleArc == d_data->minScaleArc || maxValue() == minValue() )
01055 return minValue();
01056
01057 double dir = line2Radians(rect().center(), pos) - d_data->origin;
01058 if ( dir < 0.0 )
01059 dir += 360.0;
01060
01061 if ( mode() == RotateScale )
01062 dir = 360.0 - dir;
01063
01064
01065
01066
01067 const double completeCircle = 360.0 / (d_data->maxScaleArc - d_data->minScaleArc)
01068 * (maxValue() - minValue());
01069
01070 double posValue = minValue() + completeCircle * dir / 360.0;
01071
01072 if ( scrollMode() == ScrMouse )
01073 {
01074 if ( d_data->previousDir >= 0.0 )
01075 {
01076
01077
01078
01079 bool clockWise = false;
01080
01081 const double angle = dir - d_data->previousDir;
01082 if ( (angle >= 0.0 && angle <= 180.0) || angle < -180.0 )
01083 clockWise = true;
01084
01085 if ( clockWise )
01086 {
01087 if ( dir < d_data->previousDir && mouseOffset() > 0.0 )
01088 {
01089
01090 setMouseOffset(mouseOffset() - completeCircle);
01091 }
01092
01093 if ( wrapping() )
01094 {
01095 if ( posValue - mouseOffset() > maxValue() )
01096 {
01097
01098
01099
01100 setMouseOffset(posValue - minValue());
01101 }
01102 }
01103 else
01104 {
01105 if ( posValue - mouseOffset() > maxValue() ||
01106 value() == maxValue() )
01107 {
01108
01109
01110
01111 setMouseOffset(posValue - maxValue());
01112 }
01113 }
01114 }
01115 else
01116 {
01117 if ( dir > d_data->previousDir && mouseOffset() < 0.0 )
01118 {
01119
01120 setMouseOffset(mouseOffset() + completeCircle);
01121 }
01122
01123 if ( wrapping() )
01124 {
01125 if ( posValue - mouseOffset() < minValue() )
01126 {
01127
01128
01129
01130 setMouseOffset(posValue - maxValue());
01131 }
01132 }
01133 else
01134 {
01135 if ( posValue - mouseOffset() < minValue() ||
01136 value() == minValue() )
01137 {
01138
01139
01140
01141 setMouseOffset(posValue - minValue());
01142 }
01143 }
01144 }
01145 }
01146 d_data->previousDir = dir;
01147 }
01148
01149 return posValue;
01150 }
01151
01155 void QwtDial::getScrollMode(const QPoint &p, int &scrollMode, int &direction)
01156 {
01157 direction = 0;
01158 scrollMode = ScrNone;
01159
01160 const QRegion region(contentsRect(), QRegion::Ellipse);
01161 if ( region.contains(p) && p != rect().center() )
01162 {
01163 scrollMode = ScrMouse;
01164 d_data->previousDir = -1.0;
01165 }
01166 }
01167
01187 void QwtDial::keyPressEvent(QKeyEvent *e)
01188 {
01189 if ( isReadOnly() )
01190 {
01191 e->ignore();
01192 return;
01193 }
01194
01195 if ( !isValid() )
01196 return;
01197
01198 double previous = prevValue();
01199 switch ( e->key() )
01200 {
01201 case Qt::Key_Down:
01202 case Qt::Key_Left:
01203 QwtDoubleRange::incValue(-1);
01204 break;
01205 #if QT_VERSION < 0x040000
01206 case Qt::Key_Prior:
01207 #else
01208 case Qt::Key_PageUp:
01209 #endif
01210 QwtDoubleRange::incValue(-pageSize());
01211 break;
01212 case Qt::Key_Home:
01213 setValue(minValue());
01214 break;
01215
01216 case Qt::Key_Up:
01217 case Qt::Key_Right:
01218 QwtDoubleRange::incValue(1);
01219 break;
01220 #if QT_VERSION < 0x040000
01221 case Qt::Key_Next:
01222 #else
01223 case Qt::Key_PageDown:
01224 #endif
01225 QwtDoubleRange::incValue(pageSize());
01226 break;
01227 case Qt::Key_End:
01228 setValue(maxValue());
01229 break;
01230 default:;
01231 e->ignore();
01232 }
01233
01234 if (value() != previous)
01235 emit sliderMoved(value());
01236 }
01237
01246 void QwtDial::updateMask()
01247 {
01248 if ( d_data->visibleBackground )
01249 clearMask();
01250 else
01251 setMask(QRegion(boundingRect(), QRegion::Ellipse));
01252 }