qwt_plot_zoomer.cpp

Go to the documentation of this file.

/******************************************************************************
 * Qwt Widget Library
 * Copyright (C) 1997   Josef Wilgen
 * Copyright (C) 2002   Uwe Rathmann
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the Qwt License, Version 1.0
 *****************************************************************************/
 
#include "qwt_plot_zoomer.h"
#include "qwt_plot.h"
#include "qwt_scale_div.h"
#include "qwt_scale_map.h"
#include "qwt_interval.h"
#include "qwt_picker_machine.h"
 
#include <qstack.h>
 
static QwtInterval qwtExpandedZoomInterval( double v1, double v2,
    double minRange, const QwtTransform* transform )
{
    double min = v1;
    double max = v2;
 
    if ( max - min < minRange )
    {
        min = 0.5 * ( min + max - minRange );
        max = min + minRange;
 
        if ( transform )
        {
            // f.e the logarithmic scale doesn't allow values
            // outside [QwtLogTransform::LogMin/QwtLogTransform::LogMax]
 
            double minBounded = transform->bounded( min );
            double maxBounded = transform->bounded( max );
 
            if ( minBounded != min )
            {
                maxBounded = transform->bounded( minBounded + minRange );
            }
            else if ( maxBounded != max )
            {
                minBounded = transform->bounded( maxBounded - minRange );
            }
 
            min = minBounded;
            max = maxBounded;
        }
    }
 
    return QwtInterval( min, max );
}
 
static QRectF qwtExpandedZoomRect( const QRectF& zoomRect, const QSizeF& minSize,
    const QwtTransform* transformX, const QwtTransform* transformY )
{
    QRectF r = zoomRect;
 
    if ( minSize.width() > r.width() )
    {
        const QwtInterval intv = qwtExpandedZoomInterval(
            r.left(), r.right(), minSize.width(), transformX );
 
        r.setLeft( intv.minValue() );
        r.setRight( intv.maxValue() );
    }
 
    if ( minSize.height() > r.height() )
    {
        const QwtInterval intv = qwtExpandedZoomInterval(
            zoomRect.top(), zoomRect.bottom(), minSize.height(), transformY );
 
        r.setTop( intv.minValue() );
        r.setBottom( intv.maxValue() );
    }
 
    return r;
}
 
class QwtPlotZoomer::PrivateData
{
  public:
    uint zoomRectIndex;
    QStack< QRectF > zoomStack;
 
    int maxStackDepth;
};
 
QwtPlotZoomer::QwtPlotZoomer( QWidget* canvas, bool doReplot )
    : QwtPlotPicker( canvas )
{
    if ( canvas )
        init( doReplot );
}
 
QwtPlotZoomer::QwtPlotZoomer( QwtAxisId xAxisId, QwtAxisId yAxisId,
        QWidget* canvas, bool doReplot )
    : QwtPlotPicker( xAxisId, yAxisId, canvas )
{
    if ( canvas )
        init( doReplot );
}
 
void QwtPlotZoomer::init( bool doReplot )
{
    m_data = new PrivateData;
 
    m_data->maxStackDepth = -1;
 
    setTrackerMode( ActiveOnly );
    setRubberBand( RectRubberBand );
    setStateMachine( new QwtPickerDragRectMachine() );
 
    if ( doReplot && plot() )
        plot()->replot();
 
    setZoomBase( scaleRect() );
}
 
QwtPlotZoomer::~QwtPlotZoomer()
{
    delete m_data;
}
 
void QwtPlotZoomer::setMaxStackDepth( int depth )
{
    m_data->maxStackDepth = depth;
 
    if ( depth >= 0 )
    {
        // unzoom if the current depth is below m_data->maxStackDepth
 
        const int zoomOut =
            m_data->zoomStack.count() - 1 - depth; // -1 for the zoom base
 
        if ( zoomOut > 0 )
        {
            zoom( -zoomOut );
            for ( int i = m_data->zoomStack.count() - 1;
                i > int( m_data->zoomRectIndex ); i-- )
            {
                ( void )m_data->zoomStack.pop(); // remove trailing rects
            }
        }
    }
}
 
int QwtPlotZoomer::maxStackDepth() const
{
    return m_data->maxStackDepth;
}
 
const QStack< QRectF >& QwtPlotZoomer::zoomStack() const
{
    return m_data->zoomStack;
}
 
QRectF QwtPlotZoomer::zoomBase() const
{
    return m_data->zoomStack[0];
}
 
