QCosmeticStroker Class Reference

#include <qcosmeticstroker_p.h>

Classes
struct	Point
struct	PointF

Public Types
enum	{ NSPANS = 255 }
enum	Caps { NoCaps = 0, CapBegin = 0x1, CapEnd = 0x2 }
enum	Direction {   TopToBottom = 0x1, BottomToTop = 0x2, LeftToRight = 0x4, RightToLeft = 0x8,   VerticalMask = 0x3, HorizontalMask = 0xc }

Public Functions
bool	clipLine (qreal &x1, qreal &y1, qreal &x2, qreal &y2)
void	drawLine (const QPointF &p1, const QPointF &p2)
void	drawPath (const QVectorPath &path)
void	drawPoints (const QPoint *points, int num)
void	drawPoints (const QPointF *points, int num)
	QCosmeticStroker (QRasterPaintEngineState *s, const QRect &dr, const QRect &dr_unclipped)
	~QCosmeticStroker ()

Public Variables
ProcessSpans	blend
QRect	clip
uint	color
int	current_span
QRect	deviceRect
bool	drawCaps
bool	lastAxisAligned
Direction	lastDir
Point	lastPixel
int	opacity
int *	pattern
int	patternLength
int	patternOffset
int	patternSize
uint *	pixels
int	ppl
int *	reversePattern
QT_FT_Span	spans [NSPANS]
QRasterPaintEngineState *	state
StrokeLine	stroke
qreal	xmax
qreal	xmin
qreal	ymax
qreal	ymin

Private Functions
void	calculateLastPoint (qreal rx1, qreal ry1, qreal rx2, qreal ry2)
void	renderCubic (const QPointF &p1, const QPointF &p2, const QPointF &p3, const QPointF &p4, int caps)
void	renderCubicSubdivision (PointF *points, int level, int caps)
void	setup ()

Detailed Description

Definition at line 61 of file qcosmeticstroker_p.h.

Enumerations

anonymous enum

anonymous enum

Enumerator
NSPANS

Definition at line 125 of file qcosmeticstroker_p.h.

{ NSPANS = 255 };

Caps

enum QCosmeticStroker::Caps

Enumerator
NoCaps
CapBegin
CapEnd

Definition at line 73 of file qcosmeticstroker_p.h.

              {
        NoCaps = 0,
        CapBegin = 0x1,
        CapEnd = 0x2,
    };

Direction

enum QCosmeticStroker::Direction

Enumerator
TopToBottom
BottomToTop
LeftToRight
RightToLeft
VerticalMask
HorizontalMask

Definition at line 80 of file qcosmeticstroker_p.h.

                   {
        TopToBottom = 0x1,
        BottomToTop = 0x2,
        LeftToRight = 0x4,
        RightToLeft = 0x8,
        VerticalMask = 0x3,
        HorizontalMask = 0xc
    };

Constructors and Destructors

QCosmeticStroker()

QCosmeticStroker::QCosmeticStroker ( QRasterPaintEngineState *  s, const QRect &  dr, const QRect &  dr_unclipped  )

inline

Definition at line 89 of file qcosmeticstroker_p.h.

        : state(s),
          deviceRect(dr_unclipped),
          clip(dr),
          pattern(0),
          reversePattern(0),
          patternSize(0),
          patternLength(0),
          patternOffset(0),
          current_span(0),
          lastDir(LeftToRight),
          lastAxisAligned(false)
    { setup(); }

~QCosmeticStroker()

QCosmeticStroker::~QCosmeticStroker ( )

inline

Definition at line 102 of file qcosmeticstroker_p.h.

{ free(pattern); free(reversePattern); }

Functions

calculateLastPoint()

void QCosmeticStroker::calculateLastPoint ( qreal  rx1, qreal  ry1, qreal  rx2, qreal  ry2  )

private

Definition at line 411 of file qcosmeticstroker.cpp.

