/****************************************************************************

**

** Copyright (C) 2016 The Qt Company Ltd.

** Contact: https://www.qt.io/licensing/

**

** This file is part of the QtGui module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** Commercial License Usage

** Licensees holding valid commercial Qt licenses may use this file in

** accordance with the commercial license agreement provided with the

** Software or, alternatively, in accordance with the terms contained in

** a written agreement between you and The Qt Company. For licensing terms

** and conditions see https://www.qt.io/terms-conditions. For further

** information use the contact form at https://www.qt.io/contact-us.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 3 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL3 included in the

** packaging of this file. Please review the following information to

** ensure the GNU Lesser General Public License version 3 requirements

** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.

**

** GNU General Public License Usage

** Alternatively, this file may be used under the terms of the GNU

** General Public License version 2.0 or (at your option) the GNU General

** Public license version 3 or any later version approved by the KDE Free

** Qt Foundation. The licenses are as published by the Free Software

** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3

** included in the packaging of this file. Please review the following

** information to ensure the GNU General Public License requirements will

** be met: https://www.gnu.org/licenses/gpl-2.0.html and

** https://www.gnu.org/licenses/gpl-3.0.html.

**

** $QT_END_LICENSE$

**

****************************************************************************/

#ifndef QPAINTER_H

#define QPAINTER_H

#include <QtGui/qtguiglobal.h>

#include <QtCore/qnamespace.h>

#include <QtCore/qrect.h>

#include <QtCore/qpoint.h>

#include <QtCore/qscopedpointer.h>

#include <QtGui/qpixmap.h>

#include <QtGui/qimage.h>

#include <QtGui/qtextoption.h>

#ifndef QT_INCLUDE_COMPAT

#include <QtGui/qpolygon.h>

#include <QtGui/qpen.h>

#include <QtGui/qbrush.h>

#include <QtGui/qmatrix.h>

#include <QtGui/qtransform.h>

#include <QtGui/qfontinfo.h>

#include <QtGui/qfontmetrics.h>

#endif

QT_BEGIN_NAMESPACE

class QBrush;

class QFontInfo;

class QFontMetrics;

class QPaintDevice;

class QPainterPath;

class QPainterPrivate;

class QPen;

class QPolygon;

class QTextItem;

class QTextEngine;

class QTransform;

class QStaticText;

class QGlyphRun;

class QPainterPrivateDeleter;

class Q_GUI_EXPORT QPainter

{

    Q_DECLARE_PRIVATE(QPainter)

    Q_GADGET

public:

    enum RenderHint {

        Antialiasing = 0x01,

        TextAntialiasing = 0x02,

        SmoothPixmapTransform = 0x04,

#if QT_DEPRECATED_SINCE(5, 14)

        HighQualityAntialiasing Q_DECL_ENUMERATOR_DEPRECATED_X("Use Antialiasing instead") = 0x08,

        NonCosmeticDefaultPen Q_DECL_ENUMERATOR_DEPRECATED_X("Default pen is non-cosmetic now") = 0x10,

#endif

        Qt4CompatiblePainting = 0x20,

        LosslessImageRendering = 0x40,

    };

    Q_FLAG(RenderHint)

    Q_DECLARE_FLAGS(RenderHints, RenderHint)

    Q_FLAG(RenderHints)

    class PixmapFragment {

    public:

        qreal x;

        qreal y;

        qreal sourceLeft;

        qreal sourceTop;

        qreal width;

        qreal height;

        qreal scaleX;

        qreal scaleY;

        qreal rotation;

        qreal opacity;

        static PixmapFragment Q_GUI_EXPORT create(const QPointF &pos, const QRectF &sourceRect,

                                            qreal scaleX = 1, qreal scaleY = 1,

                                            qreal rotation = 0, qreal opacity = 1);

    };

    enum PixmapFragmentHint {

        OpaqueHint = 0x01

    };

    Q_DECLARE_FLAGS(PixmapFragmentHints, PixmapFragmentHint)

    QPainter();

    explicit QPainter(QPaintDevice *);

    ~QPainter();

    QPaintDevice *device() const;

    bool begin(QPaintDevice *);

    bool end();

    bool isActive() const;

#if QT_DEPRECATED_SINCE(5, 13)

    QT_DEPRECATED_X("Use begin(QPaintDevice*) instead")

    void initFrom(const QPaintDevice *device);

#endif

    enum CompositionMode {

        CompositionMode_SourceOver,

