#include <QtCore/qglobal.h>
#include <QtCore/qmutex.h>
#include <private/qrasterdefs_p.h>
#include <private/qgrayraster_p.h>
#include <qpainterpath.h>
#include <qdebug.h>
#include <qhash.h>
#include <qlabel.h>
#include <qbitmap.h>
#include <qmath.h>
#include <private/qfontengine_ft_p.h>
#include <private/qmath_p.h>
#include <private/qtextengine_p.h>
#include <private/qfontengine_p.h>
#include <private/qpixmap_raster_p.h>
#include <private/qimage_p.h>
#include <private/qstatictext_p.h>
#include <private/qcosmeticstroker_p.h>
#include "qmemrotate_p.h"
#include "qpaintengine_raster_p.h"
#include "qoutlinemapper_p.h"
#include <qt_windows.h>
#include <qvarlengtharray.h>
#include "qguifunctions_wince.h"
#include <limits.h>

Classes
struct	ClipData

class	QGradientCache

struct	QGradientCache::CacheInfo

struct	QRasterFloatPoint

Macros
#define	int_dim(pos, dim) (int(pos+dim) - int(pos))

#define	qreal_to_fixed_26_6(f) (int(f * 64))

#define	QT_FAST_SPANS

#define	QT_FT_BEGIN_HEADER

#define	QT_FT_END_HEADER

#define	qt_swap_int(x, y) { int tmp = (x); (x) = (y); (y) = tmp; }

#define	qt_swap_qreal(x, y) { qreal tmp = (x); (x) = (y); (y) = tmp; }

Enumerations
enum	LineDrawMode { LineDrawClipped, LineDrawNormal, LineDrawIncludeLastPixel }

enum	RotationType

Functions
static uchar *	alignAddress (uchar *address, quintptr alignmentMask)

static void	drawEllipse_midpoint_i (const QRect &rect, const QRect &clip, ProcessSpans pen_func, ProcessSpans brush_func, QSpanData pen_data, QSpanData brush_data)
	Draws an ellipse using the integer point midpoint algorithm. More...

static void	drawEllipsePoints (int x, int y, int length, const QRect &rect, const QRect &clip, ProcessSpans pen_func, ProcessSpans brush_func, QSpanData pen_data, QSpanData brush_data)

static int	fast_ceil_positive (const qreal &v)

static void	fillRect_normalized (const QRect &r, QSpanData data, QRasterPaintEnginePrivate pe)

static bool	isAbove (const QPointF a, const QPointF b)

template<typename T >
static bool	isRect (const T *pts, int elementCount)

static bool	monoVal (const uchar *s, int x)

int	q_gray_rendered_spans (QT_FT_Raster raster)

static void	qrasterpaintengine_dirty_clip (QRasterPaintEnginePrivate d, QRasterPaintEngineState s)

static void	qrasterpaintengine_state_setNoClip (QRasterPaintEngineState *s)

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

static void	qt_ft_outline_line_to (qfixed x, qfixed y, void *data)

static void	qt_ft_outline_move_to (qfixed x, qfixed y, void *data)

const QVector< QRgb > *	qt_image_colortable (const QImage &image)

Q_GUI_EXPORT QImage	qt_imageForBrush (int brushStyle, bool invert)

static const QSpan *	qt_intersect_spans (const QClipData clip, int currentClip, const QSpan spans, const QSpan end, QSpan **outSpans, int available)

static int	qt_intersect_spans (QT_FT_Span *spans, int numSpans, const QRect &clip)

QRectF	qt_mapRect_non_normalizing (const QRectF &r, const QTransform &t)

static void	qt_merge_clip (const QClipData c1, const QClipData c2, QClipData *result)

Q_GUI_EXPORT bool	qt_scaleForTransform (const QTransform &transform, qreal *scale)

static void	qt_span_clip (int count, const QSpan spans, void userData)

static void	qt_span_fill_clipped (int count, const QSpan spans, void userData)

static void	qt_span_fill_clipRect (int count, const QSpan spans, void userData)

static bool	splitPolygon (const QPointF points, int pointCount, QVector< QPointF > upper, QVector< QPointF > *lower)

static const QRect	toAlignedRect_positive (const QRectF &rect)

static QRect	toNormalizedFillRect (const QRectF &rect)

static const QRect	toRect_normalized (const QRectF &rect)

Variables
static const qreal	aliasedCoordinateDelta = 0.5 - 0.015625

bool	qt_applefontsmoothing_enabled

bool	qt_cleartype_enabled

Macro Definition Documentation

◆ int_dim

