/**************************************************************************** ** ** Copyright (C) 2011 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 #include "private/qstylehelper_p.h" #include 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 = QLatin1Literal("$qt-brush$") % HexString(brushStyle) % QLatin1Char(invert ? '1' : '0'); 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(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(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(d); break; case Qt::LinearGradientPattern: case Qt::RadialGradientPattern: case Qt::ConicalGradientPattern: delete static_cast(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 the \l{Paint System}. \sa Qt::BrushStyle, QPainter, QColor */ #ifndef QT_NO_THREAD // Special deleter that only deletes if the ref-count goes to zero template <> class QGlobalStaticDeleter { public: QGlobalStatic &globalStatic; QGlobalStaticDeleter(QGlobalStatic &_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(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 x; switch(newStyle) { case Qt::TexturePattern: { QTexturedBrushData *tbd = new QTexturedBrushData; if (d->style == Qt::TexturePattern) { QTexturedBrushData *data = static_cast(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(x.data())->gradient = static_cast(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(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(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(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(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(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(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; istyle == 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 transforms or different pixmaps or gradients depending on the style. \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 transforms and equal pixmaps or gradients depending on the style. \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 || b.d->transform != d->transform) return false; switch (d->style) { case Qt::TexturePattern: { const QPixmap &us = (static_cast(d.data()))->pixmap(); const QPixmap &them = (static_cast(b.d.data()))->pixmap(); return ((us.isNull() && them.isNull()) || us.cacheKey() == them.cacheKey()); } case Qt::LinearGradientPattern: case Qt::RadialGradientPattern: case Qt::ConicalGradientPattern: { const QGradientBrushData *d1 = static_cast(d.data()); const QGradientBrushData *d2 = static_cast(b.d.data()); return d1->gradient == d2->gradient; } default: return true; } } /*! \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 static const char *BRUSH_STYLES[] = { "NoBrush", "SolidPattern", "Dense1Pattern", "Dense2Pattern", "Dense3Pattern", "Dense4Pattern", "Dense5Pattern", "Dense6Pattern", "Dense7Pattern", "HorPattern", "VerPattern", "CrossPattern", "BDiagPattern", "FDiagPattern", "DiagCrossPattern", "LinearGradientPattern", "RadialGradientPattern", "ConicalGradientPattern", 0, 0, 0, 0, 0, 0, "TexturePattern" // 24 }; dbg.nospace() << "QBrush(" << b.color() << ',' << BRUSH_STYLES[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 {Serializing Qt Data Types} */ 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 stops = gradient->stops(); s << quint32(stops.size()); for (int i = 0; i < stops.size(); ++i) { const QGradientStop &stop = stops.at(i); s << QPair(double(stop.first), stop.second); } } if (gradient->type() == QGradient::LinearGradient) { s << static_cast(gradient)->start(); s << static_cast(gradient)->finalStop(); } else if (gradient->type() == QGradient::RadialGradient) { s << static_cast(gradient)->center(); s << static_cast(gradient)->focalPoint(); s << (double) static_cast(gradient)->radius(); } else { // type == Conical s << static_cast(gradient)->center(); s << (double) static_cast(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 {Serializing Qt Data Types} */ 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(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 \header \o QLinearGradient \o QRadialGradient \o QConicalGradient \row \o \inlineimage qgradient-linear.png \o \inlineimage qgradient-radial.png \o \inlineimage qgradient-conical.png \endtable The colors in a gradient are 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) && !qIsNaN(pos)) { qWarning("QGradient::setColorAt: Color position must be specified in the range 0 to 1"); return; } int index = 0; if (!qIsNaN(pos)) 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> 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(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. */ /*! \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