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

equal deleted inserted replaced

-:5dc02b23752f
+:3e2da88830cd
 #if defined(Q_OS_SYMBIAN)
 # include <private/qt_s60_p.h>
 #endif
 #include "qpixmap_raster_p.h"
+#include "private/qstylehelper_p.h"
 QT_BEGIN_NAMESPACE
 // ### Qt 5: remove
 Q_GUI_EXPORT qint64 qt_pixmap_id(const QPixmap &pixmap)
 }
 if (size() == s)
 return;
+// QPixmap.data member may be QRuntimePixmapData so use pixmapData() function to get
+// the actual underlaying runtime pixmap data.
+QPixmapData *pd = pixmapData();
 // Create new pixmap
-QPixmap pm(QSize(w, h), data ? data->type : QPixmapData::PixmapType);
+QPixmap pm(QSize(w, h), pd ? pd->type : QPixmapData::PixmapType);
 bool uninit = false;
 #if defined(Q_WS_X11)
-QX11PixmapData *x11Data = data && data->classId() == QPixmapData::X11Class ? static_cast<QX11PixmapData*>(data.data()) : 0;
+QX11PixmapData *x11Data = pd && pd->classId() == QPixmapData::X11Class ? static_cast<QX11PixmapData*>(pd) : 0;
 if (x11Data) {
 pm.x11SetScreen(x11Data->xinfo.screen());
 uninit = x11Data->flags & QX11PixmapData::Uninitialized;
 }
 #elif defined(Q_WS_MAC)