#define int_dim	(	pos,
		dim
	)	(int(pos+dim) - int(pos))

Definition at line 128 of file qpaintengine_raster.cpp.

Referenced by QRasterPaintEngine::drawEllipse().

◆ qreal_to_fixed_26_6

#define qreal_to_fixed_26_6 ( f ) (int(f * 64))

Definition at line 113 of file qpaintengine_raster.cpp.

◆ QT_FAST_SPANS

#define QT_FAST_SPANS

Definition at line 122 of file qpaintengine_raster.cpp.

◆ QT_FT_BEGIN_HEADER

#define QT_FT_BEGIN_HEADER

Definition at line 45 of file qpaintengine_raster.cpp.

◆ QT_FT_END_HEADER

#define QT_FT_END_HEADER

Definition at line 46 of file qpaintengine_raster.cpp.

◆ qt_swap_int

#define qt_swap_int	(	x,
		y
	)	{ int tmp = (x); (x) = (y); (y) = tmp; }

Definition at line 114 of file qpaintengine_raster.cpp.

◆ qt_swap_qreal

#define qt_swap_qreal	(	x,
		y
	)	{ qreal tmp = (x); (x) = (y); (y) = tmp; }

Definition at line 115 of file qpaintengine_raster.cpp.

Enumeration Type Documentation

◆ LineDrawMode

enum LineDrawMode

Enumerator
LineDrawClipped
LineDrawNormal
LineDrawIncludeLastPixel

Definition at line 157 of file qpaintengine_raster.cpp.

                   {
     LineDrawClipped,
     LineDrawNormal,
     LineDrawIncludeLastPixel
 };

◆ RotationType

enum RotationType

Definition at line 2216 of file qpaintengine_raster.cpp.

                       {
         Rotation90,
         Rotation180,
         Rotation270,
         NoRotation
     };

Function Documentation

◆ alignAddress()

static uchar* alignAddress	(	uchar *	address,
		quintptr	alignmentMask
	)

inlinestatic

Definition at line 3775 of file qpaintengine_raster.cpp.

Referenced by QRasterPaintEnginePrivate::rasterize().

 {
     return (uchar *)(((quintptr)address + alignmentMask) & ~alignmentMask);
 }

◆ drawEllipse_midpoint_i()

static void drawEllipse_midpoint_i	(	const QRect &	rect,
		const QRect &	clip,
		ProcessSpans	pen_func,
		ProcessSpans	brush_func,
		QSpanData *	pen_data,
		QSpanData *	brush_data
	)

static

Draws an ellipse using the integer point midpoint algorithm.

Warning: This function is not part of the public interface.

Definition at line 5133 of file qpaintengine_raster.cpp.

Referenced by QRasterPaintEngine::drawEllipse().

 {
     const qreal a = qreal(rect.width()) / 2;
     const qreal b = qreal(rect.height()) / 2;
     qreal d = b*b - (a*a*b) + qreal(0.25)*a*a;
 
     int x = 0;
     int y = (rect.height() + 1) / 2;
     int startx = x;
 
     // region 1
     while (a*a*(2*y - 1) > 2*b*b*(x + 1)) {
         if (d < 0) { // select E
             d += b*b*(2*x + 3);
             ++x;
         } else {     // select SE
             d += b*b*(2*x + 3) + a*a*(-2*y + 2);
             drawEllipsePoints(startx, y, x - startx + 1, rect, clip,
                               pen_func, brush_func, pen_data, brush_data);
             startx = ++x;
             --y;
         }
     }
     drawEllipsePoints(startx, y, x - startx + 1, rect, clip,
                       pen_func, brush_func, pen_data, brush_data);
 
     // region 2
     d = b*b*(x + qreal(0.5))*(x + qreal(0.5)) + a*a*((y - 1)*(y - 1) - b*b);
     const int miny = rect.height() & 0x1;
     while (y > miny) {
         if (d < 0) { // select SE
             d += b*b*(2*x + 2) + a*a*(-2*y + 3);
             ++x;
         } else {     // select S
             d += a*a*(-2*y + 3);
         }
         --y;
         drawEllipsePoints(x, y, 1, rect, clip,
                           pen_func, brush_func, pen_data, brush_data);
     }
 }

◆ drawEllipsePoints()

static void drawEllipsePoints	(	int	x,
		int	y,
		int	length,
		const QRect &	rect,
		const QRect &	clip,
		ProcessSpans	pen_func,
		ProcessSpans	brush_func,
		QSpanData *	pen_data,
		QSpanData *	brush_data
	)

inlinestatic

