QStroker Class Reference

#include <qstroker_p.h>

Inheritance diagram for QStroker:

Public Types
enum	LineJoinMode {   FlatJoin, SquareJoin, MiterJoin, RoundJoin,   RoundCap, SvgMiterJoin }

Public Functions
Qt::PenCapStyle	capStyle () const
LineJoinMode	capStyleMode () const
void	emitCubicTo (qfixed c1x, qfixed c1y, qfixed c2x, qfixed c2y, qfixed ex, qfixed ey)
void	emitLineTo (qfixed x, qfixed y)
void	emitMoveTo (qfixed x, qfixed y)
void	joinPoints (qfixed x, qfixed y, const QLineF &nextLine, LineJoinMode join)
Qt::PenJoinStyle	joinStyle () const
LineJoinMode	joinStyleMode () const
qfixed	miterLimit () const
	QStroker ()
void	setCapStyle (Qt::PenCapStyle capStyle)
void	setJoinStyle (Qt::PenJoinStyle style)
void	setMiterLimit (qfixed length)
void	setStrokeWidth (qfixed width)
qfixed	strokeWidth () const
	~QStroker ()
Public Functions inherited from QStrokerOps
virtual void	begin (void *customData)
	Prepares the stroker. More...
QRectF	clipRect () const
void	cubicTo (qfixed x1, qfixed y1, qfixed x2, qfixed y2, qfixed ex, qfixed ey)
qfixed	curveThreshold () const
virtual void	end ()
	Finishes the stroke. More...
void	lineTo (qfixed x, qfixed y)
void	moveTo (qfixed x, qfixed y)
	QStrokerOps ()
void	setClipRect (const QRectF &clip)
void	setCubicToHook (qStrokerCubicToHook cubicToHook)
void	setCurveThreshold (qfixed threshold)
void	setCurveThresholdFromTransform (const QTransform &transform)
void	setLineToHook (qStrokerLineToHook lineToHook)
void	setMoveToHook (qStrokerMoveToHook moveToHook)
void	strokeEllipse (const QRectF &ellipse, void *data, const QTransform &matrix)
	Convenience function for stroking an ellipse with bounding rect rect. More...
void	strokePath (const QPainterPath &path, void *data, const QTransform &matrix)
	Convenience function that decomposes path into begin(), moveTo(), lineTo(), curevTo() and end() calls. More...
void	strokePolygon (const QPointF *points, int pointCount, bool implicit_close, void *data, const QTransform &matrix)
	Convenience function for stroking a polygon of the pointCount first points in points. More...
virtual	~QStrokerOps ()

Protected Functions
virtual void	processCurrentSubpath ()
	This function is called to stroke the currently built up subpath. More...
Protected Functions inherited from QStrokerOps
void	emitCubicTo (qfixed c1x, qfixed c1y, qfixed c2x, qfixed c2y, qfixed ex, qfixed ey)
void	emitLineTo (qfixed x, qfixed y)
void	emitMoveTo (qfixed x, qfixed y)

Static Protected Functions
static Qt::PenCapStyle	capForJoinMode (LineJoinMode mode)
static Qt::PenJoinStyle	joinForJoinMode (LineJoinMode mode)
static LineJoinMode	joinModeForCap (Qt::PenCapStyle)
static LineJoinMode	joinModeForJoin (Qt::PenJoinStyle joinStyle)

Protected Variables
qfixed	m_back1X
qfixed	m_back1Y
qfixed	m_back2X
qfixed	m_back2Y
LineJoinMode	m_capStyle
LineJoinMode	m_joinStyle
qfixed	m_miterLimit
qfixed	m_strokeWidth
Protected Variables inherited from QStrokerOps
QRectF	m_clip_rect
qStrokerCubicToHook	m_cubicTo
qfixed	m_curveThreshold
void *	m_customData
qfixed	m_dashThreshold
QDataBuffer< Element >	m_elements
qStrokerLineToHook	m_lineTo
qStrokerMoveToHook	m_moveTo

Detailed Description

Definition at line 196 of file qstroker_p.h.

Enumerations

LineJoinMode

enum QStroker::LineJoinMode

