void ScrollZoomer::setHScrollBarMode( Qt::ScrollBarPolicy mode )

{

    if ( hScrollBarMode() != mode )

    {

        d_hScrollData->mode = mode;

        updateScrollBars();

    }

}

void ScrollZoomer::setVScrollBarMode( Qt::ScrollBarPolicy mode )

{

    if ( vScrollBarMode() != mode )

    {

        d_vScrollData->mode = mode;

        updateScrollBars();

    }

}

Qt::ScrollBarPolicy ScrollZoomer::hScrollBarMode() const

{

    return d_hScrollData->mode;

}

Qt::ScrollBarPolicy ScrollZoomer::vScrollBarMode() const

{

    return d_vScrollData->mode;

}

void ScrollZoomer::setHScrollBarPosition( ScrollBarPosition pos )

{

    if ( d_hScrollData->position != pos )

    {

        d_hScrollData->position = pos;

        updateScrollBars();

    }

}

void ScrollZoomer::setVScrollBarPosition( ScrollBarPosition pos )

{

    if ( d_vScrollData->position != pos )

    {

        d_vScrollData->position = pos;

        updateScrollBars();

    }

}

ScrollZoomer::ScrollBarPosition ScrollZoomer::hScrollBarPosition() const

{

    return d_hScrollData->position;

}

ScrollZoomer::ScrollBarPosition ScrollZoomer::vScrollBarPosition() const

{

    return d_vScrollData->position;

}

void ScrollZoomer::setCornerWidget( QWidget *w )

{

    if ( w != d_cornerWidget )

    {

        if ( canvas() )

        {

            delete d_cornerWidget;

            d_cornerWidget = w;

            if ( d_cornerWidget->parent() != canvas() )

                d_cornerWidget->setParent( canvas() );

            updateScrollBars();

        }

    }

}

QWidget *ScrollZoomer::cornerWidget() const

{

    return d_cornerWidget;

}

bool ScrollZoomer::eventFilter( QObject *object, QEvent *event )

{

    if ( object == canvas() )

    {

        switch( event->type() )

        {

            case QEvent::Resize:

            {

                int left, top, right, bottom;

                canvas()->getContentsMargins( &left, &top, &right, &bottom );

                QRect rect;

                rect.setSize( static_cast<QResizeEvent *>( event )->size() );

                rect.adjust( left, top, -right, -bottom );

                layoutScrollBars( rect );

                break;

            }

            case QEvent::ChildRemoved:

            {

                const QObject *child =

                    static_cast<QChildEvent *>( event )->child();

                if ( child == d_cornerWidget )

                    d_cornerWidget = NULL;

                else if ( child == d_hScrollData->scrollBar )

                    d_hScrollData->scrollBar = NULL;

                else if ( child == d_vScrollData->scrollBar )

                    d_vScrollData->scrollBar = NULL;

                break;

            }

            default:

                break;

        }

    }

    return QwtPlotZoomer::eventFilter( object, event );

}

bool ScrollZoomer::needScrollBar( Qt::Orientation orientation ) const

{

    Qt::ScrollBarPolicy mode;

    double zoomMin, zoomMax, baseMin, baseMax;

    if ( orientation == Qt::Horizontal )

    {

        mode = d_hScrollData->mode;

        // baseMin = zoomBase().left();

        // baseMax = zoomBase().right();

        baseMin = d_limits.left();

        baseMax = d_limits.right();

        zoomMin = zoomRect().left();

        zoomMax = zoomRect().right();

    }

    else

    {

        mode = d_vScrollData->mode;

        // baseMin = zoomBase().top();

        // baseMax = zoomBase().bottom();

        baseMin = d_limits.top();

        baseMax = d_limits.bottom();

        zoomMin = zoomRect().top();

        zoomMax = zoomRect().bottom();

    }

    bool needed = false;

    switch( mode )

    {

        case Qt::ScrollBarAlwaysOn:

            needed = true;

            break;

        case Qt::ScrollBarAlwaysOff:

            needed = false;

            break;

        default:

        {

            if ( baseMin < zoomMin || baseMax > zoomMax )

                needed = true;

            break;

        }

    }

    return needed;

}

void ScrollZoomer::updateScrollBars()