Warning: This function is not part of the public interface. x and y is relative to the midpoint of rect.

Definition at line 5058 of file qpaintengine_raster.cpp.

Referenced by drawEllipse_midpoint_i().

 {
     if (length == 0)
         return;
 
     QT_FT_Span outline[4];
     const int midx = rect.x() + (rect.width() + 1) / 2;
     const int midy = rect.y() + (rect.height() + 1) / 2;
 
     x = x + midx;
     y = midy - y;
 
     // topleft
     outline[0].x = midx + (midx - x) - (length - 1) - (rect.width() & 0x1);
     outline[0].len = qMin(length, x - outline[0].x);
     outline[0].y = y;
     outline[0].coverage = 255;
 
     // topright
     outline[1].x = x;
     outline[1].len = length;
     outline[1].y = y;
     outline[1].coverage = 255;
 
     // bottomleft
     outline[2].x = outline[0].x;
     outline[2].len = outline[0].len;
     outline[2].y = midy + (midy - y) - (rect.height() & 0x1);
     outline[2].coverage = 255;
 
     // bottomright
     outline[3].x = x;
     outline[3].len = length;
     outline[3].y = outline[2].y;
     outline[3].coverage = 255;
 
     if (brush_func && outline[0].x + outline[0].len < outline[1].x) {
         QT_FT_Span fill[2];
 
         // top fill
         fill[0].x = outline[0].x + outline[0].len - 1;
         fill[0].len = qMax(0, outline[1].x - fill[0].x);
         fill[0].y = outline[1].y;
         fill[0].coverage = 255;
 
         // bottom fill
         fill[1].x = outline[2].x + outline[2].len - 1;
         fill[1].len = qMax(0, outline[3].x - fill[1].x);
         fill[1].y = outline[3].y;
         fill[1].coverage = 255;
 
         int n = (fill[0].y >= fill[1].y ? 1 : 2);
         n = qt_intersect_spans(fill, n, clip);
         if (n > 0)
             brush_func(n, fill, brush_data);
     }
     if (pen_func) {
         int n = (outline[1].y >= outline[2].y ? 2 : 4);
         n = qt_intersect_spans(outline, n, clip);
         if (n > 0)
             pen_func(n, outline, pen_data);
     }
 }

◆ fast_ceil_positive()

static int fast_ceil_positive ( const qreal & v )

inlinestatic

Definition at line 2143 of file qpaintengine_raster.cpp.

Referenced by toAlignedRect_positive().

 {
     const int iv = int(v);
     if (v - iv == 0)
         return iv;
     else
         return iv + 1;
 }

◆ fillRect_normalized()

static void fillRect_normalized	(	const QRect &	r,
		QSpanData *	data,
		QRasterPaintEnginePrivate *	pe
	)

static

Definition at line 1435 of file qpaintengine_raster.cpp.

Referenced by QRasterPaintEngine::drawImage(), QRasterPaintEngine::drawRects(), QRasterPaintEngine::drawTiledPixmap(), QRasterPaintEngine::fill(), and QRasterPaintEngine::fillRect().

 {
     int x1, x2, y1, y2;
 
     bool rectClipped = true;
 
     if (data->clip) {
         x1 = qMax(r.x(), data->clip->xmin);
         x2 = qMin(r.x() + r.width(), data->clip->xmax);
         y1 = qMax(r.y(), data->clip->ymin);
         y2 = qMin(r.y() + r.height(), data->clip->ymax);
         rectClipped = data->clip->hasRectClip;
 
     } else if (pe) {
         x1 = qMax(r.x(), pe->deviceRect.x());
         x2 = qMin(r.x() + r.width(), pe->deviceRect.x() + pe->deviceRect.width());
         y1 = qMax(r.y(), pe->deviceRect.y());
         y2 = qMin(r.y() + r.height(), pe->deviceRect.y() + pe->deviceRect.height());
     } else {
         x1 = qMax(r.x(), 0);
         x2 = qMin(r.x() + r.width(), data->rasterBuffer->width());
         y1 = qMax(r.y(), 0);
         y2 = qMin(r.y() + r.height(), data->rasterBuffer->height());
     }
 
     if (x2 <= x1 || y2 <= y1)
         return;
 
     const int width = x2 - x1;
     const int height = y2 - y1;
 
     bool isUnclipped = rectClipped
                        || (pe && pe->isUnclipped_normalized(QRect(x1, y1, width, height)));
 
     if (pe && isUnclipped) {
         const QPainter::CompositionMode mode = pe->rasterBuffer->compositionMode;
 
         if (data->fillRect && (mode == QPainter::CompositionMode_Source
                                || (mode == QPainter::CompositionMode_SourceOver
                                    && qAlpha(data->solid.color) == 255)))
         {
             data->fillRect(data->rasterBuffer, x1, y1, width, height,
                            data->solid.color);
             return;
         }
     }
 
     ProcessSpans blend = isUnclipped ? data->unclipped_blend : data->blend;
 
     const int nspans = 256;
     QT_FT_Span spans[nspans];
 
     Q_ASSERT(data->blend);
     int y = y1;
     while (y < y2) {
         int n = qMin(nspans, y2 - y);
         int i = 0;
         while (i < n) {
             spans[i].x = x1;
             spans[i].len = width;
             spans[i].y = y + i;
             spans[i].coverage = 255;
             ++i;
         }
 
         blend(n, spans, data);
         y += n;
     }
 }