        CompositionMode_DestinationOver,

        CompositionMode_Clear,

        CompositionMode_Source,

        CompositionMode_Destination,

        CompositionMode_SourceIn,

        CompositionMode_DestinationIn,

        CompositionMode_SourceOut,

        CompositionMode_DestinationOut,

        CompositionMode_SourceAtop,

        CompositionMode_DestinationAtop,

        CompositionMode_Xor,

        //svg 1.2 blend modes

        CompositionMode_Plus,

        CompositionMode_Multiply,

        CompositionMode_Screen,

        CompositionMode_Overlay,

        CompositionMode_Darken,

        CompositionMode_Lighten,

        CompositionMode_ColorDodge,

        CompositionMode_ColorBurn,

        CompositionMode_HardLight,

        CompositionMode_SoftLight,

        CompositionMode_Difference,

        CompositionMode_Exclusion,

        // ROPs

        RasterOp_SourceOrDestination,

        RasterOp_SourceAndDestination,

        RasterOp_SourceXorDestination,

        RasterOp_NotSourceAndNotDestination,

        RasterOp_NotSourceOrNotDestination,

        RasterOp_NotSourceXorDestination,

        RasterOp_NotSource,

        RasterOp_NotSourceAndDestination,

        RasterOp_SourceAndNotDestination,

        RasterOp_NotSourceOrDestination,

        RasterOp_SourceOrNotDestination,

        RasterOp_ClearDestination,

        RasterOp_SetDestination,

        RasterOp_NotDestination

    };

    void setCompositionMode(CompositionMode mode);

    CompositionMode compositionMode() const;

    const QFont &font() const;

    void setFont(const QFont &f);

    QFontMetrics fontMetrics() const;

    QFontInfo fontInfo() const;

    void setPen(const QColor &color);

    void setPen(const QPen &pen);

    void setPen(Qt::PenStyle style);

    const QPen &pen() const;

    void setBrush(const QBrush &brush);

    void setBrush(Qt::BrushStyle style);

    const QBrush &brush() const;

    // attributes/modes

    void setBackgroundMode(Qt::BGMode mode);

    Qt::BGMode backgroundMode() const;

    QPoint brushOrigin() const;

    inline void setBrushOrigin(int x, int y);

    inline void setBrushOrigin(const QPoint &);

    void setBrushOrigin(const QPointF &);

    void setBackground(const QBrush &bg);

    const QBrush &background() const;

    qreal opacity() const;

    void setOpacity(qreal opacity);

    // Clip functions

    QRegion clipRegion() const;

    QPainterPath clipPath() const;

    void setClipRect(const QRectF &, Qt::ClipOperation op = Qt::ReplaceClip);

    void setClipRect(const QRect &, Qt::ClipOperation op = Qt::ReplaceClip);

    inline void setClipRect(int x, int y, int w, int h, Qt::ClipOperation op = Qt::ReplaceClip);

    void setClipRegion(const QRegion &, Qt::ClipOperation op = Qt::ReplaceClip);

    void setClipPath(const QPainterPath &path, Qt::ClipOperation op = Qt::ReplaceClip);

    void setClipping(bool enable);

    bool hasClipping() const;

    QRectF clipBoundingRect() const;

    void save();

    void restore();

    // XForm functions

#if QT_DEPRECATED_SINCE(5, 13)

    QT_DEPRECATED_X("Use setTransform() instead")

    void setMatrix(const QMatrix &matrix, bool combine = false);

    QT_DEPRECATED_X("Use transform() instead")

    const QMatrix &matrix() const;

    QT_DEPRECATED_X("Use deviceTransform() instead")

    const QMatrix &deviceMatrix() const;

    QT_DEPRECATED_X("Use resetTransform() instead")

    void resetMatrix();

#endif

    void setTransform(const QTransform &transform, bool combine = false);

    const QTransform &transform() const;

    const QTransform &deviceTransform() const;

    void resetTransform();

#if QT_DEPRECATED_SINCE(5, 13)

    QT_DEPRECATED_X("Use setWorldTransform() instead")

    void setWorldMatrix(const QMatrix &matrix, bool combine = false);

    QT_DEPRECATED_X("Use worldTransform() instead")

    const QMatrix &worldMatrix() const;

    QT_DEPRECATED_X("Use combinedTransform() instead")

    QMatrix combinedMatrix() const;

    QT_DEPRECATED_X("Use setWorldMatrixEnabled() instead")