void QwtPlotZoomer::setZoomBase( bool doReplot )
{
    QwtPlot* plt = plot();
    if ( plt == NULL )
        return;
 
    if ( doReplot )
        plt->replot();
 
    m_data->zoomStack.clear();
    m_data->zoomStack.push( scaleRect() );
    m_data->zoomRectIndex = 0;
 
    rescale();
}
 
void QwtPlotZoomer::setZoomBase( const QRectF& base )
{
    const QwtPlot* plt = plot();
    if ( !plt )
        return;
 
    const QRectF sRect = scaleRect();
    const QRectF bRect = base | sRect;
 
    m_data->zoomStack.clear();
    m_data->zoomStack.push( bRect );
    m_data->zoomRectIndex = 0;
 
    if ( base != sRect )
    {
        m_data->zoomStack.push( sRect );
        m_data->zoomRectIndex++;
    }
 
    rescale();
}
 
QRectF QwtPlotZoomer::zoomRect() const
{
    return m_data->zoomStack[m_data->zoomRectIndex];
}
 
uint QwtPlotZoomer::zoomRectIndex() const
{
    return m_data->zoomRectIndex;
}
 
void QwtPlotZoomer::zoom( const QRectF& rect )
{
    if ( m_data->maxStackDepth >= 0 &&
        int( m_data->zoomRectIndex ) >= m_data->maxStackDepth )
    {
        return;
    }
 
    const QRectF zoomRect = rect.normalized();
    if ( zoomRect != m_data->zoomStack[m_data->zoomRectIndex] )
    {
        for ( uint i = m_data->zoomStack.count() - 1;
            i > m_data->zoomRectIndex; i-- )
        {
            ( void )m_data->zoomStack.pop();
        }
 
        m_data->zoomStack.push( zoomRect );
        m_data->zoomRectIndex++;
 
        rescale();
 
        Q_EMIT zoomed( zoomRect );
    }
}
 
void QwtPlotZoomer::zoom( int offset )
{
    int newIndex;
 
    if ( offset == 0 )
    {
        newIndex = 0;
    }
    else
    {
        newIndex = m_data->zoomRectIndex + offset;
        newIndex = qBound( 0, newIndex, m_data->zoomStack.count() - 1 );
    }
 
    if ( newIndex != static_cast< int >( m_data->zoomRectIndex ) )
    {
        m_data->zoomRectIndex = newIndex;
        rescale();
        Q_EMIT zoomed( zoomRect() );
    }
}
 
void QwtPlotZoomer::setZoomStack(
    const QStack< QRectF >& zoomStack, int zoomRectIndex )
{
    if ( zoomStack.isEmpty() )
        return;
 
    if ( m_data->maxStackDepth >= 0 &&
        zoomStack.count() > m_data->maxStackDepth )
    {
        return;
    }
 
    if ( zoomRectIndex < 0 || zoomRectIndex > zoomStack.count() )
        zoomRectIndex = zoomStack.count() - 1;
 
    const bool doRescale = zoomStack[zoomRectIndex] != zoomRect();
 
    m_data->zoomStack = zoomStack;
    m_data->zoomRectIndex = uint( zoomRectIndex );
 
    if ( doRescale )
    {
        rescale();
        Q_EMIT zoomed( zoomRect() );
    }
}
 
void QwtPlotZoomer::rescale()
{
    QwtPlot* plt = plot();
    if ( !plt )
        return;
 
    const QRectF& rect = m_data->zoomStack[m_data->zoomRectIndex];
    if ( rect != scaleRect() )
    {
        const bool doReplot = plt->autoReplot();
        plt->setAutoReplot( false );
 
        double x1 = rect.left();
        double x2 = rect.right();
        if ( !plt->axisScaleDiv( xAxis() ).isIncreasing() )
            qSwap( x1, x2 );
 
        plt->setAxisScale( xAxis(), x1, x2 );
 
        double y1 = rect.top();
        double y2 = rect.bottom();
        if ( !plt->axisScaleDiv( yAxis() ).isIncreasing() )
            qSwap( y1, y2 );
 
        plt->setAxisScale( yAxis(), y1, y2 );
 
        plt->setAutoReplot( doReplot );
 
        plt->replot();
    }
}
 
void QwtPlotZoomer::setAxes( QwtAxisId xAxisId, QwtAxisId yAxisId )
{
    if ( xAxisId != QwtPlotPicker::xAxis() || yAxisId != QwtPlotPicker::yAxis() )
    {
        QwtPlotPicker::setAxes( xAxisId, yAxisId );
        setZoomBase( scaleRect() );
    }
}
 
