nmWATI/Src/nmNum/nmPlot/nmObjLineTool.cpp

#include <QPainter>

#include "nmObjLine.h"
#include "nmObjLineTool.h"

nmObjLineTool::nmObjLineTool() : nmObjPointTool()
{
    setText(tr("nObjPointTool"));
    m_oNot = NOT_Line;
}

bool nmObjLineTool::onLeftDown(const QPointF& pt)
{
    if (NULL == m_pObj)
    {
        m_ptStart = pt;
        m_bTracking = true;
        return true;
    }

    return nmObjPointTool::onLeftDown(pt);
}

bool nmObjLineTool::onMouseMove(const QPointF& pt)
{
    if (NULL == m_pObj)
    {
        m_ptMove = pt;

//        Qt::CursorShape o = getCursorBy(0, 0);
//        changeCursor(o);

        if (m_bTracking)
        {
            m_rtTracker = getView()->adjustRectFitViewAspect(getTrackRect());
            updateLastMoveArea(true);
        }

        return true;
    }

    return nmObjPointTool::onMouseMove(pt);
}

bool nmObjLineTool::onLeftUp(const QPointF& pt)
{
    if (NULL == m_pObj)
    {
        getView()->setSnapshotMode(false);
        if (m_bTracking)
        {
            m_bTracking = false;
        }

        QVector<QPointF> vec;
        vec << m_ptStart << pt;
        emit sigPtsFinished(vec);

        return true;
    }
    return nmObjPointTool::onLeftUp(pt);
}

bool nmObjLineTool::onMouseWheel(const QPointF& pt, int delta)
{
    return nmObjPointTool::onMouseWheel(pt, delta);
}

bool nmObjLineTool::onLeftDoubleClick(const QPointF& pt)
{
    return nmObjPointTool::onLeftDoubleClick(pt);
}

void nmObjLineTool::onPaint(QPainter* painter, const ZxPaintParam& param)
{
    nmObjLine* pObj = dynamic_cast<nmObjLine*>(m_pObj);
    if (pObj == NULL)
    {
        Qt::CursorShape o = Qt::CrossCursor;
        if (m_bTracking)
        {
            painter->save();
            QPen focus(Qt::DashLine);
            painter->setPen(focus);
            painter->drawLine(m_ptStart, getCurrentPos());
            changeCursor(o);
            painter->restore();
        }
        else
        {
            changeCursor(o);
        }
    }
    else
    {
        if (m_bTracking)
        {
            painter->save();

            Qt::CursorShape o = getCursorBy((int)m_oHitOption, pObj->m_nHitIndex);

            QVector<QPointF> vec = pObj->getAllPos();
            if (m_oHitOption == OHO_Point &&
                    pObj->m_nHitIndex == 0)
            {
                QPen focus(Qt::DashLine);
                QPointF endPoint = vec[1];
                painter->drawPoint(endPoint);
                painter->drawPoint(getCurrentPos());
                painter->setPen(focus);
                painter->drawLine(endPoint,getCurrentPos());
            }
            else if (m_oHitOption == OHO_Point &&
                    pObj->m_nHitIndex == 1)
            {
                QPen focus(Qt::DashLine);
                QPointF startPoint = vec[0];
                painter->drawPoint(startPoint);
                painter->drawPoint(getCurrentPos());
                painter->setPen(focus);
                painter->drawLine(startPoint,getCurrentPos());
            }
            else if (m_oHitOption == OHO_Bound)
            {
                QPen focus(Qt::DashLine);
                QPointF pt1 = vec[0];
                QPointF pt2 = vec[1];
                QPointF ptOld = m_ptStart;
                QPointF ptNew = getCurrentPos();
                pt1 = pObj->offsetPoint(pt1, ptOld, ptNew);
                pt2 = pObj->offsetPoint(pt2, ptOld, ptNew);
                painter->drawPoint(pt1);
                painter->drawPoint(pt2);
                painter->setPen(focus);
                painter->drawLine(pt1, pt2);
            }

            changeCursor(o);
            painter->restore();
        }
    }
}

Qt::CursorShape nmObjLineTool::getCursorBy(const int& nOption,
                    const int& nSubIndex)
{
    if (nOption < 0)
    {
        return Qt::ArrowCursor;
    }

    ObjHitOption oHitOption = (ObjHitOption)nOption;
    if (oHitOption == OHO_Point)
    {
        return (Qt::CrossCursor);
    }
    else if (oHitOption == OHO_Bound)
    {
        return (Qt::SizeAllCursor);
    }

    return Qt::ArrowCursor;
}