Merge remote-tracking branch 'origin/4.7' into qt-master-from-4.7

Conflicts:
	src/openvg/qvg_symbian.cpp
	src/s60installs/bwins/QtGuiu.def
	src/s60installs/eabi/QtGuiu.def

7 files changed, 1114 insertions, 3 deletions

diff --git a/src/gui/image/image.pri b/src/gui/image/image.pri
index 92ea397..a5e37f3 100644
--- a/src/gui/image/image.pri
+++ b/src/gui/image/image.pri
@@ -29,7 +29,9 @@ HEADERS += \
         image/qpixmapdata_p.h \
         image/qpixmapdatafactory_p.h \
         image/qpixmapfilter_p.h \
-        image/qimagepixmapcleanuphooks_p.h
+        image/qimagepixmapcleanuphooks_p.h \
+        image/qvolatileimage_p.h \
+        image/qvolatileimagedata_p.h
 
 SOURCES += \
         image/qbitmap.cpp \
@@ -53,7 +55,8 @@ SOURCES += \
         image/qpixmap_raster.cpp \
         image/qpixmap_blitter.cpp \
         image/qnativeimage.cpp \
-        image/qimagepixmapcleanuphooks.cpp
+        image/qimagepixmapcleanuphooks.cpp \
+        image/qvolatileimage.cpp
 
 win32 {
     SOURCES += image/qpixmap_win.cpp
@@ -77,6 +80,13 @@ else:symbian {
     SOURCES += image/qpixmap_s60.cpp
 }
 
+!symbian|contains(S60_VERSION, 3.1)|contains(S60_VERSION, 3.2) {
+    SOURCES += image/qvolatileimagedata.cpp
+}
+else {
+    SOURCES += image/qvolatileimagedata_symbian.cpp
+}
+
 # Built-in image format support
 HEADERS += \
         image/qbmphandler_p.h \
diff --git a/src/gui/image/qpixmapdata_p.h b/src/gui/image/qpixmapdata_p.h
index 5c05c28..db5ff4a 100644
--- a/src/gui/image/qpixmapdata_p.h
+++ b/src/gui/image/qpixmapdata_p.h
@@ -71,7 +71,8 @@ public:
 #if defined(Q_OS_SYMBIAN)
     enum NativeType {
         FbsBitmap,
-        SgImage
+        SgImage,
+        VolatileImage
     };
 #endif
     enum ClassId { RasterClass, X11Class, MacClass, DirectFBClass,
diff --git a/src/gui/image/qvolatileimage.cpp b/src/gui/image/qvolatileimage.cpp
new file mode 100644
index 0000000..098e9a1
--- /dev/null
+++ b/src/gui/image/qvolatileimage.cpp
@@ -0,0 +1,318 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 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 "qvolatileimage_p.h"
+#include "qvolatileimagedata_p.h"
+#include <QtGui/private/qpaintengine_raster_p.h>
+#include <QtGui/private/qpixmapdata_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QVolatileImagePaintEnginePrivate : public QRasterPaintEnginePrivate
+{
+public:
+    QVolatileImagePaintEnginePrivate() { }
+    QVolatileImage *img;
+};
+
+class QVolatileImagePaintEngine : public QRasterPaintEngine
+{
+    Q_DECLARE_PRIVATE(QVolatileImagePaintEngine)
+
+public:
+    QVolatileImagePaintEngine(QPaintDevice *device, QVolatileImage *img);
+    bool begin(QPaintDevice *device);
+    bool end();
+    void drawPixmap(const QPointF &p, const QPixmap &pm);
+    void drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr);
+};
+
+QVolatileImage::QVolatileImage()
+    : d(new QVolatileImageData)
+{
+}
+
+QVolatileImage::QVolatileImage(int w, int h, QImage::Format format)
+    : d(new QVolatileImageData(w, h, format))
+{
+}
+
+QVolatileImage::QVolatileImage(const QImage &sourceImage)
+    : d(new QVolatileImageData(sourceImage))
+{
+}
+
+QVolatileImage::QVolatileImage(void *nativeImage, void *nativeMask)
+    : d(new QVolatileImageData(nativeImage, nativeMask))
+{
+}
+
+// Need non-inline, non-autogenerated copy ctor, dtor, op= to keep the
+// fwd declared QSharedData working.
+
+QVolatileImage::QVolatileImage(const QVolatileImage &other)
+    : d(other.d)
+{
+}
+
+QVolatileImage::~QVolatileImage()
+{
+}
+
+QVolatileImage &QVolatileImage::operator=(const QVolatileImage &rhs)
+{
+    d = rhs.d;
+    return *this;
+}
+
+bool QVolatileImage::isNull() const
+{
+    return d->image.isNull();
+}
+
+QImage::Format QVolatileImage::format() const
+{
+    return d->image.format();
+}
+
+int QVolatileImage::width() const
+{
+    return d->image.width();
+}
+
+int QVolatileImage::height() const
+{
+    return d->image.height();
+}
+
+int QVolatileImage::bytesPerLine() const
+{
+    return d->image.bytesPerLine();
+}
+
+int QVolatileImage::byteCount() const
+{
+    return d->image.byteCount();
+}
+
+int QVolatileImage::depth() const
+{
+    return d->image.depth();
+}
+
+bool QVolatileImage::hasAlphaChannel() const
+{
+    return d->image.hasAlphaChannel();
+}
+
+void QVolatileImage::beginDataAccess() const
+{
+    d->beginDataAccess();
+}
+
+void QVolatileImage::endDataAccess(bool readOnly) const
+{
+    d->endDataAccess(readOnly);
+}
+
+/*!
+  Access to pixel data via bits() or constBits() should be guarded by
+  begin/endDataAccess().
+ */
+uchar *QVolatileImage::bits()
+{
+    return d->image.bits();
+}
+
+const uchar *QVolatileImage::constBits() const
+{
+    return d->image.constBits();
+}
+
+bool QVolatileImage::ensureFormat(QImage::Format format)
+{
+    return d->ensureFormat(format);
+}
+
+/*!
+  This will always perform a copy of the pixel data.
+ */
+QImage QVolatileImage::toImage() const
+{
+    d->beginDataAccess();
+    QImage newImage = d->image.copy(); // no sharing allowed
+    d->endDataAccess(true);
+    return newImage;
+}
+
+/*!
+  Returns a reference to the image that is potentially using some native
+  buffer internally. Access to the image's pixel data should be guarded by
+  begin/endDataAccess(). Use it when there is a need for QImage APIs not provided
+  by this class. The returned QImage must never be shared or assigned to.
+  */
+QImage &QVolatileImage::imageRef() // non-const, in order to cause a detach
+{
+    d->ensureImage();
+    return d->image;
+}
+
+void *QVolatileImage::duplicateNativeImage() const
+{
+    return d->duplicateNativeImage();
+}
+
+void QVolatileImage::setAlphaChannel(const QPixmap &alphaChannel)
+{
+    ensureFormat(QImage::Format_ARGB32_Premultiplied);
+    beginDataAccess();
+    imageRef().setAlphaChannel(alphaChannel.toImage());
+    endDataAccess();
+    d->ensureImage();
+}
+
+void QVolatileImage::fill(uint pixelValue)
+{
+    beginDataAccess();
+    imageRef().fill(pixelValue);
+    endDataAccess();
+    d->ensureImage();
+}
+
+void QVolatileImage::copyFrom(QVolatileImage *source, const QRect &rect)
+{
+    if (source->isNull()) {
+        return;
+    }
+    QRect r = rect;
+    if (rect.isNull()) {
+        r = QRect(0, 0, source->width(), source->height());
+    }
+    source->beginDataAccess();
+    QImage &srcImgRef(source->imageRef());
+    int srcbpl = srcImgRef.bytesPerLine();
+    int srcbpp = srcImgRef.depth() / 8;
+    const uchar *sptr = srcImgRef.constBits() + r.y() * srcbpl;
+    beginDataAccess();
+    QImage &dstImgRef(imageRef());
+    int dstbpl = dstImgRef.bytesPerLine();
+    uchar *dptr = dstImgRef.bits();
+    for (int y = 0; y < r.height(); ++y) {
+        qMemCopy(dptr, sptr + r.x() * srcbpp, r.width() * srcbpp);
+        sptr += srcbpl;
+        dptr += dstbpl;
+    }
+    endDataAccess();
+    source->endDataAccess(true);
+}
+
+/*!
+    To be called from the PixmapData's paintEngine().
+  */
+QPaintEngine *QVolatileImage::paintEngine()
+{
+    if (!d->pengine) {
+        d->pengine = new QVolatileImagePaintEngine(&imageRef(), this);
+    }
+    return d->pengine;
+}
+
+QVolatileImagePaintEngine::QVolatileImagePaintEngine(QPaintDevice *device,
+                                                             QVolatileImage *img)
+    : QRasterPaintEngine(*(new QVolatileImagePaintEnginePrivate), device)
+{
+    Q_D(QVolatileImagePaintEngine);
+    d->img = img;
+}
+
+bool QVolatileImagePaintEngine::begin(QPaintDevice *device)
+{
+    Q_D(QVolatileImagePaintEngine);
+    d->img->beginDataAccess();
+    return QRasterPaintEngine::begin(device);
+}
+
+bool QVolatileImagePaintEngine::end()
+{
+    Q_D(QVolatileImagePaintEngine);
+    bool ret = QRasterPaintEngine::end();
+    d->img->endDataAccess();
+    return ret;
+}
+
+// For non-RasterClass pixmaps drawPixmap() would call toImage() which is slow in
+// our case. Therefore drawPixmap() is rerouted to drawImage().
+
+void QVolatileImagePaintEngine::drawPixmap(const QPointF &p, const QPixmap &pm)
+{
+#ifdef Q_OS_SYMBIAN
+    void *nativeData = pm.pixmapData()->toNativeType(QPixmapData::VolatileImage);
+    if (nativeData) {
+        QVolatileImage *img = static_cast<QVolatileImage *>(nativeData);
+        img->beginDataAccess();
+        QRasterPaintEngine::drawImage(p, img->imageRef());
+        img->endDataAccess(true);
+    } else {
+        QRasterPaintEngine::drawPixmap(p, pm);
+    }
+#else
+    QRasterPaintEngine::drawPixmap(p, pm);
+#endif
+}
+
+void QVolatileImagePaintEngine::drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr)
+{
+#ifdef Q_OS_SYMBIAN
+    void *nativeData = pm.pixmapData()->toNativeType(QPixmapData::VolatileImage);
+    if (nativeData) {
+        QVolatileImage *img = static_cast<QVolatileImage *>(nativeData);
+        img->beginDataAccess();
+        QRasterPaintEngine::drawImage(r, img->imageRef(), sr);
+        img->endDataAccess(true);
+    } else {
+        QRasterPaintEngine::drawPixmap(r, pm, sr);
+    }
+#else
+    QRasterPaintEngine::drawPixmap(r, pm, sr);
+#endif
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/image/qvolatileimage_p.h b/src/gui/image/qvolatileimage_p.h
new file mode 100644
index 0000000..fc5d6b1
--- /dev/null
+++ b/src/gui/image/qvolatileimage_p.h
@@ -0,0 +1,101 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 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$
+**
+****************************************************************************/
+
+#ifndef QVOLATILEIMAGE_P_H
+#define QVOLATILEIMAGE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtGui/qimage.h>
+#include <QtCore/qshareddata.h>
+
+QT_BEGIN_NAMESPACE
+
+class QVolatileImageData;
+
+class Q_GUI_EXPORT QVolatileImage
+{
+public:
+    QVolatileImage();
+    QVolatileImage(int w, int h, QImage::Format format);
+    explicit QVolatileImage(const QImage &sourceImage);
+    explicit QVolatileImage(void *nativeImage, void *nativeMask = 0);
+    QVolatileImage(const QVolatileImage &other);
+    ~QVolatileImage();
+    QVolatileImage &operator=(const QVolatileImage &rhs);
+
+    bool isNull() const;
+    QImage::Format format() const;
+    int width() const;
+    int height() const;
+    int bytesPerLine() const;
+    int byteCount() const;
+    int depth() const;
+    bool hasAlphaChannel() const;
+    void beginDataAccess() const;
+    void endDataAccess(bool readOnly = false) const;
+    uchar *bits();
+    const uchar *constBits() const;
+    bool ensureFormat(QImage::Format format);
+    QImage toImage() const;
+    QImage &imageRef();
+    QPaintEngine *paintEngine();
+    void setAlphaChannel(const QPixmap &alphaChannel);
+    void fill(uint pixelValue);
+    void *duplicateNativeImage() const;
+    void copyFrom(QVolatileImage *source, const QRect &rect);
+
+private:
+    QSharedDataPointer<QVolatileImageData> d;
+};
+
+QT_END_NAMESPACE
+
+#endif // QVOLATILEIMAGE_P_H
diff --git a/src/gui/image/qvolatileimagedata.cpp b/src/gui/image/qvolatileimagedata.cpp
new file mode 100644
index 0000000..51b5995
--- /dev/null
+++ b/src/gui/image/qvolatileimagedata.cpp
@@ -0,0 +1,113 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 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 "qvolatileimagedata_p.h"
+#include <QtGui/qpaintengine.h>
+
+QT_BEGIN_NAMESPACE
+
+QVolatileImageData::QVolatileImageData()
+    : pengine(0)
+{
+}
+
+QVolatileImageData::QVolatileImageData(int w, int h, QImage::Format format)
+    : pengine(0)
+{
+    image = QImage(w, h, format);
+}
+
+QVolatileImageData::QVolatileImageData(const QImage &sourceImage)
+    : pengine(0)
+{
+    image = sourceImage;
+}
+
+QVolatileImageData::QVolatileImageData(void *, void *)
+    : pengine(0)
+{
+    // Not supported.
+}
+
+QVolatileImageData::QVolatileImageData(const QVolatileImageData &other)
+{
+    image = other.image;
+    // The detach is not mandatory here but we do it nonetheless in order to
+    // keep the behavior consistent with other platforms.
+    image.detach();
+    pengine = 0;
+}
+
+QVolatileImageData::~QVolatileImageData()
+{
+    delete pengine;
+}
+
+void QVolatileImageData::beginDataAccess() const
+{
+    // nothing to do here
+}
+
+void QVolatileImageData::endDataAccess(bool readOnly) const
+{
+    Q_UNUSED(readOnly);
+    // nothing to do here
+}
+
+bool QVolatileImageData::ensureFormat(QImage::Format format)
+{
+    if (image.format() != format) {
+        image = image.convertToFormat(format);
+    }
+    return true;
+}
+
+void *QVolatileImageData::duplicateNativeImage() const
+{
+    return 0;
+}
+
+void QVolatileImageData::ensureImage()
+{
+    // nothing to do here
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/image/qvolatileimagedata_p.h b/src/gui/image/qvolatileimagedata_p.h
new file mode 100644
index 0000000..dab1685
--- /dev/null
+++ b/src/gui/image/qvolatileimagedata_p.h
@@ -0,0 +1,97 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 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$
+**
+****************************************************************************/
+
+#ifndef QVOLATILEIMAGEDATA_P_H
+#define QVOLATILEIMAGEDATA_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtGui/qimage.h>
+#include <QtCore/qshareddata.h>
+
+#ifdef Q_OS_SYMBIAN
+class CFbsBitmap;
+#endif
+
+QT_BEGIN_NAMESPACE
+
+class QVolatileImageData : public QSharedData
+{
+public:
+    QVolatileImageData();
+    QVolatileImageData(int w, int h, QImage::Format format);
+    QVolatileImageData(const QImage &sourceImage);
+    QVolatileImageData(void *nativeImage, void *nativeMask);
+    QVolatileImageData(const QVolatileImageData &other);
+    ~QVolatileImageData();
+
+    void beginDataAccess() const;
+    void endDataAccess(bool readOnly = false) const;
+    bool ensureFormat(QImage::Format format);
+    void *duplicateNativeImage() const;
+    void ensureImage();
+
+#ifdef Q_OS_SYMBIAN
+    void updateImage();
+    void initWithBitmap(CFbsBitmap *source);
+    void applyMask(CFbsBitmap *mask);
+    void ensureBitmap();
+    void release();
+    QVolatileImageData *next;
+    QVolatileImageData *prev;
+    CFbsBitmap *bitmap;
+#endif
+    QImage image;
+    QPaintEngine *pengine;
+};
+
+QT_END_NAMESPACE
+
+#endif // QVOLATILEIMAGEDATA_P_H
diff --git a/src/gui/image/qvolatileimagedata_symbian.cpp b/src/gui/image/qvolatileimagedata_symbian.cpp
new file mode 100644
index 0000000..474d0ef
--- /dev/null
+++ b/src/gui/image/qvolatileimagedata_symbian.cpp
@@ -0,0 +1,471 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 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 "qvolatileimagedata_p.h"
+#include <fbs.h>
+#include <QtGui/private/qt_s60_p.h>
+#include <QtGui/qpaintengine.h>
+#include <QtGui/private/qimage_p.h>
+
+QT_BEGIN_NAMESPACE
+
+static CFbsBitmap *rasterizeBitmap(CFbsBitmap *bitmap, TDisplayMode newMode)
+{
+    if (!bitmap) {
+        return 0;
+    }
+    QScopedPointer<CFbsBitmap> newBitmap(new CFbsBitmap);
+    if (newBitmap->Create(bitmap->SizeInPixels(), newMode) != KErrNone) {
+        qWarning("QVolatileImage: Failed to create new bitmap");
+        return 0;
+    }
+    CFbsBitmapDevice *bitmapDevice = 0;
+    CFbsBitGc *bitmapGc = 0;
+    QT_TRAP_THROWING(bitmapDevice = CFbsBitmapDevice::NewL(newBitmap.data()));
+    QScopedPointer<CFbsBitmapDevice> bitmapDevicePtr(bitmapDevice);
+    QT_TRAP_THROWING(bitmapGc = CFbsBitGc::NewL());
+    bitmapGc->Activate(bitmapDevice);
+    bitmapGc->BitBlt(TPoint(), bitmap);
+    delete bitmapGc;
+    return newBitmap.take();
+}
+
+static inline TDisplayMode format2TDisplayMode(QImage::Format format)
+{
+    TDisplayMode mode;
+    switch (format) {
+    case QImage::Format_MonoLSB:
+        mode = EGray2;
+        break;
+    case QImage::Format_Indexed8:
+        mode = EColor256;
+        break;
+    case QImage::Format_RGB444:
+        mode = EColor4K;
+        break;
+    case QImage::Format_RGB16:
+        mode = EColor64K;
+        break;
+    case QImage::Format_RGB888:
+        mode = EColor16M;
+        break;
+    case QImage::Format_RGB32:
+        mode = EColor16MU;
+        break;
+    case QImage::Format_ARGB32:
+        mode = EColor16MA;
+        break;
+    case QImage::Format_ARGB32_Premultiplied:
+        mode = Q_SYMBIAN_ECOLOR16MAP;
+        break;
+    default:
+        mode = ENone;
+        break;
+    }
+    return mode;
+}
+
+static CFbsBitmap *imageToBitmap(const QImage &image)
+{
+    if (image.isNull()) {
+        return 0;
+    }
+    CFbsBitmap *bitmap = new CFbsBitmap;
+    if (bitmap->Create(TSize(image.width(), image.height()),
+                       format2TDisplayMode(image.format())) == KErrNone) {
+        bitmap->BeginDataAccess();
+        uchar *dptr = reinterpret_cast<uchar *>(bitmap->DataAddress());
+        int bmpLineLen = bitmap->DataStride();
+        int imgLineLen = image.bytesPerLine();
+        if (bmpLineLen == imgLineLen) {
+            qMemCopy(dptr, image.constBits(), image.byteCount());
+        } else {
+            int len = qMin(bmpLineLen, imgLineLen);
+            const uchar *sptr = image.constBits();
+            for (int y = 0; y < image.height(); ++y) {
+                qMemCopy(dptr, sptr, len);
+                dptr += bmpLineLen;
+                sptr += imgLineLen;
+            }
+        }
+        bitmap->EndDataAccess();
+    } else {
+        qWarning("QVolatileImage: Failed to create source bitmap");
+        delete bitmap;
+        bitmap = 0;
+    }
+    return bitmap;
+}
+
+static CFbsBitmap *copyData(const QVolatileImageData &source)
+{
+    source.beginDataAccess();
+    CFbsBitmap *bmp = imageToBitmap(source.image);
+    source.endDataAccess();
+    return bmp;
+}
+
+static CFbsBitmap *convertData(const QVolatileImageData &source, QImage::Format newFormat)
+{
+    source.beginDataAccess();
+    QImage img = source.image.convertToFormat(newFormat);
+    CFbsBitmap *bmp = imageToBitmap(img);
+    source.endDataAccess();
+    return bmp;
+}
+
+static CFbsBitmap *duplicateBitmap(const CFbsBitmap &sourceBitmap)
+{
+    CFbsBitmap *bitmap = new CFbsBitmap;
+    if (bitmap->Duplicate(sourceBitmap.Handle()) != KErrNone) {
+        qWarning("QVolatileImage: Failed to duplicate source bitmap");
+        delete bitmap;
+        bitmap = 0;
+    }
+    return bitmap;
+}
+
+static CFbsBitmap *createBitmap(int w, int h, QImage::Format format)
+{
+    CFbsBitmap *bitmap = new CFbsBitmap;
+    if (bitmap->Create(TSize(w, h), format2TDisplayMode(format)) != KErrNone) {
+        qWarning("QVolatileImage: Failed to create source bitmap %d,%d (%d)", w, h, format);
+        delete bitmap;
+        bitmap = 0;
+    }
+    return bitmap;
+}
+
+static inline bool bitmapNeedsCopy(CFbsBitmap *bitmap)
+{
+    bool needsCopy = bitmap->IsCompressedInRAM();
+#ifdef Q_SYMBIAN_HAS_EXTENDED_BITMAP_TYPE
+    needsCopy |= (bitmap->ExtendedBitmapType() != KNullUid);
+#endif
+    return needsCopy;
+}
+
+static bool cleanup_function_registered = false;
+static QVolatileImageData *firstImageData = 0;
+
+static void cleanup()
+{
+    if (RFbsSession::GetSession()) {
+        QVolatileImageData *imageData = firstImageData;
+        while (imageData) {
+            imageData->release();
+            imageData = imageData->next;
+        }
+    }
+}
+
+static void ensureCleanup()
+{
+    // Destroy all underlying bitmaps in a post routine to prevent panics.
+    // This is a must because CFbsBitmap destructor needs the fbs session,
+    // that was used to create the bitmap, to be open still.
+    if (!cleanup_function_registered) {
+        qAddPostRoutine(cleanup);
+        cleanup_function_registered = true;
+    }
+}
+
+static void registerImageData(QVolatileImageData *imageData)
+{
+    ensureCleanup();
+    imageData->next = firstImageData;
+    if (firstImageData) {
+        firstImageData->prev = imageData;
+    }
+    firstImageData = imageData;
+}
+
+static void unregisterImageData(QVolatileImageData *imageData)
+{
+    if (imageData->prev) {
+        imageData->prev->next = imageData->next;
+    } else {
+        firstImageData = imageData->next;
+    }
+    if (imageData->next) {
+        imageData->next->prev = imageData->prev;
+    }
+}
+
+QVolatileImageData::QVolatileImageData()
+    : next(0), prev(0), bitmap(0), pengine(0)
+{
+    registerImageData(this);
+}
+
+QVolatileImageData::QVolatileImageData(int w, int h, QImage::Format format)
+    : next(0), prev(0), bitmap(0), pengine(0)
+{
+    registerImageData(this);
+    bitmap = createBitmap(w, h, format);
+    updateImage();
+}
+
+QVolatileImageData::QVolatileImageData(const QImage &sourceImage)
+    : next(0), prev(0), bitmap(0), pengine(0)
+{
+    registerImageData(this);
+    image = sourceImage;
+    // The following is not mandatory, but we do it here to have a bitmap
+    // created always in order to reduce local heap usage.
+    ensureBitmap();
+}
+
+QVolatileImageData::QVolatileImageData(void *nativeImage, void *nativeMask)
+    : next(0), prev(0), bitmap(0), pengine(0)
+{
+    registerImageData(this);
+    if (nativeImage) {
+        CFbsBitmap *source = static_cast<CFbsBitmap *>(nativeImage);
+        CFbsBitmap *mask = static_cast<CFbsBitmap *>(nativeMask);
+        initWithBitmap(source);
+        if (mask) {
+            applyMask(mask);
+        }
+    }
+}
+
+QVolatileImageData::QVolatileImageData(const QVolatileImageData &other)
+{
+    bitmap = 0;
+    pengine = 0;
+    next = prev = 0;
+    registerImageData(this);
+    if (!other.image.isNull()) {
+        bitmap = copyData(other);
+        updateImage();
+    }
+}
+
+QVolatileImageData::~QVolatileImageData()
+{
+    release();
+    unregisterImageData(this);
+}
+
+void QVolatileImageData::release()
+{
+    delete bitmap;
+    bitmap = 0;
+    delete pengine;
+    pengine = 0;
+}
+
+void QVolatileImageData::beginDataAccess() const
+{
+    if (bitmap) {
+        bitmap->BeginDataAccess();
+    }
+}
+
+void QVolatileImageData::endDataAccess(bool readOnly) const
+{
+    if (bitmap) {
+        bitmap->EndDataAccess(readOnly);
+    }
+}
+
+bool QVolatileImageData::ensureFormat(QImage::Format format)
+{
+    if (image.isNull()) {
+        return false;
+    }
+    if (image.format() != format) {
+        CFbsBitmap *newBitmap = convertData(*this, format);
+        if (newBitmap && newBitmap != bitmap) {
+            delete bitmap;
+            bitmap = newBitmap;
+            updateImage();
+        } else {
+            return false;
+        }
+    }
+    return true;
+}
+
+void *QVolatileImageData::duplicateNativeImage() const
+{
+    const_cast<QVolatileImageData *>(this)->ensureBitmap();
+    if (bitmap) {
+        if (bitmap->DisplayMode() == EColor16M) {
+            // slow path: needs rgb swapping
+            beginDataAccess();
+            QImage tmp = image.rgbSwapped();
+            endDataAccess(true);
+            return imageToBitmap(tmp);
+        } else if (bitmap->DisplayMode() == EGray2) {
+            // slow path: needs inverting pixels
+            beginDataAccess();
+            QImage tmp = image.copy();
+            endDataAccess(true);
+            tmp.invertPixels();
+            return imageToBitmap(tmp);
+        } else {
+            // fast path: just duplicate the bitmap
+            return duplicateBitmap(*bitmap);
+        }
+    }
+    return 0;
+}
+
+void QVolatileImageData::updateImage()
+{
+    if (bitmap) {
+        TSize size = bitmap->SizeInPixels();
+        beginDataAccess();
+        // Use existing buffer, no copy.  The data address never changes so it
+        // is enough to do this whenever we have a new CFbsBitmap.  N.B. never
+        // use const uchar* here, that would create a read-only image data which
+        // would make a copy in detach() even when refcount is 1.
+        image = QImage(reinterpret_cast<uchar *>(bitmap->DataAddress()),
+                       size.iWidth, size.iHeight, bitmap->DataStride(),
+                       qt_TDisplayMode2Format(bitmap->DisplayMode()));
+        endDataAccess(true);
+    } else {
+        image = QImage();
+    }
+}
+
+void QVolatileImageData::initWithBitmap(CFbsBitmap *source)
+{
+    bool needsCopy = bitmapNeedsCopy(source);
+    if (source->DisplayMode() == EColor16M) {
+        // EColor16M is BGR
+        CFbsBitmap *unswappedBmp = source;
+        if (needsCopy) {
+            unswappedBmp = rasterizeBitmap(source, source->DisplayMode());
+        }
+        unswappedBmp->BeginDataAccess();
+        TSize sourceSize = unswappedBmp->SizeInPixels();
+        QImage img((uchar *) unswappedBmp->DataAddress(),
+                   sourceSize.iWidth, sourceSize.iHeight, unswappedBmp->DataStride(),
+                   qt_TDisplayMode2Format(unswappedBmp->DisplayMode()));
+        img = img.rgbSwapped();
+        unswappedBmp->EndDataAccess(true);
+        bitmap = imageToBitmap(img);
+        if (needsCopy) {
+            delete unswappedBmp;
+        }
+    } else if (needsCopy) {
+        // Rasterize extended and compressed bitmaps.
+        bitmap = rasterizeBitmap(source, EColor16MAP);
+    } else {
+        // Efficient path: no pixel data copying. Just duplicate. This of course
+        // means the original bitmap's data may get modified, but that's fine
+        // and is in accordance with the QPixmap::fromSymbianCFbsBitmap() docs.
+        bitmap = duplicateBitmap(*source);
+    }
+    updateImage();
+    if (bitmap && bitmap->DisplayMode() == EGray2) {
+        // Symbian thinks set pixels are white/transparent, Qt thinks they are
+        // foreground/solid. Invert mono bitmaps so that masks work correctly.
+        beginDataAccess();
+        image.invertPixels();
+        endDataAccess();
+    }
+}
+
+void QVolatileImageData::applyMask(CFbsBitmap *mask)
+{
+    ensureFormat(QImage::Format_ARGB32_Premultiplied);
+    bool destroyMask = false;
+    if (bitmapNeedsCopy(mask)) {
+        mask = rasterizeBitmap(mask, EColor16MU);
+        if (!mask) {
+            return;
+        }
+        destroyMask = true;
+    }
+    mask->BeginDataAccess();
+    TSize maskSize = mask->SizeInPixels();
+    QImage maskImg((const uchar *) mask->DataAddress(), maskSize.iWidth, maskSize.iHeight,
+                   mask->DataStride(), qt_TDisplayMode2Format(mask->DisplayMode()));
+    if (mask->DisplayMode() == EGray2) {
+        maskImg = maskImg.copy();
+        maskImg.invertPixels();
+    }
+    beginDataAccess();
+    image.setAlphaChannel(maskImg);
+    endDataAccess();
+    mask->EndDataAccess(true);
+    ensureImage();
+    if (destroyMask) {
+        delete mask;
+    }
+}
+
+void QVolatileImageData::ensureImage()
+{
+    if (bitmap && !image.isNull()) {
+        QImageData *imaged = image.data_ptr();
+        if (imaged->ref != 1 || imaged->ro_data) {
+            // This is bad, the imagedata got shared somehow. Detach, in order to
+            // have the next check fail and thus have 'image' recreated.
+            beginDataAccess();
+            image.detach();
+            endDataAccess(true);
+        }
+    }
+    if (bitmap && image.constBits() != reinterpret_cast<const uchar *>(bitmap->DataAddress())) {
+        // Should not ever get here. If we do it means that either 'image' has
+        // been replaced with a copy (e.g. because some QImage API assigned a
+        // new, regular QImage to *this) or the bitmap's data address changed
+        // unexpectedly.
+        qWarning("QVolatileImageData: Ptr mismatch");
+        // Recover by recreating the image so that it uses the bitmap as its buffer.
+        updateImage();
+    }
+}
+
+void QVolatileImageData::ensureBitmap()
+{
+    if (!bitmap && !image.isNull()) {
+        bitmap = imageToBitmap(image);
+        updateImage();
+    }
+}
+
+QT_END_NAMESPACE