void QwtPlotZoomer::widgetMouseReleaseEvent( QMouseEvent* me )
{
    if ( mouseMatch( MouseSelect2, me ) )
        zoom( 0 );
    else if ( mouseMatch( MouseSelect3, me ) )
        zoom( -1 );
    else if ( mouseMatch( MouseSelect6, me ) )
        zoom( +1 );
    else
        QwtPlotPicker::widgetMouseReleaseEvent( me );
}
 
void QwtPlotZoomer::widgetKeyPressEvent( QKeyEvent* ke )
{
    if ( !isActive() )
    {
        if ( keyMatch( KeyUndo, ke ) )
            zoom( -1 );
        else if ( keyMatch( KeyRedo, ke ) )
            zoom( +1 );
        else if ( keyMatch( KeyHome, ke ) )
            zoom( 0 );
    }
 
    QwtPlotPicker::widgetKeyPressEvent( ke );
}
 
void QwtPlotZoomer::moveBy( double dx, double dy )
{
    const QRectF& rect = m_data->zoomStack[m_data->zoomRectIndex];
    moveTo( QPointF( rect.left() + dx, rect.top() + dy ) );
}
 
void QwtPlotZoomer::moveTo( const QPointF& pos )
{
    double x = pos.x();
    double y = pos.y();
 
    if ( x < zoomBase().left() )
        x = zoomBase().left();
    if ( x > zoomBase().right() - zoomRect().width() )
        x = zoomBase().right() - zoomRect().width();
 
    if ( y < zoomBase().top() )
        y = zoomBase().top();
    if ( y > zoomBase().bottom() - zoomRect().height() )
        y = zoomBase().bottom() - zoomRect().height();
 
    if ( x != zoomRect().left() || y != zoomRect().top() )
    {
        m_data->zoomStack[m_data->zoomRectIndex].moveTo( x, y );
        rescale();
    }
}
 
bool QwtPlotZoomer::accept( QPolygon& pa ) const
{
    if ( pa.count() < 2 )
        return false;
 
    QRect rect = QRect( pa.first(), pa.last() );
    rect = rect.normalized();
 
    const int minSize = 2;
    if ( rect.width() < minSize && rect.height() < minSize )
        return false;
 
    const int minZoomSize = 11;
 
    const QPoint center = rect.center();
    rect.setSize( rect.size().expandedTo( QSize( minZoomSize, minZoomSize ) ) );
    rect.moveCenter( center );
 
    pa.resize( 2 );
    pa[0] = rect.topLeft();
    pa[1] = rect.bottomRight();
 
    return true;
}
 
QSizeF QwtPlotZoomer::minZoomSize() const
{
    return QSizeF( m_data->zoomStack[0].width() / 10e4,
        m_data->zoomStack[0].height() / 10e4 );
}
 
void QwtPlotZoomer::begin()
{
    if ( m_data->maxStackDepth >= 0 )
    {
        if ( m_data->zoomRectIndex >= uint( m_data->maxStackDepth ) )
            return;
    }
 
    const QSizeF minSize = minZoomSize();
    if ( minSize.isValid() )
    {
        const QSizeF sz =
            m_data->zoomStack[m_data->zoomRectIndex].size() * 0.9999;
 
        if ( minSize.width() >= sz.width() &&
            minSize.height() >= sz.height() )
        {
            return;
        }
    }
 
    QwtPlotPicker::begin();
}
 
bool QwtPlotZoomer::end( bool ok )
{
    ok = QwtPlotPicker::end( ok );
    if ( !ok )
        return false;
 
    QwtPlot* plot = QwtPlotZoomer::plot();
    if ( !plot )
        return false;
 
    const QPolygon& pa = selection();
    if ( pa.count() < 2 )
        return false;
 
    QRect rect = QRect( pa.first(), pa.last() );
    rect = rect.normalized();
 
    const QwtScaleMap xMap = plot->canvasMap( xAxis() );
    const QwtScaleMap yMap = plot->canvasMap( yAxis() );
 
    QRectF zoomRect = QwtScaleMap::invTransform( xMap, yMap, rect ).normalized();
 
    zoomRect = qwtExpandedZoomRect( zoomRect, minZoomSize(),
        xMap.transformation(), yMap.transformation() );
 
    zoom( zoomRect );
 
    return true;
}
 
#if QWT_MOC_INCLUDE
#include "moc_qwt_plot_zoomer.cpp"
#endif