{
    // this is basically the same code as used in the aliased stroke method,
    // but it only determines the direction and last point of a line
    //
    // This is being used to have proper dropout control for closed contours
    // by calculating the direction and last pixel of the last segment in the contour.
    // the info is then used to perform dropout control when drawing the first line segment
    // of the contour
    lastPixel.x = -1;
    lastPixel.y = -1;

    if (clipLine(rx1, ry1, rx2, ry2))
        return;

    const int half = 31;
    int x1 = toF26Dot6(rx1) + half;
    int y1 = toF26Dot6(ry1) + half;
    int x2 = toF26Dot6(rx2) + half;
    int y2 = toF26Dot6(ry2) + half;

    int dx = qAbs(x2 - x1);
    int dy = qAbs(y2 - y1);

    if (dx < dy) {
        // vertical
        bool swapped = false;
        if (y1 > y2) {
            swapped = true;
            qSwap(y1, y2);
            qSwap(x1, x2);
        }
        int xinc = F16Dot16FixedDiv(x2 - x1, y2 - y1);
        int x = x1 << 10;

        int y = (y1 + 32) >> 6;
        int ys = (y2 + 32) >> 6;

        if (y != ys) {
            x += ( ((((y << 6) + 32 - y1)))  * xinc ) >> 6;

            if (swapped) {
                lastPixel.x = x >> 16;
                lastPixel.y = y;
                lastDir = QCosmeticStroker::BottomToTop;
            } else {
                lastPixel.x = (x + (ys - y - 1)*xinc) >> 16;
                lastPixel.y = ys - 1;
                lastDir = QCosmeticStroker::TopToBottom;
            }
            lastAxisAligned = qAbs(xinc) < (1 << 14);
        }
    } else {
        // horizontal
        if (!dx)
            return;

        bool swapped = false;
        if (x1 > x2) {
            swapped = true;
            qSwap(x1, x2);
            qSwap(y1, y2);
        }
        int yinc = F16Dot16FixedDiv(y2 - y1, x2 - x1);
        int y = y1 << 10;

        int x = (x1 + 32) >> 6;
        int xs = (x2 + 32) >> 6;

        if (x != xs) {
            y += ( ((((x << 6) + 32 - x1)))  * yinc ) >> 6;

            if (swapped) {
                lastPixel.x = x;
                lastPixel.y = y >> 16;
                lastDir = QCosmeticStroker::RightToLeft;
            } else {
                lastPixel.x = xs - 1;
                lastPixel.y = (y + (xs - x - 1)*yinc) >> 16;
                lastDir = QCosmeticStroker::LeftToRight;
            }
            lastAxisAligned = qAbs(yinc) < (1 << 14);
        }
    }
//    qDebug() << "   moveTo: setting last pixel to x/y dir" << lastPixel.x << lastPixel.y << lastDir;
}

clipLine()

bool QCosmeticStroker::clipLine	(	qreal &	x1,
		qreal &	y1,
		qreal &	x2,
		qreal &	y2
	)

Definition at line 312 of file qcosmeticstroker.cpp.

Referenced by drawLine(), and drawLineAA().

{
    // basic/rough clipping is done in floating point coordinates to avoid
    // integer overflow problems.
    if (x1 < xmin) {
        if (x2 <= xmin)
            goto clipped;
        y1 += (y2 - y1)/(x2 - x1) * (xmin - x1);
        x1 = xmin;
    } else if (x1 > xmax) {
        if (x2 >= xmax)
            goto clipped;
        y1 += (y2 - y1)/(x2 - x1) * (xmax - x1);
        x1 = xmax;
    }
    if (x2 < xmin) {
        lastPixel.x = -1;
        y2 += (y2 - y1)/(x2 - x1) * (xmin - x2);
        x2 = xmin;
    } else if (x2 > xmax) {
        lastPixel.x = -1;
        y2 += (y2 - y1)/(x2 - x1) * (xmax - x2);
        x2 = xmax;
    }

    if (y1 < ymin) {
        if (y2 <= ymin)
            goto clipped;
        x1 += (x2 - x1)/(y2 - y1) * (ymin - y1);
        y1 = ymin;
    } else if (y1 > ymax) {
        if (y2 >= ymax)
            goto clipped;
        x1 += (x2 - x1)/(y2 - y1) * (ymax - y1);
        y1 = ymax;
    }
    if (y2 < ymin) {
        lastPixel.x = -1;
        x2 += (x2 - x1)/(y2 - y1) * (ymin - y2);
        y2 = ymin;
    } else if (y2 > ymax) {
        lastPixel.x = -1;
        x2 += (x2 - x1)/(y2 - y1) * (ymax - y2);
        y2 = ymax;
    }

    return false;

  clipped:
    lastPixel.x = -1;
    return true;
}

