qpainterpath.cpp File Reference

#include "qpainterpath.h"
#include "qpainterpath_p.h"
#include <qbitmap.h>
#include <qdebug.h>
#include <qiodevice.h>
#include <qlist.h>
#include <qmatrix.h>
#include <qpen.h>
#include <qpolygon.h>
#include <qtextlayout.h>
#include <qvarlengtharray.h>
#include <qmath.h>
#include <private/qbezier_p.h>
#include <private/qfontengine_p.h>
#include <private/qnumeric_p.h>
#include <private/qobject_p.h>
#include <private/qpathclipper_p.h>
#include <private/qstroker_p.h>
#include <private/qtextengine_p.h>
#include <limits.h>

Go to the source code of this file.

Classes
struct	QPainterPathPrivateDeleter

Macros
#define	PM_DISPLAY
#define	PM_INIT
#define	PM_MEASURE(x)
#define	QT_BEZIER_A(bezier, coord)
#define	QT_BEZIER_B(bezier, coord)
#define	QT_BEZIER_C(bezier, coord)
#define	QT_BEZIER_CHECK_T(bezier, t)
#define	SIGN(x)   ((x < 0)?-1:1)

Functions
static QBezier	bezierAtT (const QPainterPath &path, qreal t, qreal *startingLength, qreal *bezierLength)
static bool	epsilonCompare (const QPointF &a, const QPointF &b, const QSizeF &epsilon)
QDataStream &	operator<< (QDataStream &s, const QPainterPath &p)
QDebug	operator<< (QDebug s, const QPainterPath &p)
QDataStream &	operator>> (QDataStream &s, QPainterPath &p)
void	qt_find_ellipse_coords (const QRectF &r, qreal angle, qreal length, QPointF *startPoint, QPointF *endPoint)
static bool	qt_isect_curve_horizontal (const QBezier &bezier, qreal y, qreal x1, qreal x2, int depth=0)
static bool	qt_isect_curve_vertical (const QBezier &bezier, qreal x, qreal y1, qreal y2, int depth=0)
static QRectF	qt_painterpath_bezier_extrema (const QBezier &b)
static bool	qt_painterpath_check_crossing (const QPainterPath *path, const QRectF &rect)
static void	qt_painterpath_isect_curve (const QBezier &bezier, const QPointF &pt, int *winding, int depth=0)
static void	qt_painterpath_isect_line (const QPointF &p1, const QPointF &p2, const QPointF &pos, int *winding)
static bool	qt_painterpath_isect_line_rect (qreal x1, qreal y1, qreal x2, qreal y2, const QRectF &rect)
void	qt_path_stroke_cubic_to (qfixed c1x, qfixed c1y, qfixed c2x, qfixed c2y, qfixed ex, qfixed ey, void *data)
void	qt_path_stroke_line_to (qfixed x, qfixed y, void *data)
void	qt_path_stroke_move_to (qfixed x, qfixed y, void *data)
QPainterPath	qt_stroke_dash (const QPainterPath &path, qreal *dashes, int dashCount)
static qreal	slopeAt (qreal t, qreal a, qreal b, qreal c, qreal d)

Macro Definition Documentation

PM_DISPLAY

#define PM_DISPLAY

Definition at line 71 of file qpainterpath.cpp.

PM_INIT

#define PM_INIT

Definition at line 69 of file qpainterpath.cpp.

PM_MEASURE

#define PM_MEASURE

(

x

)

Definition at line 70 of file qpainterpath.cpp.

QT_BEZIER_A

#define QT_BEZIER_A	(		bezier,
			coord
	)

Value:

3 * (-bezier.coord##1 \
                                        + 3*bezier.coord##2 \
                                        - 3*bezier.coord##3 \
                                        +bezier.coord##4)

Definition at line 1419 of file qpainterpath.cpp.

Referenced by qt_painterpath_bezier_extrema().

QT_BEZIER_B

#define QT_BEZIER_B	(		bezier,
			coord
	)

Value:

6 * (bezier.coord##1 \
                                        - 2*bezier.coord##2 \
                                        + bezier.coord##3)

Definition at line 1424 of file qpainterpath.cpp.

Referenced by qt_painterpath_bezier_extrema().

QT_BEZIER_C

#define QT_BEZIER_C	(		bezier,
			coord
	)