    void setMatrixEnabled(bool enabled);

    QT_DEPRECATED_X("Use worldMatrixEnabled() instead")

    bool matrixEnabled() const;

#endif

    void setWorldTransform(const QTransform &matrix, bool combine = false);

    const QTransform &worldTransform() const;

    QTransform combinedTransform() const;

    void setWorldMatrixEnabled(bool enabled);

    bool worldMatrixEnabled() const;

    void scale(qreal sx, qreal sy);

    void shear(qreal sh, qreal sv);

    void rotate(qreal a);

    void translate(const QPointF &offset);

    inline void translate(const QPoint &offset);

    inline void translate(qreal dx, qreal dy);

    QRect window() const;

    void setWindow(const QRect &window);

    inline void setWindow(int x, int y, int w, int h);

    QRect viewport() const;

    void setViewport(const QRect &viewport);

    inline void setViewport(int x, int y, int w, int h);

    void setViewTransformEnabled(bool enable);

    bool viewTransformEnabled() const;

    // drawing functions

    void strokePath(const QPainterPath &path, const QPen &pen);

    void fillPath(const QPainterPath &path, const QBrush &brush);

    void drawPath(const QPainterPath &path);

    inline void drawPoint(const QPointF &pt);

    inline void drawPoint(const QPoint &p);

    inline void drawPoint(int x, int y);

    void drawPoints(const QPointF *points, int pointCount);

    inline void drawPoints(const QPolygonF &points);

    void drawPoints(const QPoint *points, int pointCount);

    inline void drawPoints(const QPolygon &points);

    inline void drawLine(const QLineF &line);

    inline void drawLine(const QLine &line);

    inline void drawLine(int x1, int y1, int x2, int y2);

    inline void drawLine(const QPoint &p1, const QPoint &p2);

    inline void drawLine(const QPointF &p1, const QPointF &p2);

    void drawLines(const QLineF *lines, int lineCount);

    inline void drawLines(const QVector<QLineF> &lines);

    void drawLines(const QPointF *pointPairs, int lineCount);

    inline void drawLines(const QVector<QPointF> &pointPairs);

    void drawLines(const QLine *lines, int lineCount);

    inline void drawLines(const QVector<QLine> &lines);

    void drawLines(const QPoint *pointPairs, int lineCount);

    inline void drawLines(const QVector<QPoint> &pointPairs);

    inline void drawRect(const QRectF &rect);

    inline void drawRect(int x1, int y1, int w, int h);

    inline void drawRect(const QRect &rect);

    void drawRects(const QRectF *rects, int rectCount);

    inline void drawRects(const QVector<QRectF> &rectangles);

    void drawRects(const QRect *rects, int rectCount);

    inline void drawRects(const QVector<QRect> &rectangles);

    void drawEllipse(const QRectF &r);

    void drawEllipse(const QRect &r);

    inline void drawEllipse(int x, int y, int w, int h);

    inline void drawEllipse(const QPointF &center, qreal rx, qreal ry);

    inline void drawEllipse(const QPoint &center, int rx, int ry);

    void drawPolyline(const QPointF *points, int pointCount);

    inline void drawPolyline(const QPolygonF &polyline);

    void drawPolyline(const QPoint *points, int pointCount);

    inline void drawPolyline(const QPolygon &polygon);

    void drawPolygon(const QPointF *points, int pointCount, Qt::FillRule fillRule = Qt::OddEvenFill);

    inline void drawPolygon(const QPolygonF &polygon, Qt::FillRule fillRule = Qt::OddEvenFill);

    void drawPolygon(const QPoint *points, int pointCount, Qt::FillRule fillRule = Qt::OddEvenFill);

    inline void drawPolygon(const QPolygon &polygon, Qt::FillRule fillRule = Qt::OddEvenFill);

    void drawConvexPolygon(const QPointF *points, int pointCount);

    inline void drawConvexPolygon(const QPolygonF &polygon);

    void drawConvexPolygon(const QPoint *points, int pointCount);

    inline void drawConvexPolygon(const QPolygon &polygon);

    void drawArc(const QRectF &rect, int a, int alen);

    inline void drawArc(const QRect &, int a, int alen);

    inline void drawArc(int x, int y, int w, int h, int a, int alen);

    void drawPie(const QRectF &rect, int a, int alen);

    inline void drawPie(int x, int y, int w, int h, int a, int alen);

    inline void drawPie(const QRect &, int a, int alen);

    void drawChord(const QRectF &rect, int a, int alen);

