10 #include "qwt_slider.h" 
   11 #include "qwt_painter.h" 
   12 #include "qwt_scale_draw.h" 
   13 #include "qwt_scale_map.h" 
   18 #include <qdrawutil.h> 
   21 #include <qstyleoption.h> 
   24 static QSize qwtHandleSize( 
const QSize& size,
 
   25     Qt::Orientation orientation, 
bool hasTrough )
 
   27     QSize handleSize = size;
 
   29     if ( handleSize.isEmpty() )
 
   31         const int handleThickness = 16;
 
   32         handleSize.setWidth( 2 * handleThickness );
 
   33         handleSize.setHeight( handleThickness );
 
   36             handleSize.transpose();
 
   38         if ( orientation == Qt::Vertical )
 
   39             handleSize.transpose();
 
   50     if ( orientation == Qt::Vertical )
 
   70 class QwtSlider::PrivateData
 
   77         , pendingValueChange( false )
 
   91     bool pendingValueChange;
 
  107     mutable QSize sizeHintCache;
 
  122     initSlider( Qt::Vertical );
 
  148 void QwtSlider::initSlider( Qt::Orientation orientation )
 
  151         setSizePolicy( QSizePolicy::Fixed, QSizePolicy::Expanding );
 
  153         setSizePolicy( QSizePolicy::Expanding, QSizePolicy::Fixed );
 
  155     setAttribute( Qt::WA_WState_OwnSizePolicy, 
false );
 
  157     m_data = 
new QwtSlider::PrivateData;
 
  162         qwtScaleDrawAlignment( 
orientation, m_data->scalePosition ) );
 
  183         qwtScaleDrawAlignment( 
orientation, m_data->scalePosition ) );
 
  185     if ( !testAttribute( Qt::WA_WState_OwnSizePolicy ) )
 
  187         QSizePolicy sp = sizePolicy();
 
  191         setAttribute( Qt::WA_WState_OwnSizePolicy, 
false );
 
  194     if ( testAttribute( Qt::WA_WState_Polished ) )
 
  195         layoutSlider( 
true );
 
  204     return m_data->orientation;
 
  220         qwtScaleDrawAlignment( m_data->orientation, 
scalePosition ) );
 
  222     if ( testAttribute( Qt::WA_WState_Polished ) )
 
  223         layoutSlider( 
true );
 
  232     return m_data->scalePosition;
 
  249     if ( width != m_data->borderWidth )
 
  251         m_data->borderWidth = width;
 
  253         if ( testAttribute( Qt::WA_WState_Polished ) )
 
  254             layoutSlider( 
true );
 
  264     return m_data->borderWidth;
 
  283     if ( 
spacing != m_data->spacing  )
 
  287         if ( testAttribute( Qt::WA_WState_Polished ) )
 
  288             layoutSlider( 
true );
 
  298     return m_data->spacing;
 
  313     if ( size != m_data->handleSize )
 
  315         m_data->handleSize = size;
 
  317         if ( testAttribute( Qt::WA_WState_Polished ) )
 
  318             layoutSlider( 
true );
 
  328     return m_data->handleSize;
 
  347     if ( scaleDraw == NULL || 
scaleDraw == previousScaleDraw )
 
  350     if ( previousScaleDraw )
 
  355     if ( testAttribute( Qt::WA_WState_Polished ) )
 
  356         layoutSlider( 
true );
 
  382     if ( testAttribute( Qt::WA_WState_Polished ) )
 
  383         layoutSlider( 
true );
 
  397     m_data->updateInterval = qMax( interval, 50 );
 
  406     return m_data->updateInterval;
 
  416     QPainter* painter, 
const QRect& sliderRect )
 const 
  420     if ( m_data->hasTrough )
 
  422         const int bw = m_data->borderWidth;
 
  423         innerRect = 
sliderRect.adjusted( bw, bw, -bw, -bw );
 
  425         painter->fillRect( innerRect, palette().brush( QPalette::Mid ) );
 
  426         qDrawShadePanel( painter, 
sliderRect, palette(), 
true, bw, NULL );
 
  429     if ( m_data->hasGroove )
 
  431         const QSize 
handleSize = qwtHandleSize( m_data->handleSize,
 
  432             m_data->orientation, m_data->hasTrough );
 
  434         const int slotExtent = 4;
 
  435         const int slotMargin = 4;
 
  440             int slotOffset = qMax( 1, 
handleSize.width() / 2 - slotMargin );
 
  441             int slotHeight = slotExtent + ( innerRect.height() % 2 );
 
  443             slotRect.setWidth( innerRect.width() - 2 * slotOffset );
 
  444             slotRect.setHeight( slotHeight );
 
  448             int slotOffset = qMax( 1, 
handleSize.height() / 2 - slotMargin );
 
  449             int slotWidth = slotExtent + ( innerRect.width() % 2 );
 
  451             slotRect.setWidth( slotWidth );
 
  452             slotRect.setHeight( innerRect.height() - 2 * slotOffset );
 
  456         slotRect.moveCenter( innerRect.center() );
 
  458         QBrush brush = palette().brush( QPalette::Dark );
 
  459         qDrawShadePanel( painter, slotRect, palette(), 
true, 1, &brush );
 
  474     const QRect& handleRect, 