◆ isAbove()

static bool isAbove	(	const QPointF *	a,
		const QPointF *	b
	)

inlinestatic

Definition at line 1839 of file qpaintengine_raster.cpp.

Referenced by splitPolygon().

 {
     return a->y() < b->y();
 }

◆ isRect()

template<typename T >

static bool isRect	(	const T *	pts,
		int	elementCount
	)

inlinestatic

Definition at line 194 of file qpaintengine_raster.cpp.

Referenced by QRasterPaintEngine::clip(), QRasterPaintEngine::drawPolygon(), QClipData::fixup(), and qt_region_strictContains().

                                                                                 {
     return (elementCount == 5 // 5-point polygon, check for closed rect
             && pts[0] == pts[8] && pts[1] == pts[9] // last point == first point
             && pts[0] == pts[6] && pts[2] == pts[4] // x values equal
             && pts[1] == pts[3] && pts[5] == pts[7] // y values equal...
             && pts[0] < pts[4] && pts[1] < pts[5]
             ) ||
            (elementCount == 4 // 4-point polygon, check for unclosed rect
             && pts[0] == pts[6] && pts[2] == pts[4] // x values equal
             && pts[1] == pts[3] && pts[5] == pts[7] // y values equal...
             && pts[0] < pts[4] && pts[1] < pts[5]
             );
 }

◆ monoVal()

static bool monoVal	(	const uchar *	s,
		int	x
	)

inlinestatic

Definition at line 2549 of file qpaintengine_raster.cpp.

Referenced by QRasterPaintEngine::alphaPenBlt().

 {
     return  (s[x>>3] << (x&7)) & 0x80;
 }

◆ q_gray_rendered_spans()

int q_gray_rendered_spans ( QT_FT_Raster raster )

Referenced by QRasterPaintEnginePrivate::rasterize().

◆ qrasterpaintengine_dirty_clip()

static void qrasterpaintengine_dirty_clip	(	QRasterPaintEnginePrivate *	d,
		QRasterPaintEngineState *	s
	)

static

Definition at line 1159 of file qpaintengine_raster.cpp.

Referenced by QRasterPaintEngine::clip(), and QRasterPaintEngine::setClipRectInDeviceCoords().

 {
     s->fillFlags |= QPaintEngine::DirtyClipPath;
     s->strokeFlags |= QPaintEngine::DirtyClipPath;
     s->pixmapFlags |= QPaintEngine::DirtyClipPath;
 
     d->solid_color_filler.clip = d->clip();
     d->solid_color_filler.adjustSpanMethods();
 
 #ifdef QT_DEBUG_DRAW
     dumpClip(d->rasterBuffer->width(), d->rasterBuffer->height(), &*d->clip());
 #endif
 
 }

◆ qrasterpaintengine_state_setNoClip()

static void qrasterpaintengine_state_setNoClip ( QRasterPaintEngineState * s )

static

Definition at line 1151 of file qpaintengine_raster.cpp.

Referenced by QRasterPaintEngine::clip().

 {
     if (s->flags.has_clip_ownership)
         delete s->clip;
     s->clip = 0;
     s->flags.has_clip_ownership = false;
 }

◆ qt_ft_outline_cubic_to()

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

static

Definition at line 219 of file qpaintengine_raster.cpp.

Referenced by QRasterPaintEngine::init().

 {
     ((QOutlineMapper *) data)->curveTo(QPointF(qt_fixed_to_real(c1x), qt_fixed_to_real(c1y)),
                                        QPointF(qt_fixed_to_real(c2x), qt_fixed_to_real(c2y)),
                                        QPointF(qt_fixed_to_real(ex), qt_fixed_to_real(ey)));
 }

