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

**

** 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)

{