QDashedStrokeProcessor Class Reference

#include <qtriangulatingstroker_p.h>

Public Functions
void	addElement (QPainterPath::ElementType type, qreal x, qreal y)
int	elementCount () const
QPainterPath::ElementType *	elementTypes () const
qreal *	points () const
void	process (const QVectorPath &path, const QPen &pen, const QRectF &clip)
	QDashedStrokeProcessor ()
void	setInvScale (qreal invScale)

Properties
QDashStroker	m_dash_stroker
qreal	m_inv_scale
QDataBuffer< qreal >	m_points
QDataBuffer< QPainterPath::ElementType >	m_types

Detailed Description

Definition at line 95 of file qtriangulatingstroker_p.h.

Constructors and Destructors

QDashedStrokeProcessor()

QDashedStrokeProcessor::QDashedStrokeProcessor

(

)

Definition at line 483 of file qtriangulatingstroker.cpp.

    : m_points(0), m_types(0),
      m_dash_stroker(0), m_inv_scale(1)
{
    m_dash_stroker.setMoveToHook(qdashprocessor_moveTo);
    m_dash_stroker.setLineToHook(qdashprocessor_lineTo);
    m_dash_stroker.setCubicToHook(qdashprocessor_cubicTo);
}

Functions

addElement()

void QDashedStrokeProcessor::addElement ( QPainterPath::ElementType  type, qreal  x, qreal  y  )

inline

Definition at line 102 of file qtriangulatingstroker_p.h.

                                                                           {
        m_points.add(x);
        m_points.add(y);
        m_types.add(type);
    }

elementCount()

int QDashedStrokeProcessor::elementCount ( ) const

inline

Definition at line 108 of file qtriangulatingstroker_p.h.

{ return m_types.size(); }

elementTypes()

QPainterPath::ElementType* QDashedStrokeProcessor::elementTypes ( ) const

inline

Definition at line 110 of file qtriangulatingstroker_p.h.

{ return m_types.data(); }

points()

qreal* QDashedStrokeProcessor::points ( ) const

inline

Definition at line 109 of file qtriangulatingstroker_p.h.

{ return m_points.data(); }

process()

void QDashedStrokeProcessor::process	(	const QVectorPath &	path,
		const QPen &	pen,
		const QRectF &	clip
	)

Definition at line 492 of file qtriangulatingstroker.cpp.

{

    const qreal *pts = path.points();
    const QPainterPath::ElementType *types = path.elements();
    int count = path.elementCount();

    bool cosmetic = pen.isCosmetic();

    m_points.reset();
    m_types.reset();
    m_points.reserve(path.elementCount());
    m_types.reserve(path.elementCount());

    qreal width = qpen_widthf(pen);
    if (width == 0)
        width = 1;

    m_dash_stroker.setDashPattern(pen.dashPattern());
    m_dash_stroker.setStrokeWidth(cosmetic ? width * m_inv_scale : width);
    m_dash_stroker.setDashOffset(pen.dashOffset());
    m_dash_stroker.setMiterLimit(pen.miterLimit());
    m_dash_stroker.setClipRect(clip);

    float curvynessAdd, curvynessMul;

    // simplfy pens that are thin in device size (2px wide or less)
    if (width < 2.5 && (cosmetic || m_inv_scale == 1)) {
        curvynessAdd = 0.5;
        curvynessMul = CURVE_FLATNESS / m_inv_scale;
    } else if (cosmetic) {
        curvynessAdd= width / 2;
        curvynessMul= CURVE_FLATNESS;
    } else {
        curvynessAdd = width * m_inv_scale;
        curvynessMul = CURVE_FLATNESS / m_inv_scale;
    }

    if (count < 2)
        return;

    const qreal *endPts = pts + (count<<1);

    m_dash_stroker.begin(this);

    if (!types) {
        m_dash_stroker.moveTo(pts[0], pts[1]);
        pts += 2;
        while (pts < endPts) {
            m_dash_stroker.lineTo(pts[0], pts[1]);
            pts += 2;
        }
    } else {
        while (pts < endPts) {
            switch (*types) {
            case QPainterPath::MoveToElement:
                m_dash_stroker.moveTo(pts[0], pts[1]);
                pts += 2;
                ++types;
                break;
            case QPainterPath::LineToElement:
                m_dash_stroker.lineTo(pts[0], pts[1]);
                pts += 2;
                ++types;
                break;
            case QPainterPath::CurveToElement: {
                QBezier b = QBezier::fromPoints(*(((const QPointF *) pts) - 1),
                                                *(((const QPointF *) pts)),
                                                *(((const QPointF *) pts) + 1),
                                                *(((const QPointF *) pts) + 2));
                QRectF bounds = b.bounds();
                float rad = qMax(bounds.width(), bounds.height());
                int threshold = qMin<float>(64, (rad + curvynessAdd) * curvynessMul);
                if (threshold < 4)
                    threshold = 4;

                qreal threshold_minus_1 = threshold - 1;
                for (int i=0; i<threshold; ++i) {
                    QPointF pt = b.pointAt(i / threshold_minus_1);
                    m_dash_stroker.lineTo(pt.x(), pt.y());
                }
                pts += 6;
                types += 3;
                break; }
            default: break;
            }
        }
    }

    m_dash_stroker.end();
}

setInvScale()

void QDashedStrokeProcessor::setInvScale ( qreal  invScale )

inline

Definition at line 112 of file qtriangulatingstroker_p.h.

Referenced by QGL2PaintEngineExPrivate::updateMatrix().

{ m_inv_scale = invScale; }

Properties

m_dash_stroker

QDashStroker QDashedStrokeProcessor::m_dash_stroker

private

Definition at line 117 of file qtriangulatingstroker_p.h.

Referenced by process(), and QDashedStrokeProcessor().

m_inv_scale

qreal QDashedStrokeProcessor::m_inv_scale

private

Definition at line 118 of file qtriangulatingstroker_p.h.

Referenced by process().

m_points

QDataBuffer<qreal> QDashedStrokeProcessor::m_points

private

Definition at line 115 of file qtriangulatingstroker_p.h.

Referenced by process().

m_types

QDataBuffer<QPainterPath::ElementType> QDashedStrokeProcessor::m_types

private

Definition at line 116 of file qtriangulatingstroker_p.h.

Referenced by process().

---

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

• /src/opengl/gl2paintengineex/qtriangulatingstroker_p.h
• /src/opengl/gl2paintengineex/qtriangulatingstroker.cpp