Value:

3 * (- bezier.coord##1 \
                                        + bezier.coord##2)

Definition at line 1428 of file qpainterpath.cpp.

Referenced by qt_painterpath_bezier_extrema().

QT_BEZIER_CHECK_T

#define QT_BEZIER_CHECK_T	(		bezier,
			t
	)

Value:

if (t >= 0 && t <= 1) { \
        QPointF p(b.pointAt(t)); \
        if (p.x() < minx) minx = p.x(); \
        else if (p.x() > maxx) maxx = p.x(); \
        if (p.y() < miny) miny = p.y(); \
        else if (p.y() > maxy) maxy = p.y(); \
    }

Definition at line 1431 of file qpainterpath.cpp.

Referenced by qt_painterpath_bezier_extrema().

SIGN

#define SIGN

(

x

)

((x < 0)?-1:1)

Referenced by QPainterPath::slopeAtPercent().

Function Documentation

bezierAtT()

static QBezier bezierAtT ( const QPainterPath &  path, qreal  t, qreal *  startingLength, qreal *  bezierLength  )

inlinestatic

Definition at line 3027 of file qpainterpath.cpp.

Referenced by QPainterPath::angleAtPercent(), QPainterPath::pointAtPercent(), and QPainterPath::slopeAtPercent().

{
    *startingLength = 0;
    if (t > 1)
        return QBezier();

    qreal curLen = 0;
    qreal totalLength = path.length();

    const int lastElement = path.elementCount() - 1;
    for (int i=0; i <= lastElement; ++i) {
        const QPainterPath::Element &e = path.elementAt(i);

        switch (e.type) {
        case QPainterPath::MoveToElement:
            break;
        case QPainterPath::LineToElement:
        {
            QLineF line(path.elementAt(i-1), e);
            qreal llen = line.length();
            curLen += llen;
            if (i == lastElement || curLen/totalLength >= t) {
                *bezierLength = llen;
                QPointF a = path.elementAt(i-1);
                QPointF delta = e - a;
                return QBezier::fromPoints(a, a + delta / 3, a + 2 * delta / 3, e);
            }
            break;
        }
        case QPainterPath::CurveToElement:
        {
            QBezier b = QBezier::fromPoints(path.elementAt(i-1),
                                            e,
                                            path.elementAt(i+1),
                                            path.elementAt(i+2));
            qreal blen = b.length();
            curLen += blen;

            if (i + 2 == lastElement || curLen/totalLength >= t) {
                *bezierLength = blen;
                return b;
            }

            i += 2;
            break;
        }
        default:
            break;
        }
        *startingLength = curLen;
    }
    return QBezier();
}

epsilonCompare()

static bool epsilonCompare ( const QPointF &  a, const QPointF &  b, const QSizeF &  epsilon  )

inlinestatic

Definition at line 2318 of file qpainterpath.cpp.

Referenced by QPainterPath::operator==().

{
    return qAbs(a.x() - b.x()) <= epsilon.width()
        && qAbs(a.y() - b.y()) <= epsilon.height();
}

operator<<() [1/2]

QDataStream& operator<<	(	QDataStream &	s,
		const QPainterPath &	p
	)

Definition at line 2509 of file qpainterpath.cpp.

Referenced by QPainterPath::detach().

{
    if (p.isEmpty()) {
        s << 0;
        return s;
    }

    s << p.elementCount();
    for (int i=0; i < p.d_func()->elements.size(); ++i) {
        const QPainterPath::Element &e = p.d_func()->elements.at(i);
        s << int(e.type);
        s << double(e.x) << double(e.y);
    }
    s << p.d_func()->cStart;
    s << int(p.d_func()->fillRule);
    return s;
}

operator<<() [2/2]

QDebug operator<<	(	QDebug	s,
		const QPainterPath &	p
	)

Definition at line 3618 of file qpainterpath.cpp.

{
    s.nospace() << "QPainterPath: Element count=" << p.elementCount() << endl;
    const char *types[] = {"MoveTo", "LineTo", "CurveTo", "CurveToData"};
    for (int i=0; i<p.elementCount(); ++i) {
        s.nospace() << " -> " << types[p.elementAt(i).type] << "(x=" << p.elementAt(i).x << ", y=" << p.elementAt(i).y << ')' << endl;

    }
    return s;
}