    inline void drawChord(int x, int y, int w, int h, int a, int alen);

    inline void drawChord(const QRect &, int a, int alen);

    void drawRoundedRect(const QRectF &rect, qreal xRadius, qreal yRadius,

                         Qt::SizeMode mode = Qt::AbsoluteSize);

    inline void drawRoundedRect(int x, int y, int w, int h, qreal xRadius, qreal yRadius,

                                Qt::SizeMode mode = Qt::AbsoluteSize);

    inline void drawRoundedRect(const QRect &rect, qreal xRadius, qreal yRadius,

                                Qt::SizeMode mode = Qt::AbsoluteSize);

#if QT_DEPRECATED_SINCE(5, 13)

    QT_DEPRECATED_X("Use drawRoundedRect(..., Qt::RelativeSize) instead")

    void drawRoundRect(const QRectF &r, int xround = 25, int yround = 25);

    QT_DEPRECATED_X("Use drawRoundedRect(..., Qt::RelativeSize) instead")

    void drawRoundRect(int x, int y, int w, int h, int = 25, int = 25);

    QT_DEPRECATED_X("Use drawRoundedRect(..., Qt::RelativeSize) instead")

    void drawRoundRect(const QRect &r, int xround = 25, int yround = 25);

#endif

    void drawTiledPixmap(const QRectF &rect, const QPixmap &pm, const QPointF &offset = QPointF());

    inline void drawTiledPixmap(int x, int y, int w, int h, const QPixmap &, int sx=0, int sy=0);

    inline void drawTiledPixmap(const QRect &, const QPixmap &, const QPoint & = QPoint());

#ifndef QT_NO_PICTURE

    void drawPicture(const QPointF &p, const QPicture &picture);

    inline void drawPicture(int x, int y, const QPicture &picture);

    inline void drawPicture(const QPoint &p, const QPicture &picture);

#endif

    void drawPixmap(const QRectF &targetRect, const QPixmap &pixmap, const QRectF &sourceRect);

    inline void drawPixmap(const QRect &targetRect, const QPixmap &pixmap, const QRect &sourceRect);

    inline void drawPixmap(int x, int y, int w, int h, const QPixmap &pm,

                           int sx, int sy, int sw, int sh);

    inline void drawPixmap(int x, int y, const QPixmap &pm,

                           int sx, int sy, int sw, int sh);

    inline void drawPixmap(const QPointF &p, const QPixmap &pm, const QRectF &sr);

    inline void drawPixmap(const QPoint &p, const QPixmap &pm, const QRect &sr);

    void drawPixmap(const QPointF &p, const QPixmap &pm);

    inline void drawPixmap(const QPoint &p, const QPixmap &pm);

    inline void drawPixmap(int x, int y, const QPixmap &pm);

    inline void drawPixmap(const QRect &r, const QPixmap &pm);

    inline void drawPixmap(int x, int y, int w, int h, const QPixmap &pm);

    void drawPixmapFragments(const PixmapFragment *fragments, int fragmentCount,

                             const QPixmap &pixmap, PixmapFragmentHints hints = PixmapFragmentHints());

    void drawImage(const QRectF &targetRect, const QImage &image, const QRectF &sourceRect,

                   Qt::ImageConversionFlags flags = Qt::AutoColor);

    inline void drawImage(const QRect &targetRect, const QImage &image, const QRect &sourceRect,

                          Qt::ImageConversionFlags flags = Qt::AutoColor);

    inline void drawImage(const QPointF &p, const QImage &image, const QRectF &sr,

                          Qt::ImageConversionFlags flags = Qt::AutoColor);

    inline void drawImage(const QPoint &p, const QImage &image, const QRect &sr,

                          Qt::ImageConversionFlags flags = Qt::AutoColor);

    inline void drawImage(const QRectF &r, const QImage &image);

    inline void drawImage(const QRect &r, const QImage &image);

    void drawImage(const QPointF &p, const QImage &image);

    inline void drawImage(const QPoint &p, const QImage &image);

    inline void drawImage(int x, int y, const QImage &image, int sx = 0, int sy = 0,

                          int sw = -1, int sh = -1, Qt::ImageConversionFlags flags = Qt::AutoColor);

    void setLayoutDirection(Qt::LayoutDirection direction);

    Qt::LayoutDirection layoutDirection() const;

#if !defined(QT_NO_RAWFONT)

