Editor.cpp

Go to the documentation of this file.

/********************************************************************************
 * Copyright (C) 2011 by Stephen Allewell                                       *
 * sallewell@users.sourceforge.net                                              *
 *                                                                              *
 * This program is free software; you can redistribute it and/or modify         *
 * it under the terms of the GNU General Public License as published by         *
 * the Free Software Foundation; either version 2 of the License, or            *
 * (at your option) any later version.                                          *
 ********************************************************************************/


#include "Editor.h"

#include <QAction>
#include <QMouseEvent>
#include <QPainter>

#include <KCharSelect>

#include <math.h>

#include "SymbolEditor.h"


const int pointsRequired[] = {1, 1, 3, 2, 2};   
Editor::Editor(QWidget *parent)
    :   QWidget(parent),
        m_index(0),
        m_charSelect(0)
{
    readSettings();

    setMouseTracking(true);
    setFocusPolicy(Qt::StrongFocus);

    m_topEdge = QLineF(0.0, 0.0, 1.0, 0.0);
    m_bottomEdge = QLineF(0.0, 1.0, 1.0, 1.0);
    m_leftEdge = QLineF(0.0, 0.0, 0.0, 1.0);
    m_rightEdge = QLineF(1.0, 0, 1.0, 1.0);

    m_angles << 0 << 45 << 90 << 135 << 180 << 225 << 270 << 315;
}


Editor::~Editor()
{
    delete m_charSelect;
}


QPair<qint16, Symbol> Editor::symbol()
{
    m_symbol.setPath(m_painterPath);
    return QPair<qint16, Symbol>(m_index, m_symbol);
}


void Editor::setSymbol(const QPair<qint16, Symbol> &pair)
{
    m_undoStack.clear();
    m_index = pair.first;
    m_symbol = pair.second;
    m_painterPath = m_symbol.path();
    deconstructPainterPath();
    update();
}


QPainterPath Editor::moveTo(const QPointF &to)
{
    QPainterPath path = m_painterPath;
    m_painterPath.moveTo(to);
    deconstructPainterPath();
    update();
    return path;
}


QPainterPath Editor::lineTo(const QPointF &to)
{
    QPainterPath path = m_painterPath;
    m_painterPath.lineTo(to);
    deconstructPainterPath();
    update();
    return path;
}


QPainterPath Editor::cubicTo(const QPointF &control1, const QPointF &control2, const QPointF &to)
{
    QPainterPath path = m_painterPath;
    m_painterPath.cubicTo(control1, control2, to);
    deconstructPainterPath();
    update();
    return path;
}


QPainterPath Editor::addRectangle(const QPointF &from, const QPointF &to)
{
    QPainterPath path = m_painterPath;
    m_painterPath.addRect(QRectF(from, to));
    deconstructPainterPath();
    update();
    return path;
}


QPainterPath Editor::addEllipse(const QPointF &from, const QPointF &to)
{
    QPainterPath path = m_painterPath;
    m_painterPath.addEllipse(QRectF(from, to));
    deconstructPainterPath();
    update();
    return path;
}


void Editor::removeLast(const QPainterPath& path)
{
    m_painterPath = path;
    deconstructPainterPath();
    update();
}


void Editor::movePoint(int index, const QPointF &to)
{
    m_points[index] = to;
    constructPainterPath();
    update();
}


void Editor::rotatePointsLeft()
{
    for (int i = 0 ; i < m_points.count() ; ++i) {
        QPointF p = m_points[i];
        m_points[i] = QPointF(p.y(), 1.0 - p.x());
    }

    for (int i = 0 ; i < m_activePoints.count() ; ++i) {
        QPointF p = m_activePoints[i];
        m_activePoints[i] = QPointF(p.y(), 1.0 - p.x());
    }

    constructPainterPath();
    update();
}


void Editor::rotatePointsRight()
{
    for (int i = 0 ; i < m_points.count() ; ++i) {
        QPointF p = m_points[i];
        m_points[i] = QPointF(1.0 - p.y(), p.x());
    }

    for (int i = 0 ; i < m_activePoints.count() ; ++i) {
        QPointF p = m_activePoints[i];
        m_activePoints[i] = QPointF(1.0 - p.y(), p.x());
    }

    constructPainterPath();
    update();
}