Enumerator
FlatJoin
SquareJoin
MiterJoin
RoundJoin
RoundCap
SvgMiterJoin

Definition at line 200 of file qstroker_p.h.

                      {
        FlatJoin,
        SquareJoin,
        MiterJoin,
        RoundJoin,
        RoundCap,
        SvgMiterJoin
    };

Constructors and Destructors

QStroker()

QStroker::QStroker

(

)

Definition at line 372 of file qstroker.cpp.

    : 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::~QStroker

(

)

Definition at line 381 of file qstroker.cpp.

{
}

Functions

capForJoinMode()

Qt::PenCapStyle QStroker::capForJoinMode ( LineJoinMode  mode )

staticprotected

Definition at line 385 of file qstroker.cpp.

{
    if (mode == FlatJoin) return Qt::FlatCap;
    else if (mode == SquareJoin) return Qt::SquareCap;
    else return Qt::RoundCap;
}

capStyle()

Qt::PenCapStyle QStroker::capStyle ( ) const

inline

Definition at line 216 of file qstroker_p.h.

{ return capForJoinMode(m_capStyle); }

capStyleMode()

LineJoinMode QStroker::capStyleMode ( ) const

inline

Definition at line 217 of file qstroker_p.h.

Referenced by qt_stroke_side().

{ return m_capStyle; }

emitCubicTo()

void QStroker::emitCubicTo ( qfixed  c1x, qfixed  c1y, qfixed  c2x, qfixed  c2y, qfixed  ex, qfixed  ey  )

inline

Definition at line 354 of file qstroker_p.h.

Referenced by joinPoints(), and qt_stroke_side().

{
    if (c2x == ex && c2y == ey) {
        if (c1x == ex && c1y == ey) {
            m_back2X = m_back1X;
            m_back2Y = m_back1Y;
        } else {
            m_back2X = c1x;
            m_back2Y = c1y;
        }
    } else {
        m_back2X = c2x;
        m_back2Y = c2y;
    }
    m_back1X = ex;
    m_back1Y = ey;
    QStrokerOps::emitCubicTo(c1x, c1y, c2x, c2y, ex, ey);
}

emitLineTo()

void QStroker::emitLineTo ( qfixed  x, qfixed  y  )

inline

Definition at line 345 of file qstroker_p.h.

Referenced by joinPoints(), and qt_stroke_side().

{
    m_back2X = m_back1X;
    m_back2Y = m_back1Y;
    m_back1X = x;
    m_back1Y = y;
    QStrokerOps::emitLineTo(x, y);
}

emitMoveTo()

void QStroker::emitMoveTo ( qfixed  x, qfixed  y  )

inline

Definition at line 336 of file qstroker_p.h.

Referenced by qt_stroke_side().

{
    m_back2X = m_back1X;
    m_back2Y = m_back1Y;
    m_back1X = x;
    m_back1Y = y;
    QStrokerOps::emitMoveTo(x, y);
}

joinForJoinMode()

Qt::PenJoinStyle QStroker::joinForJoinMode ( LineJoinMode  mode )

staticprotected

Definition at line 399 of file qstroker.cpp.

{
    if (mode == FlatJoin) return Qt::BevelJoin;
    else if (mode == MiterJoin) return Qt::MiterJoin;
    else if (mode == SvgMiterJoin) return Qt::SvgMiterJoin;
    else return Qt::RoundJoin;
}

joinModeForCap()

QStroker::LineJoinMode QStroker::joinModeForCap ( Qt::PenCapStyle  style )

staticprotected

Definition at line 392 of file qstroker.cpp.

{
    if (style == Qt::FlatCap) return FlatJoin;
    else if (style == Qt::SquareCap) return SquareJoin;
    else return RoundCap;
}

joinModeForJoin()

QStroker::LineJoinMode QStroker::joinModeForJoin ( Qt::PenJoinStyle  joinStyle )

staticprotected

Definition at line 407 of file qstroker.cpp.

{
    if (joinStyle == Qt::BevelJoin) return FlatJoin;
    else if (joinStyle == Qt::MiterJoin) return MiterJoin;
    else if (joinStyle == Qt::SvgMiterJoin) return SvgMiterJoin;
    else return RoundJoin;
}

