FCL/sf/mw/qt: comparison src/gui/image/qpicture.cpp

equal deleted inserted replaced

--1:000000000000
+:1918ee327afb
+/****************************************************************************
+**
+** Copyright (C) 2009 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 "qpicture.h"
+#include <private/qpicture_p.h>
+#ifndef QT_NO_PICTURE
+#include <private/qfactoryloader_p.h>
+#include <private/qpaintengine_pic_p.h>
+#include "qdatastream.h"
+#include "qfile.h"
+#include "qimage.h"
+#include "qmutex.h"
+#include "qpainter.h"
+#include "qpainterpath.h"
+#include "qpixmap.h"
+#include "qregion.h"
+#include "qdebug.h"
+QT_BEGIN_NAMESPACE
+void qt_format_text(const QFont &fnt, const QRectF &_r,
+int tf, const QTextOption *opt, const QString& str, QRectF *brect,
+int tabstops, int *, int tabarraylen,
+QPainter *painter);
+/*!
+\class QPicture
+\brief The QPicture class is a paint device that records and
+replays QPainter commands.
+\ingroup painting
+\ingroup shared
+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:
+\snippet doc/src/snippets/picture/picture.cpp 0
+Note that the list of painter commands is reset on each call to
+the QPainter::begin() function.
+Example of how to replay a picture:
+\snippet doc/src/snippets/picture/picture.cpp 1
+Pictures can also be drawn using play(). Some basic data about a
+picture is available, for example, size(), isNull() and
+boundingRect().
+\sa QMovie
+*/
+const char  *qt_mfhdr_tag = "QPIC"; // header tag
+static const quint16 mfhdr_maj = 11; // major version #
+static const quint16 mfhdr_min = 0; // minor version #
+extern int qt_defaultDpiX();
+extern int qt_defaultDpiY();
+/*!
+Constructs an empty picture.
+The \a formatVersion parameter may be used to \e 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.
+*/
+QPicture::QPicture(int formatVersion)
+: 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();
+}
+}
+/*!
+Constructs a copy of \a pic.
+This constructor is fast thanks to \l{implicit sharing}.
+*/
+QPicture::QPicture(const QPicture &pic)
+: QPaintDevice(), d_ptr(pic.d_ptr)
+{
+}
+/*! \internal */
+QPicture::QPicture(QPicturePrivate &dptr)
+: QPaintDevice(),
+d_ptr(&dptr)
+{
+}
+/*!
+Destroys the picture.
+*/
+QPicture::~QPicture()
+{
+}
+/*!
+\internal
+*/
+int QPicture::devType() const
+{
+return QInternal::Picture;
+}
+/*!
+\fn bool QPicture::isNull() const
+Returns true if the picture contains no data; otherwise returns
+false.
+*/
+/*!
+\fn uint QPicture::size() const
+Returns the size of the picture data.
+\sa data()
+*/
+/*!
+\fn 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.
+\sa size(), isNull()
+*/
+bool QPicture::isNull() const
+{
+return d_func()->pictb.buffer().isNull();
+}
+uint QPicture::size() const
+{
+return d_func()->pictb.buffer().size();
+}
+const char* QPicture::data() const
+{
+return d_func()->pictb.buffer();
+}
+void QPicture::detach()
+{
+d_ptr.detach();
+}
+bool QPicture::isDetached() const
+{
+return d_func()->ref == 1;
+}
+/*!
+Sets the picture data directly from \a data and \a size. This
+function copies the input data.
+\sa data(), size()
+*/
+void QPicture::setData(const char* data, uint size)
+{
+detach();
+d_func()->pictb.setData(data, size);
+d_func()->resetFormat();                                // we'll have to check
+}
+/*!
+Loads a picture from the file specified by \a fileName and returns
+true if successful; otherwise returns false.
+Please note that the \a format parameter has been deprecated and
+will have no effect.
+\sa save()
+*/
+bool QPicture::load(const QString &fileName, const char *format)
+{
+QFile f(fileName);
+if (!f.open(QIODevice::ReadOnly))
+return false;
+return load(&f, format);
+}
+/*!
+\overload
+\a dev is the device to use for loading.
+*/
+bool QPicture::load(QIODevice *dev, const char *format)
+{
+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();
+}
+/*!
+Saves a picture to the file specified by \a fileName and returns
+true if successful; otherwise returns false.
+Please note that the \a format parameter has been deprecated and
+will have no effect.
+\sa load()
+*/
+bool QPicture::save(const QString &fileName, const char *format)
+{
+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);
+}
+/*!
+\overload
+\a dev is the device to use for saving.
+*/
+bool QPicture::save(QIODevice *dev, const char *format)
+{
+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;
+}
+/*!
+Returns the picture's bounding rectangle or an invalid rectangle
+if the picture contains no data.
+*/
+QRect QPicture::boundingRect() const
+{
+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;
+}
+/*!
+Sets the picture's bounding rectangle to \a r. The automatically
+calculated value is overridden.
+*/
+void QPicture::setBoundingRect(const QRect &r)
+{
+d_func()->override_rect = r;
+}
+/*!
+Replays the picture using \a painter, and returns true if
+successful; otherwise returns false.
+This function does exactly the same as QPainter::drawPicture()
+with (x, y) = (0, 0).
+*/
+bool QPicture::play(QPainter *painter)
+{
+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
+}
+//
+// QFakeDevice is used to create fonts with a custom DPI
+//
+class QFakeDevice : public QPaintDevice
+{
+public:
+QFakeDevice() { dpi_x = qt_defaultDpiX(); dpi_y = qt_defaultDpiY(); }
+void setDpiX(int dpi) { dpi_x = dpi; }
+void setDpiY(int dpi) { dpi_y = dpi; }
+QPaintEngine *paintEngine() const { return 0; }
+int metric(PaintDeviceMetric m) const
+{
+switch(m) {
+case PdmPhysicalDpiX:
+case PdmDpiX:
+return dpi_x;
+case PdmPhysicalDpiY:
+case PdmDpiY:
+return dpi_y;
+default:
+return QPaintDevice::metric(m);
+}
+}
+private:
+int dpi_x;
+int dpi_y;
+};
+/*!
+\internal
+Iterates over the internal picture data and draws the picture using
+\a painter.
+*/
+bool QPicture::exec(QPainter *painter, QDataStream &s, int nrecords)
+{
+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;
+}
+/*!
+\internal
+Internal implementation of the virtual QPaintDevice::metric()
+function.
+A picture has the following hard-coded values: numcolors=16777216
+and depth=24.
+\a m is the metric to get.
+*/
+int QPicture::metric(PaintDeviceMetric m) const
+{
+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;
+}
+/*!
+\fn void QPicture::detach()
+\internal
+Detaches from shared picture data and makes sure that this picture
+is the only one referring to the data.
+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.
+*/
+/*! \fn bool QPicture::isDetached() const
+\internal
+*/
+/*! \internal
+### Qt 5 - remove me
+*/
+void QPicture::detach_helper()
+{
+// 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");
+}
+/*!
+Assigns picture \a p to this picture and returns a reference to
+this picture.
+*/
+QPicture& QPicture::operator=(const QPicture &p)
+{
+d_ptr = p.d_ptr;
+return *this;
+}
+/*!
+\internal
+Constructs a QPicturePrivate
+*/
+QPicturePrivate::QPicturePrivate()
+: in_memory_only(false)
+{
+}
+/*!
+\internal
+Copy-Constructs a QPicturePrivate. Needed when detaching.
+*/
+QPicturePrivate::QPicturePrivate(const QPicturePrivate &other)
+: trecs(other.trecs),
+formatOk(other.formatOk),
+formatMinor(other.formatMinor),
+brect(other.brect),
+override_rect(other.override_rect),
+in_memory_only(false)
+{
+pictb.setData(other.pictb.data(), other.pictb.size());
+if (other.pictb.isOpen()) {
+pictb.open(other.pictb.openMode());
+pictb.seek(other.pictb.pos());
+}
+}
+/*!
+\internal
+Sets formatOk to false and resets the format version numbers to default
+*/
+void QPicturePrivate::resetFormat()
+{
+formatOk = false;
+formatMajor = mfhdr_maj;
+formatMinor = mfhdr_min;
+}
+/*!
+\internal
+Checks data integrity and format version number. Set formatOk to
+true on success, to false otherwise. Returns the resulting formatOk
+value.
+*/
+bool QPicturePrivate::checkFormat()
+{
+resetFormat();
+// can't check anything in an empty buffer
+if (pictb.size() == 0 || pictb.isOpen())
+return false;
+pictb.open(QIODevice::ReadOnly);                        // open buffer device
+QDataStream s;
+s.setDevice(&pictb);                        // attach data stream to buffer
+char mf_id[4];                                // picture header tag
+s.readRawData(mf_id, 4);                        // read actual tag
+if (memcmp(mf_id, qt_mfhdr_tag, 4) != 0) {         // wrong header id
+qWarning("QPicturePaintEngine::checkFormat: Incorrect header");
+pictb.close();
+return false;
+}
+int cs_start = sizeof(quint32);                // pos of checksum word
+int data_start = cs_start + sizeof(quint16);
+quint16 cs,ccs;
+QByteArray buf = pictb.buffer();        // pointer to data
+s >> cs;                                // read checksum
+ccs = (quint16) qChecksum(buf.constData() + data_start, buf.size() - data_start);
+if (ccs != cs) {
+qWarning("QPicturePaintEngine::checkFormat: Invalid checksum %x, %x expected",
+ccs, cs);
+pictb.close();
+return false;
+}
+quint16 major, minor;
+s >> major >> minor;                        // read version number
+if (major > mfhdr_maj) {                // new, incompatible version
+qWarning("QPicturePaintEngine::checkFormat: Incompatible version %d.%d",
+major, minor);
+pictb.close();
+return false;
+}
+s.setVersion(major != 4 ? major : 3);
+quint8  c, clen;
+s >> c >> clen;
+if (c == QPicturePrivate::PdcBegin) {
+if (!(major >= 1 && major <= 3)) {
+qint32 l, t, w, h;
+s >> l >> t >> w >> h;
+brect = QRect(l, t, w, h);
+}
+} else {
+qWarning("QPicturePaintEngine::checkFormat: Format error");
+pictb.close();
+return false;
+}
+pictb.close();
+formatOk = true;                        // picture seems to be ok
+formatMajor = major;
+formatMinor = minor;
+return true;
+}
+/*! \internal */
+QPaintEngine *QPicture::paintEngine() const
+{
+if (!d_func()->paintEngine)
+const_cast<QPicture*>(this)->d_func()->paintEngine.reset(new QPicturePaintEngine);
+return d_func()->paintEngine.data();
+}
+/*****************************************************************************
+QPicture stream functions
+*****************************************************************************/
+#ifndef QT_NO_DATASTREAM
+/*!
+\relates QPicture
+Writes picture \a r to the stream \a s and returns a reference to
+the stream.
+*/
+QDataStream &operator<<(QDataStream &s, const QPicture &r)
+{
+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;
+}
+/*!
+\relates QPicture
+Reads a picture from the stream \a s into picture \a r and returns
+a reference to the stream.
+*/
+QDataStream &operator>>(QDataStream &s, QPicture &r)
+{
+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;
+}
+#endif // QT_NO_DATASTREAM
+#ifndef QT_NO_PICTUREIO
+QT_BEGIN_INCLUDE_NAMESPACE
+#include "qregexp.h"
+#include "qapplication.h"
+#include "qpictureformatplugin.h"
+QT_END_INCLUDE_NAMESPACE
+/*!
+\obsolete
+Returns a string that specifies the picture format of the file \a
+fileName, or 0 if the file cannot be read or if the format is not
+recognized.
+\sa load() save()
+*/
+const char* QPicture::pictureFormat(const QString &fileName)
+{
+return QPictureIO::pictureFormat(fileName);
+}
+/*!
+\obsolete
+Returns a list of picture formats that are supported for picture
+input.
+\sa outputFormats() inputFormatList() QPictureIO
+*/
+QList<QByteArray> QPicture::inputFormats()
+{
+return QPictureIO::inputFormats();
+}
+static QStringList qToStringList(const QList<QByteArray> arr)
+{
+QStringList list;
+for (int i = 0; i < arr.count(); ++i)
+list.append(QString::fromLatin1(arr.at(i)));
+return list;
+}
+/*!
+\obsolete
+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.
+\snippet doc/src/snippets/picture/picture.cpp 2
+\sa outputFormatList() inputFormats() QPictureIO
+*/
+QStringList QPicture::inputFormatList()
+{
+return qToStringList(QPictureIO::inputFormats());
+}
+/*!
+\obsolete
+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.
+\snippet doc/src/snippets/picture/picture.cpp 3
+\sa inputFormatList() outputFormats() QPictureIO
+*/
+QStringList QPicture::outputFormatList()
+{
+return qToStringList(QPictureIO::outputFormats());
+}
+/*!
+\obsolete
+Returns a list of picture formats that are supported for picture
+output.
+\sa inputFormats() outputFormatList() QPictureIO
+*/
+QList<QByteArray> QPicture::outputFormats()
+{
+return QPictureIO::outputFormats();
+}
+/*****************************************************************************
+QPictureIO member functions
+*****************************************************************************/
+/*!
+\obsolete
+\class QPictureIO
+\brief The QPictureIO class contains parameters for loading and
+saving pictures.
+\ingroup painting
+\ingroup io
+QPictureIO contains a QIODevice object that is used for picture data
+I/O. The programmer can install new picture file formats in addition
+to those that Qt provides.
+You don't normally need to use this class; QPicture::load(),
+QPicture::save().
+\sa QPicture QPixmap QFile
+*/
+struct QPictureIOData
+{
+QPicture        pi;                                // picture
+int                iostat;                                // IO status
+QByteArray        frmt;                                // picture format
+QIODevice  *iodev;                                // IO device
+QString        fname;                                // file name
+QString     descr;                                // picture description
+const char *parameters;
+int quality;
+float gamma;
+};
+/*!
+Constructs a QPictureIO object with all parameters set to zero.
+*/
+QPictureIO::QPictureIO()
+{
+init();
+}
+/*!
+Constructs a QPictureIO object with the I/O device \a ioDevice and a
+\a format tag.
+*/
+QPictureIO::QPictureIO(QIODevice *ioDevice, const char *format)
+{
+init();
+d->iodev = ioDevice;
+d->frmt = format;
+}
+/*!
+Constructs a QPictureIO object with the file name \a fileName and a
+\a format tag.
+*/
+QPictureIO::QPictureIO(const QString &fileName, const char* format)
+{
+init();
+d->frmt = format;
+d->fname = fileName;
+}
+/*!
+Contains initialization common to all QPictureIO constructors.
+*/
+void QPictureIO::init()
+{
+d = new QPictureIOData();
+d->parameters = 0;
+d->quality = -1; // default quality of the current format
+d->gamma=0.0f;
+d->iostat = 0;
+d->iodev  = 0;
+}
+/*!
+Destroys the object and all related data.
+*/
+QPictureIO::~QPictureIO()
+{
+if (d->parameters)
+delete [] (char*)d->parameters;
+delete d;
+}
+/*****************************************************************************
+QPictureIO picture handler functions
+*****************************************************************************/
+class QPictureHandler
+{
+public:
+QPictureHandler(const char *f, const char *h, const QByteArray& fl,
+picture_io_handler r, picture_io_handler w);
+QByteArray              format;                        // picture format
+QRegExp              header;                        // picture header pattern
+enum TMode { Untranslated=0, TranslateIn, TranslateInOut } text_mode;
+picture_io_handler  read_picture;                // picture read function
+picture_io_handler  write_picture;                // picture write function
+bool              obsolete;                        // support not "published"
+};
+QPictureHandler::QPictureHandler(const char *f, const char *h, const QByteArray& fl,
+picture_io_handler r, picture_io_handler w)
+: format(f), header(QString::fromLatin1(h))
+{
+text_mode = Untranslated;
+if (fl.contains('t'))
+text_mode = TranslateIn;
+else if (fl.contains('T'))
+text_mode = TranslateInOut;
+obsolete = fl.contains('O');
+read_picture  = r;
+write_picture = w;
+}
+typedef QList<QPictureHandler *> QPHList;
+Q_GLOBAL_STATIC(QPHList, pictureHandlers)
+#ifndef QT_NO_LIBRARY
+Q_GLOBAL_STATIC(QMutex, mutex)
+Q_GLOBAL_STATIC_WITH_ARGS(QFactoryLoader, factoryLoader,
+(QPictureFormatInterface_iid,
+QLatin1String("/pictureformats")))
+#endif
+void qt_init_picture_plugins()
+{
+#ifndef QT_NO_LIBRARY
+QMutexLocker locker(mutex());
+QFactoryLoader *loader = factoryLoader();
+QStringList keys = loader->keys();
+for (int i = 0; i < keys.count(); ++i)
+if (QPictureFormatInterface *format = qobject_cast<QPictureFormatInterface*>(loader->instance(keys.at(i))))
+format->installIOHandler(keys.at(i));
+#endif
+}
+static void cleanup()
+{
+// make sure that picture handlers are delete before plugin manager
+if (QPHList *list = pictureHandlers()) {
+qDeleteAll(*list);
+list->clear();
+}
+}
+void qt_init_picture_handlers()                // initialize picture handlers
+{
+static QBasicAtomicInt done = Q_BASIC_ATOMIC_INITIALIZER(0);
+if (done.testAndSetRelaxed(0, 1)) {
+qAddPostRoutine(cleanup);
+}
+}
+static QPictureHandler *get_picture_handler(const char *format)
+{                                                // get pointer to handler
+qt_init_picture_handlers();
+qt_init_picture_plugins();
+if (QPHList *list = pictureHandlers()) {
+for (int i = 0; i < list->size(); ++i) {
+if (list->at(i)->format == format)
+return list->at(i);
+}
+}
+return 0;                                        // no such handler
+}
+/*!
+Defines a picture I/O handler for the picture format called \a
+format, which is recognized using the regular
+expression defined in \a header, read using \a readPicture and
+written using \a writePicture.
+\a flags is a string of single-character flags for this format.
+The only flag defined currently is T (upper case), so the only
+legal value for \a flags are "T" and the empty string. The "T"
+flag means that the picture file is a text file, and Qt should treat
+all newline conventions as equivalent. (XPM files and some PPM
+files are text files for example.)
+\a format is used to select a handler to write a QPicture; \a header
+is used to select a handler to read an picture file.
+If \a readPicture is a null pointer, the QPictureIO will not be able
+to read pictures in \a format. If \a writePicture is a null pointer,
+the QPictureIO will not be able to write pictures in \a format. If
+both are null, the QPictureIO object is valid but useless.
+Example:
+\snippet doc/src/snippets/picture/picture.cpp 6
+\codeline
+\snippet doc/src/snippets/picture/picture.cpp 7
+\codeline
+\snippet doc/src/snippets/picture/picture.cpp 8
+Before the regular expression test, all the 0 bytes in the file header are
+converted to 1 bytes. This is done because when Qt was ASCII-based, QRegExp
+could not handle 0 bytes in strings.
+The regexp is only applied on the first 14 bytes of the file.
+(Note that if one handlerIO supports writing a format and another
+supports reading it, Qt supports both reading and writing. If two
+handlers support the same operation, Qt chooses one arbitrarily.)
+*/
+void QPictureIO::defineIOHandler(const char *format,
+const char *header,
+const char *flags,
+picture_io_handler readPicture,
+picture_io_handler writePicture)
+{
+qt_init_picture_handlers();
+if (QPHList *list = pictureHandlers()) {
+QPictureHandler *p;
+p = new QPictureHandler(format, header, QByteArray(flags), readPicture, writePicture);
+list->prepend(p);
+}
+}
+/*****************************************************************************
+QPictureIO normal member functions
+*****************************************************************************/
+/*!
+Returns the picture currently set.
+\sa setPicture()
+*/
+const QPicture &QPictureIO::picture() const { return d->pi; }
+/*!
+Returns the picture's IO status. A non-zero value indicates an
+error, whereas 0 means that the IO operation was successful.
+\sa setStatus()
+*/
+int QPictureIO::status() const { return d->iostat; }
+/*!
+Returns the picture format string or 0 if no format has been
+explicitly set.
+*/
+const char *QPictureIO::format() const { return d->frmt; }
+/*!
+Returns the IO device currently set.
+\sa setIODevice()
+*/
+QIODevice *QPictureIO::ioDevice() const { return d->iodev; }
+/*!
+Returns the file name currently set.
+\sa setFileName()
+*/
+QString QPictureIO::fileName() const { return d->fname; }
+/*!
+Returns the picture description string.
+\sa setDescription()
+*/
+QString QPictureIO::description() const { return d->descr; }
+/*!
+Sets the picture to \a picture.
+\sa picture()
+*/
+void QPictureIO::setPicture(const QPicture &picture)
+{
+d->pi = picture;
+}
+/*!
+Sets the picture IO status to \a status. A non-zero value indicates
+an error, whereas 0 means that the IO operation was successful.
+\sa status()
+*/
+void QPictureIO::setStatus(int status)
+{
+d->iostat = status;
+}
+/*!
+Sets the picture format to \a format for the picture to be read or
+written.
+It is necessary to specify a format before writing an picture, but
+it is not necessary to specify a format before reading an picture.
+If no format has been set, Qt guesses the picture format before
+reading it. If a format is set the picture will only be read if it
+has that format.
+\sa read() write() format()
+*/
+void QPictureIO::setFormat(const char *format)
+{
+d->frmt = format;
+}
+/*!
+Sets the IO device to be used for reading or writing an picture.
+Setting the IO device allows pictures to be read/written to any
+block-oriented QIODevice.
+If \a ioDevice is not null, this IO device will override file name
+settings.
+\sa setFileName()
+*/
+void QPictureIO::setIODevice(QIODevice *ioDevice)
+{
+d->iodev = ioDevice;
+}
+/*!
+Sets the name of the file to read or write an picture from to \a
+fileName.
+\sa setIODevice()
+*/
+void QPictureIO::setFileName(const QString &fileName)
+{
+d->fname = fileName;
+}
+/*!
+Returns the quality of the written picture, related to the
+compression ratio.
+\sa setQuality() QPicture::save()
+*/
+int QPictureIO::quality() const
+{
+return d->quality;
+}
+/*!
+Sets the quality of the written picture to \a q, related to the
+compression ratio.
+\a q must be in the range -1..100. Specify 0 to obtain small
+compressed files, 100 for large uncompressed files. (-1 signifies
+the default compression.)
+\sa quality() QPicture::save()
+*/
+void QPictureIO::setQuality(int q)
+{
+d->quality = q;
+}
+/*!
+Returns the picture's parameters string.
+\sa setParameters()
+*/
+const char *QPictureIO::parameters() const
+{
+return d->parameters;
+}
+/*!
+Sets the picture's parameter string to \a parameters. This is for
+picture handlers that require special parameters.
+Although the current picture formats supported by Qt ignore the
+parameters string, it may be used in future extensions or by
+contributions (for example, JPEG).
+\sa parameters()
+*/
+void QPictureIO::setParameters(const char *parameters)
+{
+if (d->parameters)
+delete [] (char*)d->parameters;
+d->parameters = qstrdup(parameters);
+}
+/*!
+Sets the gamma value at which the picture will be viewed to \a
+gamma. If the picture format stores a gamma value for which the
+picture is intended to be used, then this setting will be used to
+modify the picture. Setting to 0.0 will disable gamma correction
+(i.e. any specification in the file will be ignored).
+The default value is 0.0.
+\sa gamma()
+*/
+void QPictureIO::setGamma(float gamma)
+{
+d->gamma=gamma;
+}
+/*!
+Returns the gamma value at which the picture will be viewed.
+\sa setGamma()
+*/
+float QPictureIO::gamma() const
+{
+return d->gamma;
+}
+/*!
+Sets the picture description string for picture handlers that support
+picture descriptions to \a description.
+Currently, no picture format supported by Qt uses the description
+string.
+*/
+void QPictureIO::setDescription(const QString &description)
+{
+d->descr = description;
+}
+/*!
+Returns a string that specifies the picture format of the file \a
+fileName, or null if the file cannot be read or if the format is
+not recognized.
+*/
+QByteArray QPictureIO::pictureFormat(const QString &fileName)
+{
+QFile file(fileName);
+QByteArray format;
+if (!file.open(QIODevice::ReadOnly))
+return format;
+format = pictureFormat(&file);
+file.close();
+return format;
+}
+/*!
+\overload
+Returns a string that specifies the picture format of the picture read
+from IO device \a d, or 0 if the device cannot be read or if the
+format is not recognized.
+Make sure that \a d is at the right position in the device (for
+example, at the beginning of the file).
+\sa QIODevice::at()
+*/
+QByteArray QPictureIO::pictureFormat(QIODevice *d)
+{
+// if you change this change the documentation for defineIOHandler()
+const int buflen = 14;
+char buf[buflen];
+char buf2[buflen];
+qt_init_picture_handlers();
+qt_init_picture_plugins();
+int pos = d->pos();                      // save position
+int rdlen = d->read(buf, buflen);        // read a few bytes
+QByteArray format;
+if (rdlen != buflen)
+return format;
+memcpy(buf2, buf, buflen);
+for (int n = 0; n < rdlen; n++)
+if (buf[n] == '\0')
+buf[n] = '\001';
+if (rdlen > 0) {
+buf[rdlen - 1] = '\0';
+QString bufStr = QString::fromLatin1(buf);
+if (QPHList *list = pictureHandlers()) {
+for (int i = 0; i < list->size(); ++i) {
+if (list->at(i)->header.indexIn(bufStr) != -1) { // try match with headers
+format = list->at(i)->format;
+break;
+}
+}
+}
+}
+d->seek(pos);                                // restore position
+return format;
+}
+/*!
+Returns a sorted list of picture formats that are supported for
+picture input.
+*/
+QList<QByteArray> QPictureIO::inputFormats()
+{
+QList<QByteArray> result;
+qt_init_picture_handlers();
+qt_init_picture_plugins();
+if (QPHList *list = pictureHandlers()) {
+for (int i = 0; i < list->size(); ++i) {
+QPictureHandler *p = list->at(i);
+if (p->read_picture && !p->obsolete  && !result.contains(p->format))
+result.append(p->format);
+}
+}
+qSort(result);
+return result;
+}
+/*!
+Returns a sorted list of picture formats that are supported for
+picture output.
+*/
+QList<QByteArray> QPictureIO::outputFormats()
+{
+qt_init_picture_handlers();
+qt_init_picture_plugins();
+QList<QByteArray> result;
+if (QPHList *list = pictureHandlers()) {
+for (int i = 0; i < list->size(); ++i) {
+QPictureHandler *p = list->at(i);
+if (p->write_picture && !p->obsolete && !result.contains(p->format))
+result.append(p->format);
+}
+}
+return result;
+}
+/*!
+Reads an picture into memory and returns true if the picture was
+successfully read; otherwise returns false.
+Before reading an picture you must set an IO device or a file name.
+If both an IO device and a file name have been set, the IO device
+will be used.
+Setting the picture file format string is optional.
+Note that this function does \e not set the \link format()
+format\endlink used to read the picture. If you need that
+information, use the pictureFormat() static functions.
+Example:
+\snippet doc/src/snippets/picture/picture.cpp 4
+\sa setIODevice() setFileName() setFormat() write() QPixmap::load()
+*/
+bool QPictureIO::read()
+{
+QFile           file;
+const char          *picture_format;
+QPictureHandler *h;
+if (d->iodev) {                                // read from io device
+// ok, already open
+} else if (!d->fname.isEmpty()) {                // read from file
+file.setFileName(d->fname);
+if (!file.open(QIODevice::ReadOnly))
+return false;                        // cannot open file
+d->iodev = &file;
+} else {                                        // no file name or io device
+return false;
+}
+if (d->frmt.isEmpty()) {
+// Try to guess format
+picture_format = pictureFormat(d->iodev);        // get picture format
+if (!picture_format) {
+if (file.isOpen()) {                        // unknown format
+file.close();
+d->iodev = 0;
+}
+return false;
+}
+} else {
+picture_format = d->frmt;
+}
+h = get_picture_handler(picture_format);
+if (file.isOpen()) {
+#if !defined(Q_OS_UNIX)
+if (h && h->text_mode) {                // reopen in translated mode
+file.close();
+file.open(QIODevice::ReadOnly | QIODevice::Text);
+}
+else
+#endif
+file.seek(0);                        // position to start
+}
+d->iostat = 1;                                        // assume error
+if (h && h->read_picture)
+(*h->read_picture)(this);
+if (file.isOpen()) {                        // picture was read using file
+file.close();
+d->iodev = 0;
+}
+return d->iostat == 0;                                // picture successfully read?
+}
+/*!
+Writes an picture to an IO device and returns true if the picture was
+successfully written; otherwise returns false.
+Before writing an picture you must set an IO device or a file name.
+If both an IO device and a file name have been set, the IO device
+will be used.
+The picture will be written using the specified picture format.
+Example:
+\snippet doc/src/snippets/picture/picture.cpp 5
+\sa setIODevice() setFileName() setFormat() read() QPixmap::save()
+*/
+bool QPictureIO::write()
+{
+if (d->frmt.isEmpty())
+return false;
+QPictureHandler *h = get_picture_handler(d->frmt);
+if (!h || !h->write_picture) {
+qWarning("QPictureIO::write: No such picture format handler: %s",
+format());
+return false;
+}
+QFile file;
+if (!d->iodev && !d->fname.isEmpty()) {
+file.setFileName(d->fname);
+bool translate = h->text_mode==QPictureHandler::TranslateInOut;
+QIODevice::OpenMode fmode = translate ? QIODevice::WriteOnly | QIODevice::Text : QIODevice::OpenMode(QIODevice::WriteOnly);
+if (!file.open(fmode))                // couldn't create file
+return false;
+d->iodev = &file;
+}
+d->iostat = 1;
+(*h->write_picture)(this);
+if (file.isOpen()) {                        // picture was written using file
+file.close();
+d->iodev = 0;
+}
+return d->iostat == 0;                                // picture successfully written?
+}
+#endif //QT_NO_PICTUREIO
+/*!
+\fn QPicture QPicture::copy() const
+Use simple assignment instead.
+*/
+QT_END_NAMESPACE
+#endif // QT_NO_PICTURE
+/*!
+\typedef QPicture::DataPtr
+\internal
+*/
+/*!
+\fn DataPtr &QPicture::data_ptr()
+\internal
+*/

changeset 0	1918ee327afb
child 4	3b1da2848fc7