drawLine()

void QCosmeticStroker::drawLine	(	const QPointF &	p1,
		const QPointF &	p2
	)

Definition at line 366 of file qcosmeticstroker.cpp.

Referenced by QRasterPaintEngine::drawLines(), and ~QCosmeticStroker().

{
    if (p1 == p2) {
        drawPoints(&p1, 1);
        return;
    }

    QPointF start = p1 * state->matrix;
    QPointF end = p2 * state->matrix;

    patternOffset = state->lastPen.dashOffset()*64;
    lastPixel.x = -1;

    stroke(this, start.x(), start.y(), end.x(), end.y(), drawCaps ? CapBegin|CapEnd : 0);

    blend(current_span, spans, &state->penData);
    current_span = 0;
}

drawPath()

void QCosmeticStroker::drawPath

(

const QVectorPath &

path

)

Definition at line 518 of file qcosmeticstroker.cpp.

Referenced by QRasterPaintEngine::drawPolygon(), QRasterPaintEngine::drawRects(), QRasterPaintEngine::stroke(), and ~QCosmeticStroker().

{
//    qDebug() << ">>>> drawpath" << path.convertToPainterPath()
//             << "antialiasing:" << (bool)(state->renderHints & QPainter::Antialiasing) << " implicit close:" << path.hasImplicitClose();
    if (path.isEmpty())
        return;

    const qreal *points = path.points();
    const QPainterPath::ElementType *type = path.elements();

    if (type) {
        const QPainterPath::ElementType *end = type + path.elementCount();

        while (type < end) {
            Q_ASSERT(type == path.elements() || *type == QPainterPath::MoveToElement);

            QPointF p = QPointF(points[0], points[1]) * state->matrix;
            patternOffset = state->lastPen.dashOffset()*64;
            lastPixel.x = -1;
            lastPixel.y = -1;

            bool closed;
            const QPainterPath::ElementType *e = subPath(type, end, points, &closed);
            if (closed) {
                const qreal *p = points + 2*(e-type);
                QPointF p1 = QPointF(p[-4], p[-3]) * state->matrix;
                QPointF p2 = QPointF(p[-2], p[-1]) * state->matrix;
                calculateLastPoint(p1.x(), p1.y(), p2.x(), p2.y());
            }
            int caps = (!closed & drawCaps) ? CapBegin : NoCaps;
//            qDebug() << "closed =" << closed << capString(caps);

            points += 2;
            ++type;

            while (type < e) {
                QPointF p2 = QPointF(points[0], points[1]) * state->matrix;
                switch (*type) {
                case QPainterPath::MoveToElement:
                    Q_ASSERT(!"Logic error");
                    break;

                case QPainterPath::LineToElement:
                    if (!closed && drawCaps && type == e - 1)
                        caps |= CapEnd;
                    stroke(this, p.x(), p.y(), p2.x(), p2.y(), caps);
                    p = p2;
                    points += 2;
                    ++type;
                    break;

                case QPainterPath::CurveToElement: {
                    if (!closed && drawCaps && type == e - 3)
                        caps |= CapEnd;
                    QPointF p3 = QPointF(points[2], points[3]) * state->matrix;
                    QPointF p4 = QPointF(points[4], points[5]) * state->matrix;
                    renderCubic(p, p2, p3, p4, caps);
                    p = p4;
                    type += 3;
                    points += 6;
                    break;
                }
                case QPainterPath::CurveToDataElement:
                    Q_ASSERT(!"QPainterPath::toSubpathPolygons(), bad element type");
                    break;
                }
                caps = NoCaps;
            }
        }
    } else { // !type, simple polygon
        QPointF p = QPointF(points[0], points[1]) * state->matrix;
        QPointF movedTo = p;
        patternOffset = state->lastPen.dashOffset()*64;
        lastPixel.x = -1;
        lastPixel.y = -1;

        const qreal *begin = points;
        const qreal *end = points + 2*path.elementCount();
        // handle closed path case
        bool closed = path.hasImplicitClose() || (points[0] == end[-2] && points[1] == end[-1]);
        int caps = (!closed & drawCaps) ? CapBegin : NoCaps;
        if (closed) {
            QPointF p2 = QPointF(end[-2], end[-1]) * state->matrix;
            calculateLastPoint(p2.x(), p2.y(), p.x(), p.y());
        }

        bool fastPenAliased = (state->flags.fast_pen && !state->flags.antialiased);
        points += 2;
        while (points < end) {
            QPointF p2 = QPointF(points[0], points[1]) * state->matrix;

            if (!closed && drawCaps && points == end - 2)
                caps |= CapEnd;

            QCosmeticStroker::Point last = this->lastPixel;
            bool unclipped = stroke(this, p.x(), p.y(), p2.x(), p2.y(), caps);

            /* fix for gaps in polylines with fastpen and aliased in a sequence
               of points with small distances: if current point p2 has been dropped
               out, keep last non dropped point p.

               However, if the line was completely outside the devicerect, we
               still need to update p to avoid drawing the line after this one from
               a bad starting position.
            */
            if (fastPenAliased && unclipped) {
                if (last.x != lastPixel.x || last.y != lastPixel.y
                    || points == begin + 2 || points == end - 2) {
                    p = p2;
                }
            } else {
                p = p2;
            }
            points += 2;
            caps = NoCaps;
        }
        if (path.hasImplicitClose())
            stroke(this, p.x(), p.y(), movedTo.x(), movedTo.y(), NoCaps);
    }


    blend(current_span, spans, &state->penData);
    current_span = 0;
}

