/****************************************************************************
**
** 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>
#include "private/qstylehelper_p.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 = QLatin1Literal("$qt-brush$")
% HexString<uint>(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<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 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<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 {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<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 {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<qreal, QColor>(n, c);
}
}
if (type == QGradient::LinearGradient) {
QPointF p1, p2;
s >> p1;
s >> p2;
QLinearGradient lg(p1, p2);
lg.setStops(stops);
lg.setSpread(spread);
lg.setCoordinateMode(cmode);
lg.setInterpolationMode(imode);
b = QBrush(lg);
} else if (type == QGradient::RadialGradient) {
QPointF center, focal;
double radius;
s >> center;
s >> focal;
s >> radius;
QRadialGradient rg(center, radius, focal);
rg.setStops(stops);
rg.setSpread(spread);
rg.setCoordinateMode(cmode);
rg.setInterpolationMode(imode);
b = QBrush(rg);
} else { // type == QGradient::ConicalGradient
QPointF center;
double angle;
s >> center;
s >> angle;
QConicalGradient cg(center, angle);
cg.setStops(stops);
cg.setSpread(spread);
cg.setCoordinateMode(cmode);
cg.setInterpolationMode(imode);
b = QBrush(cg);
}
} else {
b = QBrush(color, (Qt::BrushStyle)style);
}
if (s.version() >= QDataStream::Qt_4_3) {
QTransform transform;
s >> transform;
b.setTransform(transform);
}
return s;
}
#endif // QT_NO_DATASTREAM
/*******************************************************************************
* QGradient implementations
*/
/*!
\class QGradient
\ingroup painting
\ingroup shared
\brief The QGradient class is used in combination with QBrush to
specify gradient fills.
Qt currently supports three types of gradient fills:
\list
\o \e Linear gradients interpolate colors between start and end points.
\o \e Radial gradients interpolate colors between a focal point and end
points on a circle surrounding it.
\o \e Conical gradients interpolate colors around a center point.
\endlist
A gradient's type can be retrieved using the type() function.
Each of the types is represented by a subclass of QGradient:
\table
\row
\o \inlineimage qgradient-linear.png
\o \inlineimage qgradient-radial.png
\o \inlineimage qgradient-conical.png
\header
\o QLinearGradient
\o QRadialGradient
\o QConicalGradient
\endtable
The colors in a gradient is defined using stop points of the
QGradientStop type, i.e. a position and a color. Use the
setColorAt() function to define a single stop
point. Alternatively, use the setStops() function to define
several stop points in one go. Note that the latter function \e
replaces the current set of stop points.
It is the gradient's complete set of stop points (accessible
through the stops() function) that describes how the gradient area
should be filled. If no stop points have been specified, a
gradient of black at 0 to white at 1 is used.
A diagonal linear gradient from black at (100, 100) to white at
(200, 200) could be specified like this:
\snippet doc/src/snippets/brush/brush.cpp 0
A gradient can have an arbitrary number of stop points. The
following would create a radial gradient starting with
red in the center, blue and then green on the edges:
\snippet doc/src/snippets/brush/brush.cpp 1
It is possible to repeat or reflect the gradient outside its area
by specifiying the \l {QGradient::Spread}{spread method} using the
setSpread() function. The default is to pad the outside area with
the color at the closest stop point. The currently set \l
{QGradient::Spread}{spread method} can be retrieved using the
spread() function. The QGradient::Spread enum defines three
different methods:
\table
\row
\o \inlineimage qradialgradient-pad.png
\o \inlineimage qradialgradient-repeat.png
\o \inlineimage qradialgradient-reflect.png
\row
\o \l {QGradient::PadSpread}{PadSpread}
\o \l {QGradient::RepeatSpread}{RepeatSpread}
\o \l {QGradient::ReflectSpread}{ReflectSpread}
\endtable
Note that the setSpread() function only has effect for linear and
radial gradients. The reason is that the conical gradient is
closed by definition, i.e. the \e conical gradient fills the
entire circle from 0 - 360 degrees, while the boundary of a radial
or a linear gradient can be specified through its radius or final
stop points, respectively.
The gradient coordinates can be specified in logical coordinates,
relative to device coordinates, or relative to object bounding box coordinates.
The \l {QGradient::CoordinateMode}{coordinate mode} can be set using the
setCoordinateMode() function. The default is LogicalMode, where the
gradient coordinates are specified in the same way as the object
coordinates. To retrieve the currently set \l {QGradient::CoordinateMode}
{coordinate mode} use coordinateMode().
\sa {demos/gradients}{The Gradients Demo}, QBrush
*/
/*!
\internal
*/
QGradient::QGradient()
: m_type(NoGradient), dummy(0)
{
}
/*!
\enum QGradient::Type
Specifies the type of gradient.
\value LinearGradient Interpolates colors between start and end points
(QLinearGradient).
\value RadialGradient Interpolate colors between a focal point and end
points on a circle surrounding it (QRadialGradient).
\value ConicalGradient Interpolate colors around a center point (QConicalGradient).
\value NoGradient No gradient is used.
\sa type()
*/
/*!
\enum QGradient::Spread
Specifies how the area outside the gradient area should be
filled.
\value PadSpread The area is filled with the closest stop
color. This is the default.
\value RepeatSpread The gradient is repeated outside the gradient
area.
\value ReflectSpread The gradient is reflected outside the
gradient area.
\sa spread(), setSpread()
*/
/*!
\fn void QGradient::setSpread(Spread method)
Specifies the spread \a method that should be used for this
gradient.
Note that this function only has effect for linear and radial
gradients.
\sa spread()
*/
/*!
\fn QGradient::Spread QGradient::spread() const
Returns the spread method use by this gradient. The default is
PadSpread.
\sa setSpread()
*/
/*!
\fn QGradient::Type QGradient::type() const
Returns the type of gradient.
*/
/*!
\fn void QGradient::setColorAt(qreal position, const QColor &color)
Creates a stop point at the given \a position with the given \a
color. The given \a position must be in the range 0 to 1.
\sa setStops(), stops()
*/
void QGradient::setColorAt(qreal pos, const QColor &color)
{
if (pos > 1 || pos < 0) {
qWarning("QGradient::setColorAt: Color position must be specified in the range 0 to 1");
return;
}
int index = 0;
while (index < m_stops.size() && m_stops.at(index).first < pos) ++index;
if (index < m_stops.size() && m_stops.at(index).first == pos)
m_stops[index].second = color;
else
m_stops.insert(index, QGradientStop(pos, color));
}
/*!
\fn void QGradient::setStops(const QGradientStops &stopPoints)
Replaces the current set of stop points with the given \a
stopPoints. The positions of the points must be in the range 0 to
1, and must be sorted with the lowest point first.
\sa setColorAt(), stops()
*/
void QGradient::setStops(const QGradientStops &stops)
{
m_stops.clear();
for (int i=0; i<stops.size(); ++i)
setColorAt(stops.at(i).first, stops.at(i).second);
}
/*!
Returns the stop points for this gradient.
If no stop points have been specified, a gradient of black at 0 to white
at 1 is used.
\sa setStops(), setColorAt()
*/
QGradientStops QGradient::stops() const
{
if (m_stops.isEmpty()) {
QGradientStops tmp;
tmp << QGradientStop(0, Qt::black) << QGradientStop(1, Qt::white);
return tmp;
}
return m_stops;
}
#define Q_DUMMY_ACCESSOR union {void *p; uint i;}; p = dummy;
/*!
\enum QGradient::CoordinateMode
\since 4.4
This enum specifies how gradient coordinates map to the paint
device on which the gradient is used.
\value LogicalMode This is the default mode. The gradient coordinates
are specified logical space just like the object coordinates.
\value StretchToDeviceMode In this mode the gradient coordinates
are relative to the bounding rectangle of the paint device,
with (0,0) in the top left corner, and (1,1) in the bottom right
corner of the paint device.
\value ObjectBoundingMode In this mode the gradient coordinates are
relative to the bounding rectangle of the object being drawn, with
(0,0) in the top left corner, and (1,1) in the bottom right corner
of the object's bounding rectangle.
*/
/*!
\since 4.4
Returns the coordinate mode of this gradient. The default mode is
LogicalMode.
*/
QGradient::CoordinateMode QGradient::coordinateMode() const
{
Q_DUMMY_ACCESSOR
return CoordinateMode(i & 0x03);
}
/*!
\since 4.4
Sets the coordinate mode of this gradient to \a mode. The default
mode is LogicalMode.
*/
void QGradient::setCoordinateMode(CoordinateMode mode)
{
Q_DUMMY_ACCESSOR
i &= ~0x03;
i |= uint(mode);
dummy = p;
}
/*!
\enum QGradient::InterpolationMode
\since 4.5
\internal
\value ComponentInterpolation The color components and the alpha component are
independently linearly interpolated.
\value ColorInterpolation The colors are linearly interpolated in
premultiplied color space.
*/
/*!
\since 4.5
\internal
Returns the interpolation mode of this gradient. The default mode is
ColorInterpolation.
*/
QGradient::InterpolationMode QGradient::interpolationMode() const
{
Q_DUMMY_ACCESSOR
return InterpolationMode((i >> 2) & 0x01);
}
/*!
\since 4.5
\internal
Sets the interpolation mode of this gradient to \a mode. The default
mode is ColorInterpolation.
*/
void QGradient::setInterpolationMode(InterpolationMode mode)
{
Q_DUMMY_ACCESSOR
i &= ~(1 << 2);
i |= (uint(mode) << 2);
dummy = p;
}
#undef Q_DUMMY_ACCESSOR
/*!
\fn bool QGradient::operator!=(const QGradient &gradient) const
\since 4.2
Returns true if the gradient is the same as the other \a gradient
specified; otherwise returns false.
\sa operator==()
*/
/*!
Returns true if the gradient is the same as the other \a gradient
specified; otherwise returns false.
\sa operator!=()
*/
bool QGradient::operator==(const QGradient &gradient) const
{
if (gradient.m_type != m_type
|| gradient.m_spread != m_spread
|| gradient.dummy != dummy) return false;
if (m_type == LinearGradient) {
if (m_data.linear.x1 != gradient.m_data.linear.x1
|| m_data.linear.y1 != gradient.m_data.linear.y1
|| m_data.linear.x2 != gradient.m_data.linear.x2
|| m_data.linear.y2 != gradient.m_data.linear.y2)
return false;
} else if (m_type == RadialGradient) {
if (m_data.radial.cx != gradient.m_data.radial.cx
|| m_data.radial.cy != gradient.m_data.radial.cy
|| m_data.radial.fx != gradient.m_data.radial.fx
|| m_data.radial.fy != gradient.m_data.radial.fy
|| m_data.radial.radius != gradient.m_data.radial.radius)
return false;
} else { // m_type == ConicalGradient
if (m_data.conical.cx != gradient.m_data.conical.cx
|| m_data.conical.cy != gradient.m_data.conical.cy
|| m_data.conical.angle != gradient.m_data.conical.angle)
return false;
}
return stops() == gradient.stops();
}
/*!
\internal
*/
bool QGradient::operator==(const QGradient &gradient)
{
return const_cast<const QGradient *>(this)->operator==(gradient);
}
/*!
\class QLinearGradient
\ingroup painting
\brief The QLinearGradient class is used in combination with QBrush to
specify a linear gradient brush.
Linear gradients interpolate colors between start and end
points. Outside these points the gradient is either padded,
reflected or repeated depending on the currently set \l
{QGradient::Spread}{spread} method:
\table
\row
\o \inlineimage qlineargradient-pad.png
\o \inlineimage qlineargradient-reflect.png
\o \inlineimage qlineargradient-repeat.png
\row
\o \l {QGradient::PadSpread}{PadSpread} (default)
\o \l {QGradient::ReflectSpread}{ReflectSpread}
\o \l {QGradient::RepeatSpread}{RepeatSpread}
\endtable
The colors in a gradient is defined using stop points of the
QGradientStop type, i.e. a position and a color. Use the
QGradient::setColorAt() or the QGradient::setStops() function to
define the stop points. It is the gradient's complete set of stop
points that describes how the gradient area should be filled. If
no stop points have been specified, a gradient of black at 0 to
white at 1 is used.
In addition to the functions inherited from QGradient, the
QLinearGradient class provides the finalStop() function which
returns the final stop point of the gradient, and the start()
function returning the start point of the gradient.
\sa QRadialGradient, QConicalGradient, {demos/gradients}{The
Gradients Demo}
*/
/*!
Constructs a default linear gradient with interpolation area
between (0, 0) and (1, 1).
\sa QGradient::setColorAt(), setStart(), setFinalStop()
*/
QLinearGradient::QLinearGradient()
{
m_type = LinearGradient;
m_spread = PadSpread;
m_data.linear.x1 = 0;
m_data.linear.y1 = 0;
m_data.linear.x2 = 1;
m_data.linear.y2 = 1;
}
/*!
Constructs a linear gradient with interpolation area between the
given \a start point and \a finalStop.
\note The expected parameter values are in pixels.
\sa QGradient::setColorAt(), QGradient::setStops()
*/
QLinearGradient::QLinearGradient(const QPointF &start, const QPointF &finalStop)
{
m_type = LinearGradient;
m_spread = PadSpread;
m_data.linear.x1 = start.x();
m_data.linear.y1 = start.y();
m_data.linear.x2 = finalStop.x();
m_data.linear.y2 = finalStop.y();
}
/*!
\fn QLinearGradient::QLinearGradient(qreal x1, qreal y1, qreal x2, qreal y2)
Constructs a linear gradient with interpolation area between (\a
x1, \a y1) and (\a x2, \a y2).
\note The expected parameter values are in pixels.
\sa QGradient::setColorAt(), QGradient::setStops()
*/
QLinearGradient::QLinearGradient(qreal xStart, qreal yStart, qreal xFinalStop, qreal yFinalStop)
{
m_type = LinearGradient;
m_spread = PadSpread;
m_data.linear.x1 = xStart;
m_data.linear.y1 = yStart;
m_data.linear.x2 = xFinalStop;
m_data.linear.y2 = yFinalStop;
}
/*!
Returns the start point of this linear gradient in logical coordinates.
\sa QGradient::stops()
*/
QPointF QLinearGradient::start() const
{
Q_ASSERT(m_type == LinearGradient);
return QPointF(m_data.linear.x1, m_data.linear.y1);
}
/*!
\fn void QLinearGradient::setStart(qreal x, qreal y)
\overload
\since 4.2
Sets the start point of this linear gradient in logical
coordinates to \a x, \a y.
\sa start()
*/
/*!
\since 4.2
Sets the start point of this linear gradient in logical
coordinates to \a start.
\sa start()
*/
void QLinearGradient::setStart(const QPointF &start)
{
Q_ASSERT(m_type == LinearGradient);
m_data.linear.x1 = start.x();
m_data.linear.y1 = start.y();
}
/*!
\fn void QLinearGradient::setFinalStop(qreal x, qreal y)
\overload
\since 4.2
Sets the final stop point of this linear gradient in logical
coordinates to \a x, \a y.
\sa start()
*/
/*!
Returns the final stop point of this linear gradient in logical coordinates.
\sa QGradient::stops()
*/
QPointF QLinearGradient::finalStop() const
{
Q_ASSERT(m_type == LinearGradient);
return QPointF(m_data.linear.x2, m_data.linear.y2);
}
/*!
\since 4.2
Sets the final stop point of this linear gradient in logical
coordinates to \a stop.
\sa finalStop()
*/
void QLinearGradient::setFinalStop(const QPointF &stop)
{
Q_ASSERT(m_type == LinearGradient);
m_data.linear.x2 = stop.x();
m_data.linear.y2 = stop.y();
}
/*!
\class QRadialGradient
\ingroup painting
\brief The QRadialGradient class is used in combination with QBrush to
specify a radial gradient brush.
Radial gradients interpolate colors between a focal point and end
points on a circle surrounding it. Outside the end points the
gradient is either padded, reflected or repeated depending on the
currently set \l {QGradient::Spread}{spread} method:
\table
\row
\o \inlineimage qradialgradient-pad.png
\o \inlineimage qradialgradient-reflect.png
\o \inlineimage qradialgradient-repeat.png
\row
\o \l {QGradient::PadSpread}{PadSpread} (default)
\o \l {QGradient::ReflectSpread}{ReflectSpread}
\o \l {QGradient::RepeatSpread}{RepeatSpread}
\endtable
The colors in a gradient is defined using stop points of the
QGradientStop type, i.e. a position and a color. Use the
QGradient::setColorAt() or the QGradient::setStops() function to
define the stop points. It is the gradient's complete set of stop
points that describes how the gradient area should be filled. If
no stop points have been specified, a gradient of black at 0 to
white at 1 is used.
In addition to the functions inherited from QGradient, the
QRadialGradient class provides the center(), focalPoint() and
radius() functions returning the gradient's center, focal point
and radius respectively.
\sa QLinearGradient, QConicalGradient, {demos/gradients}{The
Gradients Demo}
*/
static QPointF qt_radial_gradient_adapt_focal_point(const QPointF ¢er,
qreal radius,
const QPointF &focalPoint)
{
// We have a one pixel buffer zone to avoid numerical instability on the
// circle border
//### this is hacky because technically we should adjust based on current matrix
const qreal compensated_radius = radius - radius * 0.001;
QLineF line(center, focalPoint);
if (line.length() > (compensated_radius))
line.setLength(compensated_radius);
return line.p2();
}
/*!
Constructs a radial gradient with the given \a center, \a
radius and \a focalPoint.
\sa QGradient::setColorAt(), QGradient::setStops()
*/
QRadialGradient::QRadialGradient(const QPointF ¢er, qreal radius, const QPointF &focalPoint)
{
m_type = RadialGradient;
m_spread = PadSpread;
m_data.radial.cx = center.x();
m_data.radial.cy = center.y();
m_data.radial.radius = radius;
QPointF adapted_focal = qt_radial_gradient_adapt_focal_point(center, radius, focalPoint);
m_data.radial.fx = adapted_focal.x();
m_data.radial.fy = adapted_focal.y();
}
/*!
Constructs a radial gradient with the given \a center, \a
radius and the focal point in the circle center.
\sa QGradient::setColorAt(), QGradient::setStops()
*/
QRadialGradient::QRadialGradient(const QPointF ¢er, qreal radius)
{
m_type = RadialGradient;
m_spread = PadSpread;
m_data.radial.cx = center.x();
m_data.radial.cy = center.y();
m_data.radial.radius = radius;
m_data.radial.fx = center.x();
m_data.radial.fy = center.y();
}
/*!
Constructs a radial gradient with the given center (\a cx, \a cy),
\a radius and focal point (\a fx, \a fy).
\sa QGradient::setColorAt(), QGradient::setStops()
*/
QRadialGradient::QRadialGradient(qreal cx, qreal cy, qreal radius, qreal fx, qreal fy)
{
m_type = RadialGradient;
m_spread = PadSpread;
m_data.radial.cx = cx;
m_data.radial.cy = cy;
m_data.radial.radius = radius;
QPointF adapted_focal = qt_radial_gradient_adapt_focal_point(QPointF(cx, cy),
radius,
QPointF(fx, fy));
m_data.radial.fx = adapted_focal.x();
m_data.radial.fy = adapted_focal.y();
}
/*!
Constructs a radial gradient with the center at (\a cx, \a cy) and the
specified \a radius. The focal point lies at the center of the circle.
\sa QGradient::setColorAt(), QGradient::setStops()
*/
QRadialGradient::QRadialGradient(qreal cx, qreal cy, qreal radius)
{
m_type = RadialGradient;
m_spread = PadSpread;
m_data.radial.cx = cx;
m_data.radial.cy = cy;
m_data.radial.radius = radius;
m_data.radial.fx = cx;
m_data.radial.fy = cy;
}
/*!
Constructs a radial gradient with the center and focal point at
(0, 0) with a radius of 1.
*/
QRadialGradient::QRadialGradient()
{
m_type = RadialGradient;
m_spread = PadSpread;
m_data.radial.cx = 0;
m_data.radial.cy = 0;
m_data.radial.radius = 1;
m_data.radial.fx = 0;
m_data.radial.fy = 0;
}
/*!
Returns the center of this radial gradient in logical coordinates.
\sa QGradient::stops()
*/
QPointF QRadialGradient::center() const
{
Q_ASSERT(m_type == RadialGradient);
return QPointF(m_data.radial.cx, m_data.radial.cy);
}
/*!
\fn void QRadialGradient::setCenter(qreal x, qreal y)
\overload
\since 4.2
Sets the center of this radial gradient in logical coordinates
to (\a x, \a y).
\sa center()
*/
/*!
\since 4.2
Sets the center of this radial gradient in logical coordinates
to \a center.
\sa center()
*/
void QRadialGradient::setCenter(const QPointF ¢er)
{
Q_ASSERT(m_type == RadialGradient);
m_data.radial.cx = center.x();
m_data.radial.cy = center.y();
}
/*!
Returns the radius of this radial gradient in logical coordinates.
\sa QGradient::stops()
*/
qreal QRadialGradient::radius() const
{
Q_ASSERT(m_type == RadialGradient);
return m_data.radial.radius;
}
/*!
\since 4.2
Sets the radius of this radial gradient in logical coordinates
to \a radius
*/
void QRadialGradient::setRadius(qreal radius)
{
Q_ASSERT(m_type == RadialGradient);
m_data.radial.radius = radius;
}
/*!
Returns the focal point of this radial gradient in logical
coordinates.
\sa QGradient::stops()
*/
QPointF QRadialGradient::focalPoint() const
{
Q_ASSERT(m_type == RadialGradient);
return QPointF(m_data.radial.fx, m_data.radial.fy);
}
/*!
\fn void QRadialGradient::setFocalPoint(qreal x, qreal y)
\overload
\since 4.2
Sets the focal point of this radial gradient in logical
coordinates to (\a x, \a y).
\sa focalPoint()
*/
/*!
\since 4.2
Sets the focal point of this radial gradient in logical
coordinates to \a focalPoint.
\sa focalPoint()
*/
void QRadialGradient::setFocalPoint(const QPointF &focalPoint)
{
Q_ASSERT(m_type == RadialGradient);
m_data.radial.fx = focalPoint.x();
m_data.radial.fy = focalPoint.y();
}
/*!
\class QConicalGradient
\ingroup painting
\brief The QConicalGradient class is used in combination with QBrush to
specify a conical gradient brush.
Conical gradients interpolate interpolate colors counter-clockwise
around a center point.
\image qconicalgradient.png
The colors in a gradient is defined using stop points of the
QGradientStop type, i.e. a position and a color. Use the
QGradient::setColorAt() or the QGradient::setStops() function to
define the stop points. It is the gradient's complete set of stop
points that describes how the gradient area should be filled. If
no stop points have been specified, a gradient of black at 0 to
white at 1 is used.
In addition to the functions inherited from QGradient, the
QConicalGradient class provides the angle() and center() functions
returning the start angle and center of the gradient.
Note that the setSpread() function has no effect for conical
gradients. The reason is that the conical gradient is closed by
definition, i.e. the conical gradient fills the entire circle from
0 - 360 degrees, while the boundary of a radial or a linear
gradient can be specified through its radius or final stop points,
respectively.
\sa QLinearGradient, QRadialGradient, {demos/gradients}{The
Gradients Demo}
*/
/*!
Constructs a conical gradient with the given \a center, starting
the interpolation at the given \a angle. The \a angle must be
specified in degrees between 0 and 360.
\sa QGradient::setColorAt(), QGradient::setStops()
*/
QConicalGradient::QConicalGradient(const QPointF ¢er, qreal angle)
{
m_type = ConicalGradient;
m_spread = PadSpread;
m_data.conical.cx = center.x();
m_data.conical.cy = center.y();
m_data.conical.angle = angle;
}
/*!
Constructs a conical gradient with the given center (\a cx, \a
cy), starting the interpolation at the given \a angle. The angle
must be specified in degrees between 0 and 360.
\sa QGradient::setColorAt(), QGradient::setStops()
*/
QConicalGradient::QConicalGradient(qreal cx, qreal cy, qreal angle)
{
m_type = ConicalGradient;
m_spread = PadSpread;
m_data.conical.cx = cx;
m_data.conical.cy = cy;
m_data.conical.angle = angle;
}
/*!
Constructs a conical with center at (0, 0) starting the
interpolation at angle 0.
\sa QGradient::setColorAt(), setCenter(), setAngle()
*/
QConicalGradient::QConicalGradient()
{
m_type = ConicalGradient;
m_spread = PadSpread;
m_data.conical.cx = 0;
m_data.conical.cy = 0;
m_data.conical.angle = 0;
}
/*!
Returns the center of the conical gradient in logical
coordinates.
\sa stops()
*/
QPointF QConicalGradient::center() const
{
Q_ASSERT(m_type == ConicalGradient);
return QPointF(m_data.conical.cx, m_data.conical.cy);
}
/*!
\fn void QConicalGradient::setCenter(qreal x, qreal y)
\overload
Sets the center of this conical gradient in logical coordinates to
(\a x, \a y).
\sa center()
*/
/*!
Sets the center of this conical gradient in logical coordinates to
\a center.
\sa center()
*/
void QConicalGradient::setCenter(const QPointF ¢er)
{
Q_ASSERT(m_type == ConicalGradient);
m_data.conical.cx = center.x();
m_data.conical.cy = center.y();
}
/*!
Returns the start angle of the conical gradient in logical
coordinates.
\sa stops()
*/
qreal QConicalGradient::angle() const
{
Q_ASSERT(m_type == ConicalGradient);
return m_data.conical.angle;
}
/*!
\since 4.2
Sets \a angle to be the start angle for this conical gradient in
logical coordinates.
\sa angle()
*/
void QConicalGradient::setAngle(qreal angle)
{
Q_ASSERT(m_type == ConicalGradient);
m_data.conical.angle = angle;
}
/*!
\typedef QGradientStop
\relates QGradient
Typedef for QPair<\l qreal, QColor>.
*/
/*!
\typedef QGradientStops
\relates QGradient
Typedef for QVector<QGradientStop>.
*/
/*!
\typedef QBrush::DataPtr
\internal
*/
/*!
\fn DataPtr &QBrush::data_ptr()
\internal
*/
/*!
\fn bool QBrush::isDetached() const
\internal
*/
/*!
\fn QTransform QBrush::transform() const
\since 4.3
Returns the current transformation matrix for the brush.
\sa setTransform()
*/
QT_END_NAMESPACE