◆ qt_ft_outline_line_to()

static void qt_ft_outline_line_to	(	qfixed	x,
		qfixed	y,
		void *	data
	)

static

Definition at line 214 of file qpaintengine_raster.cpp.

Referenced by QRasterPaintEngine::init().

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

◆ qt_ft_outline_move_to()

static void qt_ft_outline_move_to	(	qfixed	x,
		qfixed	y,
		void *	data
	)

static

Definition at line 209 of file qpaintengine_raster.cpp.

Referenced by QRasterPaintEngine::init().

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

◆ qt_image_colortable()

const QVector<QRgb>* qt_image_colortable ( const QImage & image )

Definition at line 122 of file qimage.cpp.

Referenced by QSpanData::setupMatrix().

 {
     return &image.d->colortable;
 }

◆ qt_imageForBrush()

Q_GUI_EXPORT QImage qt_imageForBrush	(	int	brushStyle,
		bool	invert
	)

Definition at line 167 of file qbrush.cpp.

Referenced by QSpanData::setup().

 {
     return qt_brushPatternImageCache()->getImage(brushStyle, invert);
 }

◆ qt_intersect_spans() [1/2]

static const QSpan* qt_intersect_spans	(	const QClipData *	clip,
		int *	currentClip,
		const QSpan *	spans,
		const QSpan *	end,
		QSpan **	outSpans,
		int	available
	)

static

Warning: This function is not part of the public interface. spans must be sorted on y

Definition at line 4325 of file qpaintengine_raster.cpp.

Referenced by drawEllipsePoints(), qt_span_clip(), qt_span_fill_clipped(), and qt_span_fill_clipRect().

 {
     const_cast<QClipData *>(clip)->initialize();
 
     QSpan *out = *outSpans;
 
     const QSpan *clipSpans = clip->m_spans + *currentClip;
     const QSpan *clipEnd = clip->m_spans + clip->count;
 
     while (available && spans < end ) {
         if (clipSpans >= clipEnd) {
             spans = end;
             break;
         }
         if (clipSpans->y > spans->y) {
             ++spans;
             continue;
         }
         if (spans->y != clipSpans->y) {
             if (spans->y < clip->count && clip->m_clipLines[spans->y].spans)
                 clipSpans = clip->m_clipLines[spans->y].spans;
             else
                 ++clipSpans;
             continue;
         }
         Q_ASSERT(spans->y == clipSpans->y);
 
         int sx1 = spans->x;
         int sx2 = sx1 + spans->len;
         int cx1 = clipSpans->x;
         int cx2 = cx1 + clipSpans->len;
 
         if (cx1 < sx1 && cx2 < sx1) {
             ++clipSpans;
             continue;
         } else if (sx1 < cx1 && sx2 < cx1) {
             ++spans;
             continue;
         }
         int x = qMax(sx1, cx1);
         int len = qMin(sx2, cx2) - x;
         if (len) {
             out->x = qMax(sx1, cx1);
             out->len = qMin(sx2, cx2) - out->x;
             out->y = spans->y;
             out->coverage = qt_div_255(spans->coverage * clipSpans->coverage);
             ++out;
             --available;
         }
         if (sx2 < cx2) {
             ++spans;
         } else {
             ++clipSpans;
         }
     }
 
     *outSpans = out;
     *currentClip = clipSpans - clip->m_spans;
     return spans;
 }

◆ qt_intersect_spans() [2/2]

static int qt_intersect_spans	(	QT_FT_Span *	spans,
		int	numSpans,
		const QRect &	clip
	)

static

Definition at line 4415 of file qpaintengine_raster.cpp.

 {
     const short minx = clip.left();
     const short miny = clip.top();
     const short maxx = clip.right();
     const short maxy = clip.bottom();
 
     int n = 0;
     for (int i = 0; i < numSpans; ++i) {
         if (spans[i].y > maxy)
             break;
         if (spans[i].y < miny
             || spans[i].x > maxx
             || spans[i].x + spans[i].len <= minx) {
             continue;
         }
         if (spans[i].x < minx) {
             spans[n].len = qMin(spans[i].len - (minx - spans[i].x), maxx - minx + 1);
             spans[n].x = minx;
         } else {
             spans[n].x = spans[i].x;
             spans[n].len = qMin(spans[i].len, ushort(maxx - spans[n].x + 1));
         }
         if (spans[n].len == 0)
             continue;
         spans[n].y = spans[i].y;
         spans[n].coverage = spans[i].coverage;
         ++n;
     }
     return n;
 }

◆ qt_mapRect_non_normalizing()