int pos )
 const 
  476     const int bw = m_data->borderWidth;
 
  478     qDrawShadePanel( painter,
 
  480         &palette().brush( QPalette::Button ) );
 
  485         qDrawShadeLine( painter, pos, 
handleRect.top() + bw,
 
  486             pos, 
handleRect.bottom() - bw, palette(), 
true, 1 );
 
  490         qDrawShadeLine( painter, 
handleRect.left() + bw, pos,
 
  491             handleRect.right() - bw, pos, palette(), 
true, 1 );
 
  507         const double v = ( 
orientation() == Qt::Horizontal )
 
  531     p -= m_data->mouseOffset;
 
  538     p = qBound( min, p, max );
 
  555     const QPoint pos = 
event->pos();
 
  557     if ( 
isValid() && m_data->sliderRect.contains( pos ) )
 
  565             if ( m_data->orientation == Qt::Horizontal )
 
  567                 if ( pos.x() < markerPos )
 
  568                     m_data->stepsIncrement = -m_data->stepsIncrement;
 
  572                 if ( pos.y() < markerPos )
 
  573                     m_data->stepsIncrement = -m_data->stepsIncrement;
 
  577                 m_data->stepsIncrement = -m_data->stepsIncrement;
 
  579             const double v = 
value();
 
  587                     m_data->pendingValueChange = 
true;
 
  592             m_data->timerTick = 
false;
 
  593             m_data->repeatTimerId = startTimer( qMax( 250, 2 * 
updateInterval() ) );
 
  608     if ( m_data->repeatTimerId > 0 )
 
  610         killTimer( m_data->repeatTimerId );
 
  611         m_data->repeatTimerId = 0;
 
  612         m_data->timerTick = 
false;
 
  613         m_data->stepsIncrement = 0;
 
  616     if ( m_data->pendingValueChange )
 
  618         m_data->pendingValueChange = 
false;
 
  635     if ( 
event->timerId() != m_data->repeatTimerId )
 
  637         QwtAbstractSlider::timerEvent( 
event );
 
  643         killTimer( m_data->repeatTimerId );
 
  644         m_data->repeatTimerId = 0;
 
  648     const double v = 
value();
 
  656             m_data->pendingValueChange = 
true;
 
  661     if ( !m_data->timerTick )
 
  664         killTimer( m_data->repeatTimerId );
 
  667         m_data->timerTick = 
true;
 
  677     QPainter painter( 
this );
 
  678     painter.setClipRegion( 
event->region() );
 
  682     style()->drawPrimitive(QStyle::PE_Widget, &opt, &painter, 
this);
 
  686         if ( !m_data->sliderRect.contains( 
event->rect() ) )
 
  702     layoutSlider( 
false );
 
  703     QwtAbstractSlider::resizeEvent( 
event );
 
  714     if ( 
event->type() == QEvent::PolishRequest )
 
  715         layoutSlider( 
false );
 
  717     return QwtAbstractSlider::event( 
event );
 
  726     if ( 
event->type() == QEvent::StyleChange ||
 
  727         event->type() == QEvent::FontChange )
 
  729         if ( testAttribute( Qt::WA_WState_Polished ) )
 
  730             layoutSlider( 
true );
 
  743 void QwtSlider::layoutSlider( 
bool update_geometry )
 
  746     if ( m_data->hasTrough )
 
  747         bw = m_data->borderWidth;
 
  749     const QSize 
handleSize = qwtHandleSize( m_data->handleSize,
 
  750         m_data->orientation, m_data->hasTrough );
 
  773         scaleMargin = qMax( d1, d2 ) - bw;
 
  776     int scaleX, scaleY, scaleLength;
 
  778     if ( m_data->orientation == Qt::Horizontal )
 
  780         const int handleMargin = 
handleSize.width() / 2 - 1;
 
  781         if ( scaleMargin > handleMargin )
 
  783             int off = scaleMargin - handleMargin;
 
  792         int handleMargin = 
handleSize.height() / 2 - 1;
 
  793         if ( scaleMargin > handleMargin )
 
  795             int off = scaleMargin - handleMargin;
 
  803     scaleLength -= 2 * bw;
 
  807     if ( m_data->orientation == Qt::Horizontal )
 
  819             scaleY = 
sliderRect.bottom() + 1 + m_data->spacing;
 
  829             scaleX = 
sliderRect.right() + 1 + m_data->spacing;
 
  843     if ( update_geometry )
 
  845         m_data->sizeHintCache = QSize(); 
 
  862     if ( m_data->hasTrough != on )
 
  864         m_data->hasTrough = on;
 
  866         if ( testAttribute( Qt::WA_WState_Polished ) )
 
  867             layoutSlider( 
true );
 
  877     return m_data->hasTrough;
 
  891     if ( m_data->hasGroove != on )
 
  893         m_data->hasGroove = on;
 
  895         if ( testAttribute( Qt::WA_WState_Polished ) )
 
  896             layoutSlider( 
true );
 
  906     return m_data->hasGroove;
 
  915     return qwtExpandedToGlobalStrut( hint );
 
  924     if ( !m_data->sizeHintCache.isEmpty() )
 
  925         return m_data->sizeHintCache;
 
  927     const QSize 