void Editor::flipPointsHorizontal()
{
    for (int i = 0 ; i < m_points.count() ; ++i) {
        QPointF p = m_points[i];
        p.setX(1.0 - p.x());
        m_points[i] = p;
    }

    for (int i = 0 ; i < m_activePoints.count() ; ++i) {
        QPointF p = m_activePoints[i];
        p.setX(1.0 - p.x());
        m_activePoints[i] = p;
    }

    constructPainterPath();
    update();
}


void Editor::flipPointsVertical()
{
    for (int i = 0 ; i < m_points.count() ; ++i) {
        QPointF p = m_points[i];
        p.setY(1.0 - p.y());
        m_points[i] = p;
    }

    for (int i = 0 ; i < m_activePoints.count() ; ++i) {
        QPointF p = m_activePoints[i];
        p.setY(1.0 - p.y());
        m_activePoints[i] = p;
    }

    constructPainterPath();
    update();
}


void Editor::setFilled(bool filled)
{
    m_symbol.setFilled(filled);
    update();
}


void Editor::setFillRule(Qt::FillRule rule)
{
    m_painterPath.setFillRule(rule);
    update();
}


void Editor::setCapStyle(Qt::PenCapStyle capStyle)
{
    m_symbol.setCapStyle(capStyle);
    update();
}


void Editor::setJoinStyle(Qt::PenJoinStyle joinStyle)
{
    m_symbol.setJoinStyle(joinStyle);
    update();
}


void Editor::setLineWidth(double width)
{
    width = round(width * 100) / 100;
    m_symbol.setLineWidth(width);
    emit minLineWidth(width == 0.01);
    emit maxLineWidth(width == 1.00);
    update();
}


QPainterPath Editor::setPath(const QPainterPath &path)
{
    QPainterPath originalPath = m_painterPath;
    m_painterPath = path;
    deconstructPainterPath();
    update();

    return originalPath;
}


void Editor::clear()
{
    m_undoStack.clear();
    m_points.clear();
    m_activePoints.clear();
    m_elements.clear();
    m_index = 0;
    m_symbol = Symbol();
    m_painterPath = m_symbol.path();
    update();
}


QUndoStack *Editor::undoStack()
{
    return &m_undoStack;
}


void Editor::selectTool(QAction *action)
{
    m_activePoints.clear();
    m_toolMode = static_cast<Editor::ToolMode>(action->data().toInt());

    if (m_toolMode == Editor::Character) {
        if (m_charSelect == 0) {
            m_charSelect = new KCharSelect(0, 0);
            connect(m_charSelect, SIGNAL(charSelected(QChar)), this, SLOT(charSelected(QChar)));
        }

        m_charSelect->show();
    } else if (m_charSelect) {
        m_charSelect->hide();
    }
}


void Editor::charSelected(const QChar &character)
{
    QPainterPath path;
    QFont font = m_charSelect->currentFont();
    path.addText(0.0, 0.0, font, QString(character));

    // scale the path to fit the bounding rectangle to fit in a rectangle 0,0-1,1  maintaining
    // aspect ratio.
    QRectF boundingRect = path.boundingRect();

    double scale = double(m_gridElements - m_borderSize - m_borderSize) / double(std::max(boundingRect.width(), boundingRect.height()) * m_gridElements);
    QTransform transform = QTransform::fromTranslate(-boundingRect.center().x(), -boundingRect.center().y()) * QTransform::fromScale(scale, scale) * QTransform::fromTranslate(0.5, 0.5);
    path = transform.map(path);

    m_undoStack.push(new AddCharacterCommand(this, path));
}


void Editor::enableSnap(bool enabled)
{
    m_snap = enabled;
}


void Editor::selectFilled(bool filled)
{
    m_undoStack.push(new ChangeFilledCommand(this, m_symbol.filled(), filled));
}


void Editor::selectFillRule(QAction *action)
{
    Qt::FillRule fillRule = static_cast<Qt::FillRule>(action->data().toInt());
    m_undoStack.push(new ChangeFillRuleCommand(this, m_symbol.path().fillRule(), fillRule));
}


void Editor::selectCapStyle(QAction *action)
{
    Qt::PenCapStyle capStyle = static_cast<Qt::PenCapStyle>(action->data().toInt());
    m_undoStack.push(new ChangeCapStyleCommand(this, m_symbol.capStyle(), capStyle));
}