operator>>()

QDataStream& operator>>	(	QDataStream &	s,
		QPainterPath &	p
	)

Definition at line 2539 of file qpainterpath.cpp.

{
    int size;
    s >> size;

    if (size == 0)
        return s;

    p.ensureData(); // in case if p.d_func() == 0
    if (p.d_func()->elements.size() == 1) {
        Q_ASSERT(p.d_func()->elements.at(0).type == QPainterPath::MoveToElement);
        p.d_func()->elements.clear();
    }
    p.d_func()->elements.reserve(p.d_func()->elements.size() + size);
    for (int i=0; i<size; ++i) {
        int type;
        double x, y;
        s >> type;
        s >> x;
        s >> y;
        Q_ASSERT(type >= 0 && type <= 3);
        if (!qt_is_finite(x) || !qt_is_finite(y)) {
#ifndef QT_NO_DEBUG
            qWarning("QDataStream::operator>>: NaN or Inf element found in path, skipping it");
#endif
            continue;
        }
        QPainterPath::Element elm = { qreal(x), qreal(y), QPainterPath::ElementType(type) };
        p.d_func()->elements.append(elm);
    }
    s >> p.d_func()->cStart;
    int fillRule;
    s >> fillRule;
    Q_ASSERT(fillRule == Qt::OddEvenFill || Qt::WindingFill);
    p.d_func()->fillRule = Qt::FillRule(fillRule);
    p.d_func()->dirtyBounds = true;
    p.d_func()->dirtyControlBounds = true;
    return s;
}

qt_find_ellipse_coords()

void qt_find_ellipse_coords	(	const QRectF &	r,
		qreal	angle,
		qreal	length,
		QPointF *	startPoint,
		QPointF *	endPoint
	)

Definition at line 97 of file qpainterpath.cpp.

Referenced by QPainterPath::arcMoveTo(), QVectorPath::convertToPainterPath(), qt_curves_for_arc(), and qt_t_for_arc_angle().

{
    if (r.isNull()) {
        if (startPoint)
            *startPoint = QPointF();
        if (endPoint)
            *endPoint = QPointF();
        return;
    }

    qreal w2 = r.width() / 2;
    qreal h2 = r.height() / 2;

    qreal angles[2] = { angle, angle + length };
    QPointF *points[2] = { startPoint, endPoint };

    for (int i = 0; i < 2; ++i) {
        if (!points[i])
            continue;

        qreal theta = angles[i] - 360 * qFloor(angles[i] / 360);
        qreal t = theta / 90;
        // truncate
        int quadrant = int(t);
        t -= quadrant;

        t = qt_t_for_arc_angle(90 * t);

        // swap x and y?
        if (quadrant & 1)
            t = 1 - t;

        qreal a, b, c, d;
        QBezier::coefficients(t, a, b, c, d);
        QPointF p(a + b + c*QT_PATH_KAPPA, d + c + b*QT_PATH_KAPPA);

        // left quadrants
        if (quadrant == 1 || quadrant == 2)
            p.rx() = -p.x();

        // top quadrants
        if (quadrant == 0 || quadrant == 1)
            p.ry() = -p.y();

        *points[i] = r.center() + QPointF(w2 * p.x(), h2 * p.y());
    }
}

qt_isect_curve_horizontal()

static bool qt_isect_curve_horizontal ( const QBezier &  bezier, qreal  y, qreal  x1, qreal  x2, int  depth = 0  )

static

Definition at line 2023 of file qpainterpath.cpp.

Referenced by qt_painterpath_check_crossing().

{
    QRectF bounds = bezier.bounds();

    if (y >= bounds.top() && y < bounds.bottom()
        && bounds.right() >= x1 && bounds.left() < x2) {
        const qreal lower_bound = qreal(.01);
        if (depth == 32 || (bounds.width() < lower_bound && bounds.height() < lower_bound))
            return true;

        QBezier first_half, second_half;
        bezier.split(&first_half, &second_half);
        if (qt_isect_curve_horizontal(first_half, y, x1, x2, depth + 1)
            || qt_isect_curve_horizontal(second_half, y, x1, x2, depth + 1))
            return true;
    }
    return false;
}

qt_isect_curve_vertical()

