/*

  Copyright © 2014 Uwe Rathmann

  This file is copied from Qwt project; you can redistribute it and/or modify it

  under the terms of the Qwt License, Version 1.0. You can obtain the original

  source code and the details of the Qwt License from the Qwt website:

  http://qwt.sourceforge.net/

*/

#include <qevent.h>

#include <qwt_plot_canvas.h>

#include <qwt_plot_layout.h>

#include <qwt_scale_engine.h>

#include <qwt_scale_widget.h>

#include "scrollbar.h"

#include "scrollzoomer.h"

class ScrollData

{

public:

    ScrollData():

        scrollBar( NULL ),

        position( ScrollZoomer::OppositeToScale ),

        mode( Qt::ScrollBarAsNeeded )

    {

    }

    ~ScrollData()

    {

        delete scrollBar;

    }

    ScrollBar *scrollBar;

    ScrollZoomer::ScrollBarPosition position;

    Qt::ScrollBarPolicy mode;

};

ScrollZoomer::ScrollZoomer( QWidget *canvas ):

    QwtPlotZoomer( canvas ),

    d_cornerWidget( NULL ),

    d_hScrollData( NULL ),

    d_vScrollData( NULL ),

    d_inZoom( false )

{

    xMin = 0.;

    xMax = 10000.;

    hViewSize = 10000;

    for ( int axis = 0; axis < QwtPlot::axisCnt; axis++ )

        d_alignCanvasToScales[ axis ] = false;

    if ( !canvas )

        return;

    d_hScrollData = new ScrollData;

    d_vScrollData = new ScrollData;

    hscrollmove = false;

    vscrollmove = false;

}

ScrollZoomer::~ScrollZoomer()

{

    delete d_cornerWidget;

    delete d_vScrollData;

    delete d_hScrollData;

}

void ScrollZoomer::setXLimits(double min, double max)

{

    xMin = min;

    xMax = max;

    setZoomBase();

}

void ScrollZoomer::setHViewSize(double size)

{

    hViewSize = size;

    setZoomBase();

}

void ScrollZoomer::setZoomBase(bool doReplot)

{

    QwtPlotZoomer::setZoomBase(doReplot);

    auto zb = zoomBase();

    auto zs = zoomStack();

    zb.setRight(xMax);

    if ((xMax - xMin) < hViewSize)

    {

        zb.setLeft(xMin);

    }

    else

    {

        zb.setLeft(xMax-hViewSize);

    }

    zs[0] = zb;

    setZoomStack(zs);

}

void ScrollZoomer::rescale()

{

    QwtScaleWidget *xScale = plot()->axisWidget( xAxis() );

    QwtScaleWidget *yScale = plot()->axisWidget( yAxis() );

    if ( zoomRectIndex() <= 0 )

    {

        if ( d_inZoom )

        {

            xScale->setMinBorderDist( 0, 0 );

            yScale->setMinBorderDist( 0, 0 );

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

            for ( int axis = 0; axis < QwtPlot::axisCnt; axis++ )

                layout->setAlignCanvasToScale( axis, d_alignCanvasToScales[ axis ] );

            d_inZoom = false;

        }

    }

    else

    {

        if ( !d_inZoom )

        {

            /*

             We set a minimum border distance.

             Otherwise the canvas size changes when scrolling,

             between situations where the major ticks are at

             the canvas borders (requiring extra space for the label)

             and situations where all labels can be painted below/top

             or left/right of the canvas.

             */

            int start, end;

            xScale->getBorderDistHint( start, end );

            xScale->setMinBorderDist( start, end );

            yScale->getBorderDistHint( start, end );

            yScale->setMinBorderDist( start, end );

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

            for ( int axis = 0; axis < QwtPlot::axisCnt; axis++ )

            {

                d_alignCanvasToScales[axis] = 

                    layout->alignCanvasToScale( axis );

            }

            layout->setAlignCanvasToScales( false );

            d_inZoom = true;

        }

    }

    // NOTE: Below snippet is copied from QwtPlotZoomer::rescale() just so that

    // we can refrain from updating y axis when moving horizontal scrollbar, so

    // that auto-scale isn't disrupted. Also we don't want to jump around in

    // x-axis when moving vertical scroll.

    {

        QwtPlot *plt = plot();

        if ( !plt )

            return;

        const QRectF &rect = zoomStack()[zoomRectIndex()];

        if ( rect != scaleRect() )

        {

            const bool doReplot = plt->autoReplot();

            plt->setAutoReplot( false );

            if (!vscrollmove)

            {

                double x1 = rect.left();

                double x2 = rect.right();

                if ( !plt->axisScaleDiv( xAxis() ).isIncreasing() )

                    qSwap( x1, x2 );

                plt->setAxisScale( xAxis(), x1, x2 );