drawPoints() [1/2]

void QCosmeticStroker::drawPoints	(	const QPoint *	points,
		int	num
	)

Definition at line 385 of file qcosmeticstroker.cpp.

Referenced by QRasterPaintEngine::drawPoints(), and ~QCosmeticStroker().

{
    const QPoint *end = points + num;
    while (points < end) {
        QPointF p = QPointF(*points) * state->matrix;
        drawPixel(this, qRound(p.x()), qRound(p.y()), 255);
        ++points;
    }

    blend(current_span, spans, &state->penData);
    current_span = 0;
}

drawPoints() [2/2]

void QCosmeticStroker::drawPoints	(	const QPointF *	points,
		int	num
	)

Definition at line 398 of file qcosmeticstroker.cpp.

{
    const QPointF *end = points + num;
    while (points < end) {
        QPointF p = (*points) * state->matrix;
        drawPixel(this, qRound(p.x()), qRound(p.y()), 255);
        ++points;
    }

    blend(current_span, spans, &state->penData);
    current_span = 0;
}

renderCubic()

void QCosmeticStroker::renderCubic ( const QPointF &  p1, const QPointF &  p2, const QPointF &  p3, const QPointF &  p4, int  caps  )

private

Definition at line 643 of file qcosmeticstroker.cpp.

{
//    qDebug() << ">>>> renderCubic" << p1 << p2 << p3 << p4 << capString(caps);
    const int maxSubDivisions = 6;
    PointF points[3*maxSubDivisions + 4];

    points[3].x = p1.x();
    points[3].y = p1.y();
    points[2].x = p2.x();
    points[2].y = p2.y();
    points[1].x = p3.x();
    points[1].y = p3.y();
    points[0].x = p4.x();
    points[0].y = p4.y();

    PointF *p = points;
    int level = maxSubDivisions;

    renderCubicSubdivision(p, level, caps);
}

