--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/gui/painting/qbrush.cpp Mon Jan 11 14:00:40 2010 +0000
@@ -0,0 +1,2161 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qbrush.h"
+#include "qpixmap.h"
+#include "qbitmap.h"
+#include "qpixmapcache.h"
+#include "qdatastream.h"
+#include "qvariant.h"
+#include "qline.h"
+#include "qdebug.h"
+#include <QtCore/qcoreapplication.h>
+
+QT_BEGIN_NAMESPACE
+
+const uchar *qt_patternForBrush(int brushStyle, bool invert)
+{
+ Q_ASSERT(brushStyle > Qt::SolidPattern && brushStyle < Qt::LinearGradientPattern);
+ if(invert) {
+ static const uchar dense1_pat[] = { 0xff, 0xbb, 0xff, 0xff, 0xff, 0xbb, 0xff, 0xff };
+ static const uchar dense2_pat[] = { 0x77, 0xff, 0xdd, 0xff, 0x77, 0xff, 0xdd, 0xff };
+ static const uchar dense3_pat[] = { 0x55, 0xbb, 0x55, 0xee, 0x55, 0xbb, 0x55, 0xee };
+ static const uchar dense4_pat[] = { 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55 };
+ static const uchar dense5_pat[] = { 0xaa, 0x44, 0xaa, 0x11, 0xaa, 0x44, 0xaa, 0x11 };
+ static const uchar dense6_pat[] = { 0x88, 0x00, 0x22, 0x00, 0x88, 0x00, 0x22, 0x00 };
+ static const uchar dense7_pat[] = { 0x00, 0x44, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00 };
+ static const uchar hor_pat[] = { 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00 };
+ static const uchar ver_pat[] = { 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10 };
+ static const uchar cross_pat[] = { 0x10, 0x10, 0x10, 0xff, 0x10, 0x10, 0x10, 0x10 };
+ static const uchar bdiag_pat[] = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 };
+ static const uchar fdiag_pat[] = { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 };
+ static const uchar dcross_pat[] = { 0x81, 0x42, 0x24, 0x18, 0x18, 0x24, 0x42, 0x81 };
+ static const uchar *const pat_tbl[] = {
+ dense1_pat, dense2_pat, dense3_pat, dense4_pat, dense5_pat,
+ dense6_pat, dense7_pat,
+ hor_pat, ver_pat, cross_pat, bdiag_pat, fdiag_pat, dcross_pat };
+ return pat_tbl[brushStyle - Qt::Dense1Pattern];
+ }
+ static const uchar dense1_pat[] = { 0x00, 0x44, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00 };
+ static const uchar dense2_pat[] = { 0x88, 0x00, 0x22, 0x00, 0x88, 0x00, 0x22, 0x00 };
+ static const uchar dense3_pat[] = { 0xaa, 0x44, 0xaa, 0x11, 0xaa, 0x44, 0xaa, 0x11 };
+ static const uchar dense4_pat[] = { 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa };
+ static const uchar dense5_pat[] = { 0x55, 0xbb, 0x55, 0xee, 0x55, 0xbb, 0x55, 0xee };
+ static const uchar dense6_pat[] = { 0x77, 0xff, 0xdd, 0xff, 0x77, 0xff, 0xdd, 0xff };
+ static const uchar dense7_pat[] = { 0xff, 0xbb, 0xff, 0xff, 0xff, 0xbb, 0xff, 0xff };
+ static const uchar hor_pat[] = { 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff };
+ static const uchar ver_pat[] = { 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef };
+ static const uchar cross_pat[] = { 0xef, 0xef, 0xef, 0x00, 0xef, 0xef, 0xef, 0xef };
+ static const uchar bdiag_pat[] = { 0x7f, 0xbf, 0xdf, 0xef, 0xf7, 0xfb, 0xfd, 0xfe };
+ static const uchar fdiag_pat[] = { 0xfe, 0xfd, 0xfb, 0xf7, 0xef, 0xdf, 0xbf, 0x7f };
+ static const uchar dcross_pat[] = { 0x7e, 0xbd, 0xdb, 0xe7, 0xe7, 0xdb, 0xbd, 0x7e };
+ static const uchar *const pat_tbl[] = {
+ dense1_pat, dense2_pat, dense3_pat, dense4_pat, dense5_pat,
+ dense6_pat, dense7_pat,
+ hor_pat, ver_pat, cross_pat, bdiag_pat, fdiag_pat, dcross_pat };
+ return pat_tbl[brushStyle - Qt::Dense1Pattern];
+}
+
+QPixmap qt_pixmapForBrush(int brushStyle, bool invert)
+{
+ QPixmap pm;
+ QString key = QLatin1String("$qt-brush$") + QString::number(brushStyle)
+ + QString::number((int)invert);
+ if (!QPixmapCache::find(key, pm)) {
+ pm = QBitmap::fromData(QSize(8, 8), qt_patternForBrush(brushStyle, invert),
+ QImage::Format_MonoLSB);
+ QPixmapCache::insert(key, pm);
+ }
+
+ return pm;
+}
+
+class QBrushPatternImageCache
+{
+public:
+ QBrushPatternImageCache()
+ : m_initialized(false)
+ {
+ init();
+ }
+
+ void init()
+ {
+ for (int style = Qt::Dense1Pattern; style <= Qt::DiagCrossPattern; ++style) {
+ int i = style - Qt::Dense1Pattern;
+ m_images[i][0] = QImage(qt_patternForBrush(style, 0), 8, 8, 1, QImage::Format_MonoLSB);
+ m_images[i][1] = QImage(qt_patternForBrush(style, 1), 8, 8, 1, QImage::Format_MonoLSB);
+ }
+ m_initialized = true;
+ }
+
+ QImage getImage(int brushStyle, bool invert) const
+ {
+ Q_ASSERT(brushStyle >= Qt::Dense1Pattern && brushStyle <= Qt::DiagCrossPattern);
+ if (!m_initialized)
+ const_cast<QBrushPatternImageCache*>(this)->init();
+ return m_images[brushStyle - Qt::Dense1Pattern][invert];
+ }
+
+ void cleanup() {
+ for (int style = Qt::Dense1Pattern; style <= Qt::DiagCrossPattern; ++style) {
+ int i = style - Qt::Dense1Pattern;
+ m_images[i][0] = QImage();
+ m_images[i][1] = QImage();
+ }
+ m_initialized = false;
+ }
+
+private:
+ QImage m_images[Qt::DiagCrossPattern - Qt::Dense1Pattern + 1][2];
+ bool m_initialized;
+};
+
+static void qt_cleanup_brush_pattern_image_cache();
+Q_GLOBAL_STATIC_WITH_INITIALIZER(QBrushPatternImageCache, qt_brushPatternImageCache,
+ {
+ qAddPostRoutine(qt_cleanup_brush_pattern_image_cache);
+ })
+
+static void qt_cleanup_brush_pattern_image_cache()
+{
+ qt_brushPatternImageCache()->cleanup();
+}
+
+Q_GUI_EXPORT
+QImage qt_imageForBrush(int brushStyle, bool invert)
+{
+ return qt_brushPatternImageCache()->getImage(brushStyle, invert);
+}
+
+struct QTexturedBrushData : public QBrushData
+{
+ QTexturedBrushData() {
+ m_has_pixmap_texture = false;
+ m_pixmap = 0;
+ }
+ ~QTexturedBrushData() {
+ delete m_pixmap;
+ }
+
+ void setPixmap(const QPixmap &pm) {
+ delete m_pixmap;
+
+ if (pm.isNull()) {
+ m_pixmap = 0;
+ m_has_pixmap_texture = false;
+ } else {
+ m_pixmap = new QPixmap(pm);
+ m_has_pixmap_texture = true;
+ }
+
+ m_image = QImage();
+ }
+
+ void setImage(const QImage &image) {
+ m_image = image;
+ delete m_pixmap;
+ m_pixmap = 0;
+ m_has_pixmap_texture = false;
+ }
+
+ QPixmap &pixmap() {
+ if (!m_pixmap) {
+ m_pixmap = new QPixmap(QPixmap::fromImage(m_image));
+ }
+ return *m_pixmap;
+ }
+
+ QImage &image() {
+ if (m_image.isNull() && m_pixmap)
+ m_image = m_pixmap->toImage();
+ return m_image;
+ }
+
+ QPixmap *m_pixmap;
+ QImage m_image;
+ bool m_has_pixmap_texture;
+};
+
+// returns true if the brush has a pixmap (or bitmap) set as the
+// brush texture, false otherwise
+bool Q_GUI_EXPORT qHasPixmapTexture(const QBrush& brush)
+{
+ if (brush.style() != Qt::TexturePattern)
+ return false;
+ QTexturedBrushData *tx_data = static_cast<QTexturedBrushData *>(brush.d.data());
+ return tx_data->m_has_pixmap_texture;
+}
+
+struct QGradientBrushData : public QBrushData
+{
+ QGradient gradient;
+};
+
+struct QBrushDataPointerDeleter
+{
+ static inline void deleteData(QBrushData *d)
+ {
+ switch (d->style) {
+ case Qt::TexturePattern:
+ delete static_cast<QTexturedBrushData*>(d);
+ break;
+ case Qt::LinearGradientPattern:
+ case Qt::RadialGradientPattern:
+ case Qt::ConicalGradientPattern:
+ delete static_cast<QGradientBrushData*>(d);
+ break;
+ default:
+ delete d;
+ }
+ }
+
+ static inline void cleanup(QBrushData *d)
+ {
+ if (d && !d->ref.deref()) {
+ deleteData(d);
+ }
+ }
+};
+
+/*!
+ \class QBrush
+ \ingroup painting
+ \ingroup shared
+
+ \brief The QBrush class defines the fill pattern of shapes drawn
+ by QPainter.
+
+ A brush has a style, a color, a gradient and a texture.
+
+ The brush style() defines the fill pattern using the
+ Qt::BrushStyle enum. The default brush style is Qt::NoBrush
+ (depending on how you construct a brush). This style tells the
+ painter to not fill shapes. The standard style for filling is
+ Qt::SolidPattern. The style can be set when the brush is created
+ using the appropriate constructor, and in addition the setStyle()
+ function provides means for altering the style once the brush is
+ constructed.
+
+ \image brush-styles.png Brush Styles
+
+ The brush color() defines the color of the fill pattern. The color
+ can either be one of Qt's predefined colors, Qt::GlobalColor, or
+ any other custom QColor. The currently set color can be retrieved
+ and altered using the color() and setColor() functions,
+ respectively.
+
+ The gradient() defines the gradient fill used when the current
+ style is either Qt::LinearGradientPattern,
+ Qt::RadialGradientPattern or Qt::ConicalGradientPattern. Gradient
+ brushes are created by giving a QGradient as a constructor
+ argument when creating the QBrush. Qt provides three different
+ gradients: QLinearGradient, QConicalGradient, and QRadialGradient
+ - all of which inherit QGradient.
+
+ \snippet doc/src/snippets/brush/gradientcreationsnippet.cpp 0
+
+ The texture() defines the pixmap used when the current style is
+ Qt::TexturePattern. You can create a brush with a texture by
+ providing the pixmap when the brush is created or by using
+ setTexture().
+
+ Note that applying setTexture() makes style() ==
+ Qt::TexturePattern, regardless of previous style
+ settings. Also, calling setColor() will not make a difference if
+ the style is a gradient. The same is the case if the style is
+ Qt::TexturePattern style unless the current texture is a QBitmap.
+
+ The isOpaque() function returns true if the brush is fully opaque
+ otherwise false. A brush is considered opaque if:
+
+ \list
+ \o The alpha component of the color() is 255.
+ \o Its texture() does not have an alpha channel and is not a QBitmap.
+ \o The colors in the gradient() all have an alpha component that is 255.
+ \endlist
+
+ \table 100%
+ \row
+ \o \inlineimage brush-outline.png Outlines
+ \o
+
+ To specify the style and color of lines and outlines, use the
+ QPainter's \l {QPen}{pen} combined with Qt::PenStyle and
+ Qt::GlobalColor:
+
+ \snippet doc/src/snippets/code/src_gui_painting_qbrush.cpp 0
+
+ Note that, by default, QPainter renders the outline (using the
+ currently set pen) when drawing shapes. Use \l {Qt::NoPen}{\c
+ painter.setPen(Qt::NoPen)} to disable this behavior.
+
+ \endtable
+
+ For more information about painting in general, see \l{The Paint
+ System} documentation.
+
+ \sa Qt::BrushStyle, QPainter, QColor
+*/
+
+#ifndef QT_NO_THREAD
+// Special deleter that only deletes if the ref-count goes to zero
+template <>
+class QGlobalStaticDeleter<QBrushData>
+{
+public:
+ QGlobalStatic<QBrushData> &globalStatic;
+ QGlobalStaticDeleter(QGlobalStatic<QBrushData> &_globalStatic)
+ : globalStatic(_globalStatic)
+ { }
+
+ inline ~QGlobalStaticDeleter()
+ {
+ if (!globalStatic.pointer->ref.deref())
+ delete globalStatic.pointer;
+ globalStatic.pointer = 0;
+ globalStatic.destroyed = true;
+ }
+};
+#endif
+
+Q_GLOBAL_STATIC_WITH_INITIALIZER(QBrushData, nullBrushInstance,
+ {
+ x->ref = 1;
+ x->style = Qt::BrushStyle(0);
+ x->color = Qt::black;
+ })
+
+static bool qbrush_check_type(Qt::BrushStyle style) {
+ switch (style) {
+ case Qt::TexturePattern:
+ qWarning("QBrush: Incorrect use of TexturePattern");
+ break;
+ case Qt::LinearGradientPattern:
+ case Qt::RadialGradientPattern:
+ case Qt::ConicalGradientPattern:
+ qWarning("QBrush: Wrong use of a gradient pattern");
+ break;
+ default:
+ return true;
+ }
+ return false;
+}
+
+/*!
+ \internal
+ Initializes the brush.
+*/
+
+void QBrush::init(const QColor &color, Qt::BrushStyle style)
+{
+ switch(style) {
+ case Qt::NoBrush:
+ d.reset(nullBrushInstance());
+ d->ref.ref();
+ if (d->color != color) setColor(color);
+ return;
+ case Qt::TexturePattern:
+ d.reset(new QTexturedBrushData);
+ break;
+ case Qt::LinearGradientPattern:
+ case Qt::RadialGradientPattern:
+ case Qt::ConicalGradientPattern:
+ d.reset(new QGradientBrushData);
+ break;
+ default:
+ d.reset(new QBrushData);
+ break;
+ }
+ d->ref = 1;
+ d->style = style;
+ d->color = color;
+}
+
+/*!
+ Constructs a default black brush with the style Qt::NoBrush
+ (i.e. this brush will not fill shapes).
+*/
+
+QBrush::QBrush()
+ : d(nullBrushInstance())
+{
+ Q_ASSERT(d);
+ d->ref.ref();
+}
+
+/*!
+ Constructs a brush with a black color and a texture set to the
+ given \a pixmap. The style is set to Qt::TexturePattern.
+
+ \sa setTexture()
+*/
+
+QBrush::QBrush(const QPixmap &pixmap)
+{
+ init(Qt::black, Qt::TexturePattern);
+ setTexture(pixmap);
+}
+
+
+/*!
+ Constructs a brush with a black color and a texture set to the
+ given \a image. The style is set to Qt::TexturePattern.
+
+ \sa setTextureImage()
+*/
+
+QBrush::QBrush(const QImage &image)
+{
+ init(Qt::black, Qt::TexturePattern);
+ setTextureImage(image);
+}
+
+/*!
+ Constructs a black brush with the given \a style.
+
+ \sa setStyle()
+*/
+
+QBrush::QBrush(Qt::BrushStyle style)
+{
+ if (qbrush_check_type(style))
+ init(Qt::black, style);
+ else {
+ d.reset(nullBrushInstance());
+ d->ref.ref();
+ }
+}
+
+/*!
+ Constructs a brush with the given \a color and \a style.
+
+ \sa setColor(), setStyle()
+*/
+
+QBrush::QBrush(const QColor &color, Qt::BrushStyle style)
+{
+ if (qbrush_check_type(style))
+ init(color, style);
+ else {
+ d.reset(nullBrushInstance());
+ d->ref.ref();
+ }
+}
+
+/*!
+ \fn QBrush::QBrush(Qt::GlobalColor color, Qt::BrushStyle style)
+
+ Constructs a brush with the given \a color and \a style.
+
+ \sa setColor(), setStyle()
+*/
+QBrush::QBrush(Qt::GlobalColor color, Qt::BrushStyle style)
+{
+ if (qbrush_check_type(style))
+ init(color, style);
+ else {
+ d.reset(nullBrushInstance());
+ d->ref.ref();
+ }
+}
+
+/*!
+ Constructs a brush with the given \a color and the custom pattern
+ stored in \a pixmap.
+
+ The style is set to Qt::TexturePattern. The color will only have
+ an effect for QBitmaps.
+
+ \sa setColor(), setPixmap()
+*/
+
+QBrush::QBrush(const QColor &color, const QPixmap &pixmap)
+{
+ init(color, Qt::TexturePattern);
+ setTexture(pixmap);
+}
+
+/*!
+
+ Constructs a brush with the given \a color and the custom pattern
+ stored in \a pixmap.
+
+ The style is set to Qt::TexturePattern. The color will only have
+ an effect for QBitmaps.
+
+ \sa setColor(), setPixmap()
+*/
+QBrush::QBrush(Qt::GlobalColor color, const QPixmap &pixmap)
+{
+ init(color, Qt::TexturePattern);
+ setTexture(pixmap);
+}
+
+/*!
+ Constructs a copy of \a other.
+*/
+
+QBrush::QBrush(const QBrush &other)
+ : d(other.d.data())
+{
+ d->ref.ref();
+}
+
+/*!
+ Constructs a brush based on the given \a gradient.
+
+ The brush style is set to the corresponding gradient style (either
+ Qt::LinearGradientPattern, Qt::RadialGradientPattern or
+ Qt::ConicalGradientPattern).
+*/
+QBrush::QBrush(const QGradient &gradient)
+{
+ Q_ASSERT_X(gradient.type() != QGradient::NoGradient, "QBrush::QBrush",
+ "QGradient should not be used directly, use the linear, radial\n"
+ "or conical gradients instead");
+
+ const Qt::BrushStyle enum_table[] = {
+ Qt::LinearGradientPattern,
+ Qt::RadialGradientPattern,
+ Qt::ConicalGradientPattern
+ };
+
+ init(QColor(), enum_table[gradient.type()]);
+ QGradientBrushData *grad = static_cast<QGradientBrushData *>(d.data());
+ grad->gradient = gradient;
+}
+
+/*!
+ Destroys the brush.
+*/
+
+QBrush::~QBrush()
+{
+}
+
+void QBrush::cleanUp(QBrushData *x)
+{
+ QBrushDataPointerDeleter::deleteData(x);
+}
+
+
+void QBrush::detach(Qt::BrushStyle newStyle)
+{
+ if (newStyle == d->style && d->ref == 1)
+ return;
+
+ QScopedPointer<QBrushData> x;
+ switch(newStyle) {
+ case Qt::TexturePattern: {
+ QTexturedBrushData *tbd = new QTexturedBrushData;
+ if (d->style == Qt::TexturePattern) {
+ QTexturedBrushData *data = static_cast<QTexturedBrushData *>(d.data());
+ if (data->m_has_pixmap_texture)
+ tbd->setPixmap(data->pixmap());
+ else
+ tbd->setImage(data->image());
+ }
+ x.reset(tbd);
+ break;
+ }
+ case Qt::LinearGradientPattern:
+ case Qt::RadialGradientPattern:
+ case Qt::ConicalGradientPattern:
+ x.reset(new QGradientBrushData);
+ static_cast<QGradientBrushData *>(x.data())->gradient =
+ static_cast<QGradientBrushData *>(d.data())->gradient;
+ break;
+ default:
+ x.reset(new QBrushData);
+ break;
+ }
+ x->ref = 1;
+ x->style = newStyle;
+ x->color = d->color;
+ x->transform = d->transform;
+ d.reset(x.take());
+}
+
+
+/*!
+ \fn QBrush &QBrush::operator=(const QBrush &brush)
+
+ Assigns the given \a brush to \e this brush and returns a
+ reference to \e this brush.
+*/
+
+QBrush &QBrush::operator=(const QBrush &b)
+{
+ if (d == b.d)
+ return *this;
+
+ b.d->ref.ref();
+ d.reset(b.d.data());
+ return *this;
+}
+
+/*!
+ Returns the brush as a QVariant
+*/
+QBrush::operator QVariant() const
+{
+ return QVariant(QVariant::Brush, this);
+}
+
+/*!
+ \fn Qt::BrushStyle QBrush::style() const
+
+ Returns the brush style.
+
+ \sa setStyle()
+*/
+
+/*!
+ Sets the brush style to \a style.
+
+ \sa style()
+*/
+
+void QBrush::setStyle(Qt::BrushStyle style)
+{
+ if (d->style == style)
+ return;
+
+ if (qbrush_check_type(style)) {
+ detach(style);
+ d->style = style;
+ }
+}
+
+
+/*!
+ \fn const QColor &QBrush::color() const
+
+ Returns the brush color.
+
+ \sa setColor()
+*/
+
+/*!
+ \fn void QBrush::setColor(const QColor &color)
+
+ Sets the brush color to the given \a color.
+
+ Note that calling setColor() will not make a difference if the
+ style is a gradient. The same is the case if the style is
+ Qt::TexturePattern style unless the current texture is a QBitmap.
+
+ \sa color()
+*/
+
+void QBrush::setColor(const QColor &c)
+{
+ detach(d->style);
+ d->color = c;
+}
+
+/*!
+ \fn void QBrush::setColor(Qt::GlobalColor color)
+ \overload
+
+ Sets the brush color to the given \a color.
+*/
+
+
+#ifdef QT3_SUPPORT
+
+/*!
+ \fn void QBrush::setPixmap(const QPixmap &pixmap)
+
+ \compat
+
+ Sets a custom pattern for this brush.
+
+ Use setTexture() instead.
+*/
+
+/*!
+ \fn QPixmap *QBrush::pixmap() const
+
+ Returns a pointer to the custom brush pattern.
+
+ Use texture() instead.
+*/
+QPixmap *QBrush::pixmap() const
+{
+ if (d->style != Qt::TexturePattern)
+ return 0;
+ QTexturedBrushData *data = static_cast<QTexturedBrushData*>(d.data());
+ QPixmap &pixmap = data->pixmap();
+ return pixmap.isNull() ? 0 : &pixmap;
+}
+#endif
+
+/*!
+ \fn QPixmap QBrush::texture() const
+
+ Returns the custom brush pattern, or a null pixmap if no custom brush pattern
+ has been set.
+
+ \sa setTexture()
+*/
+QPixmap QBrush::texture() const
+{
+ return d->style == Qt::TexturePattern
+ ? (static_cast<QTexturedBrushData *>(d.data()))->pixmap()
+ : QPixmap();
+}
+
+/*!
+ Sets the brush pixmap to \a pixmap. The style is set to
+ Qt::TexturePattern.
+
+ The current brush color will only have an effect for monochrome
+ pixmaps, i.e. for QPixmap::depth() == 1 (\l {QBitmap}{QBitmaps}).
+
+ \sa texture()
+*/
+
+void QBrush::setTexture(const QPixmap &pixmap)
+{
+ if (!pixmap.isNull()) {
+ detach(Qt::TexturePattern);
+ QTexturedBrushData *data = static_cast<QTexturedBrushData *>(d.data());
+ data->setPixmap(pixmap);
+ } else {
+ detach(Qt::NoBrush);
+ }
+}
+
+
+/*!
+ \since 4.2
+
+ Returns the custom brush pattern, or a null image if no custom
+ brush pattern has been set.
+
+ If the texture was set as a QPixmap it will be converted to a
+ QImage.
+
+ \sa setTextureImage()
+*/
+
+QImage QBrush::textureImage() const
+{
+ return d->style == Qt::TexturePattern
+ ? (static_cast<QTexturedBrushData *>(d.data()))->image()
+ : QImage();
+}
+
+
+/*!
+ \since 4.2
+
+ Sets the brush image to \a image. The style is set to
+ Qt::TexturePattern.
+
+ Note the current brush color will \e not have any affect on
+ monochrome images, as opposed to calling setTexture() with a
+ QBitmap. If you want to change the color of monochrome image
+ brushes, either convert the image to QBitmap with \c
+ QBitmap::fromImage() and set the resulting QBitmap as a texture,
+ or change the entries in the color table for the image.
+
+ \sa textureImage(), setTexture()
+*/
+
+void QBrush::setTextureImage(const QImage &image)
+{
+ if (!image.isNull()) {
+ detach(Qt::TexturePattern);
+ QTexturedBrushData *data = static_cast<QTexturedBrushData *>(d.data());
+ data->setImage(image);
+ } else {
+ detach(Qt::NoBrush);
+ }
+}
+
+
+/*!
+ Returns the gradient describing this brush.
+*/
+const QGradient *QBrush::gradient() const
+{
+ if (d->style == Qt::LinearGradientPattern
+ || d->style == Qt::RadialGradientPattern
+ || d->style == Qt::ConicalGradientPattern) {
+ return &static_cast<const QGradientBrushData *>(d.data())->gradient;
+ }
+ return 0;
+}
+
+
+/*!
+ Returns true if the brush is fully opaque otherwise false. A brush
+ is considered opaque if:
+
+ \list
+ \i The alpha component of the color() is 255.
+ \i Its texture() does not have an alpha channel and is not a QBitmap.
+ \i The colors in the gradient() all have an alpha component that is 255.
+ \endlist
+*/
+
+bool QBrush::isOpaque() const
+{
+ bool opaqueColor = d->color.alpha() == 255;
+
+ // Test awfully simple case first
+ if (d->style == Qt::SolidPattern)
+ return opaqueColor;
+
+ if (d->style == Qt::LinearGradientPattern
+ || d->style == Qt::RadialGradientPattern
+ || d->style == Qt::ConicalGradientPattern) {
+ QGradientStops stops = gradient()->stops();
+ for (int i=0; i<stops.size(); ++i)
+ if (stops.at(i).second.alpha() != 255)
+ return false;
+ return true;
+ } else if (d->style == Qt::TexturePattern) {
+ return qHasPixmapTexture(*this)
+ ? !texture().hasAlphaChannel() && !texture().isQBitmap()
+ : !textureImage().hasAlphaChannel();
+ }
+
+ return false;
+}
+
+
+/*!
+ \since 4.2
+
+ Sets \a matrix as an explicit transformation matrix on the
+ current brush. The brush transformation matrix is merged with
+ QPainter transformation matrix to produce the final result.
+
+ \sa matrix()
+*/
+void QBrush::setMatrix(const QMatrix &matrix)
+{
+ setTransform(QTransform(matrix));
+}
+
+/*!
+ \since 4.3
+
+ Sets \a matrix as an explicit transformation matrix on the
+ current brush. The brush transformation matrix is merged with
+ QPainter transformation matrix to produce the final result.
+
+ \sa transform()
+*/
+void QBrush::setTransform(const QTransform &matrix)
+{
+ detach(d->style);
+ d->transform = matrix;
+}
+
+
+/*!
+ \fn void QBrush::matrix() const
+ \since 4.2
+
+ Returns the current transformation matrix for the brush.
+
+ \sa setMatrix()
+*/
+
+/*!
+ \fn bool QBrush::operator!=(const QBrush &brush) const
+
+ Returns true if the brush is different from the given \a brush;
+ otherwise returns false.
+
+ Two brushes are different if they have different styles, colors or
+ pixmaps.
+
+ \sa operator==()
+*/
+
+/*!
+ \fn bool QBrush::operator==(const QBrush &brush) const
+
+ Returns true if the brush is equal to the given \a brush;
+ otherwise returns false.
+
+ Two brushes are equal if they have equal styles, colors and
+ pixmaps.
+
+ \sa operator!=()
+*/
+
+bool QBrush::operator==(const QBrush &b) const
+{
+ if (b.d == d)
+ return true;
+ if (b.d->style == d->style && b.d->color == d->color) {
+ switch (d->style) {
+ case Qt::TexturePattern: {
+ QPixmap &us = (static_cast<QTexturedBrushData *>(d.data()))->pixmap();
+ QPixmap &them = (static_cast<QTexturedBrushData *>(b.d.data()))->pixmap();
+ return ((us.isNull() && them.isNull()) || us.cacheKey() == them.cacheKey());
+ }
+ case Qt::LinearGradientPattern:
+ case Qt::RadialGradientPattern:
+ case Qt::ConicalGradientPattern:
+ {
+ QGradientBrushData *d1 = static_cast<QGradientBrushData *>(d.data());
+ QGradientBrushData *d2 = static_cast<QGradientBrushData *>(b.d.data());
+ return d1->gradient == d2->gradient;
+ }
+ default:
+ return true;
+ }
+ }
+ return false;
+}
+
+/*!
+ \fn QBrush::operator const QColor&() const
+
+ Returns the brush's color.
+
+ Use color() instead.
+*/
+
+#ifndef QT_NO_DEBUG_STREAM
+/*!
+ \internal
+*/
+QDebug operator<<(QDebug dbg, const QBrush &b)
+{
+#ifndef Q_BROKEN_DEBUG_STREAM
+ dbg.nospace() << "QBrush(" << b.color() << ',' << b.style() << ')';
+ return dbg.space();
+#else
+ qWarning("This compiler doesn't support streaming QBrush to QDebug");
+ return dbg;
+ Q_UNUSED(b);
+#endif
+}
+#endif
+
+/*****************************************************************************
+ QBrush stream functions
+ *****************************************************************************/
+#ifndef QT_NO_DATASTREAM
+/*!
+ \fn QDataStream &operator<<(QDataStream &stream, const QBrush &brush)
+ \relates QBrush
+
+ Writes the given \a brush to the given \a stream and returns a
+ reference to the \a stream.
+
+ \sa {Format of the QDataStream Operators}
+*/
+
+QDataStream &operator<<(QDataStream &s, const QBrush &b)
+{
+ quint8 style = (quint8) b.style();
+ bool gradient_style = false;
+
+ if (style == Qt::LinearGradientPattern || style == Qt::RadialGradientPattern
+ || style == Qt::ConicalGradientPattern)
+ gradient_style = true;
+
+ if (s.version() < QDataStream::Qt_4_0 && gradient_style)
+ style = Qt::NoBrush;
+
+ s << style << b.color();
+ if (b.style() == Qt::TexturePattern) {
+ s << b.texture();
+ } else if (s.version() >= QDataStream::Qt_4_0 && gradient_style) {
+ const QGradient *gradient = b.gradient();
+ int type_as_int = int(gradient->type());
+ s << type_as_int;
+ if (s.version() >= QDataStream::Qt_4_3) {
+ s << int(gradient->spread());
+ s << int(gradient->coordinateMode());
+ }
+
+ if (s.version() >= QDataStream::Qt_4_5)
+ s << int(gradient->interpolationMode());
+
+ if (sizeof(qreal) == sizeof(double)) {
+ s << gradient->stops();
+ } else {
+ // ensure that we write doubles here instead of streaming the stops
+ // directly; otherwise, platforms that redefine qreal might generate
+ // data that cannot be read on other platforms.
+ QVector<QGradientStop> stops = gradient->stops();
+ s << quint32(stops.size());
+ for (int i = 0; i < stops.size(); ++i) {
+ const QGradientStop &stop = stops.at(i);
+ s << QPair<double, QColor>(double(stop.first), stop.second);
+ }
+ }
+
+ if (gradient->type() == QGradient::LinearGradient) {
+ s << static_cast<const QLinearGradient *>(gradient)->start();
+ s << static_cast<const QLinearGradient *>(gradient)->finalStop();
+ } else if (gradient->type() == QGradient::RadialGradient) {
+ s << static_cast<const QRadialGradient *>(gradient)->center();
+ s << static_cast<const QRadialGradient *>(gradient)->focalPoint();
+ s << (double) static_cast<const QRadialGradient *>(gradient)->radius();
+ } else { // type == Conical
+ s << static_cast<const QConicalGradient *>(gradient)->center();
+ s << (double) static_cast<const QConicalGradient *>(gradient)->angle();
+ }
+ }
+ if (s.version() >= QDataStream::Qt_4_3)
+ s << b.transform();
+ return s;
+}
+
+/*!
+ \fn QDataStream &operator>>(QDataStream &stream, QBrush &brush)
+ \relates QBrush
+
+ Reads the given \a brush from the given \a stream and returns a
+ reference to the \a stream.
+
+ \sa {Format of the QDataStream Operators}
+*/
+
+QDataStream &operator>>(QDataStream &s, QBrush &b)
+{
+ quint8 style;
+ QColor color;
+ s >> style;
+ s >> color;
+ if (style == Qt::TexturePattern) {
+ QPixmap pm;
+ s >> pm;
+ b = QBrush(color, pm);
+ } else if (style == Qt::LinearGradientPattern
+ || style == Qt::RadialGradientPattern
+ || style == Qt::ConicalGradientPattern) {
+
+ int type_as_int;
+ QGradient::Type type;
+ QGradientStops stops;
+ QGradient::CoordinateMode cmode = QGradient::LogicalMode;
+ QGradient::Spread spread = QGradient::PadSpread;
+ QGradient::InterpolationMode imode = QGradient::ColorInterpolation;
+
+ s >> type_as_int;
+ type = QGradient::Type(type_as_int);
+ if (s.version() >= QDataStream::Qt_4_3) {
+ s >> type_as_int;
+ spread = QGradient::Spread(type_as_int);
+ s >> type_as_int;
+ cmode = QGradient::CoordinateMode(type_as_int);
+ }
+
+ if (s.version() >= QDataStream::Qt_4_5) {
+ s >> type_as_int;
+ imode = QGradient::InterpolationMode(type_as_int);
+ }
+
+ if (sizeof(qreal) == sizeof(double)) {
+ s >> stops;
+ } else {
+ quint32 numStops;
+ double n;
+ QColor c;
+
+ s >> numStops;
+ for (quint32 i = 0; i < numStops; ++i) {
+ s >> n >> c;
+ stops << QPair<qreal, QColor>(n, c);
+ }
+ }
+
+ if (type == QGradient::LinearGradient) {
+ QPointF p1, p2;
+ s >> p1;
+ s >> p2;
+ QLinearGradient lg(p1, p2);
+ lg.setStops(stops);
+ lg.setSpread(spread);
+ lg.setCoordinateMode(cmode);
+ lg.setInterpolationMode(imode);
+ b = QBrush(lg);
+ } else if (type == QGradient::RadialGradient) {
+ QPointF center, focal;
+ double radius;
+ s >> center;
+ s >> focal;
+ s >> radius;
+ QRadialGradient rg(center, radius, focal);
+ rg.setStops(stops);
+ rg.setSpread(spread);
+ rg.setCoordinateMode(cmode);
+ rg.setInterpolationMode(imode);
+ b = QBrush(rg);
+ } else { // type == QGradient::ConicalGradient
+ QPointF center;
+ double angle;
+ s >> center;
+ s >> angle;
+ QConicalGradient cg(center, angle);
+ cg.setStops(stops);
+ cg.setSpread(spread);
+ cg.setCoordinateMode(cmode);
+ cg.setInterpolationMode(imode);
+ b = QBrush(cg);
+ }
+ } else {
+ b = QBrush(color, (Qt::BrushStyle)style);
+ }
+ if (s.version() >= QDataStream::Qt_4_3) {
+ QTransform transform;
+ s >> transform;
+ b.setTransform(transform);
+ }
+ return s;
+}
+#endif // QT_NO_DATASTREAM
+
+/*******************************************************************************
+ * QGradient implementations
+ */
+
+
+/*!
+ \class QGradient
+ \ingroup painting
+ \ingroup shared
+
+ \brief The QGradient class is used in combination with QBrush to
+ specify gradient fills.
+
+ Qt currently supports three types of gradient fills:
+
+ \list
+ \o \e Linear gradients interpolate colors between start and end points.
+ \o \e Radial gradients interpolate colors between a focal point and end
+ points on a circle surrounding it.
+ \o \e Conical gradients interpolate colors around a center point.
+ \endlist
+
+ A gradient's type can be retrieved using the type() function.
+ Each of the types is represented by a subclass of QGradient:
+
+ \table
+ \row
+ \o \inlineimage qgradient-linear.png
+ \o \inlineimage qgradient-radial.png
+ \o \inlineimage qgradient-conical.png
+ \header
+ \o QLinearGradient
+ \o QRadialGradient
+ \o QConicalGradient
+ \endtable
+
+ The colors in a gradient is defined using stop points of the
+ QGradientStop type, i.e. a position and a color. Use the
+ setColorAt() function to define a single stop
+ point. Alternatively, use the setStops() function to define
+ several stop points in one go. Note that the latter function \e
+ replaces the current set of stop points.
+
+ It is the gradient's complete set of stop points (accessible
+ through the stops() function) that describes how the gradient area
+ should be filled. If no stop points have been specified, a
+ gradient of black at 0 to white at 1 is used.
+
+ A diagonal linear gradient from black at (100, 100) to white at
+ (200, 200) could be specified like this:
+
+ \snippet doc/src/snippets/brush/brush.cpp 0
+
+ A gradient can have an arbitrary number of stop points. The
+ following would create a radial gradient starting with
+ red in the center, blue and then green on the edges:
+
+ \snippet doc/src/snippets/brush/brush.cpp 1
+
+ It is possible to repeat or reflect the gradient outside its area
+ by specifiying the \l {QGradient::Spread}{spread method} using the
+ setSpread() function. The default is to pad the outside area with
+ the color at the closest stop point. The currently set \l
+ {QGradient::Spread}{spread method} can be retrieved using the
+ spread() function. The QGradient::Spread enum defines three
+ different methods:
+
+ \table
+ \row
+ \o \inlineimage qradialgradient-pad.png
+ \o \inlineimage qradialgradient-repeat.png
+ \o \inlineimage qradialgradient-reflect.png
+ \row
+ \o \l {QGradient::PadSpread}{PadSpread}
+ \o \l {QGradient::RepeatSpread}{RepeatSpread}
+ \o \l {QGradient::ReflectSpread}{ReflectSpread}
+ \endtable
+
+ Note that the setSpread() function only has effect for linear and
+ radial gradients. The reason is that the conical gradient is
+ closed by definition, i.e. the \e conical gradient fills the
+ entire circle from 0 - 360 degrees, while the boundary of a radial
+ or a linear gradient can be specified through its radius or final
+ stop points, respectively.
+
+ The gradient coordinates can be specified in logical coordinates,
+ relative to device coordinates, or relative to object bounding box coordinates.
+ The \l {QGradient::CoordinateMode}{coordinate mode} can be set using the
+ setCoordinateMode() function. The default is LogicalMode, where the
+ gradient coordinates are specified in the same way as the object
+ coordinates. To retrieve the currently set \l {QGradient::CoordinateMode}
+ {coordinate mode} use coordinateMode().
+
+
+ \sa {demos/gradients}{The Gradients Demo}, QBrush
+*/
+
+/*!
+ \internal
+*/
+QGradient::QGradient()
+ : m_type(NoGradient), dummy(0)
+{
+}
+
+
+/*!
+ \enum QGradient::Type
+
+ Specifies the type of gradient.
+
+ \value LinearGradient Interpolates colors between start and end points
+ (QLinearGradient).
+
+ \value RadialGradient Interpolate colors between a focal point and end
+ points on a circle surrounding it (QRadialGradient).
+
+ \value ConicalGradient Interpolate colors around a center point (QConicalGradient).
+ \value NoGradient No gradient is used.
+
+ \sa type()
+*/
+
+/*!
+ \enum QGradient::Spread
+
+ Specifies how the area outside the gradient area should be
+ filled.
+
+ \value PadSpread The area is filled with the closest stop
+ color. This is the default.
+
+ \value RepeatSpread The gradient is repeated outside the gradient
+ area.
+
+ \value ReflectSpread The gradient is reflected outside the
+ gradient area.
+
+ \sa spread(), setSpread()
+*/
+
+/*!
+ \fn void QGradient::setSpread(Spread method)
+
+ Specifies the spread \a method that should be used for this
+ gradient.
+
+ Note that this function only has effect for linear and radial
+ gradients.
+
+ \sa spread()
+*/
+
+/*!
+ \fn QGradient::Spread QGradient::spread() const
+
+ Returns the spread method use by this gradient. The default is
+ PadSpread.
+
+ \sa setSpread()
+*/
+
+/*!
+ \fn QGradient::Type QGradient::type() const
+
+ Returns the type of gradient.
+*/
+
+/*!
+ \fn void QGradient::setColorAt(qreal position, const QColor &color)
+
+ Creates a stop point at the given \a position with the given \a
+ color. The given \a position must be in the range 0 to 1.
+
+ \sa setStops(), stops()
+*/
+
+void QGradient::setColorAt(qreal pos, const QColor &color)
+{
+ if (pos > 1 || pos < 0) {
+ qWarning("QGradient::setColorAt: Color position must be specified in the range 0 to 1");
+ return;
+ }
+
+ int index = 0;
+ while (index < m_stops.size() && m_stops.at(index).first < pos) ++index;
+
+ if (index < m_stops.size() && m_stops.at(index).first == pos)
+ m_stops[index].second = color;
+ else
+ m_stops.insert(index, QGradientStop(pos, color));
+}
+
+/*!
+ \fn void QGradient::setStops(const QGradientStops &stopPoints)
+
+ Replaces the current set of stop points with the given \a
+ stopPoints. The positions of the points must be in the range 0 to
+ 1, and must be sorted with the lowest point first.
+
+ \sa setColorAt(), stops()
+*/
+void QGradient::setStops(const QGradientStops &stops)
+{
+ m_stops.clear();
+ for (int i=0; i<stops.size(); ++i)
+ setColorAt(stops.at(i).first, stops.at(i).second);
+}
+
+
+/*!
+ Returns the stop points for this gradient.
+
+ If no stop points have been specified, a gradient of black at 0 to white
+ at 1 is used.
+
+ \sa setStops(), setColorAt()
+*/
+QGradientStops QGradient::stops() const
+{
+ if (m_stops.isEmpty()) {
+ QGradientStops tmp;
+ tmp << QGradientStop(0, Qt::black) << QGradientStop(1, Qt::white);
+ return tmp;
+ }
+ return m_stops;
+}
+
+#define Q_DUMMY_ACCESSOR union {void *p; uint i;}; p = dummy;
+
+/*!
+ \enum QGradient::CoordinateMode
+ \since 4.4
+
+ This enum specifies how gradient coordinates map to the paint
+ device on which the gradient is used.
+
+ \value LogicalMode This is the default mode. The gradient coordinates
+ are specified logical space just like the object coordinates.
+ \value StretchToDeviceMode In this mode the gradient coordinates
+ are relative to the bounding rectangle of the paint device,
+ with (0,0) in the top left corner, and (1,1) in the bottom right
+ corner of the paint device.
+ \value ObjectBoundingMode In this mode the gradient coordinates are
+ relative to the bounding rectangle of the object being drawn, with
+ (0,0) in the top left corner, and (1,1) in the bottom right corner
+ of the object's bounding rectangle.
+*/
+
+/*!
+ \since 4.4
+
+ Returns the coordinate mode of this gradient. The default mode is
+ LogicalMode.
+*/
+QGradient::CoordinateMode QGradient::coordinateMode() const
+{
+ Q_DUMMY_ACCESSOR
+ return CoordinateMode(i & 0x03);
+}
+
+/*!
+ \since 4.4
+
+ Sets the coordinate mode of this gradient to \a mode. The default
+ mode is LogicalMode.
+*/
+void QGradient::setCoordinateMode(CoordinateMode mode)
+{
+ Q_DUMMY_ACCESSOR
+ i &= ~0x03;
+ i |= uint(mode);
+ dummy = p;
+}
+
+/*!
+ \enum QGradient::InterpolationMode
+ \since 4.5
+ \internal
+
+ \value ComponentInterpolation The color components and the alpha component are
+ independently linearly interpolated.
+ \value ColorInterpolation The colors are linearly interpolated in
+ premultiplied color space.
+*/
+
+/*!
+ \since 4.5
+ \internal
+
+ Returns the interpolation mode of this gradient. The default mode is
+ ColorInterpolation.
+*/
+QGradient::InterpolationMode QGradient::interpolationMode() const
+{
+ Q_DUMMY_ACCESSOR
+ return InterpolationMode((i >> 2) & 0x01);
+}
+
+/*!
+ \since 4.5
+ \internal
+
+ Sets the interpolation mode of this gradient to \a mode. The default
+ mode is ColorInterpolation.
+*/
+void QGradient::setInterpolationMode(InterpolationMode mode)
+{
+ Q_DUMMY_ACCESSOR
+ i &= ~(1 << 2);
+ i |= (uint(mode) << 2);
+ dummy = p;
+}
+
+#undef Q_DUMMY_ACCESSOR
+
+/*!
+ \fn bool QGradient::operator!=(const QGradient &gradient) const
+ \since 4.2
+
+ Returns true if the gradient is the same as the other \a gradient
+ specified; otherwise returns false.
+
+ \sa operator==()
+*/
+
+/*!
+ Returns true if the gradient is the same as the other \a gradient
+ specified; otherwise returns false.
+
+ \sa operator!=()
+*/
+bool QGradient::operator==(const QGradient &gradient) const
+{
+ if (gradient.m_type != m_type
+ || gradient.m_spread != m_spread
+ || gradient.dummy != dummy) return false;
+
+ if (m_type == LinearGradient) {
+ if (m_data.linear.x1 != gradient.m_data.linear.x1
+ || m_data.linear.y1 != gradient.m_data.linear.y1
+ || m_data.linear.x2 != gradient.m_data.linear.x2
+ || m_data.linear.y2 != gradient.m_data.linear.y2)
+ return false;
+ } else if (m_type == RadialGradient) {
+ if (m_data.radial.cx != gradient.m_data.radial.cx
+ || m_data.radial.cy != gradient.m_data.radial.cy
+ || m_data.radial.fx != gradient.m_data.radial.fx
+ || m_data.radial.fy != gradient.m_data.radial.fy
+ || m_data.radial.radius != gradient.m_data.radial.radius)
+ return false;
+ } else { // m_type == ConicalGradient
+ if (m_data.conical.cx != gradient.m_data.conical.cx
+ || m_data.conical.cy != gradient.m_data.conical.cy
+ || m_data.conical.angle != gradient.m_data.conical.angle)
+ return false;
+ }
+
+ return stops() == gradient.stops();
+}
+
+/*!
+ \internal
+*/
+bool QGradient::operator==(const QGradient &gradient)
+{
+ return const_cast<const QGradient *>(this)->operator==(gradient);
+}
+
+/*!
+ \class QLinearGradient
+ \ingroup painting
+
+ \brief The QLinearGradient class is used in combination with QBrush to
+ specify a linear gradient brush.
+
+ Linear gradients interpolate colors between start and end
+ points. Outside these points the gradient is either padded,
+ reflected or repeated depending on the currently set \l
+ {QGradient::Spread}{spread} method:
+
+ \table
+ \row
+ \o \inlineimage qlineargradient-pad.png
+ \o \inlineimage qlineargradient-reflect.png
+ \o \inlineimage qlineargradient-repeat.png
+ \row
+ \o \l {QGradient::PadSpread}{PadSpread} (default)
+ \o \l {QGradient::ReflectSpread}{ReflectSpread}
+ \o \l {QGradient::RepeatSpread}{RepeatSpread}
+ \endtable
+
+ The colors in a gradient is defined using stop points of the
+ QGradientStop type, i.e. a position and a color. Use the
+ QGradient::setColorAt() or the QGradient::setStops() function to
+ define the stop points. It is the gradient's complete set of stop
+ points that describes how the gradient area should be filled. If
+ no stop points have been specified, a gradient of black at 0 to
+ white at 1 is used.
+
+ In addition to the functions inherited from QGradient, the
+ QLinearGradient class provides the finalStop() function which
+ returns the final stop point of the gradient, and the start()
+ function returning the start point of the gradient.
+
+ \sa QRadialGradient, QConicalGradient, {demos/gradients}{The
+ Gradients Demo}
+*/
+
+
+/*!
+ Constructs a default linear gradient with interpolation area
+ between (0, 0) and (1, 1).
+
+ \sa QGradient::setColorAt(), setStart(), setFinalStop()
+*/
+
+QLinearGradient::QLinearGradient()
+{
+ m_type = LinearGradient;
+ m_spread = PadSpread;
+ m_data.linear.x1 = 0;
+ m_data.linear.y1 = 0;
+ m_data.linear.x2 = 1;
+ m_data.linear.y2 = 1;
+}
+
+
+/*!
+ Constructs a linear gradient with interpolation area between the
+ given \a start point and \a finalStop.
+
+ \note The expected parameter values are in pixels.
+
+ \sa QGradient::setColorAt(), QGradient::setStops()
+*/
+QLinearGradient::QLinearGradient(const QPointF &start, const QPointF &finalStop)
+{
+ m_type = LinearGradient;
+ m_spread = PadSpread;
+ m_data.linear.x1 = start.x();
+ m_data.linear.y1 = start.y();
+ m_data.linear.x2 = finalStop.x();
+ m_data.linear.y2 = finalStop.y();
+}
+
+/*!
+ \fn QLinearGradient::QLinearGradient(qreal x1, qreal y1, qreal x2, qreal y2)
+
+ Constructs a linear gradient with interpolation area between (\a
+ x1, \a y1) and (\a x2, \a y2).
+
+ \note The expected parameter values are in pixels.
+
+ \sa QGradient::setColorAt(), QGradient::setStops()
+*/
+QLinearGradient::QLinearGradient(qreal xStart, qreal yStart, qreal xFinalStop, qreal yFinalStop)
+{
+ m_type = LinearGradient;
+ m_spread = PadSpread;
+ m_data.linear.x1 = xStart;
+ m_data.linear.y1 = yStart;
+ m_data.linear.x2 = xFinalStop;
+ m_data.linear.y2 = yFinalStop;
+}
+
+
+/*!
+ Returns the start point of this linear gradient in logical coordinates.
+
+ \sa QGradient::stops()
+*/
+
+QPointF QLinearGradient::start() const
+{
+ Q_ASSERT(m_type == LinearGradient);
+ return QPointF(m_data.linear.x1, m_data.linear.y1);
+}
+
+/*!
+ \fn void QLinearGradient::setStart(qreal x, qreal y)
+ \overload
+ \since 4.2
+
+ Sets the start point of this linear gradient in logical
+ coordinates to \a x, \a y.
+
+ \sa start()
+*/
+
+/*!
+ \since 4.2
+
+ Sets the start point of this linear gradient in logical
+ coordinates to \a start.
+
+ \sa start()
+*/
+
+void QLinearGradient::setStart(const QPointF &start)
+{
+ Q_ASSERT(m_type == LinearGradient);
+ m_data.linear.x1 = start.x();
+ m_data.linear.y1 = start.y();
+}
+
+
+/*!
+ \fn void QLinearGradient::setFinalStop(qreal x, qreal y)
+ \overload
+ \since 4.2
+
+ Sets the final stop point of this linear gradient in logical
+ coordinates to \a x, \a y.
+
+ \sa start()
+*/
+
+/*!
+ Returns the final stop point of this linear gradient in logical coordinates.
+
+ \sa QGradient::stops()
+*/
+
+QPointF QLinearGradient::finalStop() const
+{
+ Q_ASSERT(m_type == LinearGradient);
+ return QPointF(m_data.linear.x2, m_data.linear.y2);
+}
+
+
+/*!
+ \since 4.2
+
+ Sets the final stop point of this linear gradient in logical
+ coordinates to \a stop.
+
+ \sa finalStop()
+*/
+
+void QLinearGradient::setFinalStop(const QPointF &stop)
+{
+ Q_ASSERT(m_type == LinearGradient);
+ m_data.linear.x2 = stop.x();
+ m_data.linear.y2 = stop.y();
+}
+
+
+/*!
+ \class QRadialGradient
+ \ingroup painting
+
+ \brief The QRadialGradient class is used in combination with QBrush to
+ specify a radial gradient brush.
+
+ Radial gradients interpolate colors between a focal point and end
+ points on a circle surrounding it. Outside the end points the
+ gradient is either padded, reflected or repeated depending on the
+ currently set \l {QGradient::Spread}{spread} method:
+
+ \table
+ \row
+ \o \inlineimage qradialgradient-pad.png
+ \o \inlineimage qradialgradient-reflect.png
+ \o \inlineimage qradialgradient-repeat.png
+ \row
+ \o \l {QGradient::PadSpread}{PadSpread} (default)
+ \o \l {QGradient::ReflectSpread}{ReflectSpread}
+ \o \l {QGradient::RepeatSpread}{RepeatSpread}
+ \endtable
+
+ The colors in a gradient is defined using stop points of the
+ QGradientStop type, i.e. a position and a color. Use the
+ QGradient::setColorAt() or the QGradient::setStops() function to
+ define the stop points. It is the gradient's complete set of stop
+ points that describes how the gradient area should be filled. If
+ no stop points have been specified, a gradient of black at 0 to
+ white at 1 is used.
+
+ In addition to the functions inherited from QGradient, the
+ QRadialGradient class provides the center(), focalPoint() and
+ radius() functions returning the gradient's center, focal point
+ and radius respectively.
+
+ \sa QLinearGradient, QConicalGradient, {demos/gradients}{The
+ Gradients Demo}
+*/
+
+static QPointF qt_radial_gradient_adapt_focal_point(const QPointF ¢er,
+ qreal radius,
+ const QPointF &focalPoint)
+{
+ // We have a one pixel buffer zone to avoid numerical instability on the
+ // circle border
+ //### this is hacky because technically we should adjust based on current matrix
+ const qreal compensated_radius = radius - radius * 0.001;
+ QLineF line(center, focalPoint);
+ if (line.length() > (compensated_radius))
+ line.setLength(compensated_radius);
+ return line.p2();
+}
+
+/*!
+ Constructs a radial gradient with the given \a center, \a
+ radius and \a focalPoint.
+
+ \sa QGradient::setColorAt(), QGradient::setStops()
+*/
+
+QRadialGradient::QRadialGradient(const QPointF ¢er, qreal radius, const QPointF &focalPoint)
+{
+ m_type = RadialGradient;
+ m_spread = PadSpread;
+ m_data.radial.cx = center.x();
+ m_data.radial.cy = center.y();
+ m_data.radial.radius = radius;
+
+ QPointF adapted_focal = qt_radial_gradient_adapt_focal_point(center, radius, focalPoint);
+ m_data.radial.fx = adapted_focal.x();
+ m_data.radial.fy = adapted_focal.y();
+}
+
+/*!
+ Constructs a radial gradient with the given \a center, \a
+ radius and the focal point in the circle center.
+
+ \sa QGradient::setColorAt(), QGradient::setStops()
+*/
+QRadialGradient::QRadialGradient(const QPointF ¢er, qreal radius)
+{
+ m_type = RadialGradient;
+ m_spread = PadSpread;
+ m_data.radial.cx = center.x();
+ m_data.radial.cy = center.y();
+ m_data.radial.radius = radius;
+ m_data.radial.fx = center.x();
+ m_data.radial.fy = center.y();
+}
+
+
+/*!
+ Constructs a radial gradient with the given center (\a cx, \a cy),
+ \a radius and focal point (\a fx, \a fy).
+
+ \sa QGradient::setColorAt(), QGradient::setStops()
+*/
+
+QRadialGradient::QRadialGradient(qreal cx, qreal cy, qreal radius, qreal fx, qreal fy)
+{
+ m_type = RadialGradient;
+ m_spread = PadSpread;
+ m_data.radial.cx = cx;
+ m_data.radial.cy = cy;
+ m_data.radial.radius = radius;
+
+ QPointF adapted_focal = qt_radial_gradient_adapt_focal_point(QPointF(cx, cy),
+ radius,
+ QPointF(fx, fy));
+
+ m_data.radial.fx = adapted_focal.x();
+ m_data.radial.fy = adapted_focal.y();
+}
+
+/*!
+ Constructs a radial gradient with the center at (\a cx, \a cy) and the
+ specified \a radius. The focal point lies at the center of the circle.
+
+ \sa QGradient::setColorAt(), QGradient::setStops()
+ */
+QRadialGradient::QRadialGradient(qreal cx, qreal cy, qreal radius)
+{
+ m_type = RadialGradient;
+ m_spread = PadSpread;
+ m_data.radial.cx = cx;
+ m_data.radial.cy = cy;
+ m_data.radial.radius = radius;
+ m_data.radial.fx = cx;
+ m_data.radial.fy = cy;
+}
+
+
+/*!
+ Constructs a radial gradient with the center and focal point at
+ (0, 0) with a radius of 1.
+*/
+QRadialGradient::QRadialGradient()
+{
+ m_type = RadialGradient;
+ m_spread = PadSpread;
+ m_data.radial.cx = 0;
+ m_data.radial.cy = 0;
+ m_data.radial.radius = 1;
+ m_data.radial.fx = 0;
+ m_data.radial.fy = 0;
+}
+
+
+/*!
+ Returns the center of this radial gradient in logical coordinates.
+
+ \sa QGradient::stops()
+*/
+
+QPointF QRadialGradient::center() const
+{
+ Q_ASSERT(m_type == RadialGradient);
+ return QPointF(m_data.radial.cx, m_data.radial.cy);
+}
+
+/*!
+ \fn void QRadialGradient::setCenter(qreal x, qreal y)
+ \overload
+ \since 4.2
+
+ Sets the center of this radial gradient in logical coordinates
+ to (\a x, \a y).
+
+ \sa center()
+*/
+
+/*!
+ \since 4.2
+
+ Sets the center of this radial gradient in logical coordinates
+ to \a center.
+
+ \sa center()
+*/
+
+void QRadialGradient::setCenter(const QPointF ¢er)
+{
+ Q_ASSERT(m_type == RadialGradient);
+ m_data.radial.cx = center.x();
+ m_data.radial.cy = center.y();
+}
+
+
+/*!
+ Returns the radius of this radial gradient in logical coordinates.
+
+ \sa QGradient::stops()
+*/
+
+qreal QRadialGradient::radius() const
+{
+ Q_ASSERT(m_type == RadialGradient);
+ return m_data.radial.radius;
+}
+
+
+/*!
+ \since 4.2
+
+ Sets the radius of this radial gradient in logical coordinates
+ to \a radius
+*/
+void QRadialGradient::setRadius(qreal radius)
+{
+ Q_ASSERT(m_type == RadialGradient);
+ m_data.radial.radius = radius;
+}
+
+
+/*!
+ Returns the focal point of this radial gradient in logical
+ coordinates.
+
+ \sa QGradient::stops()
+*/
+
+QPointF QRadialGradient::focalPoint() const
+{
+ Q_ASSERT(m_type == RadialGradient);
+ return QPointF(m_data.radial.fx, m_data.radial.fy);
+}
+
+/*!
+ \fn void QRadialGradient::setFocalPoint(qreal x, qreal y)
+ \overload
+ \since 4.2
+
+ Sets the focal point of this radial gradient in logical
+ coordinates to (\a x, \a y).
+
+ \sa focalPoint()
+*/
+
+/*!
+ \since 4.2
+
+ Sets the focal point of this radial gradient in logical
+ coordinates to \a focalPoint.
+
+ \sa focalPoint()
+*/
+
+void QRadialGradient::setFocalPoint(const QPointF &focalPoint)
+{
+ Q_ASSERT(m_type == RadialGradient);
+ m_data.radial.fx = focalPoint.x();
+ m_data.radial.fy = focalPoint.y();
+}
+
+
+
+/*!
+ \class QConicalGradient
+ \ingroup painting
+
+ \brief The QConicalGradient class is used in combination with QBrush to
+ specify a conical gradient brush.
+
+ Conical gradients interpolate interpolate colors counter-clockwise
+ around a center point.
+
+ \image qconicalgradient.png
+
+ The colors in a gradient is defined using stop points of the
+ QGradientStop type, i.e. a position and a color. Use the
+ QGradient::setColorAt() or the QGradient::setStops() function to
+ define the stop points. It is the gradient's complete set of stop
+ points that describes how the gradient area should be filled. If
+ no stop points have been specified, a gradient of black at 0 to
+ white at 1 is used.
+
+ In addition to the functions inherited from QGradient, the
+ QConicalGradient class provides the angle() and center() functions
+ returning the start angle and center of the gradient.
+
+ Note that the setSpread() function has no effect for conical
+ gradients. The reason is that the conical gradient is closed by
+ definition, i.e. the conical gradient fills the entire circle from
+ 0 - 360 degrees, while the boundary of a radial or a linear
+ gradient can be specified through its radius or final stop points,
+ respectively.
+
+ \sa QLinearGradient, QRadialGradient, {demos/gradients}{The
+ Gradients Demo}
+*/
+
+
+/*!
+ Constructs a conical gradient with the given \a center, starting
+ the interpolation at the given \a angle. The \a angle must be
+ specified in degrees between 0 and 360.
+
+ \sa QGradient::setColorAt(), QGradient::setStops()
+*/
+
+QConicalGradient::QConicalGradient(const QPointF ¢er, qreal angle)
+{
+ m_type = ConicalGradient;
+ m_spread = PadSpread;
+ m_data.conical.cx = center.x();
+ m_data.conical.cy = center.y();
+ m_data.conical.angle = angle;
+}
+
+
+/*!
+ Constructs a conical gradient with the given center (\a cx, \a
+ cy), starting the interpolation at the given \a angle. The angle
+ must be specified in degrees between 0 and 360.
+
+ \sa QGradient::setColorAt(), QGradient::setStops()
+*/
+
+QConicalGradient::QConicalGradient(qreal cx, qreal cy, qreal angle)
+{
+ m_type = ConicalGradient;
+ m_spread = PadSpread;
+ m_data.conical.cx = cx;
+ m_data.conical.cy = cy;
+ m_data.conical.angle = angle;
+}
+
+
+/*!
+ Constructs a conical with center at (0, 0) starting the
+ interpolation at angle 0.
+
+ \sa QGradient::setColorAt(), setCenter(), setAngle()
+*/
+
+QConicalGradient::QConicalGradient()
+{
+ m_type = ConicalGradient;
+ m_spread = PadSpread;
+ m_data.conical.cx = 0;
+ m_data.conical.cy = 0;
+ m_data.conical.angle = 0;
+}
+
+
+/*!
+ Returns the center of the conical gradient in logical
+ coordinates.
+
+ \sa stops()
+*/
+
+QPointF QConicalGradient::center() const
+{
+ Q_ASSERT(m_type == ConicalGradient);
+ return QPointF(m_data.conical.cx, m_data.conical.cy);
+}
+
+
+/*!
+ \fn void QConicalGradient::setCenter(qreal x, qreal y)
+
+ \overload
+
+ Sets the center of this conical gradient in logical coordinates to
+ (\a x, \a y).
+
+ \sa center()
+*/
+
+/*!
+ Sets the center of this conical gradient in logical coordinates to
+ \a center.
+
+ \sa center()
+*/
+
+void QConicalGradient::setCenter(const QPointF ¢er)
+{
+ Q_ASSERT(m_type == ConicalGradient);
+ m_data.conical.cx = center.x();
+ m_data.conical.cy = center.y();
+}
+
+/*!
+ Returns the start angle of the conical gradient in logical
+ coordinates.
+
+ \sa stops()
+*/
+
+qreal QConicalGradient::angle() const
+{
+ Q_ASSERT(m_type == ConicalGradient);
+ return m_data.conical.angle;
+}
+
+
+/*!
+ \since 4.2
+
+ Sets \a angle to be the start angle for this conical gradient in
+ logical coordinates.
+
+ \sa angle()
+*/
+
+void QConicalGradient::setAngle(qreal angle)
+{
+ Q_ASSERT(m_type == ConicalGradient);
+ m_data.conical.angle = angle;
+}
+
+/*!
+ \typedef QGradientStop
+ \relates QGradient
+
+ Typedef for QPair<\l qreal, QColor>.
+*/
+
+/*!
+ \typedef QGradientStops
+ \relates QGradient
+
+ Typedef for QVector<QGradientStop>.
+*/
+
+/*!
+ \typedef QBrush::DataPtr
+ \internal
+*/
+
+/*!
+ \fn DataPtr &QBrush::data_ptr()
+ \internal
+*/
+
+
+/*!
+ \fn bool QBrush::isDetached() const
+ \internal
+*/
+
+/*!
+ \fn QTransform QBrush::transform() const
+ \since 4.3
+
+ Returns the current transformation matrix for the brush.
+
+ \sa setTransform()
+*/
+
+QT_END_NAMESPACE