    void drawGlyphRun(const QPointF &position, const QGlyphRun &glyphRun);

#endif

    void drawStaticText(const QPointF &topLeftPosition, const QStaticText &staticText);

    inline void drawStaticText(const QPoint &topLeftPosition, const QStaticText &staticText);

    inline void drawStaticText(int left, int top, const QStaticText &staticText);

    void drawText(const QPointF &p, const QString &s);

    inline void drawText(const QPoint &p, const QString &s);

    inline void drawText(int x, int y, const QString &s);

    void drawText(const QPointF &p, const QString &str, int tf, int justificationPadding);

    void drawText(const QRectF &r, int flags, const QString &text, QRectF *br = nullptr);

    void drawText(const QRect &r, int flags, const QString &text, QRect *br = nullptr);

    inline void drawText(int x, int y, int w, int h, int flags, const QString &text, QRect *br = nullptr);

    void drawText(const QRectF &r, const QString &text, const QTextOption &o = QTextOption());

    QRectF boundingRect(const QRectF &rect, int flags, const QString &text);

    QRect boundingRect(const QRect &rect, int flags, const QString &text);

    inline QRect boundingRect(int x, int y, int w, int h, int flags, const QString &text);

    QRectF boundingRect(const QRectF &rect, const QString &text, const QTextOption &o = QTextOption());

    void drawTextItem(const QPointF &p, const QTextItem &ti);

    inline void drawTextItem(int x, int y, const QTextItem &ti);

    inline void drawTextItem(const QPoint &p, const QTextItem &ti);

    void fillRect(const QRectF &, const QBrush &);

    inline void fillRect(int x, int y, int w, int h, const QBrush &);

    void fillRect(const QRect &, const QBrush &);

    void fillRect(const QRectF &, const QColor &color);

    inline void fillRect(int x, int y, int w, int h, const QColor &color);

    void fillRect(const QRect &, const QColor &color);

    inline void fillRect(int x, int y, int w, int h, Qt::GlobalColor c);

    inline void fillRect(const QRect &r, Qt::GlobalColor c);

    inline void fillRect(const QRectF &r, Qt::GlobalColor c);

    inline void fillRect(int x, int y, int w, int h, Qt::BrushStyle style);

    inline void fillRect(const QRect &r, Qt::BrushStyle style);

    inline void fillRect(const QRectF &r, Qt::BrushStyle style);

    inline void fillRect(int x, int y, int w, int h, QGradient::Preset preset);

    inline void fillRect(const QRect &r, QGradient::Preset preset);

    inline void fillRect(const QRectF &r, QGradient::Preset preset);

    void eraseRect(const QRectF &);

    inline void eraseRect(int x, int y, int w, int h);

    inline void eraseRect(const QRect &);

    void setRenderHint(RenderHint hint, bool on = true);

    void setRenderHints(RenderHints hints, bool on = true);

    RenderHints renderHints() const;

    inline bool testRenderHint(RenderHint hint) const { return renderHints() & hint; }

    QPaintEngine *paintEngine() const;

#if QT_DEPRECATED_SINCE(5, 13)

    QT_DEPRECATED_X("Use QWidget::render() instead")

    static void setRedirected(const QPaintDevice *device, QPaintDevice *replacement,

                              const QPoint& offset = QPoint());

    QT_DEPRECATED_X("Use QWidget::render() instead")

    static QPaintDevice *redirected(const QPaintDevice *device, QPoint *offset = nullptr);

    QT_DEPRECATED_X("Use QWidget::render() instead")

    static void restoreRedirected(const QPaintDevice *device);

#endif

    void beginNativePainting();

    void endNativePainting();

private:

    Q_DISABLE_COPY(QPainter)

    QScopedPointer<QPainterPrivate> d_ptr;

    friend class QWidget;

    friend class QFontEngine;

    friend class QFontEngineBox;

    friend class QFontEngineFT;

    friend class QFontEngineMac;

    friend class QFontEngineWin;

    friend class QPaintEngine;

    friend class QPaintEngineExPrivate;

    friend class QOpenGLPaintEngine;

    friend class QWin32PaintEngine;

    friend class QWin32PaintEnginePrivate;

    friend class QRasterPaintEngine;

    friend class QAlphaPaintEngine;

    friend class QPreviewPaintEngine;

    friend class QTextEngine;

};

Q_DECLARE_TYPEINFO(QPainter::PixmapFragment, Q_RELOCATABLE_TYPE);