-QMacPixmapData *macData = data && data->classId() == QPixmapData::MacClass ? static_cast<QMacPixmapData*>(data.data()) : 0;
+QMacPixmapData *macData = pd && pd->classId() == QPixmapData::MacClass ? static_cast<QMacPixmapData*>(pd) : 0;
 if (macData)
 uninit = macData->uninit;
 #endif
 if (!uninit && !isNull()) {
 // Copy old pixmap
 p.drawPixmap(0, 0, *this, 0, 0, qMin(width(), w), qMin(height(), h));
 }
 #if defined(Q_WS_X11)
 if (x11Data && x11Data->x11_mask) {
-QX11PixmapData *pmData = static_cast<QX11PixmapData*>(pm.data.data());
+QX11PixmapData *pmData = static_cast<QX11PixmapData*>(pd);
 pmData->x11_mask = (Qt::HANDLE)XCreatePixmap(X11->display,
 RootWindow(x11Data->xinfo.display(),
 x11Data->xinfo.screen()),
 w, h, 1);
 GC gc = XCreateGC(X11->display, pmData->x11_mask, 0, 0);
 {
 if (fileName.isEmpty())
 return false;
 QFileInfo info(fileName);
-QString key = QLatin1String("qt_pixmap_") + info.absoluteFilePath() + QLatin1Char('_') + QString::number(info.lastModified().toTime_t()) + QLatin1Char('_') +
+if (!info.exists())
-QString::number(info.size()) + QLatin1Char('_') + QString::number(data ? data->pixelType() : QPixmapData::PixmapType);
+return false;
+QString key = QLatin1Literal("qt_pixmap")
+% info.absoluteFilePath()
+% HexString<uint>(info.lastModified().toTime_t())
+% HexString<quint64>(info.size())
+% HexString<uint>(data ? data->pixelType() : QPixmapData::PixmapType);
 if (QPixmapCache::find(key, *this))
 return true;
 QScopedPointer<QPixmapData> tmp(QPixmapData::create(0, 0, data ? data->type : QPixmapData::PixmapType));
 */
 Qt::HANDLE QPixmap::handle() const
 {
 #if defined(Q_WS_X11)
-if (data && data->classId() == QPixmapData::X11Class)
+const QPixmapData *pd = pixmapData();
-return static_cast<const QX11PixmapData*>(data.constData())->handle();
+if (pd && pd->classId() == QPixmapData::X11Class)
+return static_cast<const QX11PixmapData*>(pd)->handle();
 #endif
 return 0;
 }
 #endif
 Writes the given \a pixmap to the given \a stream as a PNG
 image. Note that writing the stream to a file will not produce a
 valid image file.
-\sa QPixmap::save(), {Format of the QDataStream Operators}
+\sa QPixmap::save(), {Serializing Qt Data Types}
 */
 QDataStream &operator<<(QDataStream &stream, const QPixmap &pixmap)
 {
 return stream << pixmap.toImage();
 /*!
 \relates QPixmap
 Reads an image from the given \a stream into the given \a pixmap.
-\sa QPixmap::load(), {Format of the QDataStream Operators}
+\sa QPixmap::load(), {Serializing Qt Data Types}
 */
 QDataStream &operator>>(QDataStream &stream, QPixmap &pixmap)
 {
 QImage image;
 i.e. transformed() returns the smallest pixmap containing all
 transformed points of the original pixmap. The static trueMatrix()
 function returns the actual matrix used for transforming the
 pixmap.
+\note When using the native X11 graphics system, the pixmap
+becomes invalid when the QApplication instance is destroyed.
 \sa QBitmap, QImage, QImageReader, QImageWriter
 */
 /*!
 void QPixmap::detach()
 {
 if (!data)
 return;
-QPixmapData::ClassId id = data->classId();
+// QPixmap.data member may be QRuntimePixmapData so use pixmapData() function to get
+// the actual underlaying runtime pixmap data.
+QPixmapData *pd = pixmapData();
+QPixmapData::ClassId id = pd->classId();
 if (id == QPixmapData::RasterClass) {
-QRasterPixmapData *rasterData = static_cast<QRasterPixmapData*>(data.data());
+QRasterPixmapData *rasterData = static_cast<QRasterPixmapData*>(pd);
 rasterData->image.detach();
 }
 if (data->is_cached && data->ref == 1)
-QImagePixmapCleanupHooks::executePixmapDataModificationHooks(data.data());
+QImagePixmapCleanupHooks::executePixmapDataModificationHooks(pd);
 #if defined(Q_WS_MAC)
-QMacPixmapData *macData = id == QPixmapData::MacClass ? static_cast<QMacPixmapData*>(data.data()) : 0;
+QMacPixmapData *macData = id == QPixmapData::MacClass ? static_cast<QMacPixmapData*>(pd) : 0;
 if (macData) {
 if (macData->cg_mask) {
 CGImageRelease(macData->cg_mask);
 macData->cg_mask = 0;
 }
 *this = copy();
 }
 ++data->detach_no;
 #if defined(Q_WS_X11)
-if (data->classId() == QPixmapData::X11Class) {
+if (pd->classId() == QPixmapData::X11Class) {
-QX11PixmapData *d = static_cast<QX11PixmapData*>(data.data());
+QX11PixmapData *d = static_cast<QX11PixmapData*>(pd);
 d->flags &= ~QX11PixmapData::Uninitialized;
 // reset the cache data
 if (d->hd2) {
 XFreePixmap(X11->display, d->hd2);
 In case of monochrome and 8-bit images, the image is first
 converted to a 32-bit pixmap and then filled with the colors in
 the color table. If this is too expensive an operation, you can
 use QBitmap::fromImage() instead.
-\sa toImage(), {QPixmap#Pixmap Conversion}{Pixmap Conversion}
+\sa fromImageReader(), toImage(), {QPixmap#Pixmap Conversion}{Pixmap Conversion}
 */
 QPixmap QPixmap::fromImage(const QImage &image, Qt::ImageConversionFlags flags)
 {
 if (image.isNull())
 return QPixmap();
 data->fromImage(image, flags);
 return QPixmap(data.take());
 }
 /*!
+\fn QPixmap QPixmap::fromImageReader(QImageReader *imageReader, Qt::ImageConversionFlags flags)
+Create a QPixmap from an image read directly from an \a imageReader.
+The \a flags argument is a bitwise-OR of the \l{Qt::ImageConversionFlags}.
+Passing 0 for \a flags sets all the default options.
+On some systems, reading an image directly to QPixmap can use less memory than
+reading a QImage to convert it to QPixmap.
+\sa fromImage(), toImage(), {QPixmap#Pixmap Conversion}{Pixmap Conversion}
+*/
+QPixmap QPixmap::fromImageReader(QImageReader *imageReader, Qt::ImageConversionFlags flags)
+{
+QGraphicsSystem *gs = QApplicationPrivate::graphicsSystem();
+QScopedPointer<QPixmapData> data(gs ? gs->createPixmapData(QPixmapData::PixmapType)
+: QGraphicsSystem::createDefaultPixmapData(QPixmapData::PixmapType));
+data->fromImageReader(imageReader, flags);
+return QPixmap(data.take());
+}
+/*!
 \fn QPixmap QPixmap::grabWindow(WId window, int x, int y, int
 width, int height)
 Creates and returns a pixmap constructed by grabbing the contents
 of the given \a window restricted by QRect(\a x, \a y, \a width,
 /*!
 \internal
 */
 QPixmapData* QPixmap::pixmapData() const
 {
-return data.data();
+if (data) {
-}
+QPixmapData* pm = data.data();
+return pm->runtimeData() ? pm->runtimeData() : pm;
+}
+return 0;
+}
 /*!
 \enum QPixmap::HBitmapFormat
 \bold{Win32 only:} This enum defines how the conversion between \c

changeset 33	3e2da88830cd
parent 30	5dc02b23752f
child 37	758a864f9613