QRectF qt_mapRect_non_normalizing	(	const QRectF &	r,
		const QTransform &	t
	)

Definition at line 2210 of file qpaintengine_raster.cpp.

Referenced by QRasterPaintEngine::drawImage().

 {
     return QRectF(r.topLeft() * t, r.bottomRight() * t);
 }

◆ qt_merge_clip()

static void qt_merge_clip	(	const QClipData *	c1,
		const QClipData *	c2,
		QClipData *	result
	)

static

Definition at line 3652 of file qpaintengine_raster.cpp.

Referenced by QRasterPaintEngine::clip().

 {
     Q_ASSERT(c1->clipSpanHeight == c2->clipSpanHeight && c1->clipSpanHeight == result->clipSpanHeight);
 
     QVarLengthArray<short, 4096> buffer;
 
     QClipData::ClipLine *c1ClipLines = const_cast<QClipData *>(c1)->clipLines();
     QClipData::ClipLine *c2ClipLines = const_cast<QClipData *>(c2)->clipLines();
     result->initialize();
 
     for (int y = 0; y < c1->clipSpanHeight; ++y) {
         const QSpan *c1_spans = c1ClipLines[y].spans;
         int c1_count = c1ClipLines[y].count;
         const QSpan *c2_spans = c2ClipLines[y].spans;
         int c2_count = c2ClipLines[y].count;
 
         if (c1_count == 0 && c2_count == 0)
             continue;
         if (c1_count == 0) {
             result->appendSpans(c2_spans, c2_count);
             continue;
         } else if (c2_count == 0) {
             result->appendSpans(c1_spans, c1_count);
             continue;
         }
 
         // we need to merge the two
 
         // find required length
         int max = qMax(c1_spans[c1_count - 1].x + c1_spans[c1_count - 1].len,
                 c2_spans[c2_count - 1].x + c2_spans[c2_count - 1].len);
         buffer.resize(max);
         memset(buffer.data(), 0, buffer.size() * sizeof(short));
 
         // Fill with old spans.
         for (int i = 0; i < c1_count; ++i) {
             const QSpan *cs = c1_spans + i;
             for (int j=cs->x; j<cs->x + cs->len; ++j)
                 buffer[j] = cs->coverage;
         }
 
         // Fill with new spans
         for (int i = 0; i < c2_count; ++i) {
             const QSpan *cs = c2_spans + i;
             for (int j = cs->x; j < cs->x + cs->len; ++j) {
                 buffer[j] += cs->coverage;
                 if (buffer[j] > 255)
                     buffer[j] = 255;
             }
         }
 
         int x = 0;
         while (x<max) {
 
             // Skip to next span
             while (x < max && buffer[x] == 0) ++x;
             if (x >= max) break;
 
             int sx = x;
             int coverage = buffer[x];
 
             // Find length of span
             while (x < max && buffer[x] == coverage)
                 ++x;
 
             result->appendSpan(sx, x - sx, y, coverage);
         }
     }
 }

◆ qt_scaleForTransform()

Q_GUI_EXPORT bool qt_scaleForTransform	(	const QTransform &	transform,
		qreal *	scale
	)

Definition at line 2407 of file qtransform.cpp.

Referenced by QRasterPaintEngine::updateMatrix().

 {
     const QTransform::TransformationType type = transform.type();
     if (type <= QTransform::TxTranslate) {
         if (scale)
             *scale = 1;
         return true;
     } else if (type == QTransform::TxScale) {
         const qreal xScale = qAbs(transform.m11());
         const qreal yScale = qAbs(transform.m22());
         if (scale)
             *scale = qMax(xScale, yScale);
         return qFuzzyCompare(xScale, yScale);
     }
 
     const qreal xScale = transform.m11() * transform.m11()
                          + transform.m21() * transform.m21();
     const qreal yScale = transform.m12() * transform.m12()
                          + transform.m22() * transform.m22();
     if (scale)
         *scale = qSqrt(qMax(xScale, yScale));
     return type == QTransform::TxRotate && qFuzzyCompare(xScale, yScale);
 }

◆ qt_span_clip()

static void qt_span_clip	(	int	count,
		const QSpan *	spans,
		void *	userData
	)

static

Definition at line 4465 of file qpaintengine_raster.cpp.