static bool qt_isect_curve_vertical ( const QBezier &  bezier, qreal  x, qreal  y1, qreal  y2, int  depth = 0  )

static

Definition at line 2042 of file qpainterpath.cpp.

Referenced by qt_painterpath_check_crossing().

{
    QRectF bounds = bezier.bounds();

    if (x >= bounds.left() && x < bounds.right()
        && bounds.bottom() >= y1 && bounds.top() < y2) {
        const qreal lower_bound = qreal(.01);
        if (depth == 32 || (bounds.width() < lower_bound && bounds.height() < lower_bound))
            return true;

        QBezier first_half, second_half;
        bezier.split(&first_half, &second_half);
        if (qt_isect_curve_vertical(first_half, x, y1, y2, depth + 1)
            || qt_isect_curve_vertical(second_half, x, y1, y2, depth + 1))
            return true;
    }
     return false;
}

qt_painterpath_bezier_extrema()

static QRectF qt_painterpath_bezier_extrema ( const QBezier &  b )

static

Definition at line 1441 of file qpainterpath.cpp.

Referenced by QPainterPath::computeBoundingRect().

{
    qreal minx, miny, maxx, maxy;

    // initialize with end points
    if (b.x1 < b.x4) {
        minx = b.x1;
        maxx = b.x4;
    } else {
        minx = b.x4;
        maxx = b.x1;
    }
    if (b.y1 < b.y4) {
        miny = b.y1;
        maxy = b.y4;
    } else {
        miny = b.y4;
        maxy = b.y1;
    }

    // Update for the X extrema
    {
        qreal ax = QT_BEZIER_A(b, x);
        qreal bx = QT_BEZIER_B(b, x);
        qreal cx = QT_BEZIER_C(b, x);
        // specialcase quadratic curves to avoid div by zero
        if (qFuzzyIsNull(ax)) {

            // linear curves are covered by initialization.
            if (!qFuzzyIsNull(bx)) {
                qreal t = -cx / bx;
                QT_BEZIER_CHECK_T(b, t);
            }

        } else {
            const qreal tx = bx * bx - 4 * ax * cx;

            if (tx >= 0) {
                qreal temp = qSqrt(tx);
                qreal rcp = 1 / (2 * ax);
                qreal t1 = (-bx + temp) * rcp;
                QT_BEZIER_CHECK_T(b, t1);

                qreal t2 = (-bx - temp) * rcp;
                QT_BEZIER_CHECK_T(b, t2);
            }
        }
    }

    // Update for the Y extrema
    {
        qreal ay = QT_BEZIER_A(b, y);
        qreal by = QT_BEZIER_B(b, y);
        qreal cy = QT_BEZIER_C(b, y);

        // specialcase quadratic curves to avoid div by zero
        if (qFuzzyIsNull(ay)) {

            // linear curves are covered by initialization.
            if (!qFuzzyIsNull(by)) {
                qreal t = -cy / by;
                QT_BEZIER_CHECK_T(b, t);
            }

        } else {
            const qreal ty = by * by - 4 * ay * cy;

            if (ty > 0) {
                qreal temp = qSqrt(ty);
                qreal rcp = 1 / (2 * ay);
                qreal t1 = (-by + temp) * rcp;
                QT_BEZIER_CHECK_T(b, t1);

                qreal t2 = (-by - temp) * rcp;
                QT_BEZIER_CHECK_T(b, t2);
            }
        }
    }
    return QRectF(minx, miny, maxx - minx, maxy - miny);
}

qt_painterpath_check_crossing()

static bool qt_painterpath_check_crossing ( const QPainterPath *  path, const QRectF &  rect  )

static

Definition at line 2064 of file qpainterpath.cpp.

Referenced by QPainterPath::contains(), and QPainterPath::intersects().

