qwt_slider.cpp

软件无线电的平台

void QwtSlider::getScrollMode(const QPoint &p, 
    int &scrollMode, int &direction )
{
    if (!d_sliderRect.contains(p))
    {
        scrollMode = ScrNone;
        direction = 0;
        return;
    }

    const int pos = ( orientation() == Qt::Horizontal ) ? p.x() : p.y();
    const int markerPos = xyPosition(value());

    if ((pos > markerPos - d_thumbLength / 2)
        && (pos < markerPos + d_thumbLength / 2))
    {
        scrollMode = ScrMouse;
        direction = 0;
        return;
    }

    scrollMode = ScrPage;
    direction = (pos > markerPos) ? 1 : -1;
    if ( scaleDraw()->i1() > scaleDraw()->i2() )
        direction = -direction;
}

//! Qt paint event
void QwtSlider::paintEvent(QPaintEvent *e)
{
    const QRect &ur = e->rect();
    if ( ur.isValid() )
    {
        QwtPaintBuffer paintBuffer(this, ur);
        draw(paintBuffer.painter(), ur);
    }
}

//! redraw the slider
void QwtSlider::draw(QPainter *painter, const QRect&)
{
    if (d_scalePos != None)
        scaleDraw()->draw(painter);

    drawSlider(painter, d_sliderRect);
    if ( hasFocus() )
    {
        const QRect rect = d_sliderRect;

#if QT_VERSION < 300
        style().drawFocusRect(painter, rect, colorGroup());
#else
        style().drawPrimitive(QStyle::PE_FocusRect, painter,
            rect, colorGroup());
#endif
    }
}

//! Qt resize event
void QwtSlider::resizeEvent(QResizeEvent *)
{
    layoutSlider( FALSE );
}

//! Recalculate the slider's geometry and layout based on
//  the current rect and fonts.
//  \param update_geometry  notify the layout system and call update
//         to redraw the scale

void QwtSlider::layoutSlider( bool update_geometry )
{
    int sliderWidth = d_thumbWidth;
    int sld1 = d_thumbLength / 2 - 1;
    int sld2 = d_thumbLength / 2 + d_thumbLength % 2;
    if ( d_bgStyle & BgTrough )
    {
        sliderWidth += 2 * d_borderWidth;
        sld1 += d_borderWidth;
        sld2 += d_borderWidth;
    }

    int scd = 0;
    if ( d_scalePos != None )
    {
        int d1, d2;
        scaleDraw()->minBorderDist(fontMetrics(), d1, d2);
        scd = QMAX(d1, d2);
    }

    int slo = scd - sld1;
    if ( slo < 0 )
        slo = 0;

    const QRect r = rect();
    switch ( d_scalePos )
    {
        case Top:
        {
            d_sliderRect.setRect(r.x() + d_xMargin + slo,
                r.y() + r.height() -
                d_yMargin - sliderWidth,
                r.width() - 2 * d_xMargin - 2 * slo,
                sliderWidth);
            scaleDraw()->setGeometry(d_sliderRect.x() + sld1,
                d_sliderRect.y() - d_scaleDist,
                d_sliderRect.width() - sld1 - sld2,
                QwtScaleDraw::Top);
            break;
        }
        case Bottom:
        {
            d_sliderRect.setRect(r.x() + d_xMargin + slo,
                r.y() + d_yMargin,
                r.width() - 2 * d_xMargin - 2 * slo,
                sliderWidth);
            scaleDraw()->setGeometry(d_sliderRect.x() + sld1,
                d_sliderRect.y() + d_sliderRect.height() +
                d_scaleDist,
                d_sliderRect.width() - sld1 - sld2,
                QwtScaleDraw::Bottom);
            break;
        }
        case Left:
        {
            d_sliderRect.setRect(r.x() + r.width() -
                sliderWidth - d_xMargin,
                r.y() + d_yMargin + slo,
                sliderWidth,
                r.height() - 2 * d_yMargin - 2 * slo);
            scaleDraw()->setGeometry(d_sliderRect.x() - d_scaleDist,
                d_sliderRect.y() + sld1,
                d_sliderRect.height() - sld1 - sld2,
                QwtScaleDraw::Left);
            break;
        }
        case Right:
        {
            d_sliderRect.setRect(r.x() + d_xMargin,
                r.y() + d_yMargin + slo,
                sliderWidth,
                r.height() - 2 * d_yMargin - 2 * slo);
            scaleDraw()->setGeometry(d_sliderRect.x() + d_sliderRect.width() +
                d_scaleDist,
                d_sliderRect.y() + sld1,
                d_sliderRect.height() - sld1 - sld2,
                QwtScaleDraw::Right);
            break;
        }
        default:
        {
            d_sliderRect.setRect(r.x() + d_xMargin,
                r.y() + d_yMargin,
                r.width() - 2 * d_xMargin,
                r.height() - 2 * d_yMargin);

            // QwtScaleDraw is derived from QwtDiMap. Even if
            // no scale is required we keep the map alive.

            if ( orientation() == Qt::Horizontal )
            {
                scaleDraw()->setIntRange(
                    d_sliderRect.x() + sld1,
                    d_sliderRect.x() + d_sliderRect.width() - sld2 - 1);
            }
            else
            {
                scaleDraw()->setIntRange(
                    d_sliderRect.y() + d_sliderRect.height() - sld2 - 1,
                    d_sliderRect.y() + sld1);
            }
        }
    }

    if ( update_geometry )
    {
        updateGeometry();
        update();
    }
}