Referenced by QRasterPaintEngine::clip().

 {
     ClipData *clipData = reinterpret_cast<ClipData *>(userData);
 
 //     qDebug() << " qt_span_clip: " << count << clipData->operation;
 //     for (int i = 0; i < qMin(count, 10); ++i) {
 //         qDebug() << "    " << spans[i].x << spans[i].y << spans[i].len << spans[i].coverage;
 //     }
 
     switch (clipData->operation) {
 
     case Qt::IntersectClip:
         {
             QClipData *newClip = clipData->newClip;
             newClip->initialize();
 
             int currentClip = 0;
             const QSpan *end = spans + count;
             while (spans < end) {
                 QSpan *newspans = newClip->m_spans + newClip->count;
                 spans = qt_intersect_spans(clipData->oldClip, &currentClip, spans, end,
                                            &newspans, newClip->allocated - newClip->count);
                 newClip->count = newspans - newClip->m_spans;
                 if (spans < end) {
                     newClip->m_spans = q_check_ptr((QSpan *)realloc(newClip->m_spans, newClip->allocated*2*sizeof(QSpan)));
                     newClip->allocated *= 2;
                 }
             }
         }
         break;
 
     case Qt::UniteClip:
     case Qt::ReplaceClip:
         clipData->newClip->appendSpans(spans, count);
         break;
     case Qt::NoClip:
         break;
     }
 }

◆ qt_span_fill_clipped()

static void qt_span_fill_clipped	(	int	count,
		const QSpan *	spans,
		void *	userData
	)

static

Definition at line 4388 of file qpaintengine_raster.cpp.

Referenced by QSpanData::adjustSpanMethods().

 {
 //     qDebug() << "qt_span_fill_clipped" << spanCount;
     QSpanData *fillData = reinterpret_cast<QSpanData *>(userData);
 
     Q_ASSERT(fillData->blend && fillData->unclipped_blend);
 
     const int NSPANS = 256;
     QSpan cspans[NSPANS];
     int currentClip = 0;
     const QSpan *end = spans + spanCount;
     while (spans < end) {
         QSpan *clipped = cspans;
         spans = qt_intersect_spans(fillData->clip, &currentClip, spans, end, &clipped, NSPANS);
 //         qDebug() << "processed " << spanCount - (end - spans) << "clipped" << clipped-cspans
 //                  << "span:" << cspans->x << cspans->y << cspans->len << spans->coverage;
 
         if (clipped - cspans)
             fillData->unclipped_blend(clipped - cspans, cspans, fillData);
     }
 }

◆ qt_span_fill_clipRect()

static void qt_span_fill_clipRect	(	int	count,
		const QSpan *	spans,
		void *	userData
	)

static

Definition at line 4449 of file qpaintengine_raster.cpp.

Referenced by QSpanData::adjustSpanMethods().

 {
     QSpanData *fillData = reinterpret_cast<QSpanData *>(userData);
     Q_ASSERT(fillData->blend && fillData->unclipped_blend);
 
     Q_ASSERT(fillData->clip);
     Q_ASSERT(!fillData->clip->clipRect.isEmpty());
 
     // hw: check if this const_cast<> is safe!!!
     count = qt_intersect_spans(const_cast<QSpan*>(spans), count,
                                fillData->clip->clipRect);
     if (count > 0)
         fillData->unclipped_blend(count, spans, fillData);
 }

◆ splitPolygon()

static bool splitPolygon	(	const QPointF *	points,
		int	pointCount,
		QVector< QPointF > *	upper,
		QVector< QPointF > *	lower
	)

static

Definition at line 1844 of file qpaintengine_raster.cpp.

Referenced by QRasterPaintEngine::fillPolygon().

 {
     Q_ASSERT(upper);
     Q_ASSERT(lower);
 
     Q_ASSERT(pointCount >= 2);
 
     QVector<const QPointF *> sorted;
     sorted.reserve(pointCount);
 
     upper->reserve(pointCount * 3 / 4);
     lower->reserve(pointCount * 3 / 4);
 
     for (int i = 0; i < pointCount; ++i)
         sorted << points + i;
 
     qSort(sorted.begin(), sorted.end(), isAbove);
 
     qreal splitY = sorted.at(sorted.size() / 2)->y();
 
     const QPointF *end = points + pointCount;
     const QPointF *last = end - 1;
 
     QVector<QPointF> *bin[2] = { upper, lower };
 
     for (const QPointF *p = points; p < end; ++p) {
         int side = p->y() < splitY;
         int lastSide = last->y() < splitY;
 
         if (side != lastSide) {
             if (qFuzzyCompare(p->y(), splitY)) {
                 bin[!side]->append(*p);
             } else if (qFuzzyCompare(last->y(), splitY)) {
                 bin[side]->append(*last);
             } else {
                 QPointF delta = *p - *last;
                 QPointF intersection(p->x() + delta.x() * (splitY - p->y()) / delta.y(), splitY);
 
                 bin[0]->append(intersection);
                 bin[1]->append(intersection);
             }
         }
 
         bin[side]->append(*p);
 
         last = p;
     }
 
     // give up if we couldn't reduce the point count
     return upper->size() < pointCount && lower->size() < pointCount;
 }