renderCubicSubdivision()

void QCosmeticStroker::renderCubicSubdivision ( QCosmeticStroker::PointF *  points, int  level, int  caps  )

private

Definition at line 690 of file qcosmeticstroker.cpp.

{
    if (level) {
        qreal dx = points[3].x - points[0].x;
        qreal dy = points[3].y - points[0].y;
        qreal len = ((qreal).25) * (qAbs(dx) + qAbs(dy));

        if (qAbs(dx * (points[0].y - points[2].y) - dy * (points[0].x - points[2].x)) >= len ||
            qAbs(dx * (points[0].y - points[1].y) - dy * (points[0].x - points[1].x)) >= len) {
            splitCubic(points);

            --level;
            renderCubicSubdivision(points + 3, level, caps & CapBegin);
            renderCubicSubdivision(points, level, caps & CapEnd);
            return;
        }
    }

    stroke(this, points[3].x, points[3].y, points[0].x, points[0].y, caps);
}

setup()

void QCosmeticStroker::setup ( )

private

Definition at line 233 of file qcosmeticstroker.cpp.

Referenced by QCosmeticStroker().

{
    blend = state->penData.blend;
    if (state->clip && state->clip->enabled && state->clip->hasRectClip && !state->clip->clipRect.isEmpty()) {
        clip &= state->clip->clipRect;
        blend = state->penData.unclipped_blend;
    }

    int strokeSelection = 0;
    if (blend == state->penData.unclipped_blend
        && state->penData.type == QSpanData::Solid
        && (state->penData.rasterBuffer->format == QImage::Format_ARGB32_Premultiplied
            || state->penData.rasterBuffer->format == QImage::Format_RGB32)
        && state->compositionMode() == QPainter::CompositionMode_SourceOver)
        strokeSelection |= FastDraw;

    if (state->renderHints & QPainter::Antialiasing)
        strokeSelection |= AntiAliased;

    const QVector<qreal> &penPattern = state->lastPen.dashPattern();
    if (penPattern.isEmpty()) {
        Q_ASSERT(!pattern && !reversePattern);
        pattern = 0;
        reversePattern = 0;
        patternLength = 0;
        patternSize = 0;
    } else {
        pattern = (int *)malloc(penPattern.size()*sizeof(int));
        reversePattern = (int *)malloc(penPattern.size()*sizeof(int));
        patternSize = penPattern.size();

        patternLength = 0;
        for (int i = 0; i < patternSize; ++i) {
            patternLength += (int) qMax(1. , penPattern.at(i)*64.);
            pattern[i] = patternLength;
        }
        patternLength = 0;
        for (int i = 0; i < patternSize; ++i) {
            patternLength += (int) qMax(1., penPattern.at(patternSize - 1 - i)*64.);
            reversePattern[i] = patternLength;
        }
        strokeSelection |= Dashed;
//        qDebug() << "setup: size=" << patternSize << "length=" << patternLength/64.;
    }

    stroke = strokeLine(strokeSelection);

    qreal width = state->lastPen.widthF();
    if (width == 0)
        opacity = 256;
    else if (state->lastPen.isCosmetic())
        opacity = (int) 256*width;
    else
        opacity = (int) 256*width*state->txscale;
    opacity = qBound(0, opacity, 256);

    drawCaps = state->lastPen.capStyle() != Qt::FlatCap;

    if (strokeSelection & FastDraw) {
        color = INTERPOLATE_PIXEL_256(state->penData.solid.color, opacity, 0, 0);
        QRasterBuffer *buffer = state->penData.rasterBuffer;
        pixels = (uint *)buffer->buffer();
        ppl = buffer->bytesPerLine()>>2;
    }

    // line drawing produces different results with different clips, so
    // we need to clip consistently when painting to the same device

    // setup FP clip bounds
    xmin = deviceRect.left() - 1;
    xmax = deviceRect.right() + 2;
    ymin = deviceRect.top() - 1;
    ymax = deviceRect.bottom() + 2;

    lastPixel.x = -1;
    lastPixel.y = -1;
}

