QPicture Class Reference

The QPicture class is a paint device that records and replays QPainter commands. More...

#include <qpicture.h>

Inheritance diagram for QPicture:

Public Types
typedef QExplicitlySharedDataPointer< QPicturePrivate >	DataPtr
Public Types inherited from QPaintDevice
enum	PaintDeviceMetric {   PdmWidth = 1, PdmHeight, PdmWidthMM, PdmHeightMM,   PdmNumColors, PdmDepth, PdmDpiX, PdmDpiY,   PdmPhysicalDpiX, PdmPhysicalDpiY }

Public Functions
QRect	boundingRect () const
	Returns the picture's bounding rectangle or an invalid rectangle if the picture contains no data. More...
const char *	data () const
	Returns a pointer to the picture data. More...
DataPtr &	data_ptr ()
void	detach ()
	Detaches from shared picture data and makes sure that this picture is the only one referring to the data. More...
int	devType () const
bool	isDetached () const
bool	isNull () const
	Returns true if the picture contains no data; otherwise returns false. More...
bool	load (QIODevice *dev, const char *format=0)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.dev is the device to use for loading. More...
bool	load (const QString &fileName, const char *format=0)
	Loads a picture from the file specified by fileName and returns true if successful; otherwise returns false. More...
QPicture &	operator= (const QPicture &p)
	Assigns picture p to this picture and returns a reference to this picture. More...
QPaintEngine *	paintEngine () const
bool	play (QPainter *p)
	Replays the picture using painter, and returns true if successful; otherwise returns false. More...
	QPicture (int formatVersion=-1)
	Constructs an empty picture. More...
	QPicture (const QPicture &)
	Constructs a copy of pic. More...
bool	save (QIODevice *dev, const char *format=0)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.dev is the device to use for saving. More...
bool	save (const QString &fileName, const char *format=0)
	Saves a picture to the file specified by fileName and returns true if successful; otherwise returns false. More...
void	setBoundingRect (const QRect &r)
	Sets the picture's bounding rectangle to r. More...
virtual void	setData (const char *data, uint size)
	Sets the picture data directly from data and size. More...
uint	size () const
	Returns the size of the picture data. More...
void	swap (QPicture &other)
	Swaps picture other with this picture. More...
	~QPicture ()
	Destroys the picture. More...
Public Functions inherited from QPaintDevice
int	colorCount () const
int	depth () const
virtual HDC	getDC () const
int	height () const
int	heightMM () const
int	logicalDpiX () const
int	logicalDpiY () const
QT_DEPRECATED int	numColors () const
bool	paintingActive () const
int	physicalDpiX () const
int	physicalDpiY () const
virtual void	releaseDC (HDC hdc) const
int	width () const
int	widthMM () const
virtual	~QPaintDevice ()

Static Public Functions
static QStringList	inputFormatList ()
	Returns a list of picture formats that are supported for picture input. More...
static QList< QByteArray >	inputFormats ()
	Returns a list of picture formats that are supported for picture input. More...
static QStringList	outputFormatList ()
	Returns a list of picture formats that are supported for picture output. More...
static QList< QByteArray >	outputFormats ()
	Returns a list of picture formats that are supported for picture output. More...
static const char *	pictureFormat (const QString &fileName)
	Returns a string that specifies the picture format of the file fileName, or 0 if the file cannot be read or if the format is not recognized. More...
Static Public Functions inherited from QPaintDevice
static QWSDisplay *	qwsDisplay ()

Protected Functions
int	metric (PaintDeviceMetric m) const
	Internal implementation of the virtual QPaintDevice::metric() function. More...
	QPicture (QPicturePrivate &data)
Protected Functions inherited from QPaintDevice
	QPaintDevice ()

Private Functions
void	detach_helper ()
bool	exec (QPainter *p, QDataStream &ds, int i)
	Iterates over the internal picture data and draws the picture using painter. More...

Properties
QExplicitlySharedDataPointer< QPicturePrivate >	d_ptr

Friends
Q_GUI_EXPORT QDataStream &	operator<< (QDataStream &in, const QPicture &p)
	Writes picture r to the stream s and returns a reference to the stream. More...
Q_GUI_EXPORT QDataStream &	operator>> (QDataStream &in, QPicture &p)
	Reads a picture from the stream s into picture r and returns a reference to the stream. More...
class	Q3Picture
class	QAlphaPaintEngine
class	QPicturePaintEngine
class	QPreviewPaintEngine

Additional Inherited Members
Protected Variables inherited from QPaintDevice
ushort	painters
Related Functions inherited from QPaintDevice
const Q_GUI_EXPORT QX11Info *	qt_x11Info (const QPaintDevice *pd)
	Returns the QX11Info structure for the pd paint device. More...