◆ toAlignedRect_positive()

static const QRect toAlignedRect_positive ( const QRectF & rect )

inlinestatic

Definition at line 2152 of file qpaintengine_raster.cpp.

Referenced by QRasterPaintEngine::drawImage().

 {
     const int xmin = int(rect.x());
     const int xmax = int(fast_ceil_positive(rect.right()));
     const int ymin = int(rect.y());
     const int ymax = int(fast_ceil_positive(rect.bottom()));
     return QRect(xmin, ymin, xmax - xmin, ymax - ymin);
 }

◆ toNormalizedFillRect()

static QRect toNormalizedFillRect ( const QRectF & rect )

inlinestatic

Definition at line 1681 of file qpaintengine_raster.cpp.

Referenced by QRasterPaintEngine::fill(), and QRasterPaintEngine::fillRect().

 {
     int x1 = qRound(rect.x() + aliasedCoordinateDelta);
     int y1 = qRound(rect.y() + aliasedCoordinateDelta);
     int x2 = qRound(rect.right() + aliasedCoordinateDelta);
     int y2 = qRound(rect.bottom() + aliasedCoordinateDelta);
 
     if (x2 < x1)
         qSwap(x1, x2);
     if (y2 < y1)
         qSwap(y1, y2);
 
     return QRect(x1, y1, x2 - x1, y2 - y1);
 }

◆ toRect_normalized()

static const QRect toRect_normalized ( const QRectF & rect )

inlinestatic

Definition at line 2133 of file qpaintengine_raster.cpp.

 {
     const int x = qRound(rect.x());
     const int y = qRound(rect.y());
     const int w = int(rect.width() + qreal(0.5));
     const int h = int(rect.height() + qreal(0.5));
 
     return QRect(x, y, w, h);
 }

Variable Documentation

◆ aliasedCoordinateDelta

const qreal aliasedCoordinateDelta = 0.5 - 0.015625

static

Definition at line 131 of file qpaintengine_raster.cpp.

Referenced by QRasterPaintEngine::drawCachedGlyphs(), QRasterPaintEngine::drawImage(), QRasterPaintEngine::drawTextItem(), and toNormalizedFillRect().

◆ qt_applefontsmoothing_enabled

bool qt_applefontsmoothing_enabled

Definition at line 208 of file qapplication_mac.mm.

Referenced by QRasterPaintEngine::begin().

◆ qt_cleartype_enabled

bool qt_cleartype_enabled

Definition at line 241 of file qapplication_win.cpp.

Referenced by QRasterPaintEngine::begin().

Classes

Macros

Enumerations

Functions

Variables

Macro Definition Documentation

◆ int_dim

◆ qreal_to_fixed_26_6

◆ QT_FAST_SPANS

◆ QT_FT_BEGIN_HEADER

◆ QT_FT_END_HEADER

◆ qt_swap_int

◆ qt_swap_qreal

Enumeration Type Documentation

◆ LineDrawMode

◆ RotationType

Function Documentation

◆ alignAddress()

◆ drawEllipse_midpoint_i()

◆ drawEllipsePoints()

◆ fast_ceil_positive()

◆ fillRect_normalized()

◆ isAbove()

◆ isRect()

◆ monoVal()

◆ q_gray_rendered_spans()

◆ qrasterpaintengine_dirty_clip()

◆ qrasterpaintengine_state_setNoClip()

◆ qt_ft_outline_cubic_to()

◆ qt_ft_outline_line_to()

◆ qt_ft_outline_move_to()

◆ qt_image_colortable()

◆ qt_imageForBrush()

◆ qt_intersect_spans() [1/2]

◆ qt_intersect_spans() [2/2]

◆ qt_mapRect_non_normalizing()

◆ qt_merge_clip()

◆ qt_scaleForTransform()

◆ qt_span_clip()

◆ qt_span_fill_clipped()

◆ qt_span_fill_clipRect()

◆ splitPolygon()

◆ toAlignedRect_positive()

◆ toNormalizedFillRect()

◆ toRect_normalized()

Variable Documentation

◆ aliasedCoordinateDelta

◆ qt_applefontsmoothing_enabled

◆ qt_cleartype_enabled