/*!

\internal

*/

{

// flattening is done by splitting the bezier until we can replace the segment by a straight

// line. We split further until the control points are close enough to the line connecting the

QPolygonF polygon;

polygon.append(QPointF(x1, y1));

return polygon;

}

return QBezier::fromPoints(transform.map(pt1()), transform.map(pt2()), transform.map(pt3()), transform.map(pt4()));

}

QBezier QBezier::getSubRange(qreal t0, qreal t1) const

{

QBezier result;

}

{

QBezier beziers[32];

beziers[0] = *this;

qAbs(b->x1 - b->x3) + qAbs(b->y1 - b->y3);

l = 1.;

}

// good enough, we pop it off and add the endpoint

polygon->append(QPointF(b->x4, b->y4));

--b;

}

}

QRectF QBezier::bounds() const

{

qreal xmin = x1;

return result;

}

QT_END_NAMESPACE

inline QPointF derivedAt(qreal t) const;

inline QPointF secondDerivedAt(qreal t) const;

QRectF bounds() const;

qreal length(qreal error = 0.01) const;

void addIfClose(qreal *length, qreal error) const;

QColor is platform and device independent. The QColormap class

maps the color to the hardware.

System} documentation.

\tableofcontents

Writes the \a color to the \a stream.

*/

QDataStream &operator<<(QDataStream &stream, const QColor &color)

