| /**************************************************************************** |
| ** |
| ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). |
| ** All rights reserved. |
| ** Contact: Nokia Corporation (qt-info@nokia.com) |
| ** |
| ** This file is part of the QtGui module of the Qt Toolkit. |
| ** |
| ** $QT_BEGIN_LICENSE:LGPL$ |
| ** GNU Lesser General Public License Usage |
| ** This file may be used under the terms of the GNU Lesser General Public |
| ** License version 2.1 as published by the Free Software Foundation and |
| ** appearing in the file LICENSE.LGPL included in the packaging of this |
| ** file. Please review the following information to ensure the GNU Lesser |
| ** General Public License version 2.1 requirements will be met: |
| ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. |
| ** |
| ** In addition, as a special exception, Nokia gives you certain additional |
| ** rights. These rights are described in the Nokia Qt LGPL Exception |
| ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. |
| ** |
| ** GNU General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU General |
| ** Public License version 3.0 as published by the Free Software Foundation |
| ** and appearing in the file LICENSE.GPL included in the packaging of this |
| ** file. Please review the following information to ensure the GNU General |
| ** Public License version 3.0 requirements will be met: |
| ** http://www.gnu.org/copyleft/gpl.html. |
| ** |
| ** Other Usage |
| ** Alternatively, this file may be used in accordance with the terms and |
| ** conditions contained in a signed written agreement between you and Nokia. |
| ** |
| ** |
| ** |
| ** |
| ** |
| ** $QT_END_LICENSE$ |
| ** |
| ****************************************************************************/ |
| |
| #include "private/qstroker_p.h" |
| #include "private/qbezier_p.h" |
| #include "private/qmath_p.h" |
| #include "qline.h" |
| #include "qtransform.h" |
| #include <qmath.h> |
| |
| QT_BEGIN_NAMESPACE |
| |
| // #define QPP_STROKE_DEBUG |
| |
| class QSubpathForwardIterator |
| { |
| public: |
| QSubpathForwardIterator(const QDataBuffer<QStrokerOps::Element> *path) |
| : m_path(path), m_pos(0) { } |
| inline int position() const { return m_pos; } |
| inline bool hasNext() const { return m_pos < m_path->size(); } |
| inline QStrokerOps::Element next() { Q_ASSERT(hasNext()); return m_path->at(m_pos++); } |
| |
| private: |
| const QDataBuffer<QStrokerOps::Element> *m_path; |
| int m_pos; |
| }; |
| |
| class QSubpathBackwardIterator |
| { |
| public: |
| QSubpathBackwardIterator(const QDataBuffer<QStrokerOps::Element> *path) |
| : m_path(path), m_pos(path->size() - 1) { } |
| |
| inline int position() const { return m_pos; } |
| |
| inline bool hasNext() const { return m_pos >= 0; } |
| |
| inline QStrokerOps::Element next() |
| { |
| Q_ASSERT(hasNext()); |
| |
| QStrokerOps::Element ce = m_path->at(m_pos); // current element |
| |
| if (m_pos == m_path->size() - 1) { |
| --m_pos; |
| ce.type = QPainterPath::MoveToElement; |
| return ce; |
| } |
| |
| const QStrokerOps::Element &pe = m_path->at(m_pos + 1); // previous element |
| |
| switch (pe.type) { |
| case QPainterPath::LineToElement: |
| ce.type = QPainterPath::LineToElement; |
| break; |
| case QPainterPath::CurveToDataElement: |
| // First control point? |
| if (ce.type == QPainterPath::CurveToElement) { |
| ce.type = QPainterPath::CurveToDataElement; |
| } else { // Second control point then |
| ce.type = QPainterPath::CurveToElement; |
| } |
| break; |
| case QPainterPath::CurveToElement: |
| ce.type = QPainterPath::CurveToDataElement; |
| break; |
| default: |
| qWarning("QSubpathReverseIterator::next: Case %d unhandled", ce.type); |
| break; |
| } |
| --m_pos; |
| |
| return ce; |
| } |
| |
| private: |
| const QDataBuffer<QStrokerOps::Element> *m_path; |
| int m_pos; |
| }; |
| |
| class QSubpathFlatIterator |
| { |
| public: |
| QSubpathFlatIterator(const QDataBuffer<QStrokerOps::Element> *path, qreal threshold) |
| : m_path(path), m_pos(0), m_curve_index(-1), m_curve_threshold(threshold) { } |
| |
| inline bool hasNext() const { return m_curve_index >= 0 || m_pos < m_path->size(); } |
| |
| QStrokerOps::Element next() |
| { |
| Q_ASSERT(hasNext()); |
| |
| if (m_curve_index >= 0) { |
| QStrokerOps::Element e = { QPainterPath::LineToElement, |
| qt_real_to_fixed(m_curve.at(m_curve_index).x()), |
| qt_real_to_fixed(m_curve.at(m_curve_index).y()) |
| }; |
| ++m_curve_index; |
| if (m_curve_index >= m_curve.size()) |
| m_curve_index = -1; |
| return e; |
| } |
| |
| QStrokerOps::Element e = m_path->at(m_pos); |
| if (e.isCurveTo()) { |
| Q_ASSERT(m_pos > 0); |
| Q_ASSERT(m_pos < m_path->size()); |
| |
| m_curve = QBezier::fromPoints(QPointF(qt_fixed_to_real(m_path->at(m_pos-1).x), |
| qt_fixed_to_real(m_path->at(m_pos-1).y)), |
| QPointF(qt_fixed_to_real(e.x), |
| qt_fixed_to_real(e.y)), |
| QPointF(qt_fixed_to_real(m_path->at(m_pos+1).x), |
| qt_fixed_to_real(m_path->at(m_pos+1).y)), |
| QPointF(qt_fixed_to_real(m_path->at(m_pos+2).x), |
| qt_fixed_to_real(m_path->at(m_pos+2).y))).toPolygon(m_curve_threshold); |
| m_curve_index = 1; |
| e.type = QPainterPath::LineToElement; |
| e.x = m_curve.at(0).x(); |
| e.y = m_curve.at(0).y(); |
| m_pos += 2; |
| } |
| Q_ASSERT(e.isLineTo() || e.isMoveTo()); |
| ++m_pos; |
| return e; |
| } |
| |
| private: |
| const QDataBuffer<QStrokerOps::Element> *m_path; |
| int m_pos; |
| QPolygonF m_curve; |
| int m_curve_index; |
| qreal m_curve_threshold; |
| }; |
| |
| template <class Iterator> bool qt_stroke_side(Iterator *it, QStroker *stroker, |
| bool capFirst, QLineF *startTangent); |
| |
| /******************************************************************************* |
| * QLineF::angle gives us the smalles angle between two lines. Here we |
| * want to identify the line's angle direction on the unit circle. |
| */ |
| static inline qreal adapted_angle_on_x(const QLineF &line) |
| { |
| qreal angle = line.angle(QLineF(0, 0, 1, 0)); |
| if (line.dy() > 0) |
| angle = 360 - angle; |
| return angle; |
| } |
| |
| QStrokerOps::QStrokerOps() |
| : m_elements(0) |
| , m_curveThreshold(qt_real_to_fixed(0.25)) |
| , m_dashThreshold(qt_real_to_fixed(0.25)) |
| , m_customData(0) |
| , m_moveTo(0) |
| , m_lineTo(0) |
| , m_cubicTo(0) |
| { |
| } |
| |
| QStrokerOps::~QStrokerOps() |
| { |
| } |
| |
| /*! |
| Prepares the stroker. Call this function once before starting a |
| stroke by calling moveTo, lineTo or cubicTo. |
| |
| The \a customData is passed back through that callback functions |
| and can be used by the user to for instance maintain state |
| information. |
| */ |
| void QStrokerOps::begin(void *customData) |
| { |
| m_customData = customData; |
| m_elements.reset(); |
| } |
| |
| |
| /*! |
| Finishes the stroke. Call this function once when an entire |
| primitive has been stroked. |
| */ |
| void QStrokerOps::end() |
| { |
| if (m_elements.size() > 1) |
| processCurrentSubpath(); |
| m_customData = 0; |
| } |
| |
| /*! |
| Convenience function that decomposes \a path into begin(), |
| moveTo(), lineTo(), curevTo() and end() calls. |
| |
| The \a customData parameter is used in the callback functions |
| |
| The \a matrix is used to transform the points before input to the |
| stroker. |
| |
| \sa begin() |
| */ |
| void QStrokerOps::strokePath(const QPainterPath &path, void *customData, const QTransform &matrix) |
| { |
| if (path.isEmpty()) |
| return; |
| |
| setCurveThresholdFromTransform(QTransform()); |
| begin(customData); |
| int count = path.elementCount(); |
| if (matrix.isIdentity()) { |
| for (int i=0; i<count; ++i) { |
| const QPainterPath::Element &e = path.elementAt(i); |
| switch (e.type) { |
| case QPainterPath::MoveToElement: |
| moveTo(qt_real_to_fixed(e.x), qt_real_to_fixed(e.y)); |
| break; |
| case QPainterPath::LineToElement: |
| lineTo(qt_real_to_fixed(e.x), qt_real_to_fixed(e.y)); |
| break; |
| case QPainterPath::CurveToElement: |
| { |
| const QPainterPath::Element &cp2 = path.elementAt(++i); |
| const QPainterPath::Element &ep = path.elementAt(++i); |
| cubicTo(qt_real_to_fixed(e.x), qt_real_to_fixed(e.y), |
| qt_real_to_fixed(cp2.x), qt_real_to_fixed(cp2.y), |
| qt_real_to_fixed(ep.x), qt_real_to_fixed(ep.y)); |
| } |
| break; |
| default: |
| break; |
| } |
| } |
| } else { |
| for (int i=0; i<count; ++i) { |
| const QPainterPath::Element &e = path.elementAt(i); |
| QPointF pt = QPointF(e.x, e.y) * matrix; |
| switch (e.type) { |
| case QPainterPath::MoveToElement: |
| moveTo(qt_real_to_fixed(pt.x()), qt_real_to_fixed(pt.y())); |
| break; |
| case QPainterPath::LineToElement: |
| lineTo(qt_real_to_fixed(pt.x()), qt_real_to_fixed(pt.y())); |
| break; |
| case QPainterPath::CurveToElement: |
| { |
| QPointF cp2 = ((QPointF) path.elementAt(++i)) * matrix; |
| QPointF ep = ((QPointF) path.elementAt(++i)) * matrix; |
| cubicTo(qt_real_to_fixed(pt.x()), qt_real_to_fixed(pt.y()), |
| qt_real_to_fixed(cp2.x()), qt_real_to_fixed(cp2.y()), |
| qt_real_to_fixed(ep.x()), qt_real_to_fixed(ep.y())); |
| } |
| break; |
| default: |
| break; |
| } |
| } |
| } |
| end(); |
| } |
| |
| /*! |
| Convenience function for stroking a polygon of the \a pointCount |
| first points in \a points. If \a implicit_close is set to true a |
| line is implictly drawn between the first and last point in the |
| polygon. Typically true for polygons and false for polylines. |
| |
| The \a matrix is used to transform the points before they enter the |
| stroker. |
| |
| \sa begin() |
| */ |
| |
| void QStrokerOps::strokePolygon(const QPointF *points, int pointCount, bool implicit_close, |
| void *data, const QTransform &matrix) |
| { |
| if (!pointCount) |
| return; |
| |
| setCurveThresholdFromTransform(QTransform()); |
| begin(data); |
| if (matrix.isIdentity()) { |
| moveTo(qt_real_to_fixed(points[0].x()), qt_real_to_fixed(points[0].y())); |
| for (int i=1; i<pointCount; ++i) |
| lineTo(qt_real_to_fixed(points[i].x()), |
| qt_real_to_fixed(points[i].y())); |
| if (implicit_close) |
| lineTo(qt_real_to_fixed(points[0].x()), qt_real_to_fixed(points[0].y())); |
| } else { |
| QPointF start = points[0] * matrix; |
| moveTo(qt_real_to_fixed(start.x()), qt_real_to_fixed(start.y())); |
| for (int i=1; i<pointCount; ++i) { |
| QPointF pt = points[i] * matrix; |
| lineTo(qt_real_to_fixed(pt.x()), qt_real_to_fixed(pt.y())); |
| } |
| if (implicit_close) |
| lineTo(qt_real_to_fixed(start.x()), qt_real_to_fixed(start.y())); |
| } |
| end(); |
| } |
| |
| /*! |
| Convenience function for stroking an ellipse with bounding rect \a |
| rect. The \a matrix is used to transform the coordinates before |
| they enter the stroker. |
| */ |
| void QStrokerOps::strokeEllipse(const QRectF &rect, void *data, const QTransform &matrix) |
| { |
| int count = 0; |
| QPointF pts[12]; |
| QPointF start = qt_curves_for_arc(rect, 0, -360, pts, &count); |
| Q_ASSERT(count == 12); // a perfect circle.. |
| |
| if (!matrix.isIdentity()) { |
| start = start * matrix; |
| for (int i=0; i<12; ++i) { |
| pts[i] = pts[i] * matrix; |
| } |
| } |
| |
| setCurveThresholdFromTransform(QTransform()); |
| begin(data); |
| moveTo(qt_real_to_fixed(start.x()), qt_real_to_fixed(start.y())); |
| for (int i=0; i<12; i+=3) { |
| cubicTo(qt_real_to_fixed(pts[i].x()), qt_real_to_fixed(pts[i].y()), |
| qt_real_to_fixed(pts[i+1].x()), qt_real_to_fixed(pts[i+1].y()), |
| qt_real_to_fixed(pts[i+2].x()), qt_real_to_fixed(pts[i+2].y())); |
| } |
| end(); |
| } |
| |
| |
| QStroker::QStroker() |
| : m_capStyle(SquareJoin), m_joinStyle(FlatJoin), |
| m_back1X(0), m_back1Y(0), |
| m_back2X(0), m_back2Y(0) |
| { |
| m_strokeWidth = qt_real_to_fixed(1); |
| m_miterLimit = qt_real_to_fixed(2); |
| } |
| |
| QStroker::~QStroker() |
| { |
| } |
| |
| Qt::PenCapStyle QStroker::capForJoinMode(LineJoinMode mode) |
| { |
| if (mode == FlatJoin) return Qt::FlatCap; |
| else if (mode == SquareJoin) return Qt::SquareCap; |
| else return Qt::RoundCap; |
| } |
| |
| QStroker::LineJoinMode QStroker::joinModeForCap(Qt::PenCapStyle style) |
| { |
| if (style == Qt::FlatCap) return FlatJoin; |
| else if (style == Qt::SquareCap) return SquareJoin; |
| else return RoundCap; |
| } |
| |
| Qt::PenJoinStyle QStroker::joinForJoinMode(LineJoinMode mode) |
| { |
| if (mode == FlatJoin) return Qt::BevelJoin; |
| else if (mode == MiterJoin) return Qt::MiterJoin; |
| else if (mode == SvgMiterJoin) return Qt::SvgMiterJoin; |
| else return Qt::RoundJoin; |
| } |
| |
| QStroker::LineJoinMode QStroker::joinModeForJoin(Qt::PenJoinStyle joinStyle) |
| { |
| if (joinStyle == Qt::BevelJoin) return FlatJoin; |
| else if (joinStyle == Qt::MiterJoin) return MiterJoin; |
| else if (joinStyle == Qt::SvgMiterJoin) return SvgMiterJoin; |
| else return RoundJoin; |
| } |
| |
| |
| /*! |
| This function is called to stroke the currently built up |
| subpath. The subpath is cleared when the function completes. |
| */ |
| void QStroker::processCurrentSubpath() |
| { |
| Q_ASSERT(!m_elements.isEmpty()); |
| Q_ASSERT(m_elements.first().type == QPainterPath::MoveToElement); |
| Q_ASSERT(m_elements.size() > 1); |
| |
| QSubpathForwardIterator fwit(&m_elements); |
| QSubpathBackwardIterator bwit(&m_elements); |
| |
| QLineF fwStartTangent, bwStartTangent; |
| |
| bool fwclosed = qt_stroke_side(&fwit, this, false, &fwStartTangent); |
| bool bwclosed = qt_stroke_side(&bwit, this, !fwclosed, &bwStartTangent); |
| |
| if (!bwclosed) |
| joinPoints(m_elements.at(0).x, m_elements.at(0).y, fwStartTangent, m_capStyle); |
| } |
| |
| |
| /*! |
| \internal |
| */ |
| void QStroker::joinPoints(qfixed focal_x, qfixed focal_y, const QLineF &nextLine, LineJoinMode join) |
| { |
| #ifdef QPP_STROKE_DEBUG |
| printf(" -----> joinPoints: around=(%.0f, %.0f), next_p1=(%.0f, %.f) next_p2=(%.0f, %.f)\n", |
| qt_fixed_to_real(focal_x), |
| qt_fixed_to_real(focal_y), |
| nextLine.x1(), nextLine.y1(), nextLine.x2(), nextLine.y2()); |
| #endif |
| // points connected already, don't join |
| |
| #if !defined (QFIXED_26_6) && !defined (Q_FIXED_32_32) |
| if (qFuzzyCompare(m_back1X, nextLine.x1()) && qFuzzyCompare(m_back1Y, nextLine.y1())) |
| return; |
| #else |
| if (m_back1X == qt_real_to_fixed(nextLine.x1()) |
| && m_back1Y == qt_real_to_fixed(nextLine.y1())) { |
| return; |
| } |
| #endif |
| |
| if (join == FlatJoin) { |
| QLineF prevLine(qt_fixed_to_real(m_back2X), qt_fixed_to_real(m_back2Y), |
| qt_fixed_to_real(m_back1X), qt_fixed_to_real(m_back1Y)); |
| QPointF isect; |
| QLineF::IntersectType type = prevLine.intersect(nextLine, &isect); |
| QLineF shortCut(prevLine.p2(), nextLine.p1()); |
| qreal angle = shortCut.angleTo(prevLine); |
| if (type == QLineF::BoundedIntersection || (angle > 90 && !qFuzzyCompare(angle, (qreal)90))) { |
| emitLineTo(focal_x, focal_y); |
| emitLineTo(qt_real_to_fixed(nextLine.x1()), qt_real_to_fixed(nextLine.y1())); |
| return; |
| } |
| emitLineTo(qt_real_to_fixed(nextLine.x1()), |
| qt_real_to_fixed(nextLine.y1())); |
| |
| } else { |
| QLineF prevLine(qt_fixed_to_real(m_back2X), qt_fixed_to_real(m_back2Y), |
| qt_fixed_to_real(m_back1X), qt_fixed_to_real(m_back1Y)); |
| |
| QPointF isect; |
| QLineF::IntersectType type = prevLine.intersect(nextLine, &isect); |
| |
| if (join == MiterJoin) { |
| qreal appliedMiterLimit = qt_fixed_to_real(m_strokeWidth * m_miterLimit); |
| |
| // If we are on the inside, do the short cut... |
| QLineF shortCut(prevLine.p2(), nextLine.p1()); |
| qreal angle = shortCut.angleTo(prevLine); |
| if (type == QLineF::BoundedIntersection || (angle > 90 && !qFuzzyCompare(angle, (qreal)90))) { |
| emitLineTo(focal_x, focal_y); |
| emitLineTo(qt_real_to_fixed(nextLine.x1()), qt_real_to_fixed(nextLine.y1())); |
| return; |
| } |
| QLineF miterLine(QPointF(qt_fixed_to_real(m_back1X), |
| qt_fixed_to_real(m_back1Y)), isect); |
| if (type == QLineF::NoIntersection || miterLine.length() > appliedMiterLimit) { |
| QLineF l1(prevLine); |
| l1.setLength(appliedMiterLimit); |
| l1.translate(prevLine.dx(), prevLine.dy()); |
| |
| QLineF l2(nextLine); |
| l2.setLength(appliedMiterLimit); |
| l2.translate(-l2.dx(), -l2.dy()); |
| |
| emitLineTo(qt_real_to_fixed(l1.x2()), qt_real_to_fixed(l1.y2())); |
| emitLineTo(qt_real_to_fixed(l2.x1()), qt_real_to_fixed(l2.y1())); |
| emitLineTo(qt_real_to_fixed(nextLine.x1()), qt_real_to_fixed(nextLine.y1())); |
| } else { |
| emitLineTo(qt_real_to_fixed(isect.x()), qt_real_to_fixed(isect.y())); |
| emitLineTo(qt_real_to_fixed(nextLine.x1()), qt_real_to_fixed(nextLine.y1())); |
| } |
| |
| } else if (join == SquareJoin) { |
| qfixed offset = m_strokeWidth / 2; |
| |
| QLineF l1(prevLine); |
| l1.translate(l1.dx(), l1.dy()); |
| l1.setLength(qt_fixed_to_real(offset)); |
| QLineF l2(nextLine.p2(), nextLine.p1()); |
| l2.translate(l2.dx(), l2.dy()); |
| l2.setLength(qt_fixed_to_real(offset)); |
| emitLineTo(qt_real_to_fixed(l1.x2()), qt_real_to_fixed(l1.y2())); |
| emitLineTo(qt_real_to_fixed(l2.x2()), qt_real_to_fixed(l2.y2())); |
| emitLineTo(qt_real_to_fixed(l2.x1()), qt_real_to_fixed(l2.y1())); |
| |
| } else if (join == RoundJoin) { |
| qfixed offset = m_strokeWidth / 2; |
| |
| QLineF shortCut(prevLine.p2(), nextLine.p1()); |
| qreal angle = shortCut.angleTo(prevLine); |
| if (type == QLineF::BoundedIntersection || (angle > 90 && !qFuzzyCompare(angle, (qreal)90))) { |
| emitLineTo(focal_x, focal_y); |
| emitLineTo(qt_real_to_fixed(nextLine.x1()), qt_real_to_fixed(nextLine.y1())); |
| return; |
| } |
| qreal l1_on_x = adapted_angle_on_x(prevLine); |
| qreal l2_on_x = adapted_angle_on_x(nextLine); |
| |
| qreal sweepLength = qAbs(l2_on_x - l1_on_x); |
| |
| int point_count; |
| QPointF curves[15]; |
| |
| QPointF curve_start = |
| qt_curves_for_arc(QRectF(qt_fixed_to_real(focal_x - offset), |
| qt_fixed_to_real(focal_y - offset), |
| qt_fixed_to_real(offset * 2), |
| qt_fixed_to_real(offset * 2)), |
| l1_on_x + 90, -sweepLength, |
| curves, &point_count); |
| |
| // // line to the beginning of the arc segment, (should not be needed). |
| // emitLineTo(qt_real_to_fixed(curve_start.x()), qt_real_to_fixed(curve_start.y())); |
| |
| for (int i=0; i<point_count; i+=3) { |
| emitCubicTo(qt_real_to_fixed(curves[i].x()), |
| qt_real_to_fixed(curves[i].y()), |
| qt_real_to_fixed(curves[i+1].x()), |
| qt_real_to_fixed(curves[i+1].y()), |
| qt_real_to_fixed(curves[i+2].x()), |
| qt_real_to_fixed(curves[i+2].y())); |
| } |
| |
| // line to the end of the arc segment, (should also not be needed). |
| emitLineTo(qt_real_to_fixed(nextLine.x1()), qt_real_to_fixed(nextLine.y1())); |
| |
| // Same as round join except we know its 180 degrees. Can also optimize this |
| // later based on the addEllipse logic |
| } else if (join == RoundCap) { |
| qfixed offset = m_strokeWidth / 2; |
| |
| // first control line |
| QLineF l1 = prevLine; |
| l1.translate(l1.dx(), l1.dy()); |
| l1.setLength(QT_PATH_KAPPA * offset); |
| |
| // second control line, find through normal between prevLine and focal. |
| QLineF l2(qt_fixed_to_real(focal_x), qt_fixed_to_real(focal_y), |
| prevLine.x2(), prevLine.y2()); |
| l2.translate(-l2.dy(), l2.dx()); |
| l2.setLength(QT_PATH_KAPPA * offset); |
| |
| emitCubicTo(qt_real_to_fixed(l1.x2()), |
| qt_real_to_fixed(l1.y2()), |
| qt_real_to_fixed(l2.x2()), |
| qt_real_to_fixed(l2.y2()), |
| qt_real_to_fixed(l2.x1()), |
| qt_real_to_fixed(l2.y1())); |
| |
| // move so that it matches |
| l2 = QLineF(l2.x1(), l2.y1(), l2.x1()-l2.dx(), l2.y1()-l2.dy()); |
| |
| // last line is parallel to l1 so just shift it down. |
| l1.translate(nextLine.x1() - l1.x1(), nextLine.y1() - l1.y1()); |
| |
| emitCubicTo(qt_real_to_fixed(l2.x2()), |
| qt_real_to_fixed(l2.y2()), |
| qt_real_to_fixed(l1.x2()), |
| qt_real_to_fixed(l1.y2()), |
| qt_real_to_fixed(l1.x1()), |
| qt_real_to_fixed(l1.y1())); |
| } else if (join == SvgMiterJoin) { |
| QLineF shortCut(prevLine.p2(), nextLine.p1()); |
| qreal angle = shortCut.angleTo(prevLine); |
| if (type == QLineF::BoundedIntersection || (angle > 90 && !qFuzzyCompare(angle, (qreal)90))) { |
| emitLineTo(focal_x, focal_y); |
| emitLineTo(qt_real_to_fixed(nextLine.x1()), qt_real_to_fixed(nextLine.y1())); |
| return; |
| } |
| QLineF miterLine(QPointF(qt_fixed_to_real(focal_x), |
| qt_fixed_to_real(focal_y)), isect); |
| if (type == QLineF::NoIntersection || miterLine.length() > qt_fixed_to_real(m_strokeWidth * m_miterLimit) / 2) { |
| emitLineTo(qt_real_to_fixed(nextLine.x1()), |
| qt_real_to_fixed(nextLine.y1())); |
| } else { |
| emitLineTo(qt_real_to_fixed(isect.x()), qt_real_to_fixed(isect.y())); |
| emitLineTo(qt_real_to_fixed(nextLine.x1()), qt_real_to_fixed(nextLine.y1())); |
| } |
| } else { |
| Q_ASSERT(!"QStroker::joinPoints(), bad join style..."); |
| } |
| } |
| } |
| |
| |
| /* |
| Strokes a subpath side using the \a it as source. Results are put into |
| \a stroke. The function returns true if the subpath side was closed. |
| If \a capFirst is true, we will use capPoints instead of joinPoints to |
| connect the first segment, other segments will be joined using joinPoints. |
| This is to put capping in order... |
| */ |
| template <class Iterator> bool qt_stroke_side(Iterator *it, |
| QStroker *stroker, |
| bool capFirst, |
| QLineF *startTangent) |
| { |
| // Used in CurveToElement section below. |
| const int MAX_OFFSET = 16; |
| QBezier offsetCurves[MAX_OFFSET]; |
| |
| Q_ASSERT(it->hasNext()); // The initaial move to |
| QStrokerOps::Element first_element = it->next(); |
| Q_ASSERT(first_element.isMoveTo()); |
| |
| qfixed2d start = first_element; |
| |
| #ifdef QPP_STROKE_DEBUG |
| qDebug(" -> (side) [%.2f, %.2f], startPos=%d", |
| qt_fixed_to_real(start.x), |
| qt_fixed_to_real(start.y)); |
| #endif |
| |
| qfixed2d prev = start; |
| |
| bool first = true; |
| |
| qfixed offset = stroker->strokeWidth() / 2; |
| |
| while (it->hasNext()) { |
| QStrokerOps::Element e = it->next(); |
| |
| // LineToElement |
| if (e.isLineTo()) { |
| #ifdef QPP_STROKE_DEBUG |
| qDebug("\n ---> (side) lineto [%.2f, %.2f]", e.x, e.y); |
| #endif |
| QLineF line(qt_fixed_to_real(prev.x), qt_fixed_to_real(prev.y), |
| qt_fixed_to_real(e.x), qt_fixed_to_real(e.y)); |
| QLineF normal = line.normalVector(); |
| normal.setLength(offset); |
| line.translate(normal.dx(), normal.dy()); |
| |
| // If we are starting a new subpath, move to correct starting point. |
| if (first) { |
| if (capFirst) |
| stroker->joinPoints(prev.x, prev.y, line, stroker->capStyleMode()); |
| else |
| stroker->emitMoveTo(qt_real_to_fixed(line.x1()), qt_real_to_fixed(line.y1())); |
| *startTangent = line; |
| first = false; |
| } else { |
| stroker->joinPoints(prev.x, prev.y, line, stroker->joinStyleMode()); |
| } |
| |
| // Add the stroke for this line. |
| stroker->emitLineTo(qt_real_to_fixed(line.x2()), |
| qt_real_to_fixed(line.y2())); |
| prev = e; |
| |
| // CurveToElement |
| } else if (e.isCurveTo()) { |
| QStrokerOps::Element cp2 = it->next(); // control point 2 |
| QStrokerOps::Element ep = it->next(); // end point |
| |
| #ifdef QPP_STROKE_DEBUG |
| qDebug("\n ---> (side) cubicTo [%.2f, %.2f]", |
| qt_fixed_to_real(ep.x), |
| qt_fixed_to_real(ep.y)); |
| #endif |
| |
| QBezier bezier = |
| QBezier::fromPoints(QPointF(qt_fixed_to_real(prev.x), qt_fixed_to_real(prev.y)), |
| QPointF(qt_fixed_to_real(e.x), qt_fixed_to_real(e.y)), |
| QPointF(qt_fixed_to_real(cp2.x), qt_fixed_to_real(cp2.y)), |
| QPointF(qt_fixed_to_real(ep.x), qt_fixed_to_real(ep.y))); |
| |
| int count = bezier.shifted(offsetCurves, |
| MAX_OFFSET, |
| offset, |
| stroker->curveThreshold()); |
| |
| if (count) { |
| // If we are starting a new subpath, move to correct starting point |
| QLineF tangent = bezier.startTangent(); |
| tangent.translate(offsetCurves[0].pt1() - bezier.pt1()); |
| if (first) { |
| QPointF pt = offsetCurves[0].pt1(); |
| if (capFirst) { |
| stroker->joinPoints(prev.x, prev.y, |
| tangent, |
| stroker->capStyleMode()); |
| } else { |
| stroker->emitMoveTo(qt_real_to_fixed(pt.x()), |
| qt_real_to_fixed(pt.y())); |
| } |
| *startTangent = tangent; |
| first = false; |
| } else { |
| stroker->joinPoints(prev.x, prev.y, |
| tangent, |
| stroker->joinStyleMode()); |
| } |
| |
| // Add these beziers |
| for (int i=0; i<count; ++i) { |
| QPointF cp1 = offsetCurves[i].pt2(); |
| QPointF cp2 = offsetCurves[i].pt3(); |
| QPointF ep = offsetCurves[i].pt4(); |
| stroker->emitCubicTo(qt_real_to_fixed(cp1.x()), qt_real_to_fixed(cp1.y()), |
| qt_real_to_fixed(cp2.x()), qt_real_to_fixed(cp2.y()), |
| qt_real_to_fixed(ep.x()), qt_real_to_fixed(ep.y())); |
| } |
| } |
| |
| prev = ep; |
| } |
| } |
| |
| if (start == prev) { |
| // closed subpath, join first and last point |
| #ifdef QPP_STROKE_DEBUG |
| qDebug("\n ---> (side) closed subpath"); |
| #endif |
| stroker->joinPoints(prev.x, prev.y, *startTangent, stroker->joinStyleMode()); |
| return true; |
| } else { |
| #ifdef QPP_STROKE_DEBUG |
| qDebug("\n ---> (side) open subpath"); |
| #endif |
| return false; |
| } |
| } |
| |
| /*! |
| \internal |
| |
| For a given angle in the range [0 .. 90], finds the corresponding parameter t |
| of the prototype cubic bezier arc segment |
| b = fromPoints(QPointF(1, 0), QPointF(1, KAPPA), QPointF(KAPPA, 1), QPointF(0, 1)); |
| |
| From the bezier equation: |
| b.pointAt(t).x() = (1-t)^3 + t*(1-t)^2 + t^2*(1-t)*KAPPA |
| b.pointAt(t).y() = t*(1-t)^2 * KAPPA + t^2*(1-t) + t^3 |
| |
| Third degree coefficients: |
| b.pointAt(t).x() = at^3 + bt^2 + ct + d |
| where a = 2-3*KAPPA, b = 3*(KAPPA-1), c = 0, d = 1 |
| |
| b.pointAt(t).y() = at^3 + bt^2 + ct + d |
| where a = 3*KAPPA-2, b = 6*KAPPA+3, c = 3*KAPPA, d = 0 |
| |
| Newton's method to find the zero of a function: |
| given a function f(x) and initial guess x_0 |
| x_1 = f(x_0) / f'(x_0) |
| x_2 = f(x_1) / f'(x_1) |
| etc... |
| */ |
| |
| qreal qt_t_for_arc_angle(qreal angle) |
| { |
| if (qFuzzyIsNull(angle)) |
| return 0; |
| |
| if (qFuzzyCompare(angle, qreal(90))) |
| return 1; |
| |
| qreal radians = Q_PI * angle / 180; |
| qreal cosAngle = qCos(radians); |
| qreal sinAngle = qSin(radians); |
| |
| // initial guess |
| qreal tc = angle / 90; |
| // do some iterations of newton's method to approximate cosAngle |
| // finds the zero of the function b.pointAt(tc).x() - cosAngle |
| tc -= ((((2-3*QT_PATH_KAPPA) * tc + 3*(QT_PATH_KAPPA-1)) * tc) * tc + 1 - cosAngle) // value |
| / (((6-9*QT_PATH_KAPPA) * tc + 6*(QT_PATH_KAPPA-1)) * tc); // derivative |
| tc -= ((((2-3*QT_PATH_KAPPA) * tc + 3*(QT_PATH_KAPPA-1)) * tc) * tc + 1 - cosAngle) // value |
| / (((6-9*QT_PATH_KAPPA) * tc + 6*(QT_PATH_KAPPA-1)) * tc); // derivative |
| |
| // initial guess |
| qreal ts = tc; |
| // do some iterations of newton's method to approximate sinAngle |
| // finds the zero of the function b.pointAt(tc).y() - sinAngle |
| ts -= ((((3*QT_PATH_KAPPA-2) * ts - 6*QT_PATH_KAPPA + 3) * ts + 3*QT_PATH_KAPPA) * ts - sinAngle) |
| / (((9*QT_PATH_KAPPA-6) * ts + 12*QT_PATH_KAPPA - 6) * ts + 3*QT_PATH_KAPPA); |
| ts -= ((((3*QT_PATH_KAPPA-2) * ts - 6*QT_PATH_KAPPA + 3) * ts + 3*QT_PATH_KAPPA) * ts - sinAngle) |
| / (((9*QT_PATH_KAPPA-6) * ts + 12*QT_PATH_KAPPA - 6) * ts + 3*QT_PATH_KAPPA); |
| |
| // use the average of the t that best approximates cosAngle |
| // and the t that best approximates sinAngle |
| qreal t = 0.5 * (tc + ts); |
| |
| #if 0 |
| printf("angle: %f, t: %f\n", angle, t); |
| qreal a, b, c, d; |
| bezierCoefficients(t, a, b, c, d); |
| printf("cosAngle: %.10f, value: %.10f\n", cosAngle, a + b + c * QT_PATH_KAPPA); |
| printf("sinAngle: %.10f, value: %.10f\n", sinAngle, b * QT_PATH_KAPPA + c + d); |
| #endif |
| |
| return t; |
| } |
| |
| Q_GUI_EXPORT void qt_find_ellipse_coords(const QRectF &r, qreal angle, qreal length, |
| QPointF* startPoint, QPointF *endPoint); |
| |
| /*! |
| \internal |
| |
| Creates a number of curves for a given arc definition. The arc is |
| defined an arc along the ellipses that fits into \a rect starting |
| at \a startAngle and an arc length of \a sweepLength. |
| |
| The function has three out parameters. The return value is the |
| starting point of the arc. The \a curves array represents the list |
| of cubicTo elements up to a maximum of \a point_count. There are of course |
| 3 points pr curve. |
| */ |
| QPointF qt_curves_for_arc(const QRectF &rect, qreal startAngle, qreal sweepLength, |
| QPointF *curves, int *point_count) |
| { |
| Q_ASSERT(point_count); |
| Q_ASSERT(curves); |
| |
| *point_count = 0; |
| if (qt_is_nan(rect.x()) || qt_is_nan(rect.y()) || qt_is_nan(rect.width()) || qt_is_nan(rect.height()) |
| || qt_is_nan(startAngle) || qt_is_nan(sweepLength)) { |
| qWarning("QPainterPath::arcTo: Adding arc where a parameter is NaN, results are undefined"); |
| return QPointF(); |
| } |
| |
| if (rect.isNull()) { |
| return QPointF(); |
| } |
| |
| qreal x = rect.x(); |
| qreal y = rect.y(); |
| |
| qreal w = rect.width(); |
| qreal w2 = rect.width() / 2; |
| qreal w2k = w2 * QT_PATH_KAPPA; |
| |
| qreal h = rect.height(); |
| qreal h2 = rect.height() / 2; |
| qreal h2k = h2 * QT_PATH_KAPPA; |
| |
| QPointF points[16] = |
| { |
| // start point |
| QPointF(x + w, y + h2), |
| |
| // 0 -> 270 degrees |
| QPointF(x + w, y + h2 + h2k), |
| QPointF(x + w2 + w2k, y + h), |
| QPointF(x + w2, y + h), |
| |
| // 270 -> 180 degrees |
| QPointF(x + w2 - w2k, y + h), |
| QPointF(x, y + h2 + h2k), |
| QPointF(x, y + h2), |
| |
| // 180 -> 90 degrees |
| QPointF(x, y + h2 - h2k), |
| QPointF(x + w2 - w2k, y), |
| QPointF(x + w2, y), |
| |
| // 90 -> 0 degrees |
| QPointF(x + w2 + w2k, y), |
| QPointF(x + w, y + h2 - h2k), |
| QPointF(x + w, y + h2) |
| }; |
| |
| if (sweepLength > 360) sweepLength = 360; |
| else if (sweepLength < -360) sweepLength = -360; |
| |
| // Special case fast paths |
| if (startAngle == 0.0) { |
| if (sweepLength == 360.0) { |
| for (int i = 11; i >= 0; --i) |
| curves[(*point_count)++] = points[i]; |
| return points[12]; |
| } else if (sweepLength == -360.0) { |
| for (int i = 1; i <= 12; ++i) |
| curves[(*point_count)++] = points[i]; |
| return points[0]; |
| } |
| } |
| |
| int startSegment = int(qFloor(startAngle / 90)); |
| int endSegment = int(qFloor((startAngle + sweepLength) / 90)); |
| |
| qreal startT = (startAngle - startSegment * 90) / 90; |
| qreal endT = (startAngle + sweepLength - endSegment * 90) / 90; |
| |
| int delta = sweepLength > 0 ? 1 : -1; |
| if (delta < 0) { |
| startT = 1 - startT; |
| endT = 1 - endT; |
| } |
| |
| // avoid empty start segment |
| if (qFuzzyIsNull(startT - qreal(1))) { |
| startT = 0; |
| startSegment += delta; |
| } |
| |
| // avoid empty end segment |
| if (qFuzzyIsNull(endT)) { |
| endT = 1; |
| endSegment -= delta; |
| } |
| |
| startT = qt_t_for_arc_angle(startT * 90); |
| endT = qt_t_for_arc_angle(endT * 90); |
| |
| const bool splitAtStart = !qFuzzyIsNull(startT); |
| const bool splitAtEnd = !qFuzzyIsNull(endT - qreal(1)); |
| |
| const int end = endSegment + delta; |
| |
| // empty arc? |
| if (startSegment == end) { |
| const int quadrant = 3 - ((startSegment % 4) + 4) % 4; |
| const int j = 3 * quadrant; |
| return delta > 0 ? points[j + 3] : points[j]; |
| } |
| |
| QPointF startPoint, endPoint; |
| qt_find_ellipse_coords(rect, startAngle, sweepLength, &startPoint, &endPoint); |
| |
| for (int i = startSegment; i != end; i += delta) { |
| const int quadrant = 3 - ((i % 4) + 4) % 4; |
| const int j = 3 * quadrant; |
| |
| QBezier b; |
| if (delta > 0) |
| b = QBezier::fromPoints(points[j + 3], points[j + 2], points[j + 1], points[j]); |
| else |
| b = QBezier::fromPoints(points[j], points[j + 1], points[j + 2], points[j + 3]); |
| |
| // empty arc? |
| if (startSegment == endSegment && qFuzzyCompare(startT, endT)) |
| return startPoint; |
| |
| if (i == startSegment) { |
| if (i == endSegment && splitAtEnd) |
| b = b.bezierOnInterval(startT, endT); |
| else if (splitAtStart) |
| b = b.bezierOnInterval(startT, 1); |
| } else if (i == endSegment && splitAtEnd) { |
| b = b.bezierOnInterval(0, endT); |
| } |
| |
| // push control points |
| curves[(*point_count)++] = b.pt2(); |
| curves[(*point_count)++] = b.pt3(); |
| curves[(*point_count)++] = b.pt4(); |
| } |
| |
| Q_ASSERT(*point_count > 0); |
| curves[*(point_count)-1] = endPoint; |
| |
| return startPoint; |
| } |
| |
| |
| static inline void qdashstroker_moveTo(qfixed x, qfixed y, void *data) { |
| ((QStroker *) data)->moveTo(x, y); |
| } |
| |
| static inline void qdashstroker_lineTo(qfixed x, qfixed y, void *data) { |
| ((QStroker *) data)->lineTo(x, y); |
| } |
| |
| static inline void qdashstroker_cubicTo(qfixed, qfixed, qfixed, qfixed, qfixed, qfixed, void *) { |
| Q_ASSERT(0); |
| // ((QStroker *) data)->cubicTo(c1x, c1y, c2x, c2y, ex, ey); |
| } |
| |
| |
| /******************************************************************************* |
| * QDashStroker members |
| */ |
| QDashStroker::QDashStroker(QStroker *stroker) |
| : m_stroker(stroker), m_dashOffset(0), m_stroke_width(1), m_miter_limit(1) |
| { |
| if (m_stroker) { |
| setMoveToHook(qdashstroker_moveTo); |
| setLineToHook(qdashstroker_lineTo); |
| setCubicToHook(qdashstroker_cubicTo); |
| } |
| } |
| |
| QVector<qfixed> QDashStroker::patternForStyle(Qt::PenStyle style) |
| { |
| const qfixed space = 2; |
| const qfixed dot = 1; |
| const qfixed dash = 4; |
| |
| QVector<qfixed> pattern; |
| |
| switch (style) { |
| case Qt::DashLine: |
| pattern << dash << space; |
| break; |
| case Qt::DotLine: |
| pattern << dot << space; |
| break; |
| case Qt::DashDotLine: |
| pattern << dash << space << dot << space; |
| break; |
| case Qt::DashDotDotLine: |
| pattern << dash << space << dot << space << dot << space; |
| break; |
| default: |
| break; |
| } |
| |
| return pattern; |
| } |
| |
| static inline bool lineRectIntersectsRect(qfixed2d p1, qfixed2d p2, const qfixed2d &tl, const qfixed2d &br) |
| { |
| return ((p1.x > tl.x || p2.x > tl.x) && (p1.x < br.x || p2.x < br.x) |
| && (p1.y > tl.y || p2.y > tl.y) && (p1.y < br.y || p2.y < br.y)); |
| } |
| |
| // If the line intersects the rectangle, this function will return true. |
| static bool lineIntersectsRect(qfixed2d p1, qfixed2d p2, const qfixed2d &tl, const qfixed2d &br) |
| { |
| if (!lineRectIntersectsRect(p1, p2, tl, br)) |
| return false; |
| if (p1.x == p2.x || p1.y == p2.y) |
| return true; |
| |
| if (p1.y > p2.y) |
| qSwap(p1, p2); // make p1 above p2 |
| qfixed2d u; |
| qfixed2d v; |
| qfixed2d w = {p2.x - p1.x, p2.y - p1.y}; |
| if (p1.x < p2.x) { |
| // backslash |
| u.x = tl.x - p1.x; u.y = br.y - p1.y; |
| v.x = br.x - p1.x; v.y = tl.y - p1.y; |
| } else { |
| // slash |
| u.x = tl.x - p1.x; u.y = tl.y - p1.y; |
| v.x = br.x - p1.x; v.y = br.y - p1.y; |
| } |
| #if defined(QFIXED_IS_26_6) || defined(QFIXED_IS_16_16) |
| qint64 val1 = qint64(u.x) * qint64(w.y) - qint64(u.y) * qint64(w.x); |
| qint64 val2 = qint64(v.x) * qint64(w.y) - qint64(v.y) * qint64(w.x); |
| return (val1 < 0 && val2 > 0) || (val1 > 0 && val2 < 0); |
| #elif defined(QFIXED_IS_32_32) |
| // Cannot do proper test because it may overflow. |
| return true; |
| #else |
| qreal val1 = u.x * w.y - u.y * w.x; |
| qreal val2 = v.x * w.y - v.y * w.x; |
| return (val1 < 0 && val2 > 0) || (val1 > 0 && val2 < 0); |
| #endif |
| } |
| |
| void QDashStroker::processCurrentSubpath() |
| { |
| int dashCount = qMin(m_dashPattern.size(), 32); |
| qfixed dashes[32]; |
| |
| if (m_stroker) { |
| m_customData = m_stroker; |
| m_stroke_width = m_stroker->strokeWidth(); |
| m_miter_limit = m_stroker->miterLimit(); |
| } |
| |
| qreal longestLength = 0; |
| qreal sumLength = 0; |
| for (int i=0; i<dashCount; ++i) { |
| dashes[i] = qMax(m_dashPattern.at(i), qreal(0)) * m_stroke_width; |
| sumLength += dashes[i]; |
| if (dashes[i] > longestLength) |
| longestLength = dashes[i]; |
| } |
| |
| if (qFuzzyIsNull(sumLength)) |
| return; |
| |
| qreal invSumLength = qreal(1) / sumLength; |
| |
| Q_ASSERT(dashCount > 0); |
| |
| dashCount = dashCount & -2; // Round down to even number |
| |
| int idash = 0; // Index to current dash |
| qreal pos = 0; // The position on the curve, 0 <= pos <= path.length |
| qreal elen = 0; // element length |
| qreal doffset = m_dashOffset * m_stroke_width; |
| |
| // make sure doffset is in range [0..sumLength) |
| doffset -= qFloor(doffset * invSumLength) * sumLength; |
| |
| while (doffset >= dashes[idash]) { |
| doffset -= dashes[idash]; |
| if (++idash >= dashCount) |
| idash = 0; |
| } |
| |
| qreal estart = 0; // The elements starting position |
| qreal estop = 0; // The element stop position |
| |
| QLineF cline; |
| |
| QPainterPath dashPath; |
| |
| QSubpathFlatIterator it(&m_elements, m_dashThreshold); |
| qfixed2d prev = it.next(); |
| |
| bool clipping = !m_clip_rect.isEmpty(); |
| qfixed2d move_to_pos = prev; |
| qfixed2d line_to_pos; |
| |
| // Pad to avoid clipping the borders of thick pens. |
| qfixed padding = qt_real_to_fixed(qMax(m_stroke_width, m_miter_limit) * longestLength); |
| qfixed2d clip_tl = { qt_real_to_fixed(m_clip_rect.left()) - padding, |
| qt_real_to_fixed(m_clip_rect.top()) - padding }; |
| qfixed2d clip_br = { qt_real_to_fixed(m_clip_rect.right()) + padding , |
| qt_real_to_fixed(m_clip_rect.bottom()) + padding }; |
| |
| bool hasMoveTo = false; |
| while (it.hasNext()) { |
| QStrokerOps::Element e = it.next(); |
| |
| Q_ASSERT(e.isLineTo()); |
| cline = QLineF(qt_fixed_to_real(prev.x), |
| qt_fixed_to_real(prev.y), |
| qt_fixed_to_real(e.x), |
| qt_fixed_to_real(e.y)); |
| elen = cline.length(); |
| |
| estop = estart + elen; |
| |
| bool done = pos >= estop; |
| |
| if (clipping) { |
| // Check if the entire line can be clipped away. |
| if (!lineIntersectsRect(prev, e, clip_tl, clip_br)) { |
| // Cut away full dash sequences. |
| elen -= qFloor(elen * invSumLength) * sumLength; |
| // Update dash offset. |
| while (!done) { |
| qreal dpos = pos + dashes[idash] - doffset - estart; |
| |
| Q_ASSERT(dpos >= 0); |
| |
| if (dpos > elen) { // dash extends this line |
| doffset = dashes[idash] - (dpos - elen); // subtract the part already used |
| pos = estop; // move pos to next path element |
| done = true; |
| } else { // Dash is on this line |
| pos = dpos + estart; |
| done = pos >= estop; |
| if (++idash >= dashCount) |
| idash = 0; |
| doffset = 0; // full segment so no offset on next. |
| } |
| } |
| hasMoveTo = false; |
| move_to_pos = e; |
| } |
| } |
| |
| // Dash away... |
| while (!done) { |
| QPointF p2; |
| |
| bool has_offset = doffset > 0; |
| bool evenDash = (idash & 1) == 0; |
| qreal dpos = pos + dashes[idash] - doffset - estart; |
| |
| Q_ASSERT(dpos >= 0); |
| |
| if (dpos > elen) { // dash extends this line |
| doffset = dashes[idash] - (dpos - elen); // subtract the part already used |
| pos = estop; // move pos to next path element |
| done = true; |
| p2 = cline.p2(); |
| } else { // Dash is on this line |
| p2 = cline.pointAt(dpos/elen); |
| pos = dpos + estart; |
| done = pos >= estop; |
| if (++idash >= dashCount) |
| idash = 0; |
| doffset = 0; // full segment so no offset on next. |
| } |
| |
| if (evenDash) { |
| line_to_pos.x = qt_real_to_fixed(p2.x()); |
| line_to_pos.y = qt_real_to_fixed(p2.y()); |
| |
| if (!clipping |
| || lineRectIntersectsRect(move_to_pos, line_to_pos, clip_tl, clip_br)) |
| { |
| // If we have an offset, we're continuing a dash |
| // from a previous element and should only |
| // continue the current dash, without starting a |
| // new subpath. |
| if (!has_offset || !hasMoveTo) { |
| emitMoveTo(move_to_pos.x, move_to_pos.y); |
| hasMoveTo = true; |
| } |
| |
| emitLineTo(line_to_pos.x, line_to_pos.y); |
| } else { |
| hasMoveTo = false; |
| } |
| move_to_pos = line_to_pos; |
| } else { |
| move_to_pos.x = qt_real_to_fixed(p2.x()); |
| move_to_pos.y = qt_real_to_fixed(p2.y()); |
| } |
| } |
| |
| // Shuffle to the next cycle... |
| estart = estop; |
| prev = e; |
| } |
| |
| } |
| |
| QT_END_NAMESPACE |