Q_DECLARE_OPERATORS_FOR_FLAGS(QPainter::RenderHints)

//

// functions

//

inline void QPainter::drawLine(const QLineF &l)

{

    drawLines(&l, 1);

}

inline void QPainter::drawLine(const QLine &line)

{

    drawLines(&line, 1);

}

inline void QPainter::drawLine(int x1, int y1, int x2, int y2)

{

    QLine l(x1, y1, x2, y2);

    drawLines(&l, 1);

}

inline void QPainter::drawLine(const QPoint &p1, const QPoint &p2)

{

    QLine l(p1, p2);

    drawLines(&l, 1);

}

inline void QPainter::drawLine(const QPointF &p1, const QPointF &p2)

{

    drawLine(QLineF(p1, p2));

}

inline void QPainter::drawLines(const QVector<QLineF> &lines)

{

    drawLines(lines.constData(), lines.size());

}

inline void QPainter::drawLines(const QVector<QLine> &lines)

{

    drawLines(lines.constData(), lines.size());

}

inline void QPainter::drawLines(const QVector<QPointF> &pointPairs)

{

    drawLines(pointPairs.constData(), pointPairs.size() / 2);

}

inline void QPainter::drawLines(const QVector<QPoint> &pointPairs)

{

    drawLines(pointPairs.constData(), pointPairs.size() / 2);

}

inline void QPainter::drawPolyline(const QPolygonF &polyline)

{

    drawPolyline(polyline.constData(), polyline.size());

}

inline void QPainter::drawPolyline(const QPolygon &polyline)

{

    drawPolyline(polyline.constData(), polyline.size());

}

inline void QPainter::drawPolygon(const QPolygonF &polygon, Qt::FillRule fillRule)

{

    drawPolygon(polygon.constData(), polygon.size(), fillRule);

}

inline void QPainter::drawPolygon(const QPolygon &polygon, Qt::FillRule fillRule)

{

    drawPolygon(polygon.constData(), polygon.size(), fillRule);

}

inline void QPainter::drawConvexPolygon(const QPolygonF &poly)

{

    drawConvexPolygon(poly.constData(), poly.size());

}

inline void QPainter::drawConvexPolygon(const QPolygon &poly)

{

    drawConvexPolygon(poly.constData(), poly.size());

}

inline void QPainter::drawRect(const QRectF &rect)

{

    drawRects(&rect, 1);

}

inline void QPainter::drawRect(int x, int y, int w, int h)

{

    QRect r(x, y, w, h);

    drawRects(&r, 1);

}

inline void QPainter::drawRect(const QRect &r)

{

    drawRects(&r, 1);

}

inline void QPainter::drawRects(const QVector<QRectF> &rects)

{

    drawRects(rects.constData(), rects.size());

}

inline void QPainter::drawRects(const QVector<QRect> &rects)

{

    drawRects(rects.constData(), rects.size());

}

inline void QPainter::drawPoint(const QPointF &p)

{

    drawPoints(&p, 1);

}

inline void QPainter::drawPoint(int x, int y)

{

    QPoint p(x, y);

    drawPoints(&p, 1);

}

inline void QPainter::drawPoint(const QPoint &p)

{

    drawPoints(&p, 1);

}

inline void QPainter::drawPoints(const QPolygonF &points)

{

    drawPoints(points.constData(), points.size());

}

inline void QPainter::drawPoints(const QPolygon &points)

{

    drawPoints(points.constData(), points.size());

}

inline void QPainter::drawRoundedRect(int x, int y, int w, int h, qreal xRadius, qreal yRadius,

                            Qt::SizeMode mode)

{

    drawRoundedRect(QRectF(x, y, w, h), xRadius, yRadius, mode);

}

inline void QPainter::drawRoundedRect(const QRect &rect, qreal xRadius, qreal yRadius,

                            Qt::SizeMode mode)

{

    drawRoundedRect(QRectF(rect), xRadius, yRadius, mode);

}

inline void QPainter::drawEllipse(int x, int y, int w, int h)

{

    drawEllipse(QRect(x, y, w, h));

}

inline void QPainter::drawEllipse(const QPointF &center, qreal rx, qreal ry)

{

    drawEllipse(QRectF(center.x() - rx, center.y() - ry, 2 * rx, 2 * ry));

}

inline void QPainter::drawEllipse(const QPoint &center, int rx, int ry)

{

    drawEllipse(QRect(center.x() - rx, center.y() - ry, 2 * rx, 2 * ry));

}

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