{
    QPointF last_pt;
    QPointF last_start;
    for (int i=0; i<path->elementCount(); ++i) {
        const QPainterPath::Element &e = path->elementAt(i);

        switch (e.type) {

        case QPainterPath::MoveToElement:
            if (i > 0
                && qFuzzyCompare(last_pt.x(), last_start.x())
                && qFuzzyCompare(last_pt.y(), last_start.y())
                && qt_painterpath_isect_line_rect(last_pt.x(), last_pt.y(),
                                                  last_start.x(), last_start.y(), rect))
                return true;
            last_start = last_pt = e;
            break;

        case QPainterPath::LineToElement:
            if (qt_painterpath_isect_line_rect(last_pt.x(), last_pt.y(), e.x, e.y, rect))
                return true;
            last_pt = e;
            break;

        case QPainterPath::CurveToElement:
            {
                QPointF cp2 = path->elementAt(++i);
                QPointF ep = path->elementAt(++i);
                QBezier bezier = QBezier::fromPoints(last_pt, e, cp2, ep);
                if (qt_isect_curve_horizontal(bezier, rect.top(), rect.left(), rect.right())
                    || qt_isect_curve_horizontal(bezier, rect.bottom(), rect.left(), rect.right())
                    || qt_isect_curve_vertical(bezier, rect.left(), rect.top(), rect.bottom())
                    || qt_isect_curve_vertical(bezier, rect.right(), rect.top(), rect.bottom()))
                    return true;
                last_pt = ep;
            }
            break;

        default:
            break;
        }
    }

    // implicitly close last subpath
    if (last_pt != last_start
        && qt_painterpath_isect_line_rect(last_pt.x(), last_pt.y(),
                                          last_start.x(), last_start.y(), rect))
        return true;

    return false;
}

qt_painterpath_isect_curve()

static void qt_painterpath_isect_curve ( const QBezier &  bezier, const QPointF &  pt, int *  winding, int  depth = 0  )

static

Definition at line 1846 of file qpainterpath.cpp.

Referenced by QPainterPath::contains().

{
    qreal y = pt.y();
    qreal x = pt.x();
    QRectF bounds = bezier.bounds();

    // potential intersection, divide and try again...
    // Please note that a sideeffect of the bottom exclusion is that
    // horizontal lines are dropped, but this is correct according to
    // scan conversion rules.
    if (y >= bounds.y() && y < bounds.y() + bounds.height()) {

        // hit lower limit... This is a rough threshold, but its a
        // tradeoff between speed and precision.
        const qreal lower_bound = qreal(.001);
        if (depth == 32 || (bounds.width() < lower_bound && bounds.height() < lower_bound)) {
            // We make the assumption here that the curve starts to
            // approximate a line after while (i.e. that it doesn't
            // change direction drastically during its slope)
            if (bezier.pt1().x() <= x) {
                (*winding) += (bezier.pt4().y() > bezier.pt1().y() ? 1 : -1);
            }
            return;
        }

        // split curve and try again...
        QBezier first_half, second_half;
        bezier.split(&first_half, &second_half);
        qt_painterpath_isect_curve(first_half, pt, winding, depth + 1);
        qt_painterpath_isect_curve(second_half, pt, winding, depth + 1);
    }
}

qt_painterpath_isect_line()

static void qt_painterpath_isect_line ( const QPointF &  p1, const QPointF &  p2, const QPointF &  pos, int *  winding  )

static

Definition at line 1814 of file qpainterpath.cpp.

Referenced by QPainterPath::contains().

{
    qreal x1 = p1.x();
    qreal y1 = p1.y();
    qreal x2 = p2.x();
    qreal y2 = p2.y();
    qreal y = pos.y();

    int dir = 1;

    if (qFuzzyCompare(y1, y2)) {
        // ignore horizontal lines according to scan conversion rule
        return;
    } else if (y2 < y1) {
        qreal x_tmp = x2; x2 = x1; x1 = x_tmp;
        qreal y_tmp = y2; y2 = y1; y1 = y_tmp;
        dir = -1;
    }

    if (y >= y1 && y < y2) {
        qreal x = x1 + ((x2 - x1) / (y2 - y1)) * (y - y1);

        // count up the winding number if we're
        if (x<=pos.x()) {
            (*winding) += dir;
        }
    }
}

qt_painterpath_isect_line_rect()

static bool qt_painterpath_isect_line_rect ( qreal  x1, qreal  y1, qreal  x2, qreal  y2, const QRectF &  rect  )

static

Definition at line 1943 of file qpainterpath.cpp.

Referenced by qt_painterpath_check_crossing().