joinPoints()

void QStroker::joinPoints	(	qfixed	focal_x,
		qfixed	focal_y,
		const QLineF &	nextLine,
		LineJoinMode	join
	)

Warning

This function is not part of the public interface.

Definition at line 442 of file qstroker.cpp.

Referenced by processCurrentSubpath(), and qt_stroke_side().

{
#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()));
            Q_UNUSED(curve_start);

            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...");
        }
    }
}

joinStyle()

Qt::PenJoinStyle QStroker::joinStyle ( ) const

inline

Definition at line 220 of file qstroker_p.h.

{ return joinForJoinMode(m_joinStyle); }

joinStyleMode()

LineJoinMode QStroker::joinStyleMode ( ) const

inline

Definition at line 221 of file qstroker_p.h.

Referenced by qt_stroke_side().

{ return m_joinStyle; }

miterLimit()

qfixed QStroker::miterLimit ( ) const

inline

Definition at line 224 of file qstroker_p.h.

Referenced by QDashStroker::processCurrentSubpath().

{ return m_miterLimit; }

processCurrentSubpath()

void QStroker::processCurrentSubpath ( )

protectedvirtual

This function is called to stroke the currently built up subpath.

The subpath is cleared when the function completes.

Implements QStrokerOps.

Definition at line 420 of file qstroker.cpp.

{
    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);
}

setCapStyle()

void QStroker::setCapStyle ( Qt::PenCapStyle  capStyle )

inline

Definition at line 215 of file qstroker_p.h.

Referenced by QPdf::Stroker::setPen().

{ m_capStyle = joinModeForCap(capStyle); }

setJoinStyle()

void QStroker::setJoinStyle ( Qt::PenJoinStyle  style )

inline

Definition at line 219 of file qstroker_p.h.

Referenced by QPdf::Stroker::setPen().

{ m_joinStyle = joinModeForJoin(style); }

setMiterLimit()

void QStroker::setMiterLimit ( qfixed  length )

inline

Definition at line 223 of file qstroker_p.h.

Referenced by QPdf::Stroker::setPen().

{ m_miterLimit = length; }

setStrokeWidth()

void QStroker::setStrokeWidth ( qfixed  width )

inline

Definition at line 212 of file qstroker_p.h.

Referenced by QPdf::Stroker::setPen(), and QPdf::Stroker::Stroker().

{ m_strokeWidth = width; }

strokeWidth()

qfixed QStroker::strokeWidth ( ) const

inline

Definition at line 213 of file qstroker_p.h.

Referenced by QDashStroker::processCurrentSubpath(), and qt_stroke_side().

{ return m_strokeWidth; }

Properties

m_back1X

qfixed QStroker::m_back1X

protected

Definition at line 246 of file qstroker_p.h.

Referenced by joinPoints().

m_back1Y

qfixed QStroker::m_back1Y

protected

Definition at line 247 of file qstroker_p.h.

Referenced by joinPoints().

m_back2X

qfixed QStroker::m_back2X

protected

Definition at line 249 of file qstroker_p.h.

Referenced by joinPoints().

m_back2Y

qfixed QStroker::m_back2Y

protected

Definition at line 250 of file qstroker_p.h.

Referenced by joinPoints().

m_capStyle

LineJoinMode QStroker::m_capStyle

protected

Definition at line 243 of file qstroker_p.h.

Referenced by processCurrentSubpath().

m_joinStyle

LineJoinMode QStroker::m_joinStyle

protected

Definition at line 244 of file qstroker_p.h.

m_miterLimit

qfixed QStroker::m_miterLimit

protected

Definition at line 241 of file qstroker_p.h.

Referenced by joinPoints(), and QStroker().

m_strokeWidth

qfixed QStroker::m_strokeWidth

protected

Definition at line 240 of file qstroker_p.h.

Referenced by joinPoints(), and QStroker().

---

The documentation for this class was generated from the following files:

• /src/gui/painting/qstroker_p.h
• /src/gui/painting/qstroker.cpp