{

    drawArc(QRectF(r), a, alen);

}

inline void QPainter::drawArc(int x, int y, int w, int h, int a, int alen)

{

    drawArc(QRectF(x, y, w, h), a, alen);

}

inline void QPainter::drawPie(const QRect &rect, int a, int alen)

{

    drawPie(QRectF(rect), a, alen);

}

inline void QPainter::drawPie(int x, int y, int w, int h, int a, int alen)

{

    drawPie(QRectF(x, y, w, h), a, alen);

}

inline void QPainter::drawChord(const QRect &rect, int a, int alen)

{

    drawChord(QRectF(rect), a, alen);

}

inline void QPainter::drawChord(int x, int y, int w, int h, int a, int alen)

{

    drawChord(QRectF(x, y, w, h), a, alen);

}

inline void QPainter::setClipRect(int x, int y, int w, int h, Qt::ClipOperation op)

{

    setClipRect(QRect(x, y, w, h), op);

}

inline void QPainter::eraseRect(const QRect &rect)

{

    eraseRect(QRectF(rect));

}

inline void QPainter::eraseRect(int x, int y, int w, int h)

{

    eraseRect(QRectF(x, y, w, h));

}

inline void QPainter::fillRect(int x, int y, int w, int h, const QBrush &b)

{

    fillRect(QRect(x, y, w, h), b);

}

inline void QPainter::fillRect(int x, int y, int w, int h, const QColor &b)

{

    fillRect(QRect(x, y, w, h), b);

}

inline void QPainter::fillRect(int x, int y, int w, int h, Qt::GlobalColor c)

{

    fillRect(QRect(x, y, w, h), QColor(c));

}

inline void QPainter::fillRect(const QRect &r, Qt::GlobalColor c)

{

    fillRect(r, QColor(c));

}

inline void QPainter::fillRect(const QRectF &r, Qt::GlobalColor c)

{

    fillRect(r, QColor(c));

}

inline void QPainter::fillRect(int x, int y, int w, int h, Qt::BrushStyle style)

{

    fillRect(QRectF(x, y, w, h), QBrush(style));

}

inline void QPainter::fillRect(const QRect &r, Qt::BrushStyle style)

{

    fillRect(QRectF(r), QBrush(style));

}

inline void QPainter::fillRect(const QRectF &r, Qt::BrushStyle style)

{

    fillRect(r, QBrush(style));

}

inline void QPainter::fillRect(int x, int y, int w, int h, QGradient::Preset p)

{

    fillRect(QRect(x, y, w, h), QGradient(p));

}

inline void QPainter::fillRect(const QRect &r, QGradient::Preset p)

{

    fillRect(r, QGradient(p));

}

inline void QPainter::fillRect(const QRectF &r, QGradient::Preset p)

{

    fillRect(r, QGradient(p));

}

inline void QPainter::setBrushOrigin(int x, int y)

{

    setBrushOrigin(QPoint(x, y));

}

inline void QPainter::setBrushOrigin(const QPoint &p)

{

    setBrushOrigin(QPointF(p));

}

inline void QPainter::drawTiledPixmap(const QRect &rect, const QPixmap &pm, const QPoint &offset)

{

    drawTiledPixmap(QRectF(rect), pm, QPointF(offset));

}

inline void QPainter::drawTiledPixmap(int x, int y, int w, int h, const QPixmap &pm, int sx, int sy)

{

    drawTiledPixmap(QRectF(x, y, w, h), pm, QPointF(sx, sy));

}

inline void QPainter::drawPixmap(const QRect &targetRect, const QPixmap &pixmap, const QRect &sourceRect)

{

    drawPixmap(QRectF(targetRect), pixmap, QRectF(sourceRect));

}

inline void QPainter::drawPixmap(const QPoint &p, const QPixmap &pm)

{

    drawPixmap(QPointF(p), pm);

}

inline void QPainter::drawPixmap(const QRect &r, const QPixmap &pm)

{

    drawPixmap(QRectF(r), pm, QRectF());

}

inline void QPainter::drawPixmap(int x, int y, const QPixmap &pm)

{

    drawPixmap(QPointF(x, y), pm);

}

inline void QPainter::drawPixmap(int x, int y, int w, int h, const QPixmap &pm)

{

    drawPixmap(QRectF(x, y, w, h), pm, QRectF());

}

inline void QPainter::drawPixmap(int x, int y, int w, int h, const QPixmap &pm,

                                 int sx, int sy, int sw, int sh)

