src/gui/painting/qstroker.cpp File Reference

#include "private/qstroker_p.h"
#include "private/qbezier_p.h"
#include "private/qmath_p.h"
#include "qline.h"

Include dependency graph for qstroker.cpp:

Go to the source code of this file.

Classes
class	QSubpathForwardIterator
class	QSubpathBackwardIterator
class	QSubpathFlatIterator
Defines
#define	ANGLE(t)   ((t) * 2 * Q_PI / 360.0)
#define	SIGN(t)   (t > 0 ? 1 : -1)
Functions
template<class Iterator>
bool	qt_stroke_side (Iterator *it, QStroker *stroker, bool capFirst, QLineF *startTangent)
static qreal	adapted_angle_on_x (const QLineF &line)
QPointF	qt_curves_for_arc (const QRectF &rect, qreal startAngle, qreal sweepLength, QPointF *curves, int *point_count)

---

Define Documentation

#define ANGLE

(

t

)

((t) * 2 * Q_PI / 360.0)

#define SIGN

(

t

)

(t > 0 ? 1 : -1)

Referenced by qt_curves_for_arc().

---

Function Documentation

static qreal adapted_angle_on_x

(

const QLineF &

line

)

[inline, static]

Definition at line 159 of file qstroker.cpp.

References angle(), QLineF::angle(), and QLineF::dy().

Referenced by QStroker::joinPoints().

{
    qreal angle = line.angle(QLineF(0, 0, 1, 0));
    if (line.dy() > 0)
        angle = 360 - angle;
    return angle;
}

Here is the call graph for this function:

QPointF qt_curves_for_arc	(	const QRectF &	rect,
		qreal	startAngle,
		qreal	sweepLength,
		QPointF *	curves,
		int *	point_count
	)

Definition at line 722 of file qstroker.cpp.

References a, ANGLE, b, ceil, QRectF::center(), h, QRectF::height(), i, int, QRectF::isNull(), QLineF::length(), QLineF::p2(), qCos, qIsNan(), qSin, QT_PATH_KAPPA, qWarning(), QLineF::setLength(), SIGN, w, QRectF::width(), QRectF::x(), x, QRectF::y(), and y.

Referenced by QPainterPath::addEllipse(), QPainterPath::arcTo(), QRasterPaintEngine::drawEllipse(), QStroker::joinPoints(), and QStrokerOps::strokeEllipse().