Detailed Description

The QPicture class is a paint device that records and replays QPainter commands.

A picture serializes painter commands to an IO device in a platform-independent format. They are sometimes referred to as meta-files.

Qt pictures use a proprietary binary format. Unlike native picture (meta-file) formats on many window systems, Qt pictures have no limitations regarding their contents. Everything that can be painted on a widget or pixmap (e.g., fonts, pixmaps, regions, transformed graphics, etc.) can also be stored in a picture.

QPicture is resolution independent, i.e. a QPicture can be displayed on different devices (for example svg, pdf, ps, printer and screen) looking the same. This is, for instance, needed for WYSIWYG print preview. QPicture runs in the default system dpi, and scales the painter to match differences in resolution depending on the window system.

Example of how to record a picture:

        QPicture picture;
        QPainter painter;
        painter.begin(&picture);           // paint in picture
        painter.drawEllipse(10,20, 80,70); // draw an ellipse
        painter.end();                     // painting done
        picture.save("drawing.pic");       // save picture

Note that the list of painter commands is reset on each call to the QPainter::begin() function.

Example of how to replay a picture:

        QPicture picture;
        picture.load("drawing.pic");           // load picture
        QPainter painter;
        painter.begin(&myImage);               // paint in myImage
        painter.drawPicture(0, 0, picture);    // draw the picture at (0,0)
        painter.end();                         // painting done

Pictures can also be drawn using play(). Some basic data about a picture is available, for example, size(), isNull() and boundingRect().

See also

QMovie

Definition at line 58 of file qpicture.h.

Typedefs

DataPtr

QPicture::DataPtr

Warning

This function is not part of the public interface.

Definition at line 122 of file qpicture.h.

Constructors and Destructors

QPicture() [1/3]

QPicture::QPicture ( int  formatVersion = -1 )

explicit

Constructs an empty picture.

The formatVersion parameter may be used to create a QPicture that can be read by applications that are compiled with earlier versions of Qt.

Note that the default formatVersion is -1 which signifies the current release, i.e. for Qt 4.0 a formatVersion of 7 is the same as the default formatVersion of -1.

Reading pictures generated by earlier versions of Qt is not supported in Qt 4.0.

Definition at line 131 of file qpicture.cpp.

    : QPaintDevice(),
      d_ptr(new QPicturePrivate)
{
    Q_D(QPicture);

    if (formatVersion == 0)
        qWarning("QPicture: invalid format version 0");

    // still accept the 0 default from before Qt 3.0.
    if (formatVersion > 0 && formatVersion != (int)mfhdr_maj) {
        d->formatMajor = formatVersion;
        d->formatMinor = 0;
        d->formatOk = false;
    } else {
        d->resetFormat();
    }
}

QPicture() [2/3]

QPicture::QPicture

(

const QPicture &

pic

)

Constructs a copy of pic.

This constructor is fast thanks to implicit sharing.

Definition at line 156 of file qpicture.cpp.

    : QPaintDevice(), d_ptr(pic.d_ptr)
{
}

~QPicture()

QPicture::~QPicture

(

)

Destroys the picture.

Definition at line 171 of file qpicture.cpp.

{
}

QPicture() [3/3]

QPicture::QPicture ( QPicturePrivate &  dptr )

protected

Warning

This function is not part of the public interface.

Definition at line 162 of file qpicture.cpp.

    : QPaintDevice(),
      d_ptr(&dptr)
{
}

Functions

boundingRect()

QRect QPicture::boundingRect

(

)

const

Returns the picture's bounding rectangle or an invalid rectangle if the picture contains no data.

Definition at line 385 of file qpicture.cpp.

Referenced by QPicturePaintEngine::begin(), metric(), and QLabelPrivate::sizeForWidth().

{
    Q_D(const QPicture);
    // Use override rect where possible.
    if (!d->override_rect.isEmpty())
        return d->override_rect;

    if (!d->formatOk)
        d_ptr->checkFormat();

    return d->brect;
}

data()

const char * QPicture::data

(

)

const

Returns a pointer to the picture data.

The pointer is only valid until the next non-const function is called on this picture. The returned pointer is 0 if the picture contains no data.

See also

size(), isNull()

Definition at line 225 of file qpicture.cpp.

{
    return d_func()->pictb.buffer();
}

data_ptr()

DataPtr & QPicture::data_ptr ( )

inline

Warning

This function is not part of the public interface.

Definition at line 123 of file qpicture.h.

{ return d_ptr; }

detach()

void QPicture::detach

(

)

Detaches from shared picture data and makes sure that this picture is the only one referring to the data.

Warning

This function is not part of the public interface.