void Editor::selectJoinStyle(QAction *action)
{
    Qt::PenJoinStyle joinStyle = static_cast<Qt::PenJoinStyle>(action->data().toInt());
    m_undoStack.push(new ChangeJoinStyleCommand(this, m_symbol.joinStyle(), joinStyle));
}


void Editor::increaseLineWidth()
{
    m_undoStack.push(new IncreaseLineWidthCommand(this, m_symbol.lineWidth(), m_symbol.lineWidth() + 0.01));
}


void Editor::decreaseLineWidth()
{
    m_undoStack.push(new DecreaseLineWidthCommand(this, m_symbol.lineWidth(), m_symbol.lineWidth() - 0.01));
}


void Editor::rotateLeft()
{
    m_undoStack.push(new RotateLeftCommand(this));
}


void Editor::rotateRight()
{
    m_undoStack.push(new RotateRightCommand(this));
}


void Editor::flipHorizontal()
{
    m_undoStack.push(new FlipHorizontalCommand(this));
}


void Editor::flipVertical()
{
    m_undoStack.push(new FlipVerticalCommand(this));
}


void Editor::scalePreferred()
{
    m_undoStack.push(new ScalePreferredCommand(this, m_painterPath, m_gridElements, m_borderSize));
}


void Editor::readSettings()
{
    m_gridElements       = Configuration::editor_GridElements();
    m_elementSize        = Configuration::editor_ElementSize();
    m_elementGrouping    = Configuration::editor_ElementGrouping();
    m_pointSize          = Configuration::editor_PointSize();
    m_snapThreshold      = 1.0 / m_gridElements * Configuration::editor_SnapThreshold();
    m_borderSize         = Configuration::editor_BorderSize();
    m_preferredSizeColor = Configuration::editor_PreferredSizeColor();
    m_guideLineColor     = Configuration::editor_GuideLineColor();

    m_size = m_gridElements * m_elementSize;
    resize(m_size + 1, m_size + 1);
    setMinimumSize(size());
}


void Editor::mousePressEvent(QMouseEvent *event)
{
    QPointF p = snapPoint(event->pos());

    if (event->buttons() & Qt::LeftButton) {
        m_start = m_tracking = p;
        m_rubberBand = QRectF();

        if (node(p)) {
            m_dragging = true;
            m_dragPointIndex = nodeUnderCursor(p);
        } else {
            addPoint(p);
        }
    }

    update();
}


void Editor::mouseMoveEvent(QMouseEvent *event)
{
    if (!m_guideLines.isEmpty()) {
        m_guideLines.clear();
        m_guideCircles.clear();
        update();
    }

    QPointF p = snapPoint(event->pos());

    if (event->buttons() & Qt::LeftButton) {
        if (m_tracking != p) {
            m_tracking = p;

            if (m_dragging) {
                if (m_dragPointIndex.first) {
                    m_points[m_dragPointIndex.second] = p;
                    constructPainterPath();
                } else {
                    m_activePoints[m_dragPointIndex.second] = p;
                }
            } else if (m_toolMode == Rectangle || m_toolMode == Ellipse) {
                m_rubberBand = QRectF(m_start, m_tracking).normalized();
            }

            update();
        }
    } else {
        if (node(p)) {
            setCursor(Qt::SizeAllCursor);
        } else {
            setCursor(Qt::ArrowCursor);
        }
    }

    if (constructGuides(p)) {
        update();
    }
}


void Editor::mouseReleaseEvent(QMouseEvent *event)
{
    QPointF p = snapPoint(event->pos());

    if (m_dragging) {
        if ((p != m_start) && (m_dragPointIndex.first)) {
            m_undoStack.push(new MovePointCommand(this, m_dragPointIndex.second, m_start, p));
        }

        m_dragging = false;
    } else if (m_toolMode == Rectangle || m_toolMode == Ellipse) {
        m_rubberBand = QRectF();

        if (p != m_start) {
            addPoint(p);
        }
    }

    update();
}


