#include <qstroker_p.h>

Inheritance diagram for QDashStroker:

Public Functions
virtual void	begin (void *data)
	Prepares the stroker. More...

qreal	dashOffset () const

QVector< qfixed >	dashPattern () const

virtual void	end ()
	Finishes the stroke. More...

	QDashStroker (QStroker *stroker)

void	setDashOffset (qreal offset)

void	setDashPattern (const QVector< qfixed > &dashPattern)

void	setMiterLimit (qreal limit)

void	setStrokeWidth (qreal width)

QStroker *	stroker () const

Public Functions inherited from QStrokerOps
QRectF	clipRect () const

void	cubicTo (qfixed x1, qfixed y1, qfixed x2, qfixed y2, qfixed ex, qfixed ey)

qfixed	curveThreshold () const

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 ()

Static Public Functions
static QVector< qfixed >	patternForStyle (Qt::PenStyle style)

Protected Functions
virtual void	processCurrentSubpath ()

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)

Protected Variables
qreal	m_dashOffset

QVector< qfixed >	m_dashPattern

qreal	m_miter_limit

qreal	m_stroke_width

QStroker *	m_stroker

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 253 of file qstroker_p.h.

Constructors and Destructors

◆ QDashStroker()

QDashStroker::QDashStroker ( QStroker * stroker )

Definition at line 1024 of file qstroker.cpp.

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

Functions

◆ begin()

void QDashStroker::begin ( void * customData )

inlinevirtual

Prepares the stroker.

Call this function once before starting a stroke by calling moveTo, lineTo or cubicTo.

The customData is passed back through that callback functions and can be used by the user to for instance maintain state information.

Reimplemented from QStrokerOps.

Definition at line 378 of file qstroker_p.h.

Referenced by QDashedStrokeProcessor::process().

 {
     if (m_stroker)
         m_stroker->begin(data);
     QStrokerOps::begin(data);
 }

◆ dashOffset()

qreal QDashStroker::dashOffset ( ) const

inline

Definition at line 266 of file qstroker_p.h.

266 { return m_dashOffset; }

QDashStroker::m_dashOffset

qreal m_dashOffset

Definition: qstroker_p.h:279

◆ dashPattern()

QVector<qfixed> QDashStroker::dashPattern ( ) const

inline

Definition at line 263 of file qstroker_p.h.

263 { return m_dashPattern; }

QDashStroker::m_dashPattern

QVector< qfixed > m_dashPattern

Definition: qstroker_p.h:278

◆ end()

void QDashStroker::end ( )

inlinevirtual

Finishes the stroke.

Call this function once when an entire primitive has been stroked.

Reimplemented from QStrokerOps.

Definition at line 385 of file qstroker_p.h.

Referenced by QDashedStrokeProcessor::process().

 {
     QStrokerOps::end();
     if (m_stroker)
         m_stroker->end();
 }

◆ patternForStyle()

QVector< qfixed > QDashStroker::patternForStyle ( Qt::PenStyle style )

static

Definition at line 1034 of file qstroker.cpp.

Referenced by QPainterPathStroker::setDashPattern().

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

◆ processCurrentSubpath()

void QDashStroker::processCurrentSubpath ( )

protectedvirtual

Implements QStrokerOps.

Definition at line 1104 of file qstroker.cpp.

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