{
    qreal left = rect.left();
    qreal right = rect.right();
    qreal top = rect.top();
    qreal bottom = rect.bottom();

    enum { Left, Right, Top, Bottom };
    // clip the lines, after cohen-sutherland, see e.g. http://www.nondot.org/~sabre/graphpro/line6.html
    int p1 = ((x1 < left) << Left)
             | ((x1 > right) << Right)
             | ((y1 < top) << Top)
             | ((y1 > bottom) << Bottom);
    int p2 = ((x2 < left) << Left)
             | ((x2 > right) << Right)
             | ((y2 < top) << Top)
             | ((y2 > bottom) << Bottom);

    if (p1 & p2)
        // completely inside
        return false;

    if (p1 | p2) {
        qreal dx = x2 - x1;
        qreal dy = y2 - y1;

        // clip x coordinates
        if (x1 < left) {
            y1 += dy/dx * (left - x1);
            x1 = left;
        } else if (x1 > right) {
            y1 -= dy/dx * (x1 - right);
            x1 = right;
        }
        if (x2 < left) {
            y2 += dy/dx * (left - x2);
            x2 = left;
        } else if (x2 > right) {
            y2 -= dy/dx * (x2 - right);
            x2 = right;
        }

        p1 = ((y1 < top) << Top)
             | ((y1 > bottom) << Bottom);
        p2 = ((y2 < top) << Top)
             | ((y2 > bottom) << Bottom);

        if (p1 & p2)
            return false;

        // clip y coordinates
        if (y1 < top) {
            x1 += dx/dy * (top - y1);
            y1 = top;
        } else if (y1 > bottom) {
            x1 -= dx/dy * (y1 - bottom);
            y1 = bottom;
        }
        if (y2 < top) {
            x2 += dx/dy * (top - y2);
            y2 = top;
        } else if (y2 > bottom) {
            x2 -= dx/dy * (y2 - bottom);
            y2 = bottom;
        }

        p1 = ((x1 < left) << Left)
             | ((x1 > right) << Right);
        p2 = ((x2 < left) << Left)
             | ((x2 > right) << Right);

        if (p1 & p2)
            return false;

        return true;
    }
    return false;
}

qt_path_stroke_cubic_to()

void qt_path_stroke_cubic_to	(	qfixed	c1x,
		qfixed	c1y,
		qfixed	c2x,
		qfixed	c2y,
		qfixed	ex,
		qfixed	ey,
		void *	data
	)

Definition at line 2595 of file qpainterpath.cpp.

Referenced by QPainterPathStrokerPrivate::QPainterPathStrokerPrivate().

{
    ((QPainterPath *) data)->cubicTo(qt_fixed_to_real(c1x), qt_fixed_to_real(c1y),
                                     qt_fixed_to_real(c2x), qt_fixed_to_real(c2y),
                                     qt_fixed_to_real(ex), qt_fixed_to_real(ey));
}

qt_path_stroke_line_to()

void qt_path_stroke_line_to	(	qfixed	x,
		qfixed	y,
		void *	data
	)

Definition at line 2590 of file qpainterpath.cpp.

Referenced by QPainterPathStrokerPrivate::QPainterPathStrokerPrivate().

{
    ((QPainterPath *) data)->lineTo(qt_fixed_to_real(x), qt_fixed_to_real(y));
}

qt_path_stroke_move_to()

void qt_path_stroke_move_to	(	qfixed	x,
		qfixed	y,
		void *	data
	)

Definition at line 2585 of file qpainterpath.cpp.

Referenced by QPainterPathStrokerPrivate::QPainterPathStrokerPrivate().

{
    ((QPainterPath *) data)->moveTo(qt_fixed_to_real(x), qt_fixed_to_real(y));
}

qt_stroke_dash()

QPainterPath qt_stroke_dash	(	const QPainterPath &	path,
		qreal *	dashes,
		int	dashCount
	)

Referenced by QPainterPathPrivateDeleter::cleanup().

slopeAt()

static qreal slopeAt ( qreal  t, qreal  a, qreal  b, qreal  c, qreal  d  )

inlinestatic

Definition at line 2922 of file qpainterpath.cpp.

Referenced by QPainterPath::angleAtPercent(), and QPainterPath::slopeAtPercent().

{
    return 3*t*t*(d - 3*c + 3*b - a) + 6*t*(c - 2*b + a) + 3*(b - a);
}