{

    qDebug() << "updateScrollBars()";

    if ( !canvas() )

        return;

    const int xAxis = QwtPlotZoomer::xAxis();

    const int yAxis = QwtPlotZoomer::yAxis();

    int xScrollBarAxis = xAxis;

    if ( hScrollBarPosition() == OppositeToScale )

        xScrollBarAxis = oppositeAxis( xScrollBarAxis );

    int yScrollBarAxis = yAxis;

    if ( vScrollBarPosition() == OppositeToScale )

        yScrollBarAxis = oppositeAxis( yScrollBarAxis );

    QwtPlotLayout *layout = plot()->plotLayout();

    bool showHScrollBar = needScrollBar( Qt::Horizontal );

    if ( showHScrollBar )

    {

        ScrollBar *sb = scrollBar( Qt::Horizontal );

        sb->setPalette( plot()->palette() );

        sb->setInverted( !plot()->axisScaleDiv( xAxis ).isIncreasing() );

        // sb->setBase( zoomBase().left(), zoomBase().right() );

        sb->setBase( d_limits.left(), d_limits.right() );

        sb->moveSlider( zoomRect().left(), zoomRect().right() );

        qDebug() << "moveSlider" << zoomRect().left() << zoomRect().right();

        if ( !sb->isVisibleTo( canvas() ) )

        {

            sb->show();

            layout->setCanvasMargin( layout->canvasMargin( xScrollBarAxis )

                + sb->extent(), xScrollBarAxis );

        }

    }

    else

    {

        if ( horizontalScrollBar() )

        {

            horizontalScrollBar()->hide();

            layout->setCanvasMargin( layout->canvasMargin( xScrollBarAxis )

                - horizontalScrollBar()->extent(), xScrollBarAxis );

        }

    }

    bool showVScrollBar = needScrollBar( Qt::Vertical );

    if ( showVScrollBar )

    {

        ScrollBar *sb = scrollBar( Qt::Vertical );

        sb->setPalette( plot()->palette() );

        sb->setInverted( plot()->axisScaleDiv( yAxis ).isIncreasing() );

        sb->setBase( d_limits.top(), d_limits.bottom() );

        sb->moveSlider( zoomRect().top(), zoomRect().bottom() );

        if ( !sb->isVisibleTo( canvas() ) )

        {

            sb->show();

            layout->setCanvasMargin( layout->canvasMargin( yScrollBarAxis )

                + sb->extent(), yScrollBarAxis );

        }

    }

    else

    {

        if ( verticalScrollBar() )

        {

            verticalScrollBar()->hide();

            layout->setCanvasMargin( layout->canvasMargin( yScrollBarAxis )

                - verticalScrollBar()->extent(), yScrollBarAxis );

        }

    }

    if ( showHScrollBar && showVScrollBar )

    {

        if ( d_cornerWidget == NULL )

        {

            d_cornerWidget = new QWidget( canvas() );

            d_cornerWidget->setAutoFillBackground( true );

            d_cornerWidget->setPalette( plot()->palette() );

        }

        d_cornerWidget->show();

    }

    else

    {

        if ( d_cornerWidget )

            d_cornerWidget->hide();

    }

    layoutScrollBars( canvas()->contentsRect() );

    plot()->updateLayout();

}

void ScrollZoomer::layoutScrollBars( const QRect &rect )

{

    int hPos = xAxis();

    if ( hScrollBarPosition() == OppositeToScale )

        hPos = oppositeAxis( hPos );

    int vPos = yAxis();

    if ( vScrollBarPosition() == OppositeToScale )

        vPos = oppositeAxis( vPos );

    ScrollBar *hScrollBar = horizontalScrollBar();

    ScrollBar *vScrollBar = verticalScrollBar();

    const int hdim = hScrollBar ? hScrollBar->extent() : 0;

    const int vdim = vScrollBar ? vScrollBar->extent() : 0;

    if ( hScrollBar && hScrollBar->isVisible() )

    {

        int x = rect.x();

        int y = ( hPos == QwtPlot::xTop )

            ? rect.top() : rect.bottom() - hdim + 1;

        int w = rect.width();

        if ( vScrollBar && vScrollBar->isVisible() )

        {

            if ( vPos == QwtPlot::yLeft )

                x += vdim;

            w -= vdim;

        }

        hScrollBar->setGeometry( x, y, w, hdim );

    }

    if ( vScrollBar && vScrollBar->isVisible() )

    {

        int pos = yAxis();

        if ( vScrollBarPosition() == OppositeToScale )

            pos = oppositeAxis( pos );

        int x = ( vPos == QwtPlot::yLeft )

            ? rect.left() : rect.right() - vdim + 1;

        int y = rect.y();

        int h = rect.height();

        if ( hScrollBar && hScrollBar->isVisible() )

        {

            if ( hPos == QwtPlot::xTop )

                y += hdim;

            h -= hdim;

        }

        vScrollBar->setGeometry( x, y, vdim, h );

    }

    if ( hScrollBar && hScrollBar->isVisible() &&

        vScrollBar && vScrollBar->isVisible() )

    {

        if ( d_cornerWidget )

        {

            QRect cornerRect(

                vScrollBar->pos().x(), hScrollBar->pos().y(),

                vdim, hdim );

            d_cornerWidget->setGeometry( cornerRect );

        }

    }

}

void ScrollZoomer::scrollBarMoved(

    Qt::Orientation o, double min, double max )

{

    Q_UNUSED( max );

    if ( o == Qt::Horizontal )

        moveTo( QPointF( min, zoomRect().top() ) );

    else

        moveTo( QPointF( zoomRect().left(), min ) );

    Q_EMIT zoomed( zoomRect() );

}

int ScrollZoomer::oppositeAxis( int axis ) const

{

    switch( axis )

    {

        case QwtPlot::xBottom:

            return QwtPlot::xTop;

        case QwtPlot::xTop:

            return QwtPlot::xBottom;

        case QwtPlot::yLeft:

            return QwtPlot::yRight;

        case QwtPlot::yRight:

            return QwtPlot::yLeft;

        default:

            break;

    }

    return axis;

}