{

    drawPixmap(QRectF(x, y, w, h), pm, QRectF(sx, sy, sw, sh));

}

inline void QPainter::drawPixmap(int x, int y, const QPixmap &pm,

                                 int sx, int sy, int sw, int sh)

{

    drawPixmap(QRectF(x, y, -1, -1), pm, QRectF(sx, sy, sw, sh));

}

inline void QPainter::drawPixmap(const QPointF &p, const QPixmap &pm, const QRectF &sr)

{

    drawPixmap(QRectF(p.x(), p.y(), -1, -1), pm, sr);

}

inline void QPainter::drawPixmap(const QPoint &p, const QPixmap &pm, const QRect &sr)

{

    drawPixmap(QRectF(p.x(), p.y(), -1, -1), pm, sr);

}

inline void QPainter::drawTextItem(int x, int y, const QTextItem &ti)

{

    drawTextItem(QPointF(x, y), ti);

}

inline void QPainter::drawImage(const QRect &targetRect, const QImage &image, const QRect &sourceRect,

                                Qt::ImageConversionFlags flags)

{

    drawImage(QRectF(targetRect), image, QRectF(sourceRect), flags);

}

inline void QPainter::drawImage(const QPointF &p, const QImage &image, const QRectF &sr,

                                Qt::ImageConversionFlags flags)

{

    drawImage(QRectF(p.x(), p.y(), -1, -1), image, sr, flags);

}

inline void QPainter::drawImage(const QPoint &p, const QImage &image, const QRect &sr,

                                Qt::ImageConversionFlags flags)

{

    drawImage(QRect(p.x(), p.y(), -1, -1), image, sr, flags);

}

inline void QPainter::drawImage(const QRectF &r, const QImage &image)

{

    drawImage(r, image, QRect(0, 0, image.width(), image.height()));

}

inline void QPainter::drawImage(const QRect &r, const QImage &image)

{

    drawImage(r, image, QRectF(0, 0, image.width(), image.height()));

}

inline void QPainter::drawImage(const QPoint &p, const QImage &image)

{

    drawImage(QPointF(p), image);

}

inline void QPainter::drawImage(int x, int y, const QImage &image, int sx, int sy, int sw, int sh,

                                Qt::ImageConversionFlags flags)

{

    if (sx == 0 && sy == 0 && sw == -1 && sh == -1 && flags == Qt::AutoColor)

        drawImage(QPointF(x, y), image);

    else

        drawImage(QRectF(x, y, -1, -1), image, QRectF(sx, sy, sw, sh), flags);

}

inline void QPainter::drawStaticText(const QPoint &p, const QStaticText &staticText)

{

    drawStaticText(QPointF(p), staticText);

}

inline void QPainter::drawStaticText(int x, int y, const QStaticText &staticText)

{

    drawStaticText(QPointF(x, y), staticText);

}

inline void QPainter::drawTextItem(const QPoint &p, const QTextItem &ti)

{

    drawTextItem(QPointF(p), ti);

}

inline void QPainter::drawText(const QPoint &p, const QString &s)

{

    drawText(QPointF(p), s);

}

inline void QPainter::drawText(int x, int y, int w, int h, int flags, const QString &str, QRect *br)

{

    drawText(QRect(x, y, w, h), flags, str, br);

}

inline void QPainter::drawText(int x, int y, const QString &s)

{

    drawText(QPointF(x, y), s);

}

inline QRect QPainter::boundingRect(int x, int y, int w, int h, int flags, const QString &text)

{

    return boundingRect(QRect(x, y, w, h), flags, text);

}

inline void QPainter::translate(qreal dx, qreal dy)

{

    translate(QPointF(dx, dy));

}

inline void QPainter::translate(const QPoint &offset)

{

    translate(offset.x(), offset.y());

}

inline void QPainter::setViewport(int x, int y, int w, int h)

{

    setViewport(QRect(x, y, w, h));

}

inline void QPainter::setWindow(int x, int y, int w, int h)

{

    setWindow(QRect(x, y, w, h));

}

#ifndef QT_NO_PICTURE

inline void QPainter::drawPicture(int x, int y, const QPicture &p)

{

    drawPicture(QPoint(x, y), p);

}

inline void QPainter::drawPicture(const QPoint &pt, const QPicture &p)

{

    drawPicture(QPointF(pt), p);

}

#endif

QT_END_NAMESPACE

#endif // QPAINTER_H