qbrush.h File Reference

#include <QtCore/qpair.h>
#include <QtCore/qpoint.h>
#include <QtCore/qvector.h>
#include <QtCore/qscopedpointer.h>
#include <QtGui/qcolor.h>
#include <QtGui/qmatrix.h>
#include <QtGui/qtransform.h>
#include <QtGui/qimage.h>
#include <QtGui/qpixmap.h>

Go to the source code of this file.

Classes
class	QBrush
	The QBrush class defines the fill pattern of shapes drawn by QPainter. More...
struct	QBrushData
class	QConicalGradient
	The QConicalGradient class is used in combination with QBrush to specify a conical gradient brush. More...
class	QGradient
	The QGradient class is used in combination with QBrush to specify gradient fills. More...
class	QLinearGradient
	The QLinearGradient class is used in combination with QBrush to specify a linear gradient brush. More...
class	QRadialGradient
	The QRadialGradient class is used in combination with QBrush to specify a radial gradient brush. More...

Typedefs
typedef QPair< qreal, QColor >	QGradientStop
typedef QVector< QGradientStop >	QGradientStops

Functions
Q_GUI_EXPORT QDataStream &	operator<< (QDataStream &, const QBrush &)
Q_GUI_EXPORT QDebug	operator<< (QDebug, const QBrush &)
Q_GUI_EXPORT QDataStream &	operator>> (QDataStream &, QBrush &)
	Q_DECLARE_TYPEINFO (QBrush, Q_MOVABLE_TYPE)

Typedef Documentation

QGradientStop

typedef QPair<qreal, QColor> QGradientStop

related

Definition at line 196 of file qbrush.h.

QGradientStops

typedef QVector<QGradientStop> QGradientStops

related

Definition at line 199 of file qbrush.h.

Function Documentation

operator<<() [1/2]

Q_GUI_EXPORT QDataStream& operator<< ( QDataStream &  , const QBrush &    )

related

Definition at line 1111 of file qbrush.cpp.

Referenced by QBrush::setColor().

{
    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;
}

operator<<() [2/2]

Q_GUI_EXPORT QDebug operator<<	(	QDebug	dbg,
		const QBrush &	b
	)

Warning

This function is not part of the public interface.

Definition at line 1058 of file qbrush.cpp.

{
#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
}

operator>>()

Q_GUI_EXPORT QDataStream& operator>> ( QDataStream &  , QBrush &    )

related

Definition at line 1182 of file qbrush.cpp.

Referenced by QBrush::setColor().

{
    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;
}

Q_DECLARE_TYPEINFO()

Q_DECLARE_TYPEINFO	(	QBrush	,
		Q_MOVABLE_TYPE
	)

Referenced by QBrush::setColor().