If multiple pictures share common data, this picture makes a copy of the data and detaches itself from the sharing mechanism. Nothing is done if there is just a single reference.

Definition at line 230 of file qpicture.cpp.

Referenced by load(), setData(), and swap().

{
    d_ptr.detach();
}

detach_helper()

void QPicture::detach_helper ( )

private

Warning

This function is not part of the public interface.

Qt 5 - remove me

Definition at line 1031 of file qpicture.cpp.

{
    // QExplicitelySharedDataPointer takes care of cloning using
    // QPicturePrivate's copy constructor. Do not call detach_helper() anymore
    // and remove in Qt 5, please.
    Q_ASSERT_X(false, "QPicture::detach_helper()", "Do not call this function");
}

devType()

int QPicture::devType ( ) const

virtual

Warning

This function is not part of the public interface.

Reimplemented from QPaintDevice.

Definition at line 178 of file qpicture.cpp.

{
    return QInternal::Picture;
}

exec()

bool QPicture::exec ( QPainter *  painter, QDataStream &  s, int  nrecords  )

private

Iterates over the internal picture data and draws the picture using painter.

Warning

This function is not part of the public interface.

Definition at line 490 of file qpicture.cpp.

Referenced by play().

{
    Q_D(QPicture);
#if defined(QT_DEBUG)
    int                strm_pos;
#endif
    quint8     c;                      // command id
    quint8     tiny_len;               // 8-bit length descriptor
    qint32     len;                    // 32-bit length descriptor
    qint16     i_16, i1_16, i2_16;     // parameters...
    qint8      i_8;
    quint32    ul;
    double     dbl;
    bool       bl;
    QByteArray  str1;
    QString     str;
    QPointF     p, p1, p2;
    QPoint      ip, ip1, ip2;
    QRect       ir;
    QRectF      r;
    QPolygonF   a;
    QPolygon    ia;
    QColor      color;
    QFont       font;
    QPen        pen;
    QBrush      brush;
    QRegion     rgn;
    QMatrix     wmatrix;
    QTransform  matrix;

    QTransform worldMatrix = painter->transform();
    worldMatrix.scale(qreal(painter->device()->logicalDpiX()) / qreal(qt_defaultDpiX()),
                      qreal(painter->device()->logicalDpiY()) / qreal(qt_defaultDpiY()));
    painter->setTransform(worldMatrix);

    while (nrecords-- && !s.atEnd()) {
        s >> c;                 // read cmd
        s >> tiny_len;          // read param length
        if (tiny_len == 255)    // longer than 254 bytes
            s >> len;
        else
            len = tiny_len;
#if defined(QT_DEBUG)
        strm_pos = s.device()->pos();
#endif
        switch (c) {            // exec cmd
        case QPicturePrivate::PdcNOP:
            break;
        case QPicturePrivate::PdcDrawPoint:
            if (d->formatMajor <= 5) {
                s >> ip;
                painter->drawPoint(ip);
            } else {
                s >> p;
                painter->drawPoint(p);
            }
            break;
        case QPicturePrivate::PdcDrawPoints:
// ## implement me in the picture paint engine
//                 s >> a >> i1_32 >> i2_32;
//                 painter->drawPoints(a.mid(i1_32, i2_32));
            break;
        case QPicturePrivate::PdcDrawPath: {
            QPainterPath path;
            s >> path;
            painter->drawPath(path);
            break;
        }
        case QPicturePrivate::PdcDrawLine:
            if (d->formatMajor <= 5) {
                s >> ip1 >> ip2;
                painter->drawLine(ip1, ip2);
            } else {
                s >> p1 >> p2;
                painter->drawLine(p1, p2);
            }
            break;
        case QPicturePrivate::PdcDrawRect:
            if (d->formatMajor <= 5) {
                s >> ir;
                painter->drawRect(ir);
            } else {
                s >> r;
                painter->drawRect(r);
            }
            break;
        case QPicturePrivate::PdcDrawRoundRect:
            if (d->formatMajor <= 5) {
                s >> ir >> i1_16 >> i2_16;
                painter->drawRoundedRect(ir, i1_16, i2_16, Qt::RelativeSize);
            } else {
                s >> r >> i1_16 >> i2_16;
                painter->drawRoundedRect(r, i1_16, i2_16, Qt::RelativeSize);
            }
            break;
        case QPicturePrivate::PdcDrawEllipse:
            if (d->formatMajor <= 5) {
                s >> ir;
                painter->drawEllipse(ir);
            } else {
                s >> r;
                painter->drawEllipse(r);
            }
            break;
        case QPicturePrivate::PdcDrawArc:
            if (d->formatMajor <= 5) {
                s >> ir;
                r = ir;
            } else {
                s >> r;
            }
            s >> i1_16 >> i2_16;
            painter->drawArc(r, i1_16, i2_16);
            break;
        case QPicturePrivate::PdcDrawPie:
            if (d->formatMajor <= 5) {
                s >> ir;
                r = ir;
            } else {
                s >> r;
            }
            s >> i1_16 >> i2_16;
            painter->drawPie(r, i1_16, i2_16);
            break;
        case QPicturePrivate::PdcDrawChord:
            if (d->formatMajor <= 5) {
                s >> ir;
                r = ir;
            } else {
                s >> r;
            }
            s >> i1_16 >> i2_16;
            painter->drawChord(r, i1_16, i2_16);
            break;
        case QPicturePrivate::PdcDrawLineSegments:
            s >> ia;
            painter->drawLines(ia);
            ia.clear();
            break;
        case QPicturePrivate::PdcDrawPolyline:
            if (d->formatMajor <= 5) {
                s >> ia;
                painter->drawPolyline(ia);
                ia.clear();
            } else {
                s >> a;
                painter->drawPolyline(a);
                a.clear();
            }
            break;
        case QPicturePrivate::PdcDrawPolygon:
            if (d->formatMajor <= 5) {
                s >> ia >> i_8;
                painter->drawPolygon(ia, i_8 ? Qt::WindingFill : Qt::OddEvenFill);
                a.clear();
            } else {
                s >> a >> i_8;
                painter->drawPolygon(a, i_8 ? Qt::WindingFill : Qt::OddEvenFill);
                a.clear();
            }
            break;
        case QPicturePrivate::PdcDrawCubicBezier: {
            s >> ia;
            QPainterPath path;
            Q_ASSERT(ia.size() == 4);
            path.moveTo(ia.at(0));
            path.cubicTo(ia.at(1), ia.at(2), ia.at(3));
            painter->strokePath(path, painter->pen());
            a.clear();
        }
            break;
        case QPicturePrivate::PdcDrawText:
            s >> ip >> str1;
            painter->drawText(ip, QString::fromLatin1(str1));
            break;
        case QPicturePrivate::PdcDrawTextFormatted:
            s >> ir >> i_16 >> str1;
            painter->drawText(ir, i_16, QString::fromLatin1(str1));
            break;
        case QPicturePrivate::PdcDrawText2:
            if (d->formatMajor <= 5) {
                s >> ip >> str;
                painter->drawText(ip, str);
            } else {
                s >> p >> str;
                painter->drawText(p, str);
            }
            break;
        case QPicturePrivate::PdcDrawText2Formatted:
            s >> ir;
            s >> i_16;
            s >> str;
            painter->drawText(ir, i_16, str);
            break;
        case QPicturePrivate::PdcDrawTextItem: {
            s >> p >> str >> font >> ul;

            // the text layout direction is not used here because it's already
            // aligned when QPicturePaintEngine::drawTextItem() serializes the
            // drawText() call, therefore ul is unsed in this context

            if (d->formatMajor >= 9) {
                s >> dbl;
                QFont fnt(font);
                if (dbl != 1.0) {
                    QFakeDevice fake;
                    fake.setDpiX(qRound(dbl*qt_defaultDpiX()));
                    fake.setDpiY(qRound(dbl*qt_defaultDpiY()));
                    fnt = QFont(font, &fake);
                }

                qreal justificationWidth;
                s >> justificationWidth;

                int flags = Qt::TextSingleLine | Qt::TextDontClip | Qt::TextForceLeftToRight;

                QSizeF size(1, 1);
                if (justificationWidth > 0) {
                    size.setWidth(justificationWidth);
                    flags |= Qt::TextJustificationForced;
                    flags |= Qt::AlignJustify;
                }

                QFontMetrics fm(fnt);
                QPointF pt(p.x(), p.y() - fm.ascent());
                qt_format_text(fnt, QRectF(pt, size), flags, /*opt*/0,
                               str, /*brect=*/0, /*tabstops=*/0, /*...*/0, /*tabarraylen=*/0, painter);
            } else {
                qt_format_text(font, QRectF(p, QSizeF(1, 1)), Qt::TextSingleLine | Qt::TextDontClip, /*opt*/0,
                               str, /*brect=*/0, /*tabstops=*/0, /*...*/0, /*tabarraylen=*/0, painter);
            }

            break;
        }
        case QPicturePrivate::PdcDrawPixmap: {
            QPixmap pixmap;
            if (d->formatMajor < 4) {
                s >> ip >> pixmap;
                painter->drawPixmap(ip, pixmap);
            } else if (d->formatMajor <= 5) {
                s >> ir >> pixmap;
                painter->drawPixmap(ir, pixmap);
            } else {
                QRectF sr;
                if (d->in_memory_only) {
                    int index;
                    s >> r >> index >> sr;
                    Q_ASSERT(index < d->pixmap_list.size());
                    pixmap = d->pixmap_list.at(index);
                } else {
                    s >> r >> pixmap >> sr;
                }
                painter->drawPixmap(r, pixmap, sr);
            }
        }
            break;
        case QPicturePrivate::PdcDrawTiledPixmap: {
            QPixmap pixmap;
            if (d->in_memory_only) {
                int index;
                s >> r >> index >> p;
                Q_ASSERT(index < d->pixmap_list.size());
                pixmap = d->pixmap_list.at(index);
            } else {
                s >> r >> pixmap >> p;
            }
            painter->drawTiledPixmap(r, pixmap, p);
        }
            break;
        case QPicturePrivate::PdcDrawImage: {
            QImage image;
            if (d->formatMajor < 4) {
                s >> p >> image;
                painter->drawImage(p, image);
            } else if (d->formatMajor <= 5){
                s >> ir >> image;
                painter->drawImage(ir, image, QRect(0, 0, ir.width(), ir.height()));
            } else {
                QRectF sr;
                if (d->in_memory_only) {
                    int index;
                    s >> r >> index >> sr >> ul;
                    Q_ASSERT(index < d->image_list.size());
                    image = d->image_list.at(index);
                } else {
                    s >> r >> image >> sr >> ul;
                }
                painter->drawImage(r, image, sr, Qt::ImageConversionFlags(ul));
            }
        }
            break;
        case QPicturePrivate::PdcBegin:
            s >> ul;                        // number of records
            if (!exec(painter, s, ul))
                return false;
            break;
        case QPicturePrivate::PdcEnd:
            if (nrecords == 0)
                return true;
            break;
        case QPicturePrivate::PdcSave:
            painter->save();
            break;
        case QPicturePrivate::PdcRestore:
            painter->restore();
            break;
        case QPicturePrivate::PdcSetBkColor:
            s >> color;
            painter->setBackground(color);
            break;
        case QPicturePrivate::PdcSetBkMode:
            s >> i_8;
            painter->setBackgroundMode((Qt::BGMode)i_8);
            break;
        case QPicturePrivate::PdcSetROP: // NOP
            s >> i_8;
            break;
        case QPicturePrivate::PdcSetBrushOrigin:
            if (d->formatMajor <= 5) {
                s >> ip;
                painter->setBrushOrigin(ip);
            } else {
                s >> p;
                painter->setBrushOrigin(p);
            }
            break;
        case QPicturePrivate::PdcSetFont:
            s >> font;
            painter->setFont(font);
            break;
        case QPicturePrivate::PdcSetPen:
            if (d->in_memory_only) {
                int index;
                s >> index;
                Q_ASSERT(index < d->pen_list.size());
                pen = d->pen_list.at(index);
            } else {
                s >> pen;
            }
            painter->setPen(pen);
            break;
        case QPicturePrivate::PdcSetBrush:
            if (d->in_memory_only) {
                int index;
                s >> index;
                Q_ASSERT(index < d->brush_list.size());
                brush = d->brush_list.at(index);
            } else {
                s >> brush;
            }
            painter->setBrush(brush);
            break;
// #ifdef Q_Q3PAINTER
//         case QPicturePrivate::PdcSetTabStops:
//                 s >> i_16;
//                 painter->setTabStops(i_16);
//                 break;
//             case QPicturePrivate::PdcSetTabArray:
//                 s >> i_16;
//                 if (i_16 == 0) {
//                     painter->setTabArray(0);
//                 } else {
//                     int *ta = new int[i_16];
//                     for (int i=0; i<i_16; i++) {
//                         s >> i1_16;
//                         ta[i] = i1_16;
//                     }
//                     painter->setTabArray(ta);
//                     delete [] ta;
//                 }
//                 break;
// #endif
        case QPicturePrivate::PdcSetVXform:
            s >> i_8;
            painter->setViewTransformEnabled(i_8);
            break;
        case QPicturePrivate::PdcSetWindow:
            if (d->formatMajor <= 5) {
                s >> ir;
                painter->setWindow(ir);
            } else {
                s >> r;
                painter->setWindow(r.toRect());
            }
            break;
        case QPicturePrivate::PdcSetViewport:
            if (d->formatMajor <= 5) {
                s >> ir;
                painter->setViewport(ir);
            } else {
                s >> r;
                painter->setViewport(r.toRect());
            }
            break;
        case QPicturePrivate::PdcSetWXform:
            s >> i_8;
            painter->setMatrixEnabled(i_8);
            break;
        case QPicturePrivate::PdcSetWMatrix:
            if (d->formatMajor >= 8) {
                s >> matrix >> i_8;
            } else {
                s >> wmatrix >> i_8;
                matrix = QTransform(wmatrix);
            }
            // i_8 is always false due to updateXForm() in qpaintengine_pic.cpp
            painter->setTransform(matrix * worldMatrix, i_8);
            break;
// #ifdef Q_Q3PAINTER
//             case QPicturePrivate::PdcSaveWMatrix:
//                 painter->saveWorldMatrix();
//                 break;
//             case QPicturePrivate::PdcRestoreWMatrix:
//                 painter->restoreWorldMatrix();
//                 break;
// #endif
        case QPicturePrivate::PdcSetClip:
            s >> i_8;
            painter->setClipping(i_8);
            break;
        case QPicturePrivate::PdcSetClipRegion:
            s >> rgn >> i_8;
            if (d->formatMajor >= 9) {
                painter->setClipRegion(rgn, Qt::ClipOperation(i_8));
            } else {
                painter->setClipRegion(rgn);
            }
            break;
        case QPicturePrivate::PdcSetClipPath:
            {
                QPainterPath path;
                s >> path >> i_8;
                painter->setClipPath(path, Qt::ClipOperation(i_8));
                break;
            }
        case QPicturePrivate::PdcSetRenderHint:
            s >> ul;
            painter->setRenderHint(QPainter::Antialiasing,
                                   bool(ul & QPainter::Antialiasing));
            painter->setRenderHint(QPainter::SmoothPixmapTransform,
                                   bool(ul & QPainter::SmoothPixmapTransform));
            break;
        case QPicturePrivate::PdcSetCompositionMode:
            s >> ul;
            painter->setCompositionMode((QPainter::CompositionMode)ul);
            break;
        case QPicturePrivate::PdcSetClipEnabled:
            s >> bl;
            painter->setClipping(bl);
            break;
        case QPicturePrivate::PdcSetOpacity:
            s >> dbl;
            painter->setOpacity(qreal(dbl));
            break;
        default:
            qWarning("QPicture::play: Invalid command %d", c);
            if (len)                        // skip unknown command
                s.device()->seek(s.device()->pos()+len);
        }
#if defined(QT_DEBUG)
        //qDebug("device->at(): %i, strm_pos: %i len: %i", (int)s.device()->pos(), strm_pos, len);
        Q_ASSERT(qint32(s.device()->pos() - strm_pos) == len);
#endif
    }
    return false;
}

