_picker = picker;

}

void ScaleOverlay::drawOverlay(QPainter* painter) const

{

    _picker->drawScaleOverlay(painter);

}

ScalePicker::ScalePicker(QwtScaleWidget* scaleWidget, QWidget* canvas) :

    QObject(scaleWidget)

{

    _scaleWidget = scaleWidget;

    _canvas = canvas;

    scaleWidget->installEventFilter(this);

    scaleWidget->setMouseTracking(true);

    pickerOverlay = new PlotOverlay(canvas, this);

    scaleOverlay = new ScaleOverlay(scaleWidget, this);

    started = false;

    pressed = false;

}

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

{

    if (event->type() == QEvent::MouseButtonPress ||

        event->type() == QEvent::MouseButtonRelease ||

        event->type() == QEvent::MouseMove)

    {

        updateSnapPoints();

        QMouseEvent* mouseEvent = (QMouseEvent*) event;

        int posPx = this->positionPx(mouseEvent);

        // do snapping unless Shift is pressed

        if (! (mouseEvent->modifiers() & Qt::ShiftModifier))

        {

            for (auto sp : snapPoints)

            {

                if (fabs(posPx-sp) <= SNAP_DISTANCE)

                {

                    posPx = sp;

                    break;

                }

            }

        }

        double pos = this->position(posPx);

        currentPosPx = posPx;

        if (event->type() == QEvent::MouseButtonPress &&

            mouseEvent->button() == Qt::LeftButton)

        {

            pressed = true; // not yet started

            firstPos = pos;

            firstPosPx = posPx;

        }

        else if (event->type() == QEvent::MouseMove)

        {

            // make sure pick size is big enough, so that just

            // clicking won't trigger pick

            if (!started && pressed && (fabs(posPx-firstPosPx) > MIN_PICK_SIZE))

            {

                started = true;

                emit pickStarted(pos);

            }

            else if (started)

            {

                pickerOverlay->updateOverlay();

                emit picking(firstPos, pos);

            }

            scaleOverlay->updateOverlay();

        }

        else // event->type() == QEvent::MouseButtonRelease

        {

            pressed = false;

            if (started)

            {

                // finalize

                started = false;

                emit picked(firstPos, pos);

            }

        }

        return true;

    }

    else if (event->type() == QEvent::Leave)

    {

        scaleOverlay->updateOverlay();

        return true;

    }

    else

    {

        return QObject::eventFilter(object, event);

    }

}

void ScalePicker::drawPlotOverlay(QPainter* painter)

{

    if (started)

    {

        painter->save();

        painter->setPen(_pen);

        QRect rect;

        if (_scaleWidget->alignment() == QwtScaleDraw::BottomScale ||

            _scaleWidget->alignment() == QwtScaleDraw::TopScale)

        {

            int height = painter->device()->height();

            rect = QRect(posCanvasPx(firstPosPx), 0, currentPosPx-firstPosPx, height);

        }

        else // vertical

        {

            int width = painter->device()->width();

            rect = QRect(0, posCanvasPx(firstPosPx), width, currentPosPx-firstPosPx);

        }

        painter->drawRect(rect);

        painter->restore();

    }

}

void ScalePicker::drawScaleOverlay(QPainter* painter)

{

    painter->save();

    // rotate & adjust coordinate system for vertical drawing

    if (_scaleWidget->alignment() == QwtScaleDraw::LeftScale ||

        _scaleWidget->alignment() == QwtScaleDraw::RightScale) // vertical

    {

        int width = painter->device()->width();

        painter->rotate(90);

        painter->translate(0, -width);

    }

    // draw the indicators

    if (started) drawTriangle(painter, firstPosPx);

    if (started || _scaleWidget->underMouse())

    {

        drawTriangle(painter, currentPosPx);

    }

    painter->restore();

}

void ScalePicker::drawTriangle(QPainter* painter, int position)

{

    const double tan60 = 1.732;

    const double trsize = 10;

    const int TRIANGLE_NUM_POINTS = 3;

    const int MARGIN = 2;

    const QPointF points[TRIANGLE_NUM_POINTS] =

        {

            {0, 0},

            {-trsize/tan60 , trsize},

            {trsize/tan60 , trsize}

        };

    painter->save();

    painter->setPen(Qt::NoPen);

    painter->setBrush(_scaleWidget->palette().windowText());

    painter->setRenderHint(QPainter::Antialiasing);

    painter->translate(position, MARGIN);

    painter->drawPolygon(points, TRIANGLE_NUM_POINTS);

    painter->restore();

}

void ScalePicker::setPen(QPen pen)

{

    _pen = pen;

}

// convert the position of the click to the plot coordinates

double ScalePicker::position(double posPx)

{

    return _scaleWidget->scaleDraw()->scaleMap().invTransform(posPx);

}

int ScalePicker::positionPx(QMouseEvent* mouseEvent)

{

    double pos;

    if (_scaleWidget->alignment() == QwtScaleDraw::BottomScale ||

        _scaleWidget->alignment() == QwtScaleDraw::TopScale)

    {

        pos = mouseEvent->pos().x();

    }

    else // left or right scale

    {

        pos = mouseEvent->pos().y();

    }

    return pos;

}

/*

 * Scale widget and canvas widget is not always aligned. Especially

 * when zooming scaleWidget moves around. This causes irregularities

 * when drawing the tracker lines. This function maps scale widgets

 * pixel coordinate to canvas' coordinate.