Properties

blend

ProcessSpans QCosmeticStroker::blend

Definition at line 128 of file qcosmeticstroker_p.h.

Referenced by drawPixel().

clip

QRect QCosmeticStroker::clip

Definition at line 111 of file qcosmeticstroker_p.h.

Referenced by drawPixel(), drawPixelARGB32(), and drawPixelARGB32Opaque().

color

uint QCosmeticStroker::color

Definition at line 132 of file qcosmeticstroker_p.h.

Referenced by drawPixelARGB32(), and drawPixelARGB32Opaque().

current_span

int QCosmeticStroker::current_span

Definition at line 127 of file qcosmeticstroker_p.h.

Referenced by drawPixel().

deviceRect

QRect QCosmeticStroker::deviceRect

Definition at line 110 of file qcosmeticstroker_p.h.

drawCaps

bool QCosmeticStroker::drawCaps

Definition at line 117 of file qcosmeticstroker_p.h.

lastAxisAligned

bool QCosmeticStroker::lastAxisAligned

Definition at line 138 of file qcosmeticstroker_p.h.

Referenced by drawLine().

lastDir

Direction QCosmeticStroker::lastDir

Definition at line 136 of file qcosmeticstroker_p.h.

Referenced by drawLine().

lastPixel

Point QCosmeticStroker::lastPixel

Definition at line 137 of file qcosmeticstroker_p.h.

Referenced by drawLine().

opacity

int QCosmeticStroker::opacity

Definition at line 130 of file qcosmeticstroker_p.h.

Referenced by drawPixel().

pattern

int* QCosmeticStroker::pattern

Definition at line 119 of file qcosmeticstroker_p.h.

Referenced by ~QCosmeticStroker().

patternLength

int QCosmeticStroker::patternLength

Definition at line 122 of file qcosmeticstroker_p.h.

patternOffset

int QCosmeticStroker::patternOffset

Definition at line 123 of file qcosmeticstroker_p.h.

patternSize

int QCosmeticStroker::patternSize

Definition at line 121 of file qcosmeticstroker_p.h.

pixels

uint* QCosmeticStroker::pixels

Definition at line 133 of file qcosmeticstroker_p.h.

Referenced by drawPixelARGB32(), and drawPixelARGB32Opaque().

ppl

int QCosmeticStroker::ppl

Definition at line 134 of file qcosmeticstroker_p.h.

Referenced by drawPixelARGB32(), and drawPixelARGB32Opaque().

reversePattern

int* QCosmeticStroker::reversePattern

Definition at line 120 of file qcosmeticstroker_p.h.

Referenced by ~QCosmeticStroker().

spans

QT_FT_Span QCosmeticStroker::spans[NSPANS]

Definition at line 126 of file qcosmeticstroker_p.h.

Referenced by drawPixel().

state

QRasterPaintEngineState* QCosmeticStroker::state

Definition at line 109 of file qcosmeticstroker_p.h.

Referenced by drawPixel().

stroke

StrokeLine QCosmeticStroker::stroke

Definition at line 116 of file qcosmeticstroker_p.h.

xmax

qreal QCosmeticStroker::xmax

Definition at line 113 of file qcosmeticstroker_p.h.

xmin

qreal QCosmeticStroker::xmin

Definition at line 113 of file qcosmeticstroker_p.h.

ymax

qreal QCosmeticStroker::ymax

Definition at line 114 of file qcosmeticstroker_p.h.

ymin

qreal QCosmeticStroker::ymin

Definition at line 114 of file qcosmeticstroker_p.h.

---

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

• /src/gui/painting/qcosmeticstroker_p.h
• /src/gui/painting/qcosmeticstroker.cpp