void Editor::addPoint(const QPointF &point)
{
    m_activePoints.append(point);

    if (m_activePoints.count() == pointsRequired[m_toolMode]) {
        switch (m_toolMode) {
        case MoveTo:
            m_undoStack.push(new MoveToCommand(this, m_activePoints.at(0)));
            break;

        case LineTo:
            m_undoStack.push(new LineToCommand(this, m_activePoints.at(0)));
            break;

        case CubicTo:
            m_undoStack.push(new CubicToCommand(this, m_activePoints.at(0), m_activePoints.at(1), m_activePoints.at(2)));
            break;

        case Rectangle:
            m_undoStack.push(new RectangleCommand(this, m_activePoints.at(0), m_activePoints.at(1)));
            break;

        case Ellipse:
            m_undoStack.push(new EllipseCommand(this, m_activePoints.at(0), m_activePoints.at(1)));
            break;
        }

        m_activePoints.clear();
    }

    update();
}


void Editor::paintEvent(QPaintEvent *event)
{
    // initialise the painter
    QPainter p(this);
    p.setRenderHint(QPainter::Antialiasing, true);
    p.fillRect(event->rect(), Qt::white);

    // draw vertical grid
    for (int x = 0 ; x < m_gridElements + 1 ; ++x) {
        if (x % m_elementGrouping) {
            p.setPen(Qt::lightGray);
        } else {
            p.setPen(Qt::darkGray);
        }

        p.drawLine(x * m_elementSize, 0, x * m_elementSize, m_size + 1);
    }

    // draw horizontal grid
    for (int y = 0 ; y < m_gridElements + 1 ; ++y) {
        if (y % m_elementGrouping) {
            p.setPen(Qt::lightGray);
        } else {
            p.setPen(Qt::darkGray);
        }

        p.drawLine(0, y * m_elementSize, m_size + 1, y * m_elementSize);
    }

    // define a rectangle for the points
    QRect dot(0, 0, m_pointSize, m_pointSize);

    // create a dashed pen for use with curve references and a wide pen for the shape
    QPen dashedPen(Qt::DashLine);

    // draw all the points as a circle
    p.setBrush(Qt::SolidPattern);

    for (int i = 0 ; i < m_points.count() ; ++i) {
        QPoint s = toScreen(m_points.at(i));
        dot.moveCenter(s);
        p.drawEllipse(dot);
    }

    for (int i = 0 ; i < m_activePoints.count() ; ++i) {
        QPoint s = toScreen(m_activePoints.at(i));
        dot.moveCenter(s);
        p.drawEllipse(dot);
    }

    // iterate through the elements and for each curve element draw the reference lines with a dashed pen
    for (int i = 0, j = 0 ; i < m_elements.count() ; ++i) {
        QPainterPath::ElementType element = m_elements[i];
        QPoint s;
        QPoint e;
        QPoint c1;
        QPoint c2;

        switch (element) {
        case QPainterPath::MoveToElement:
            // increment to next pointer
            ++j;
            break;

        case QPainterPath::LineToElement:
            // increment to next pointer
            j++;
            break;

        case QPainterPath::CurveToElement:
            p.setPen(dashedPen);
            s = toScreen(m_points.at(j - 1));
            c1 = toScreen(m_points.at(j++));
            c2 = toScreen(m_points.at(j++));
            e = toScreen(m_points.at(j++));
            p.drawLine(s, c1);
            p.drawLine(c1, c2);
            p.drawLine(c2, e);
            break;
        }
    }

    // draw the rubber band rectangle or the active points for the current command
    if (m_rubberBand.isValid()) {
        p.setBrush(Qt::NoBrush);

        if (m_toolMode == Rectangle) {
            p.drawRect(QRect(toScreen(m_rubberBand.topLeft()), toScreen(m_rubberBand.bottomRight())));
        } else {
            p.drawEllipse(QRect(toScreen(m_rubberBand.topLeft()), toScreen(m_rubberBand.bottomRight())));
        }
    } else if (m_activePoints.count() && m_toolMode != Rectangle && m_toolMode != Ellipse) {
        p.setPen(dashedPen);
        QPoint s;

        if (m_points.count()) {
            s = toScreen(m_points.last());
        }

        for (int i = 0 ; i < m_activePoints.count() ; ++i) {
            QPoint e = toScreen(m_activePoints[i]);
            p.drawLine(s, e);
            s = e;
        }
    }

    // draw a rectangle representing the preferred symbol size allowing for some white space
    int border = m_elementSize * m_borderSize;
    QRect preferredSizeRect = QRect(0, 0, m_size, m_size).adjusted(border, border, -border, -border);
    QColor preferredSizeColor(m_preferredSizeColor);
    preferredSizeColor.setAlpha(128);
    p.setPen(preferredSizeColor);
    p.setBrush(Qt::NoBrush);
    p.drawRect(preferredSizeRect);

    // scale the painter and draw the path
    p.scale(m_size, m_size);
    QColor c(Qt::black);
    c.setAlpha(128);
    QPen pathPen(c);
    pathPen.setWidthF(m_symbol.filled() ? 0.0 : m_symbol.lineWidth());
    pathPen.setCapStyle(m_symbol.capStyle());
    pathPen.setJoinStyle(m_symbol.joinStyle());
    p.setPen(pathPen);
    QBrush pathFill(m_symbol.filled() ? Qt::SolidPattern : Qt::NoBrush);
    pathFill.setColor(c);
    p.setBrush(pathFill);
    p.drawPath(m_painterPath);

    // draw the guidelines
    QColor guideLineColor(m_guideLineColor);
    guideLineColor.setAlpha(128);
    QPen guideLinePen(guideLineColor);
    p.setPen(guideLinePen);
    p.setBrush(Qt::NoBrush);
    QRectF snapRect(0, 0, 0.03, 0.03);

    foreach (const QPointF & snapPoint, m_snapPoints) {
        snapRect.moveCenter(snapPoint);
        p.drawRect(snapRect);
    }

    foreach (const QLineF & guideLine, m_guideLines) {
        p.drawLine(guideLine);
    }

    foreach (qreal guideCircle, m_guideCircles) {
        p.drawEllipse(QPointF(0.5, 0.5), guideCircle, guideCircle);
    }
}