//! Notify change of value
void QwtSlider::valueChange()
{
    QwtSliderBase::valueChange();
    update();
}


//! Notify change of range
void QwtSlider::rangeChange()
{
    if (!hasUserScale())
    {
        scaleDraw()->setScale(minValue(), maxValue(), 
            scaleMaxMajor(), scaleMaxMinor(),
            scaleDraw()->scaleDiv().logScale());
    }

    QwtSliderBase::rangeChange();
    layoutSlider();
}

/*!
  \brief Set distances between the widget's border and internals.
  \param xMargin Horizontal margin
  \param yMargin Vertical margin
*/
void QwtSlider::setMargins(int xMargin, int yMargin)
{
    if ( xMargin < 0 )
        xMargin = 0;
    if ( yMargin < 0 )
        yMargin = 0;

    if ( xMargin != d_xMargin || yMargin != d_yMargin )
    {
        d_xMargin = xMargin;
        d_yMargin = yMargin;
        layoutSlider();
    }
}

/*!
  \return Horizontal: MinimumExpanding/Fixed,
        Vertical: Fixed/MinimumExpanding
*/
QSizePolicy QwtSlider::sizePolicy() const
{
    QSizePolicy sp;
    if ( orientation() == Qt::Horizontal )
    {
        sp.setHorData( QSizePolicy::MinimumExpanding );
        sp.setVerData( QSizePolicy::Fixed );
    }
    else
    {
        sp.setHorData( QSizePolicy::Fixed );
        sp.setVerData( QSizePolicy::MinimumExpanding );
    }
    return sp;
}

/*!
  \return QwtSlider::minimumSizeHint()
*/
QSize QwtSlider::sizeHint() const
{
    return minimumSizeHint();
}

/*!
  \brief Return a minimum size hint
  \warning The return value of QwtSlider::minimumSizeHint() depends on 
           the font and the scale.
*/
QSize QwtSlider::minimumSizeHint() const
{
    int w = 0, h = 0;

    int sliderWidth = d_thumbWidth;
    if (d_bgStyle & BgTrough)
        sliderWidth += 2 * d_borderWidth;

    if (d_scalePos != None)
    {
        int msWidth = scaleDraw()->minWidth( QPen(), fontMetrics() );
        int msHeight = scaleDraw()->minHeight( QPen(), fontMetrics() );
        
        int d1, d2;
        scaleDraw()->minBorderDist(fontMetrics(), d1, d2);
        int msMbd = QMAX(d1, d2);

        int mbd = d_thumbLength / 2;
        if (d_bgStyle & BgTrough)
            mbd += d_borderWidth;

        if ( mbd < msMbd )
            mbd = msMbd;

        if (orientation() == Qt::Vertical)
        {
            w = 2 * d_xMargin + sliderWidth + msWidth + d_scaleDist;
            h = msHeight - 2 * msMbd + 2 * mbd + 2 * d_yMargin;
        }
        else
        {
            w = msWidth - 2 * msMbd + 2 * mbd + 2 * d_xMargin;
            h = 2 * d_yMargin + sliderWidth  + msHeight + d_scaleDist;
        }
    }
    else  // no scale
    {
        if (orientation() == Qt::Vertical)
        {
            w = 2 * d_xMargin + sliderWidth;
            h = 200 + 2 * d_yMargin;
        }
        else
        {
            w = 200 + 2 * d_xMargin;
            h = 2 * d_yMargin + sliderWidth;
        }
    }
    return QSize(w,h);
}