/****************************************************************************+
−
**+
−
** Copyright (C) 2010 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+
−
    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<QTexturedBrushData *>(d.data()))->pixmap();+
−
            const 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:+
−
        {+
−
            const QGradientBrushData *d1 = static_cast<QGradientBrushData *>(d.data());+
−
            const QGradientBrushData *d2 = static_cast<QGradientBrushData *>(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 {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 &center,+
−
                                                    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 &center, 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 &center, 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 &center)+
−
{+
−
    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 &center, 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 &center)+
−
{+
−
    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+
−