void Editor::keyPressEvent(QKeyEvent *event)
{
    switch (event->key()) {
    case Qt::Key_Escape:
        m_activePoints.clear();
        update();
        break;

    default:
        QWidget::keyPressEvent(event);
        break;
    }
}


QPointF Editor::toSymbol(const QPoint &point) const
{
    double sx = static_cast<double>(point.x()) / m_size;
    double sy = static_cast<double>(point.y()) / m_size;
    return QPointF(sx, sy);
}


QPointF Editor::snapPoint(const QPoint &point) const
{
    QPair<bool, QPointF> snap = snapToGuide(toSymbol(point));

    if (!snap.first) {
        snap = snapToGrid(point);
    }

    return snap.second;
}


QPair<bool, QPointF> Editor::snapToGrid(const QPoint &point) const
{
    QPair<bool, QPointF> snap(false, toSymbol(point));

    if (m_snap) {
        double sx = round(static_cast<double>(point.x()) * m_gridElements / (m_size)) / m_gridElements;
        double sy = round(static_cast<double>(point.y()) * m_gridElements / (m_size)) / m_gridElements;
        snap.first = true;
        snap.second = QPointF(sx, sy);
    }

    return snap;
}


QPair<bool, QPointF> Editor::snapToGuide(const QPointF &point) const
{
    QPair<bool, QPointF> snap(false, point);

    if (m_snap) {
        foreach (const QPointF & p, m_snapPoints) {
            if ((point - p).manhattanLength() < m_snapThreshold) {
                snap.first = true;
                snap.second = p;
                break;
            }
        }
    }

    return snap;
}


QPoint Editor::toScreen(const QPointF &point) const
{
    int sx = floor(point.x() * m_size);
    int sy = floor(point.y() * m_size);
    return QPoint(sx, sy);
}


bool Editor::node(const QPointF &point) const
{
    bool found = false;

    for (int i = 0 ; i < m_points.count() ; ++i) {
        QPointF distance = point - m_points[i];

        if (distance.manhattanLength() < m_snapThreshold) {
            found = true;
        }
    }

    for (int i = 0 ; i < m_activePoints.count() ; ++i) {
        QPointF distance = point - m_activePoints[i];

        if (distance.manhattanLength() < m_snapThreshold) {
            found = true;
        }
    }

    return found;
}


QPair<bool, int> Editor::nodeUnderCursor(const QPointF &point) const
{
    for (int i = 0 ; i < m_points.count() ; ++i) {
        QPointF distance = point - m_points[i];

        if (distance.manhattanLength() < m_snapThreshold) {
            return QPair<bool, int>(true, i);
        }
    }

    for (int i = 0 ; i < m_activePoints.count() ; ++i) {
        QPointF distance = point - m_activePoints[i];

        if (distance.manhattanLength() < m_snapThreshold) {
            return QPair<bool, int>(false, i);
        }
    }

    return QPair<bool, int>(false, -1);
}