handleSize = qwtHandleSize( m_data->handleSize,
 
  928         m_data->orientation, m_data->hasTrough );
 
  931     if ( m_data->hasTrough )
 
  932         bw = m_data->borderWidth;
 
  934     int sliderLength = 0;
 
  942         const int scaleBorderDist = 2 * ( qMax( d1, d2 ) - bw );
 
  944         int handleBorderDist;
 
  945         if ( m_data->orientation == Qt::Horizontal )
 
  951         if ( handleBorderDist > scaleBorderDist )
 
  954             sliderLength += handleBorderDist - scaleBorderDist;
 
  957         scaleExtent += m_data->spacing;
 
  958         scaleExtent += qwtCeil( 
scaleDraw()->extent( font() ) );
 
  961     sliderLength = qMax( sliderLength, 84 ); 
 
  966     if ( m_data->orientation == Qt::Horizontal )
 
  969         h = 
handleSize.height() + 2 * bw + scaleExtent;
 
  973         w = 
handleSize.width() + 2 * bw + scaleExtent;
 
  978     const QMargins m = contentsMargins();
 
  980     w += m.left() + m.right();
 
  981     h += m.top() + m.bottom();
 
  983     m_data->sizeHintCache = QSize( w, h );
 
  984     return m_data->sizeHintCache;
 
  997     QPoint center = m_data->sliderRect.center();
 
  998     if ( m_data->orientation == Qt::Horizontal )
 
  999         center.setX( markerPos );
 
 1001         center.setY( markerPos );
 
 1004     rect.setSize( qwtHandleSize( m_data->handleSize,
 
 1005         m_data->orientation, m_data->hasTrough ) );
 
 1006     rect.moveCenter( center );
 
 1016     return m_data->sliderRect;
 
 1020 #include "moc_qwt_slider.cpp" 
virtual void draw(QPainter *, const QPalette &) const
Draw the scale.
const QwtScaleMap & scaleMap() const
double lowerBound() const
const QwtAbstractScaleDraw * abstractScaleDraw() const
int transform(double) const
void setAbstractScaleDraw(QwtAbstractScaleDraw *)
Set a scale draw.
double upperBound() const
void setScale(double lowerBound, double upperBound)
Specify a scale.
virtual void changeEvent(QEvent *) override
An abstract base class for slider widgets with a scale.
virtual void scaleChange() override
virtual void mouseReleaseEvent(QMouseEvent *) override
virtual void mousePressEvent(QMouseEvent *) override
void valueChanged(double value)
Notify a change of value.
void setValue(double value)
void incrementValue(int stepCount)
double value() const
Returns the current value.
void sliderMoved(double value)
static void drawFocusRect(QPainter *, const QWidget *)
Draw a focus rectangle on a widget using its style.
A class for drawing scales.
void setLength(double length)
void move(double x, double y)
void getBorderDistHint(const QFont &, int &start, int &end) const
Determine the minimum border distance.
int minLength(const QFont &) const
void setAlignment(Alignment)
Alignment alignment() const
@ BottomScale
The scale is below.
@ TopScale
The scale is above.
@ RightScale
The scale is right.
@ LeftScale
The scale is left.
double invTransform(double p) const
virtual void mouseReleaseEvent(QMouseEvent *) override
@ LeadingScale
The scale is right of a vertical or below a horizontal slider.
@ TrailingScale
The scale is left of a vertical or above a horizontal slider.
@ NoScale
The slider has no scale.
virtual void resizeEvent(QResizeEvent *) override
virtual ~QwtSlider()
Destructor.
virtual bool isScrollPosition(const QPoint &) const override
Determine what to do when the user presses a mouse button.
void setOrientation(Qt::Orientation)
Set the orientation.
const QwtScaleDraw * scaleDraw() const
void setScalePosition(ScalePosition)
Change the position of the scale.
virtual void paintEvent(QPaintEvent *) override
QwtSlider(QWidget *parent=NULL)
virtual bool event(QEvent *) override
virtual QSize minimumSizeHint() const override
virtual void drawHandle(QPainter *, const QRect &, int pos) const
void setHandleSize(const QSize &)
Set the slider's handle size.
virtual void timerEvent(QTimerEvent *) override
int updateInterval() const
void setScaleDraw(QwtScaleDraw *)
Set a scale draw.
void setSpacing(int)
Change the spacing between trough and scale.
virtual double scrolledTo(const QPoint &) const override
Determine the value for a new position of the slider handle.
virtual void changeEvent(QEvent *) override
ScalePosition scalePosition() const
void setBorderWidth(int)
Change the slider's border width.
virtual void scaleChange() override
Notify changed scale.
virtual QSize sizeHint() const override
virtual void mousePressEvent(QMouseEvent *) override
void setUpdateInterval(int)
Specify the update interval for automatic scrolling.
Qt::Orientation orientation() const
virtual void drawSlider(QPainter *, const QRect &) const