{
    Q_ASSERT(point_count);
    Q_ASSERT(curves);

#ifndef QT_NO_DEBUG
    if (qIsNan(rect.x()) || qIsNan(rect.y()) || qIsNan(rect.width()) || qIsNan(rect.height())
        || qIsNan(startAngle) || qIsNan(sweepLength))
        qWarning("QPainterPath::arcTo: Adding arc where a parameter is NaN, results are undefined");
#endif
    *point_count = 0;

    if (rect.isNull()) {
        return QPointF();
    }

    if (sweepLength > 360) sweepLength = 360;
    else if (sweepLength < -360) sweepLength = -360;

    // Special case fast path
    if (startAngle == 0.0 && sweepLength == 360.0) {
        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;

        // 0 -> 270 degrees
        curves[(*point_count)++] = QPointF(x + w, y + h2 + h2k);
        curves[(*point_count)++] = QPointF(x + w2 + w2k, y + h);
        curves[(*point_count)++] = QPointF(x + w2, y + h);

        // 270 -> 180 degrees
        curves[(*point_count)++] = QPointF(x + w2 - w2k, y + h);
        curves[(*point_count)++] = QPointF(x, y + h2 + h2k);
        curves[(*point_count)++] = QPointF(x, y + h2);

        // 180 -> 90 degrees
        curves[(*point_count)++] = QPointF(x, y + h2 - h2k);
        curves[(*point_count)++] = QPointF(x + w2 - w2k, y);
        curves[(*point_count)++] = QPointF(x + w2, y);

        // 90 -> 0 degrees
        curves[(*point_count)++] = QPointF(x + w2 + w2k, y);
        curves[(*point_count)++] = QPointF(x + w, y + h2 - h2k);
        curves[(*point_count)++] = QPointF(x + w, y + h2);

        return QPointF(x + w, y + h2);
    }

#define ANGLE(t) ((t) * 2 * Q_PI / 360.0)
#define SIGN(t) (t > 0 ? 1 : -1)
    qreal a = rect.width() / 2.0;
    qreal b = rect.height() / 2.0;

    qreal absSweepLength = (sweepLength < 0 ? -sweepLength : sweepLength);
    int iterations = (int)ceil((absSweepLength) / 90.0);

    QPointF first_point;

    if (iterations == 0) {
        first_point = rect.center() + QPointF(a * qCos(ANGLE(startAngle)),
                                              -b * qSin(ANGLE(startAngle)));
    } else {
        qreal clength = sweepLength / iterations;
        qreal cosangle1, sinangle1, cosangle2, sinangle2;

        for (int i=0; i<iterations; ++i) {
            qreal cangle = startAngle + i * clength;

            cosangle1 = qCos(ANGLE(cangle));
            sinangle1 = qSin(ANGLE(cangle));
            cosangle2 = qCos(ANGLE(cangle + clength));
            sinangle2 = qSin(ANGLE(cangle + clength));

            // Find the start and end point of the curve.
            QPointF startPoint = rect.center() + QPointF(a * cosangle1, -b * sinangle1);
            QPointF endPoint = rect.center() + QPointF(a * cosangle2, -b * sinangle2);

            // The derived at the start and end point.
            qreal sdx = -a * sinangle1;
            qreal sdy = -b * cosangle1;
            qreal edx = -a * sinangle2;
            qreal edy = -b * cosangle2;

            // Creating the tangent lines. We need to reverse their direction if the
            // sweep is negative (clockwise)
            QLineF controlLine1(startPoint, startPoint + SIGN(sweepLength) * QPointF(sdx, sdy));
            QLineF controlLine2(endPoint, endPoint - SIGN(sweepLength) * QPointF(edx, edy));

            // We need to scale down the control lines to match that of the current sweeplength.
            // qAbs because we only want to scale, not change direction.
            qreal kappa = QT_PATH_KAPPA * qAbs(clength) / 90.0;
            // Adjust their length to fit the magic KAPPA length.
            controlLine1.setLength(controlLine1.length() * kappa);
            controlLine2.setLength(controlLine2.length() * kappa);

            curves[(*point_count)++] = controlLine1.p2();
            curves[(*point_count)++] = controlLine2.p2();
            curves[(*point_count)++] = endPoint;

            if (i == 0)
                first_point = startPoint;
        }
    }

    return first_point;
}

Here is the call graph for this function:

template<class Iterator>

bool qt_stroke_side	(	Iterator *	it,
		QStroker *	stroker,
		bool	capFirst,
		QLineF *	startTangent
	)

Definition at line 579 of file qstroker.cpp.

References QStroker::capStyleMode(), QStroker::curveThreshold(), QLineF::dx(), QLineF::dy(), QStroker::emitCubicTo(), QStroker::emitLineTo(), QStroker::emitMoveTo(), QBezier::fromPoints(), i, QStroker::joinPoints(), QStroker::joinStyleMode(), QLineF::normalVector(), QBezier::pt1(), QBezier::pt3(), QBezier::pt4(), qDebug(), qt_fixed_to_real, qt_real_to_fixed, QLineF::setLength(), QBezier::shifted(), start, QStroker::strokeWidth(), QLineF::translate(), qfixed2d::x, QStrokerOps::Element::x, QPointF::x(), QLineF::x1(), QLineF::x2(), qfixed2d::y, QStrokerOps::Element::y, QPointF::y(), QLineF::y1(), and QLineF::y2().

Referenced by QStroker::processCurrentSubpath().

{
    // 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
                if (first) {
                    QPointF pt = offsetCurves[0].pt1();
                    if (capFirst) {
                        stroker->joinPoints(prev.x, prev.y,
                                            QLineF(pt, offsetCurves[0].pt2()),
                                            stroker->capStyleMode());
                    } else {
                        stroker->emitMoveTo(qt_real_to_fixed(pt.x()),
                                            qt_real_to_fixed(pt.y()));
                    }
                    *startTangent = QLineF(offsetCurves[0].pt1(), offsetCurves[0].pt2());
                    first = false;
                } else {
                    stroker->joinPoints(prev.x, prev.y,
                                        QLineF(offsetCurves[0].pt1(), offsetCurves[0].pt2()),
                                        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;
    }
}

Here is the call graph for this function:

---