inputFormatList()

QStringList QPicture::inputFormatList ( )

static

Returns a list of picture formats that are supported for picture input.

Note that if you want to iterate over the list, you should iterate over a copy, e.g.

        QStringList list = QPicture::inputFormatList();
        foreach (const QString &string, list)
            myProcessing(string);

See also

outputFormatList() inputFormats() QPictureIO

Definition at line 1314 of file qpicture.cpp.

{
    return qToStringList(QPictureIO::inputFormats());
}

inputFormats()

QList< QByteArray > QPicture::inputFormats ( )

static

Returns a list of picture formats that are supported for picture input.

See also

outputFormats() inputFormatList() QPictureIO

Definition at line 1286 of file qpicture.cpp.

{
    return QPictureIO::inputFormats();
}

isDetached()

bool QPicture::isDetached

(

)

const

Warning

This function is not part of the public interface.

Definition at line 235 of file qpicture.cpp.

{
    return d_func()->ref == 1;
}

isNull()

bool QPicture::isNull

(

)

const

Returns true if the picture contains no data; otherwise returns false.

Definition at line 215 of file qpicture.cpp.

Referenced by QLabelPrivate::sizeForWidth().

{
    return d_func()->pictb.buffer().isNull();
}

load() [1/2]

bool QPicture::load	(	QIODevice *	dev,
		const char *	format = 0
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.dev is the device to use for loading.

Definition at line 279 of file qpicture.cpp.

Referenced by load().

{
    if(format) {
#ifndef QT_NO_PICTUREIO
        QPictureIO io(dev, format);
        bool result = io.read();
        if (result) {
            operator=(io.picture());

        } else if (format)
#else
            bool result = false;
#endif
        {
            qWarning("QPicture::load: No such picture format: %s", format);
        }
        return result;
    }

    detach();
    QByteArray a = dev->readAll();

    d_func()->pictb.setData(a);                        // set byte array in buffer
    return d_func()->checkFormat();
}

load() [2/2]

bool QPicture::load	(	const QString &	fileName,
		const char *	format = 0
	)

Loads a picture from the file specified by fileName and returns true if successful; otherwise returns false.

Please note that the format parameter has been deprecated and will have no effect.

See also

save()

Definition at line 265 of file qpicture.cpp.

{
    QFile f(fileName);
    if (!f.open(QIODevice::ReadOnly))
        return false;
    return load(&f, format);
}

metric()

int QPicture::metric ( PaintDeviceMetric  m ) const

protectedvirtual

Internal implementation of the virtual QPaintDevice::metric() function.

Warning

This function is not part of the public interface.

A picture has the following hard-coded values: numcolors=16777216 and depth=24.

m is the metric to get.

Reimplemented from QPaintDevice.

Definition at line 972 of file qpicture.cpp.

{
    int val;
    QRect brect = boundingRect();
    switch (m) {
        case PdmWidth:
            val = brect.width();
            break;
        case PdmHeight:
            val = brect.height();
            break;
        case PdmWidthMM:
            val = int(25.4/qt_defaultDpiX()*brect.width());
            break;
        case PdmHeightMM:
            val = int(25.4/qt_defaultDpiY()*brect.height());
            break;
        case PdmDpiX:
        case PdmPhysicalDpiX:
            val = qt_defaultDpiX();
            break;
        case PdmDpiY:
        case PdmPhysicalDpiY:
            val = qt_defaultDpiY();
            break;
        case PdmNumColors:
            val = 16777216;
            break;
        case PdmDepth:
            val = 24;
            break;
        default:
            val = 0;
            qWarning("QPicture::metric: Invalid metric command");
    }
    return val;
}

operator=()

QPicture & QPicture::operator=

(

const QPicture &

p

)

Assigns picture p to this picture and returns a reference to this picture.

Definition at line 1043 of file qpicture.cpp.

Referenced by load(), and save().

{
    d_ptr = p.d_ptr;
    return *this;
}

outputFormatList()

QStringList QPicture::outputFormatList ( )

static

Returns a list of picture formats that are supported for picture output.

Note that if you want to iterate over the list, you should iterate over a copy, e.g.

        QStringList list = QPicture::outputFormatList();
        foreach (const QString &string, list)
            myProcessing(string);

See also

inputFormatList() outputFormats() QPictureIO

Definition at line 1335 of file qpicture.cpp.

{
    return qToStringList(QPictureIO::outputFormats());
}

outputFormats()

QList< QByteArray > QPicture::outputFormats ( )

static

Returns a list of picture formats that are supported for picture output.

See also

inputFormats() outputFormatList() QPictureIO

Definition at line 1351 of file qpicture.cpp.

{
    return QPictureIO::outputFormats();
}

paintEngine()

QPaintEngine * QPicture::paintEngine ( ) const

virtual

Warning

This function is not part of the public interface.

Implements QPaintDevice.

Definition at line 1183 of file qpicture.cpp.

Referenced by paintEngine().

{
    if (!d_func()->paintEngine)
        const_cast<QPicture*>(this)->d_func()->paintEngine.reset(new QPicturePaintEngine);
    return d_func()->paintEngine.data();
}

pictureFormat()

const char * QPicture::pictureFormat ( const QString &  fileName )

static

Returns a string that specifies the picture format of the file fileName, or 0 if the file cannot be read or if the format is not recognized.

See also

load() save()

Definition at line 1270 of file qpicture.cpp.

{
    return QPictureIO::pictureFormat(fileName);
}

play()

bool QPicture::play

(

QPainter *

painter

)

Replays the picture using painter, and returns true if successful; otherwise returns false.

This function does exactly the same as QPainter::drawPicture() with (x, y) = (0, 0).

Definition at line 416 of file qpicture.cpp.

{
    Q_D(QPicture);

    if (d->pictb.size() == 0)                        // nothing recorded
        return true;

    if (!d->formatOk && !d->checkFormat())
        return false;

    d->pictb.open(QIODevice::ReadOnly);                // open buffer device
    QDataStream s;
    s.setDevice(&d->pictb);                        // attach data stream to buffer
    s.device()->seek(10);                        // go directly to the data
    s.setVersion(d->formatMajor == 4 ? 3 : d->formatMajor);

    quint8  c, clen;
    quint32 nrecords;
    s >> c >> clen;
    Q_ASSERT(c == QPicturePrivate::PdcBegin);
    // bounding rect was introduced in ver 4. Read in checkFormat().
    if (d->formatMajor >= 4) {
        qint32 dummy;
        s >> dummy >> dummy >> dummy >> dummy;
    }
    s >> nrecords;
    if (!exec(painter, s, nrecords)) {
        qWarning("QPicture::play: Format error");
        d->pictb.close();
        return false;
    }
    d->pictb.close();
    return true;                                // no end-command
}

save() [1/2]

bool QPicture::save	(	QIODevice *	dev,
		const char *	format = 0
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.dev is the device to use for saving.

Definition at line 352 of file qpicture.cpp.

Referenced by save().

{
    if (paintingActive()) {
        qWarning("QPicture::save: still being painted on. "
                  "Call QPainter::end() first");
        return false;
    }

    if(format) {
#ifndef QT_NO_PICTUREIO
        QPictureIO io(dev, format);
        bool result = io.write();
        if (result) {
            operator=(io.picture());
        } else if (format)
#else
        bool result = false;
#endif
        {
            qWarning("QPicture::save: No such picture format: %s", format);
        }
        return result;
    }

    dev->write(d_func()->pictb.buffer(), d_func()->pictb.buffer().size());
    return true;
}

save() [2/2]

bool QPicture::save	(	const QString &	fileName,
		const char *	format = 0
	)

Saves a picture to the file specified by fileName and returns true if successful; otherwise returns false.

Please note that the format parameter has been deprecated and will have no effect.

See also

load()

Definition at line 315 of file qpicture.cpp.

{
    if (paintingActive()) {
        qWarning("QPicture::save: still being painted on. "
                  "Call QPainter::end() first");
        return false;
    }


    if(format) {
#ifndef QT_NO_PICTUREIO
        QPictureIO io(fileName, format);
        bool result = io.write();
        if (result) {
            operator=(io.picture());
        } else if (format)
#else
        bool result = false;
#endif
        {
            qWarning("QPicture::save: No such picture format: %s", format);
        }
        return result;
    }

    QFile f(fileName);
    if (!f.open(QIODevice::WriteOnly))
        return false;
    return save(&f, format);
}

setBoundingRect()

void QPicture::setBoundingRect

(

const QRect &

r

)

Sets the picture's bounding rectangle to r.

The automatically calculated value is overridden.

Definition at line 403 of file qpicture.cpp.

{
    d_func()->override_rect = r;
}

setData()

void QPicture::setData ( const char *  data, uint  size  )

virtual

Sets the picture data directly from data and size.

This function copies the input data.

See also

data(), size()

Definition at line 247 of file qpicture.cpp.

{
    detach();
    d_func()->pictb.setData(data, size);
    d_func()->resetFormat();                                // we'll have to check
}

size()

uint QPicture::size

(

)

const

Returns the size of the picture data.

See also

data()

Definition at line 220 of file qpicture.cpp.

Referenced by exec().

{
    return d_func()->pictb.buffer().size();
}

swap()

void QPicture::swap ( QPicture &  other )

inline

Swaps picture other with this picture.

Since

4.8

This operation is very fast and never fails.

Definition at line 88 of file qpicture.h.

{ d_ptr.swap(other.d_ptr); }

Friends and Related Functions

operator<<

QDataStream & operator<< ( QDataStream &  in, const QPicture &  p  )

friend

Writes picture r to the stream s and returns a reference to the stream.

Definition at line 1205 of file qpicture.cpp.

{
    quint32 size = r.d_func()->pictb.buffer().size();
    s << size;
    // null picture ?
    if (size == 0)
        return s;
    // just write the whole buffer to the stream
    s.writeRawData (r.d_func()->pictb.buffer(), r.d_func()->pictb.buffer().size());
    return s;
}

operator>>

QDataStream & operator>> ( QDataStream &  in, QPicture &  p  )

friend

Reads a picture from the stream s into picture r and returns a reference to the stream.

Definition at line 1227 of file qpicture.cpp.

{
    QDataStream sr;

    // "init"; this code is similar to the beginning of QPicture::cmd()
    sr.setDevice(&r.d_func()->pictb);
    sr.setVersion(r.d_func()->formatMajor);
    quint32 len;
    s >> len;
    QByteArray data;
    if (len > 0) {
        data.resize(len);
        s.readRawData(data.data(), len);
    }

    r.d_func()->pictb.setData(data);
    r.d_func()->resetFormat();
    return s;
}

Q3Picture

friend class Q3Picture

friend

Definition at line 117 of file qpicture.h.

QAlphaPaintEngine

friend class QAlphaPaintEngine

friend

Definition at line 118 of file qpicture.h.

QPicturePaintEngine

friend class QPicturePaintEngine

friend

Definition at line 116 of file qpicture.h.

QPreviewPaintEngine

friend class QPreviewPaintEngine

friend

Definition at line 119 of file qpicture.h.

Properties

d_ptr

QExplicitlySharedDataPointer<QPicturePrivate> QPicture::d_ptr

private

Definition at line 115 of file qpicture.h.

Referenced by boundingRect(), detach(), operator=(), and swap().

---

The documentation for this class was generated from the following files:

• /src/gui/image/qpicture.h
• /src/gui/image/qpicture.cpp