void Editor::deconstructPainterPath()
{
    m_points.clear();
    m_activePoints.clear();
    m_elements.clear();

    for (int i = 0 ; i < m_painterPath.elementCount() ; ++i) {
        QPainterPath::Element e = m_painterPath.elementAt(i);

        switch (e.type) {
        case QPainterPath::MoveToElement:
            m_elements.append(e.type);
            m_points.append(QPointF(e));
            break;

        case QPainterPath::LineToElement:
            m_elements.append(e.type);
            m_points.append(QPointF(e));
            break;

        case QPainterPath::CurveToElement:
            m_elements.append(e.type);
            m_points.append(QPointF(e));
            break;

        case QPainterPath::CurveToDataElement:
            m_points.append(QPointF(e));
            break;
        }
    }
}


void Editor::constructPainterPath()
{
    QPainterPath path;;

    for (int i = 0, j = 0 ; i < m_elements.count() ; ++i) {
        QPainterPath::ElementType e = m_elements[i];

        switch (e) {
        case QPainterPath::MoveToElement:
            path.moveTo(m_points[j++]);
            break;

        case QPainterPath::LineToElement:
            path.lineTo(m_points[j++]);
            break;

        case QPainterPath::CurveToElement:
            path.cubicTo(m_points[j], m_points[j + 1], m_points[j + 2]);
            j += 3;
            break;
        }
    }

    path.setFillRule(m_painterPath.fillRule());
    m_painterPath = path;
}


bool Editor::constructGuides(const QPointF &to)
{
    foreach (const QPointF & from, m_points) {
        constructLineGuides(from, to);
        constructCircleGuides(from, to);
    }

    foreach (const QPointF & from, m_activePoints) {
        constructLineGuides(from, to);
        constructCircleGuides(from, to);
    }

    return !m_guideLines.isEmpty();
}


void Editor::constructLineGuides(const QPointF &from, const QPointF &to)
{
    if (from != to) {
        QLineF line(from, to);

        if (m_angles.contains(line.angle())) {
            m_guideLines.append(projected(line));
        }
    }
}


void Editor::constructCircleGuides(const QPointF &from, const QPointF &to)
{
    QVector<QPointF> intersections;
    intersections << QPointF(1.0 - from.x(), from.y()) << QPointF(from.x(), 1.0 - from.y()) << QPointF(1.0 - from.x(), 1.0 - from.y());
    bool circles = false;

    foreach (const QPointF & i, intersections) {
        if (i == from) { // point is on center line
            break;
        }

        if (i == to) {
            m_guideLines.append(projected(QLineF(i, to)));
            circles = true;
        }
    }

    if (circles) {
        m_guideCircles.append(sqrt(pow(0.5 - to.x(), 2) + pow(0.5 - to.y(), 2)));
    }
}


QLineF Editor::projected(const QLineF &line) const
{
    QPointF intersectTop;
    QPointF intersectBottom;
    QPointF intersectLeft;
    QPointF intersectRight;

    QLineF::IntersectType t;
    QLineF::IntersectType b;
    QLineF::IntersectType l;
    QLineF::IntersectType r;

    t = line.intersect(m_topEdge, &intersectTop);
    b = line.intersect(m_bottomEdge, &intersectBottom);
    l = line.intersect(m_leftEdge, &intersectLeft);
    r = line.intersect(m_rightEdge, &intersectRight);

    if (t == 0) {      // horizontal line
        return QLineF(intersectLeft, intersectRight);
    }

    if (l == 0) {      // vertical line
        return QLineF(intersectTop, intersectBottom);
    }

    if (intersectTop == QPointF(0.0, 0.0) || intersectTop == QPointF(1.0, 0.0)) { // diagonal line at the corners
        return QLineF(intersectTop, intersectBottom);
    }

    if (intersectTop.x() > 0.0 && intersectTop.x() < 1.0) {
        if (intersectLeft.y() > 0.0 && intersectLeft.y() < 1.0) {
            return QLineF(intersectTop, intersectLeft);
        } else {
            return QLineF(intersectTop, intersectRight);
        }
    } else {
        if (intersectLeft.y() > 0.0 && intersectLeft.y() < 1.0) {
            return QLineF(intersectBottom, intersectLeft);
        } else {
            return QLineF(intersectBottom, intersectRight);
        }
    }
}