{

Reads the \a color from the \a stream.

*/

QDataStream &operator>>(QDataStream &stream, QColor &color)

{

template <typename Type> class QDataBuffer

{

public:

{

capacity = res;

siz = 0;

}

~QDataBuffer()

{

}

inline void reset() { siz = 0; }

inline void reserve(int size) {

if (size > capacity) {

while (capacity < size)

capacity *= 2;

buffer = (Type*) qRealloc(buffer, capacity * sizeof(Type));

inline void shrink(int size) {

capacity = size;

}

inline void swap(QDataBuffer<Type> &other) {

xTarget.resize(columns + 1);

yTarget.resize(rows + 1);

xTarget[0] = targetRect.left();

xTarget[1] = targetCenterLeft;

xTarget[columns - 1] = targetCenterRight;

painter->drawPixmapFragments(opaqueData.data(), opaqueData.size(), pixmap, QPainter::OpaqueHint);

if (translucentData.size())

painter->drawPixmapFragments(translucentData.data(), translucentData.size(), pixmap);

}

QT_END_NAMESPACE

coordinate system. The standard coordinate system of a

QPaintDevice has its origin located at the top-left position. The

\e x values increase to the right; \e y values increase

System}{coordinate system} documentation.

QPainter has functions to translate, scale, shear and rotate the

\snippet doc/src/snippets/matrix/matrix.cpp 2

\endtable

{demos/affine}{Affine Transformations Demo}, {Transformations Example}

*/

Writes the given \a matrix to the given \a stream and returns a

reference to the stream.

*/

QDataStream &operator<<(QDataStream &s, const QMatrix &m)

Reads the given \a matrix from the given \a stream and returns a

reference to the stream.

*/

QDataStream &operator>>(QDataStream &s, QMatrix &m)

// ### We can kill this copying and just use the buffer straight...

m_elements.resize(count);

m_element_types.resize(0);

}

class QOutlineMapper

{

public:

{

}

CGContextSetInterpolationQuality(d->hd, (hints & QPainter::SmoothPixmapTransform) ?

kCGInterpolationHigh : kCGInterpolationNone);

}

}

/*

Q_DECLARE_PUBLIC(QCoreGraphicsPaintEngine)

public:

QCoreGraphicsPaintEnginePrivate()

{

}

CGShadingRef shading;

int stackCount;

bool complexXForm;

enum { CosmeticNone, CosmeticTransformPath, CosmeticSetPenWidth } cosmeticPen;

// pixel and cosmetic pen size in user coordinates.

}

#endif

/*!

d->hdc = 0;

#endif

// The antialiasing raster.

d->grayRaster.reset(new QT_FT_Raster);

Q_CHECK_PTR(d->grayRaster.data());

QT_THROW(std::bad_alloc()); // an error creating the raster is caused by a bad malloc

d->rasterizer.reset(new QRasterizer);

d->rasterBuffer.reset(new QRasterBuffer());

d->outlineMapper.reset(new QOutlineMapper);

{

Q_D(QRasterPaintEngine);

qt_ft_grays_raster.raster_done(*d->grayRaster.data());

}

return;

}

void *data = userData;

QT_FT_BBox clip_box = { deviceRect.x(),

int new_size = rasterPoolSize * 2;

if (new_size > 1024 * 1024) {

qWarning("QPainter: Rasterization of primitive failed");

}

#if defined(Q_WS_WIN64)

_aligned_free(rasterPoolBase);

#else

#endif

rasterPoolSize = new_size;

done = true;

}

}

}

void QRasterPaintEnginePrivate::recalculateFastImages()

{

Q_DECLARE_PUBLIC(QRasterPaintEngine)

public:

void rasterizeLine_dashed(QLineF line, qreal width,

int *dashIndex, qreal *dashOffset, bool *inDash);

QScopedPointer<QDashStroker> dashStroker;

QScopedPointer<QT_FT_Raster> grayRaster;

QDataBuffer<QLineF> cachedLines;

QSpanData image_filler;

return X11->pattern_fills[i].picture;

}

// none found, replace one

if (X11->pattern_fills[i].screen != screen && X11->pattern_fills[i].picture) {

XRenderFreePicture (X11->display, X11->pattern_fills[i].picture);

struct StrokeHandler {

QDataBuffer<qreal> pts;

QDataBuffer<QPainterPath::ElementType> types;

};

return;

if (!d->strokeHandler) {

d->stroker.setMoveToHook(qpaintengineex_moveTo);

d->stroker.setLineToHook(qpaintengineex_lineTo);

d->stroker.setCubicToHook(qpaintengineex_cubicTo);

// change the current transform. Normal transformed,

// non-cosmetic pens will be transformed as part of fill

// later, so they are also covered here..

d->activeStroker->begin(d->strokeHandler);

if (types) {

while (points < lastPoint) {

QPainterPath painterPath = state()->matrix.map(path.convertToPainterPath());

d->activeStroker->strokePath(painterPath, d->strokeHandler, QTransform());

} else {

d->activeStroker->begin(d->strokeHandler);

if (types) {

while (points < lastPoint) {

devices. If the painter is active, device() returns the paint

device on which the painter paints, and paintEngine() returns the

paint engine that the painter is currently operating on. For more

Sometimes it is desirable to make someone else paint on an unusual

QPaintDevice. QPainter supports a static function to do this,

\o viewport(), window(), worldTransform() make up the painter's coordinate

transformation system. For more information, see the \l

System} documentation.

\o hasClipping() tells whether the painter clips at all. (The paint

All the tranformation operations operate on the transformation

worldTransform(). A matrix transforms a point in the plane to another

point. For more information about the transformation matrix, see

The setWorldTransform() function can replace or add to the currently

set worldTransform(). The resetTransform() function resets any

logical coordinates, and the worldTransform() is identical with the

transformation matrix.

\section1 Clipping

functions is safe.

For more information about the coordinate system, transformations

\sa setWorldTransform(), QTransform

*/

preserve the properties of perspective transformations.

\sa {QPainter#Coordinate Transformations}{Coordinate Transformations},

*/

const QMatrix &QPainter::worldMatrix() const

Returns true if world transformation is enabled; otherwise returns

false.

*/

bool QPainter::worldMatrixEnabled() const

\snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 6

\endtable

*/

/*!

\snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 7

\endtable

*/

/*!

Draws a single point at the given \a position using the current

pen's color.

*/

/*!

Draws the first \a pointCount points in the array \a points using

the current pen's color.

*/

void QPainter::drawPoints(const QPointF *points, int pointCount)

{

\snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 9

\endtable

*/

void QPainter::drawEllipse(const QRectF &r)

{

\snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 10

\endtable

*/

void QPainter::drawArc(const QRectF &r, int a, int alen)

\snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 11

\endtable

*/

void QPainter::drawPie(const QRectF &r, int a, int alen)

{

\snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 12

\endtable

*/

void QPainter::drawChord(const QRectF &r, int a, int alen)

{

\snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 13

\endtable

*/

void QPainter::drawPolyline(const QPointF *points, int pointCount)

{

\l{Qt::FillRule} for a more detailed description of these fill

rules.

*/

void QPainter::drawPolygon(const QPointF *points, int pointCount, Qt::FillRule fillRule)

{

On some platforms (e.g. X11), the drawConvexPolygon() function can

be faster than the drawPolygon() function.

*/

/*!

gf.glyphs = engine.shapedGlyphs(&si);

gf.chars = engine.layoutData->string.unicode() + si.position;

gf.num_chars = engine.length(item);

gf.logClusters = engine.logClusters(&si);

drawTextItem(QPointF(x.toReal(), p.y()), gf);

}

}

The default window rectangle is the same as the device's

rectangle.

System#Window-Viewport Conversion}{Window-Viewport Conversion}

*/

The default viewport rectangle is the same as the device's

rectangle.

System#Window-Viewport Conversion}{Window-Viewport Conversion}

*/

Enables view transformations if \a enable is true, or disables

view transformations if \a enable is false.

Conversion}{Window-Viewport Conversion}

*/

Writes the given painter \a path to the given \a stream, and

returns a reference to the \a stream.

*/

QDataStream &operator<<(QDataStream &s, const QPainterPath &p)

{

Reads a painter path from the given \a stream into the specified \a path,

and returns a reference to the \a stream.

*/

QDataStream &operator>>(QDataStream &s, QPainterPath &p)

{

};

SegmentTree::SegmentTree(QPathSegments &segments)

{

m_bounds.x1 = qt_inf();

m_bounds.y1 = qt_inf();

for (int i = 0; i < m_segments.points(); ++i)

addVertex(m_segments.pointAt(i));

for (int i = 0; i < m_segments.segments(); ++i) {

intersections.reset();

}

}

{

}

{

m_segments.setPath(subject);

m_segments.addPath(clip);

else if (clipIsRect)

return subjectPath.intersects(r2);

a.setPath(subjectPath);

b.setPath(clipPath);

QIntersectionFinder finder;

if (clipIsRect)

return subjectPath.contains(r2);

a.setPath(subjectPath);

b.setPath(clipPath);

QIntersectionFinder finder;

};

void setPath(const QPainterPath &path);

void addPath(const QPainterPath &path);

return QPointF(x, y);

}

{

}

if (!points)

return;

QPainterPath p;

for (int i=0; i!=pointCount;++i) {

p.moveTo(points[i]);

p.lineTo(points[i] + QPointF(0, 0.001));

}

drawPath(p);

}

void QPdfBaseEngine::drawLines (const QLineF *lines, int lineCount)

if (!lines)

return;

QPainterPath p;

for (int i=0; i!=lineCount;++i) {

p.moveTo(lines[i].p1());

p.lineTo(lines[i].p2());

}

drawPath(p);

}

void QPdfBaseEngine::drawRects (const QRectF *rects, int rectCount)

Writes the given \a polygon to the given \a stream, and returns a

reference to the stream.

*/

QDataStream &operator<<(QDataStream &s, const QPolygon &a)

{

Reads a polygon from the given \a stream into the given \a

polygon, and returns a reference to the stream.

*/

QDataStream &operator>>(QDataStream &s, QPolygon &a)

{

Writes the given \a polygon to the given \a stream, and returns a

reference to the stream.

*/

QDataStream &operator<<(QDataStream &s, const QPolygonF &a)

Reads a polygon from the given \a stream into the given \a

polygon, and returns a reference to the stream.

*/

QDataStream &operator>>(QDataStream &s, QPolygonF &a)

template <typename InType, typename OutType, typename CastType> class QPolygonClipper

{

public:

{

x1 = y1 = x2 = y2 = 0;

}

void QPdfEnginePrivate::writeInfo()

{

info = addXrefEntry(-1);

QDateTime now = QDateTime::currentDateTime().toUTC();

QTime t = now.time();

QDate d = now.date();

d.year(),

d.month(),

d.day(),

return object;

}

QT_END_NAMESPACE

#endif // QT_NO_PRINTER

void writePage();

int addXrefEntry(int object, bool printostr = true);

void xprintf(const char* fmt, ...);

inline void write(const QByteArray &data) {

stream->writeRawData(data.constData(), data.size());

};

QScanConverter::QScanConverter()

, m_size(0)

, m_intersections(0)

{

}

template <typename T>

void qScanConvert(QScanConverter &d, T allVertical)

{

qSort(d.m_lines.data(), d.m_lines.data() + d.m_lines.size(), QT_PREPEND_NAMESPACE(topOrder));

int line = 0;

for (int y = d.m_lines.first().top; y <= d.m_bottom; ++y) {

class QSubpathFlatIterator

{

public:

inline bool hasNext() const { return m_curve_index >= 0 || m_pos < m_path->size(); }

QPointF(qt_fixed_to_real(m_path->at(m_pos+1).x),

qt_fixed_to_real(m_path->at(m_pos+1).y)),

QPointF(qt_fixed_to_real(m_path->at(m_pos+2).x),

m_curve_index = 1;

e.type = QPainterPath::LineToElement;

e.x = m_curve.at(0).x();

int m_pos;

QPolygonF m_curve;

int m_curve_index;

};

template <class Iterator> bool qt_stroke_side(Iterator *it, QStroker *stroker,

}

QStrokerOps::QStrokerOps()

{

}

{

}

/*!

Prepares the stroker. Call this function once before starting a

stroke by calling moveTo, lineTo or cubicTo.

if (path.isEmpty())

return;

begin(customData);

int count = path.elementCount();

if (matrix.isIdentity()) {

{

if (!pointCount)

return;

begin(data);

if (matrix.isIdentity()) {

moveTo(qt_real_to_fixed(points[0].x()), qt_real_to_fixed(points[0].y()));

}

}

begin(data);

moveTo(qt_real_to_fixed(start.x()), qt_real_to_fixed(start.y()));

for (int i=0; i<12; i+=3) {

{

m_strokeWidth = qt_real_to_fixed(1);

m_miterLimit = qt_real_to_fixed(2);

}

QStroker::~QStroker()

{

}

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

QPainterPath dashPath;

qfixed2d prev = it.next();

bool clipping = !m_clip_rect.isEmpty();

qfixed ex, qfixed ey,

void *data);

class Q_GUI_EXPORT QStrokerOps

{

public:

QRectF clipRect() const { return m_clip_rect; }

void setClipRect(const QRectF &clip) { m_clip_rect = clip; }

protected:

inline void emitMoveTo(qfixed x, qfixed y);

inline void emitLineTo(qfixed x, qfixed y);

QDataBuffer<Element> m_elements;

QRectF m_clip_rect;

void *m_customData;

qStrokerMoveToHook m_moveTo;

void setMiterLimit(qfixed length) { m_miterLimit = length; }

qfixed miterLimit() const { return m_miterLimit; }

void joinPoints(qfixed x, qfixed y, const QLineF &nextLine, LineJoinMode join);

inline void emitMoveTo(qfixed x, qfixed y);

inline void emitLineTo(qfixed x, qfixed y);

qfixed m_strokeWidth;

qfixed m_miterLimit;

LineJoinMode m_capStyle;

LineJoinMode m_joinStyle;

};

{

public:

QImageTextureGlyphCache(QFontEngineGlyphCache::Type type, const QTransform &matrix)

return true;

}

static inline bool cubicTo_clipped(QPainterPath &path, const QTransform &transform, const QPointF &a, const QPointF &b, const QPointF &c, const QPointF &d, bool needsMoveTo)

{

// Convert projective xformed curves to line

// segments so they can be transformed more accurately

for (int i = 0; i < segment.size() - 1; ++i)

if (lineTo_clipped(path, transform, segment.at(i), segment.at(i+1), needsMoveTo))