Long live Qt!

57 files changed, 30847 insertions, 0 deletions

diff --git a/src/gui/image/image.pri b/src/gui/image/image.pri
new file mode 100644
index 0000000..ca52974
--- /dev/null
+++ b/src/gui/image/image.pri
@@ -0,0 +1,108 @@
+# -*-mode:sh-*-
+# Qt image handling
+
+# Qt kernel module
+
+HEADERS += \
+        image/qbitmap.h \
+        image/qicon.h \
+        image/qiconengine.h \
+        image/qiconengineplugin.h \
+        image/qimage.h \
+        image/qimage_p.h \
+        image/qimageiohandler.h \
+        image/qimagereader.h \
+        image/qimagewriter.h \
+        image/qmovie.h \
+        image/qnativeimage_p.h \
+        image/qpaintengine_pic_p.h \
+        image/qpicture.h \
+        image/qpicture_p.h \
+        image/qpictureformatplugin.h \
+        image/qpixmap.h \
+        image/qpixmap_raster_p.h \
+        image/qpixmapcache.h \
+        image/qpixmapdata_p.h \
+        image/qpixmapdatafactory_p.h \
+        image/qpixmapfilter_p.h
+
+SOURCES += \
+        image/qbitmap.cpp \
+        image/qicon.cpp \
+        image/qimage.cpp \
+        image/qimageiohandler.cpp \
+        image/qimagereader.cpp \
+        image/qimagewriter.cpp \
+        image/qpaintengine_pic.cpp \
+        image/qpicture.cpp \
+        image/qpictureformatplugin.cpp \
+        image/qpixmap.cpp \
+        image/qpixmapcache.cpp \
+        image/qpixmapdata.cpp \
+        image/qpixmapdatafactory.cpp \
+        image/qpixmapfilter.cpp \
+        image/qiconengine.cpp \
+        image/qiconengineplugin.cpp \
+        image/qmovie.cpp \
+        image/qpixmap_raster.cpp \
+        image/qnativeimage.cpp \
+
+win32 {
+    SOURCES += image/qpixmap_win.cpp
+}
+embedded {
+    SOURCES += image/qpixmap_qws.cpp
+}
+x11 {
+    HEADERS += image/qpixmap_x11_p.h
+    SOURCES += image/qpixmap_x11.cpp 
+}
+mac {
+    HEADERS += image/qpixmap_mac_p.h
+    SOURCES += image/qpixmap_mac.cpp
+}
+
+# Built-in image format support
+HEADERS += \
+        image/qbmphandler_p.h \
+        image/qppmhandler_p.h \
+        image/qxbmhandler_p.h \
+        image/qxpmhandler_p.h
+
+SOURCES += \
+        image/qbmphandler.cpp \
+        image/qppmhandler.cpp \
+        image/qxbmhandler.cpp \
+        image/qxpmhandler.cpp
+
+# 3rd party / system PNG support
+!contains(QT_CONFIG, no-png) {
+    HEADERS += image/qpnghandler_p.h
+    SOURCES += image/qpnghandler.cpp
+
+    contains(QT_CONFIG, system-png) {
+        unix:LIBS  += -lpng
+        win32:LIBS += libpng.lib
+    } else {
+        !isEqual(QT_ARCH, i386):!isEqual(QT_ARCH, x86_64):DEFINES += PNG_NO_ASSEMBLER_CODE
+        INCLUDEPATH  += ../3rdparty/libpng ../3rdparty/zlib
+        SOURCES += ../3rdparty/libpng/png.c \
+          ../3rdparty/libpng/pngerror.c \
+          ../3rdparty/libpng/pngget.c \
+          ../3rdparty/libpng/pngmem.c \
+          ../3rdparty/libpng/pngpread.c \
+          ../3rdparty/libpng/pngread.c \
+          ../3rdparty/libpng/pngrio.c \
+          ../3rdparty/libpng/pngrtran.c \
+          ../3rdparty/libpng/pngrutil.c \
+          ../3rdparty/libpng/pngset.c \
+          ../3rdparty/libpng/pngtrans.c \
+          ../3rdparty/libpng/pngwio.c \
+          ../3rdparty/libpng/pngwrite.c \
+          ../3rdparty/libpng/pngwtran.c \
+          ../3rdparty/libpng/pngwutil.c \
+          ../3rdparty/libpng/pnggccrd.c
+    }
+} else {
+    DEFINES *= QT_NO_IMAGEFORMAT_PNG
+}
diff --git a/src/gui/image/qbitmap.cpp b/src/gui/image/qbitmap.cpp
new file mode 100644
index 0000000..3805b6e
--- /dev/null
+++ b/src/gui/image/qbitmap.cpp
@@ -0,0 +1,403 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qbitmap.h"
+#include "qpixmapdata_p.h"
+#include "qimage.h"
+#include "qvariant.h"
+#include <qpainter.h>
+#include <private/qgraphicssystem_p.h>
+#include <private/qapplication_p.h>
+
+QT_BEGIN_NAMESPACE
+
+/*!
+    \class QBitmap
+    \brief The QBitmap class provides monochrome (1-bit depth) pixmaps.
+
+    \ingroup multimedia
+    \ingroup shared
+
+    The QBitmap class is a monochrome off-screen paint device used
+    mainly for creating custom QCursor and QBrush objects,
+    constructing QRegion objects, and for setting masks for pixmaps
+    and widgets.
+
+    QBitmap is a QPixmap subclass ensuring a depth of 1, except for
+    null objects which have a depth of 0. If a pixmap with a depth
+    greater than 1 is assigned to a bitmap, the bitmap will be
+    dithered automatically.
+
+    Use the QColor objects Qt::color0 and Qt::color1 when drawing on a
+    QBitmap object (or a QPixmap object with depth 1).
+
+    Painting with Qt::color0 sets the bitmap bits to 0, and painting
+    with Qt::color1 sets the bits to 1. For a bitmap, 0-bits indicate
+    background (or transparent pixels) and 1-bits indicate foreground
+    (or opaque pixels). Use the clear() function to set all the bits
+    to Qt::color0. Note that using the Qt::black and Qt::white colors
+    make no sense because the QColor::pixel() value is not necessarily
+    0 for black and 1 for white.
+
+    The QBitmap class provides the transformed() function returning a
+    transformed copy of the bitmap; use the QMatrix argument to
+    translate, scale, shear, and rotate the bitmap. In addition,
+    QBitmap provides the static fromData() function which returns a
+    bitmap constructed from the given \c uchar data, and the static
+    fromImage() function returning a converted copy of a QImage
+    object.
+
+    Just like the QPixmap class, QBitmap is optimized by the use of
+    implicit data sharing. For more information, see the {Implicit
+    Data Sharing} documentation.
+
+    \sa  QPixmap, QImage, QImageReader, QImageWriter
+*/
+
+
+/*!
+    Constructs a null bitmap.
+
+    \sa QPixmap::isNull()
+*/
+
+QBitmap::QBitmap()
+    : QPixmap(QSize(0, 0), QPixmapData::BitmapType)
+{
+}
+
+/*!
+    \fn QBitmap::QBitmap(int width, int height)
+
+    Constructs a bitmap with the given \a width and \a height. The pixels
+    inside are uninitialized.
+
+    \sa clear()
+*/
+
+QBitmap::QBitmap(int w, int h)
+    : QPixmap(QSize(w, h), QPixmapData::BitmapType)
+{
+}
+
+/*!
+    Constructs a bitmap with the given \a size.  The pixels in the
+    bitmap are uninitialized.
+
+    \sa clear()
+*/
+
+QBitmap::QBitmap(const QSize &size)
+    : QPixmap(size, QPixmapData::BitmapType)
+{
+}
+
+/*!
+    \fn QBitmap::clear()
+
+    Clears the bitmap, setting all its bits to Qt::color0.
+*/
+
+/*!
+    Constructs a bitmap that is a copy of the given \a pixmap.
+
+    If the pixmap has a depth greater than 1, the resulting bitmap
+    will be dithered automatically.
+
+    \sa QPixmap::depth(), fromImage(), fromData()
+*/
+
+QBitmap::QBitmap(const QPixmap &pixmap)
+{
+    QBitmap::operator=(pixmap);
+}
+
+/*!
+    \fn QBitmap::QBitmap(const QImage &image)
+
+    Constructs a bitmap that is a copy of the given \a image.
+
+    Use the static fromImage() function instead.
+*/
+
+/*!
+    Constructs a bitmap from the file specified by the given \a
+    fileName. If the file does not exist, or has an unknown format,
+    the bitmap becomes a null bitmap.
+
+    The \a fileName and \a format parameters are passed on to the
+    QPixmap::load() function. If the file format uses more than 1 bit
+    per pixel, the resulting bitmap will be dithered automatically.
+
+    \sa QPixmap::isNull(), QImageReader::imageFormat()
+*/
+
+QBitmap::QBitmap(const QString& fileName, const char *format)
+    : QPixmap(QSize(0, 0), QPixmapData::BitmapType)
+{
+    load(fileName, format, Qt::MonoOnly);
+}
+
+/*!
+    \overload
+
+    Assigns the given \a pixmap to this bitmap and returns a reference
+    to this bitmap.
+
+    If the pixmap has a depth greater than 1, the resulting bitmap
+    will be dithered automatically.
+
+    \sa QPixmap::depth()
+ */
+
+QBitmap &QBitmap::operator=(const QPixmap &pixmap)
+{
+    if (pixmap.isNull()) {                        // a null pixmap
+        QBitmap bm(0, 0);
+        QBitmap::operator=(bm);
+    } else if (pixmap.depth() == 1) {                // 1-bit pixmap
+        QPixmap::operator=(pixmap);                // shallow assignment
+    } else {                                        // n-bit depth pixmap
+        QImage image;
+        image = pixmap.toImage();                                // convert pixmap to image
+        *this = fromImage(image);                                // will dither image
+    }
+    return *this;
+}
+
+
+#ifdef QT3_SUPPORT
+QBitmap::QBitmap(int w, int h, const uchar *bits, bool isXbitmap)
+{
+    *this = fromData(QSize(w, h), bits, isXbitmap ? QImage::Format_MonoLSB : QImage::Format_Mono);
+}
+
+
+QBitmap::QBitmap(const QSize &size, const uchar *bits, bool isXbitmap)
+{
+    *this = fromData(size, bits, isXbitmap ? QImage::Format_MonoLSB : QImage::Format_Mono);
+}
+#endif
+
+/*!
+  Destroys the bitmap.
+*/
+QBitmap::~QBitmap()
+{
+}
+
+/*!
+   Returns the bitmap as a QVariant.
+*/
+QBitmap::operator QVariant() const
+{
+    return QVariant(QVariant::Bitmap, this);
+}
+
+/*!
+    \fn QBitmap &QBitmap::operator=(const QImage &image)
+    \overload
+
+    Converts the given \a image to a bitmap, and assigns the result to
+    this bitmap. Returns a reference to the bitmap.
+
+    Use the static fromImage() function instead.
+*/
+
+/*!
+    Returns a copy of the given \a image converted to a bitmap using
+    the specified image conversion \a flags.
+
+    \sa fromData()
+*/
+QBitmap QBitmap::fromImage(const QImage &image, Qt::ImageConversionFlags flags)
+{
+    if (image.isNull())
+        return QBitmap();
+
+    QImage img = image.convertToFormat(QImage::Format_MonoLSB, flags);
+
+    // make sure image.color(0) == Qt::color0 (white)
+    // and image.color(1) == Qt::color1 (black)
+    const QRgb c0 = QColor(Qt::black).rgb();
+    const QRgb c1 = QColor(Qt::white).rgb();
+    if (img.color(0) == c0 && img.color(1) == c1) {
+        img.invertPixels();
+        img.setColor(0, c1);
+        img.setColor(1, c0);
+    }
+
+    QPixmapData *d;
+    QGraphicsSystem* gs = QApplicationPrivate::graphicsSystem();
+    if (gs)
+        d = gs->createPixmapData(QPixmapData::BitmapType);
+    else
+        d = QGraphicsSystem::createDefaultPixmapData(QPixmapData::BitmapType);
+
+    d->fromImage(img, flags | Qt::MonoOnly);
+    return QPixmap(d);
+}
+
+/*!
+    Constructs a bitmap with the given \a size, and sets the contents to
+    the \a bits supplied.
+
+    The bitmap data has to be byte aligned and provided in in the bit
+    order specified by \a monoFormat. The mono format must be either
+    QImage::Format_Mono or QImage::Format_MonoLSB. Use
+    QImage::Format_Mono to specify data on the XBM format.
+
+    \sa fromImage()
+
+*/
+QBitmap QBitmap::fromData(const QSize &size, const uchar *bits, QImage::Format monoFormat)
+{
+    Q_ASSERT(monoFormat == QImage::Format_Mono || monoFormat == QImage::Format_MonoLSB);
+
+    QImage image(size, monoFormat);
+    image.setColor(0, QColor(Qt::color0).rgb());
+    image.setColor(1, QColor(Qt::color1).rgb());
+
+    // Need to memcpy each line separatly since QImage is 32bit aligned and
+    // this data is only byte aligned...
+    int bytesPerLine = (size.width() + 7) / 8;
+    for (int y = 0; y < size.height(); ++y)
+        memcpy(image.scanLine(y), bits + bytesPerLine * y, bytesPerLine);
+    return QBitmap::fromImage(image);
+}
+
+/*!
+    Returns a copy of this bitmap, transformed according to the given
+    \a matrix.
+
+    \sa QPixmap::transformed()
+ */
+QBitmap QBitmap::transformed(const QTransform &matrix) const
+{
+    QBitmap bm = QPixmap::transformed(matrix);
+    return bm;
+}
+
+/*!
+  \overload
+
+  This convenience function converts the \a matrix to a QTransform
+  and calls the overloaded function.
+*/
+QBitmap QBitmap::transformed(const QMatrix &matrix) const
+{
+    return transformed(QTransform(matrix));
+}
+
+#ifdef QT3_SUPPORT
+/*!
+    \fn QBitmap QBitmap::xForm(const QMatrix &matrix) const
+
+    Returns a copy of this bitmap, transformed according to the given
+    \a matrix.
+
+    Use transformed() instead.
+*/
+
+/*!
+    \fn QBitmap::QBitmap(const QSize &size, bool clear)
+
+    Constructs a bitmap with the given \a size. If \a clear is true,
+    the bits are initialized to Qt::color0.
+
+    Use the corresponding QBitmap() constructor instead, and then call
+    the clear() function if the \a clear parameter is true.
+*/
+
+/*!
+    \fn QBitmap::QBitmap(int width, int height, bool clear)
+
+    Constructs a bitmap with the given \a width and \a height.  If \a
+    clear is true, the bits are initialized to Qt::color0.
+
+    Use the corresponding QBitmap() constructor instead, and then call
+    the clear() function if the \a clear parameter is true.
+*/
+
+/*!
+    \fn QBitmap::QBitmap(int width, int height, const uchar *bits, bool isXbitmap)
+
+    Constructs a bitmap with the given \a width and \a height, and
+    sets the contents to the \a bits supplied. The \a isXbitmap flag
+    should be true if \a bits was generated by the X11 bitmap
+    program.
+
+    Use the static fromData() function instead. If \a isXbitmap is
+    true, use the default bit order(QImage_FormatMonoLSB) otherwise
+    use QImage::Format_Mono.
+
+    \omit
+    The X bitmap bit order is little endian.  The QImage
+    documentation discusses bit order of monochrome images. Opposed to
+    QImage, the data has to be byte aligned.
+
+    Example (creates an arrow bitmap):
+    \snippet doc/src/snippets/code/src_gui_image_qbitmap.cpp 0
+    \endomit
+*/
+
+
+/*!
+  \fn QBitmap::QBitmap(const QSize &size, const uchar *bits, bool isXbitmap)
+
+    \overload
+
+    Constructs a bitmap with the given \a size, and sets the contents
+    to the \a bits supplied. The \a isXbitmap flag should be true if
+    \a bits was generated by the X11 bitmap program.
+
+    \omit
+    The X bitmap bit order is little endian.  The QImage documentation
+    discusses bit order of monochrome images.
+    \endomit
+
+    Use the static fromData() function instead. If \a isXbitmap is
+    true, use the default bit order(QImage_FormatMonoLSB) otherwise
+    use QImage::Format_Mono.
+*/
+#endif
+
+QT_END_NAMESPACE
diff --git a/src/gui/image/qbitmap.h b/src/gui/image/qbitmap.h
new file mode 100644
index 0000000..b17e4ac
--- /dev/null
+++ b/src/gui/image/qbitmap.h
@@ -0,0 +1,106 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QBITMAP_H
+#define QBITMAP_H
+
+#include <QtGui/qpixmap.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+class QVariant;
+
+class Q_GUI_EXPORT QBitmap : public QPixmap
+{
+public:
+    QBitmap();
+    QBitmap(const QPixmap &);
+    QBitmap(int w, int h);
+    explicit QBitmap(const QSize &);
+    explicit QBitmap(const QString &fileName, const char *format=0);
+    ~QBitmap();
+
+    QBitmap &operator=(const QPixmap &);
+    operator QVariant() const;
+
+    inline void clear() { fill(Qt::color0); }
+
+    static QBitmap fromImage(const QImage &image, Qt::ImageConversionFlags flags = Qt::AutoColor);
+    static QBitmap fromData(const QSize &size, const uchar *bits,
+                            QImage::Format monoFormat = QImage::Format_MonoLSB);
+
+    QBitmap transformed(const QMatrix &) const;
+    QBitmap transformed(const QTransform &matrix) const;
+#ifdef QT3_SUPPORT
+    inline QT3_SUPPORT_CONSTRUCTOR QBitmap(int w, int h, bool clear);
+    inline QT3_SUPPORT_CONSTRUCTOR QBitmap(const QSize &, bool clear);
+    QT3_SUPPORT_CONSTRUCTOR QBitmap(int w, int h, const uchar *bits, bool isXbitmap=false);
+    QT3_SUPPORT_CONSTRUCTOR QBitmap(const QSize &, const uchar *bits, bool isXbitmap=false);
+    inline QT3_SUPPORT QBitmap xForm(const QMatrix &matrix) const { return transformed(QTransform(matrix)); }
+    QT3_SUPPORT_CONSTRUCTOR QBitmap(const QImage &image) { *this = fromImage(image); }
+    QT3_SUPPORT QBitmap &operator=(const QImage &image) { *this = fromImage(image); return *this; }
+#endif
+};
+Q_DECLARE_SHARED(QBitmap)
+
+#ifdef QT3_SUPPORT
+inline QBitmap::QBitmap(int w, int h, bool clear)
+    : QPixmap(QSize(w, h), 1)
+{
+    if (clear) this->clear();
+}
+
+inline QBitmap::QBitmap(const QSize &size, bool clear)
+    : QPixmap(size, 1)
+{
+    if (clear) this->clear();
+}
+#endif
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QBITMAP_H
diff --git a/src/gui/image/qbmphandler.cpp b/src/gui/image/qbmphandler.cpp
new file mode 100644
index 0000000..6734e02
--- /dev/null
+++ b/src/gui/image/qbmphandler.cpp
@@ -0,0 +1,833 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "private/qbmphandler_p.h"
+
+#ifndef QT_NO_IMAGEFORMAT_BMP
+
+#include <qimage.h>
+#include <qvariant.h>
+#include <qvector.h>
+
+QT_BEGIN_NAMESPACE
+
+static void swapPixel01(QImage *image)        // 1-bpp: swap 0 and 1 pixels
+{
+    int i;
+    if (image->depth() == 1 && image->numColors() == 2) {
+        register uint *p = (uint *)image->bits();
+        int nbytes = image->numBytes();
+        for (i=0; i<nbytes/4; i++) {
+            *p = ~*p;
+            p++;
+        }
+        uchar *p2 = (uchar *)p;
+        for (i=0; i<(nbytes&3); i++) {
+            *p2 = ~*p2;
+            p2++;
+        }
+        QRgb t = image->color(0);                // swap color 0 and 1
+        image->setColor(0, image->color(1));
+        image->setColor(1, t);
+    }
+}
+
+/*
+    QImageIO::defineIOHandler("BMP", "^BM", 0,
+                               read_bmp_image, write_bmp_image);
+*/
+
+/*****************************************************************************
+  BMP (DIB) image read/write functions
+ *****************************************************************************/
+
+const int BMP_FILEHDR_SIZE = 14;                // size of BMP_FILEHDR data
+
+QDataStream &operator>>(QDataStream &s, BMP_FILEHDR &bf)
+{                                                // read file header
+    s.readRawData(bf.bfType, 2);
+    s >> bf.bfSize >> bf.bfReserved1 >> bf.bfReserved2 >> bf.bfOffBits;
+    return s;
+}
+
+QDataStream &operator<<(QDataStream &s, const BMP_FILEHDR &bf)
+{                                                // write file header
+    s.writeRawData(bf.bfType, 2);
+    s << bf.bfSize << bf.bfReserved1 << bf.bfReserved2 << bf.bfOffBits;
+    return s;
+}
+
+
+const int BMP_OLD  = 12;                        // old Windows/OS2 BMP size
+const int BMP_WIN  = 40;                        // new Windows BMP size
+const int BMP_OS2  = 64;                        // new OS/2 BMP size
+
+const int BMP_RGB  = 0;                                // no compression
+const int BMP_RLE8 = 1;                                // run-length encoded, 8 bits
+const int BMP_RLE4 = 2;                                // run-length encoded, 4 bits
+const int BMP_BITFIELDS = 3;                        // RGB values encoded in data as bit-fields
+
+
+QDataStream &operator>>(QDataStream &s, BMP_INFOHDR &bi)
+{
+    s >> bi.biSize;
+    if (bi.biSize == BMP_WIN || bi.biSize == BMP_OS2) {
+        s >> bi.biWidth >> bi.biHeight >> bi.biPlanes >> bi.biBitCount;
+        s >> bi.biCompression >> bi.biSizeImage;
+        s >> bi.biXPelsPerMeter >> bi.biYPelsPerMeter;
+        s >> bi.biClrUsed >> bi.biClrImportant;
+    }
+    else {                                        // probably old Windows format
+        qint16 w, h;
+        s >> w >> h >> bi.biPlanes >> bi.biBitCount;
+        bi.biWidth  = w;
+        bi.biHeight = h;
+        bi.biCompression = BMP_RGB;                // no compression
+        bi.biSizeImage = 0;
+        bi.biXPelsPerMeter = bi.biYPelsPerMeter = 0;
+        bi.biClrUsed = bi.biClrImportant = 0;
+    }
+    return s;
+}
+
+QDataStream &operator<<(QDataStream &s, const BMP_INFOHDR &bi)
+{
+    s << bi.biSize;
+    s << bi.biWidth << bi.biHeight;
+    s << bi.biPlanes;
+    s << bi.biBitCount;
+    s << bi.biCompression;
+    s << bi.biSizeImage;
+    s << bi.biXPelsPerMeter << bi.biYPelsPerMeter;
+    s << bi.biClrUsed << bi.biClrImportant;
+    return s;
+}
+
+static int calc_shift(int mask)
+{
+    int result = 0;
+    while (!(mask & 1)) {
+        result++;
+        mask >>= 1;
+    }
+    return result;
+}
+
+static bool read_dib_fileheader(QDataStream &s, BMP_FILEHDR &bf)
+{
+    // read BMP file header
+    s >> bf;
+    if (s.status() != QDataStream::Ok)
+        return false;
+
+    // check header
+    if (qstrncmp(bf.bfType,"BM",2) != 0)
+        return false;
+
+    return true;
+}
+
+static bool read_dib_infoheader(QDataStream &s, BMP_INFOHDR &bi)
+{
+    s >> bi;                                        // read BMP info header
+    if (s.status() != QDataStream::Ok)
+        return false;
+
+    int nbits = bi.biBitCount;
+    int comp = bi.biCompression;
+    if (!(nbits == 1 || nbits == 4 || nbits == 8 || nbits == 16 || nbits == 24 || nbits == 32) ||
+        bi.biPlanes != 1 || comp > BMP_BITFIELDS)
+        return false;                                        // weird BMP image
+    if (!(comp == BMP_RGB || (nbits == 4 && comp == BMP_RLE4) ||
+        (nbits == 8 && comp == BMP_RLE8) || ((nbits == 16 || nbits == 32) && comp == BMP_BITFIELDS)))
+         return false;                                // weird compression type
+
+    return true;
+}
+
+static bool read_dib_body(QDataStream &s, const BMP_INFOHDR &bi, int offset, int startpos, QImage &image)
+{
+    QIODevice* d = s.device();
+    if (d->atEnd())                                // end of stream/file
+        return false;
+#if 0
+    qDebug("offset...........%d", offset);
+    qDebug("startpos.........%d", startpos);
+    qDebug("biSize...........%d", bi.biSize);
+    qDebug("biWidth..........%d", bi.biWidth);
+    qDebug("biHeight.........%d", bi.biHeight);
+    qDebug("biPlanes.........%d", bi.biPlanes);
+    qDebug("biBitCount.......%d", bi.biBitCount);
+    qDebug("biCompression....%d", bi.biCompression);
+    qDebug("biSizeImage......%d", bi.biSizeImage);
+    qDebug("biXPelsPerMeter..%d", bi.biXPelsPerMeter);
+    qDebug("biYPelsPerMeter..%d", bi.biYPelsPerMeter);
+    qDebug("biClrUsed........%d", bi.biClrUsed);
+    qDebug("biClrImportant...%d", bi.biClrImportant);
+#endif
+    int w = bi.biWidth,         h = bi.biHeight,  nbits = bi.biBitCount;
+    int t = bi.biSize,         comp = bi.biCompression;
+    int red_mask = 0;
+    int green_mask = 0;
+    int blue_mask = 0;
+    int red_shift = 0;
+    int green_shift = 0;
+    int blue_shift = 0;
+    int red_scale = 0;
+    int green_scale = 0;
+    int blue_scale = 0;
+
+    int ncols = 0;
+    int depth = 0;
+    QImage::Format format;
+    switch (nbits) {
+        case 32:
+        case 24:
+        case 16:
+            depth = 32;
+            format = QImage::Format_RGB32;
+            break;
+        case 8:
+        case 4:
+            depth = 8;
+            format = QImage::Format_Indexed8;
+            break;
+        default:
+            depth = 1;
+            format = QImage::Format_Mono;
+    }
+
+    if (bi.biHeight < 0)
+        h = -h;                  // support images with negative height
+
+    if (image.size() != QSize(w, h) || image.format() != format) {
+        image = QImage(w, h, format);
+        if (image.isNull())                        // could not create image
+            return false;
+    }
+
+    if (depth != 32) {
+        ncols = bi.biClrUsed ? bi.biClrUsed : 1 << nbits;
+        image.setNumColors(ncols);
+    }
+
+    image.setDotsPerMeterX(bi.biXPelsPerMeter);
+    image.setDotsPerMeterY(bi.biYPelsPerMeter);
+
+    if (!d->isSequential())
+        d->seek(startpos + BMP_FILEHDR_SIZE + bi.biSize); // goto start of colormap
+
+    if (ncols > 0) {                                // read color table
+        uchar rgb[4];
+        int   rgb_len = t == BMP_OLD ? 3 : 4;
+        for (int i=0; i<ncols; i++) {
+            if (d->read((char *)rgb, rgb_len) != rgb_len)
+                return false;
+            image.setColor(i, qRgb(rgb[2],rgb[1],rgb[0]));
+            if (d->atEnd())                        // truncated file
+                return false;
+        }
+    } else if (comp == BMP_BITFIELDS && (nbits == 16 || nbits == 32)) {
+        if (d->read((char *)&red_mask, sizeof(red_mask)) != sizeof(red_mask))
+            return false;
+        if (d->read((char *)&green_mask, sizeof(green_mask)) != sizeof(green_mask))
+            return false;
+        if (d->read((char *)&blue_mask, sizeof(blue_mask)) != sizeof(blue_mask))
+            return false;
+        red_shift = calc_shift(red_mask);
+        red_scale = 256 / ((red_mask >> red_shift) + 1);
+        green_shift = calc_shift(green_mask);
+        green_scale = 256 / ((green_mask >> green_shift) + 1);
+        blue_shift = calc_shift(blue_mask);
+        blue_scale = 256 / ((blue_mask >> blue_shift) + 1);
+    } else if (comp == BMP_RGB && (nbits == 24 || nbits == 32)) {
+        blue_mask = 0x000000ff;
+        green_mask = 0x0000ff00;
+        red_mask = 0x00ff0000;
+        blue_shift = 0;
+        green_shift = 8;
+        red_shift = 16;
+        blue_scale = green_scale = red_scale = 1;
+    } else if (comp == BMP_RGB && nbits == 16) {
+        blue_mask = 0x001f;
+        green_mask = 0x03e0;
+        red_mask = 0x7c00;
+        blue_shift = 0;
+        green_shift = 2;
+        red_shift = 7;
+        red_scale = 1;
+        green_scale = 1;
+        blue_scale = 8;
+    }
+
+    // offset can be bogus, be careful
+    if (offset>=0 && startpos + offset > d->pos()) {
+        if (!d->isSequential())
+            d->seek(startpos + offset);                // start of image data
+    }
+
+    int             bpl = image.bytesPerLine();
+    uchar *data = image.bits();
+
+    if (nbits == 1) {                                // 1 bit BMP image
+        while (--h >= 0) {
+            if (d->read((char*)(data + h*bpl), bpl) != bpl)
+                break;
+        }
+        if (ncols == 2 && qGray(image.color(0)) < qGray(image.color(1)))
+            swapPixel01(&image);                // pixel 0 is white!
+    }
+
+    else if (nbits == 4) {                        // 4 bit BMP image
+        int    buflen = ((w+7)/8)*4;
+        uchar *buf    = new uchar[buflen];
+        if (comp == BMP_RLE4) {                // run length compression
+            int x=0, y=0, c, i;
+            quint8 b;
+            register uchar *p = data + (h-1)*bpl;
+            const uchar *endp = p + w;
+            while (y < h) {
+                if (!d->getChar((char *)&b))
+                    break;
+                if (b == 0) {                        // escape code
+                    if (!d->getChar((char *)&b) || b == 1) {
+                        y = h;                // exit loop
+                    } else switch (b) {
+                        case 0:                        // end of line
+                            x = 0;
+                            y++;
+                            p = data + (h-y-1)*bpl;
+                            break;
+                        case 2:                        // delta (jump)
+                        {
+                            quint8 tmp;
+                            d->getChar((char *)&tmp);
+                            x += tmp;
+                            d->getChar((char *)&tmp);
+                            y += tmp;
+                        }
+
+                            // Protection
+                            if ((uint)x >= (uint)w)
+                                x = w-1;
+                            if ((uint)y >= (uint)h)
+                                y = h-1;
+
+                            p = data + (h-y-1)*bpl + x;
+                            break;
+                        default:                // absolute mode
+                            // Protection
+                            if (p + b > endp)
+                                b = endp-p;
+
+                            i = (c = b)/2;
+                            while (i--) {
+                                d->getChar((char *)&b);
+                                *p++ = b >> 4;
+                                *p++ = b & 0x0f;
+                            }
+                            if (c & 1) {
+                                unsigned char tmp;
+                                d->getChar((char *)&tmp);
+                                *p++ = tmp >> 4;
+                            }
+                            if ((((c & 3) + 1) & 2) == 2)
+                                d->getChar(0);        // align on word boundary
+                            x += c;
+                    }
+                } else {                        // encoded mode
+                    // Protection
+                    if (p + b > endp)
+                        b = endp-p;
+
+                    i = (c = b)/2;
+                    d->getChar((char *)&b);                // 2 pixels to be repeated
+                    while (i--) {
+                        *p++ = b >> 4;
+                        *p++ = b & 0x0f;
+                    }
+                    if (c & 1)
+                        *p++ = b >> 4;
+                    x += c;
+                }
+            }
+        } else if (comp == BMP_RGB) {                // no compression
+            memset(data, 0, h*bpl);
+            while (--h >= 0) {
+                if (d->read((char*)buf,buflen) != buflen)
+                    break;
+                register uchar *p = data + h*bpl;
+                uchar *b = buf;
+                for (int i=0; i<w/2; i++) {        // convert nibbles to bytes
+                    *p++ = *b >> 4;
+                    *p++ = *b++ & 0x0f;
+                }
+                if (w & 1)                        // the last nibble
+                    *p = *b >> 4;
+            }
+        }
+        delete [] buf;
+    }
+
+    else if (nbits == 8) {                        // 8 bit BMP image
+        if (comp == BMP_RLE8) {                // run length compression
+            int x=0, y=0;
+            quint8 b;
+            register uchar *p = data + (h-1)*bpl;
+            const uchar *endp = p + w;
+            while (y < h) {
+                if (!d->getChar((char *)&b))
+                    break;
+                if (b == 0) {                        // escape code
+                    if (!d->getChar((char *)&b) || b == 1) {
+                            y = h;                // exit loop
+                    } else switch (b) {
+                        case 0:                        // end of line
+                            x = 0;
+                            y++;
+                            p = data + (h-y-1)*bpl;
+                            break;
+                        case 2:                        // delta (jump)
+                            // Protection
+                            if ((uint)x >= (uint)w)
+                                x = w-1;
+                            if ((uint)y >= (uint)h)
+                                y = h-1;
+
+                            {
+                                quint8 tmp;
+                                d->getChar((char *)&tmp);
+                                x += tmp;
+                                d->getChar((char *)&tmp);
+                                y += tmp;
+                            }
+                            p = data + (h-y-1)*bpl + x;
+                            break;
+                        default:                // absolute mode
+                            // Protection
+                            if (p + b > endp)
+                                b = endp-p;
+
+                            if (d->read((char *)p, b) != b)
+                                return false;
+                            if ((b & 1) == 1)
+                                d->getChar(0);        // align on word boundary
+                            x += b;
+                            p += b;
+                    }
+                } else {                        // encoded mode
+                    // Protection
+                    if (p + b > endp)
+                        b = endp-p;
+
+                    char tmp;
+                    d->getChar(&tmp);
+                    memset(p, tmp, b); // repeat pixel
+                    x += b;
+                    p += b;
+                }
+            }
+        } else if (comp == BMP_RGB) {                // uncompressed
+            while (--h >= 0) {
+                if (d->read((char *)data + h*bpl, bpl) != bpl)
+                    break;
+            }
+        }
+    }
+
+    else if (nbits == 16 || nbits == 24 || nbits == 32) { // 16,24,32 bit BMP image
+        register QRgb *p;
+        QRgb  *end;
+        uchar *buf24 = new uchar[bpl];
+        int    bpl24 = ((w*nbits+31)/32)*4;
+        uchar *b;
+        int c;
+
+        while (--h >= 0) {
+            p = (QRgb *)(data + h*bpl);
+            end = p + w;
+            if (d->read((char *)buf24,bpl24) != bpl24)
+                break;
+            b = buf24;
+            while (p < end) {
+                c = *(uchar*)b | (*(uchar*)(b+1)<<8);
+                if (nbits != 16)
+                    c |= *(uchar*)(b+2)<<16;
+                *p++ = qRgb(((c & red_mask) >> red_shift) * red_scale,
+                                        ((c & green_mask) >> green_shift) * green_scale,
+                                        ((c & blue_mask) >> blue_shift) * blue_scale);
+                b += nbits/8;
+            }
+        }
+        delete[] buf24;
+    }
+
+    if (bi.biHeight < 0) {
+        // Flip the image
+        uchar *buf = new uchar[bpl];
+        h = -bi.biHeight;
+        for (int y = 0; y < h/2; ++y) {
+            memcpy(buf, data + y*bpl, bpl);
+            memcpy(data + y*bpl, data + (h-y-1)*bpl, bpl);
+            memcpy(data + (h-y-1)*bpl, buf, bpl);
+        }
+        delete [] buf;
+    }
+
+    return true;
+}
+
+// this is also used in qmime_win.cpp
+bool qt_write_dib(QDataStream &s, QImage image)
+{
+    int        nbits;
+    int        bpl_bmp;
+    int        bpl = image.bytesPerLine();
+
+    QIODevice* d = s.device();
+    if (!d->isWritable())
+        return false;
+
+    if (image.depth() == 8 && image.numColors() <= 16) {
+        bpl_bmp = (((bpl+1)/2+3)/4)*4;
+        nbits = 4;
+    } else if (image.depth() == 32) {
+        bpl_bmp = ((image.width()*24+31)/32)*4;
+        nbits = 24;
+#ifdef Q_WS_QWS
+    } else if (image.depth() == 1 || image.depth() == 8) {
+        // Qt for Embedded Linux doesn't word align.
+        bpl_bmp = ((image.width()*image.depth()+31)/32)*4;
+        nbits = image.depth();
+#endif
+    } else {
+        bpl_bmp = bpl;
+        nbits = image.depth();
+    }
+
+    BMP_INFOHDR bi;
+    bi.biSize               = BMP_WIN;                // build info header
+    bi.biWidth               = image.width();
+    bi.biHeight               = image.height();
+    bi.biPlanes               = 1;
+    bi.biBitCount      = nbits;
+    bi.biCompression   = BMP_RGB;
+    bi.biSizeImage     = bpl_bmp*image.height();
+    bi.biXPelsPerMeter = image.dotsPerMeterX() ? image.dotsPerMeterX()
+                                                : 2834; // 72 dpi default
+    bi.biYPelsPerMeter = image.dotsPerMeterY() ? image.dotsPerMeterY() : 2834;
+    bi.biClrUsed       = image.numColors();
+    bi.biClrImportant  = image.numColors();
+    s << bi;                                        // write info header
+    if (s.status() != QDataStream::Ok)
+        return false;
+
+    if (image.depth() != 32) {                // write color table
+        uchar *color_table = new uchar[4*image.numColors()];
+        uchar *rgb = color_table;
+        QVector<QRgb> c = image.colorTable();
+        for (int i=0; i<image.numColors(); i++) {
+            *rgb++ = qBlue (c[i]);
+            *rgb++ = qGreen(c[i]);
+            *rgb++ = qRed  (c[i]);
+            *rgb++ = 0;
+        }
+        if (d->write((char *)color_table, 4*image.numColors()) == -1) {
+            delete [] color_table;
+            return false;
+        }
+        delete [] color_table;
+    }
+
+    if (image.format() == QImage::Format_MonoLSB)
+        image = image.convertToFormat(QImage::Format_Mono);
+
+    int y;
+
+    if (nbits == 1 || nbits == 8) {                // direct output
+#ifdef Q_WS_QWS
+        // Qt for Embedded Linux doesn't word align.
+        int pad = bpl_bmp - bpl;
+        char padding[4];
+#endif
+        for (y=image.height()-1; y>=0; y--) {
+            if (d->write((char*)image.scanLine(y), bpl) == -1)
+                return false;
+#ifdef Q_WS_QWS
+            if (d->write(padding, pad) == -1)
+                return false;
+#endif
+        }
+        return true;
+    }
+
+    uchar *buf        = new uchar[bpl_bmp];
+    uchar *b, *end;
+    register uchar *p;
+
+    memset(buf, 0, bpl_bmp);
+    for (y=image.height()-1; y>=0; y--) {        // write the image bits
+        if (nbits == 4) {                        // convert 8 -> 4 bits
+            p = image.scanLine(y);
+            b = buf;
+            end = b + image.width()/2;
+            while (b < end) {
+                *b++ = (*p << 4) | (*(p+1) & 0x0f);
+                p += 2;
+            }
+            if (image.width() & 1)
+                *b = *p << 4;
+        } else {                                // 32 bits
+            QRgb *p   = (QRgb *)image.scanLine(y);
+            QRgb *end = p + image.width();
+            b = buf;
+            while (p < end) {
+                *b++ = qBlue(*p);
+                *b++ = qGreen(*p);
+                *b++ = qRed(*p);
+                p++;
+            }
+        }
+        if (bpl_bmp != d->write((char*)buf, bpl_bmp)) {
+            delete[] buf;
+            return false;
+        }
+    }
+    delete[] buf;
+    return true;
+}
+
+// this is also used in qmime_win.cpp
+bool qt_read_dib(QDataStream &s, QImage &image)
+{
+    BMP_INFOHDR bi;
+    if (!read_dib_infoheader(s, bi))
+        return false;
+    return read_dib_body(s, bi, -1, -BMP_FILEHDR_SIZE, image);
+}
+
+QBmpHandler::QBmpHandler()
+    : state(Ready)
+{
+}
+
+bool QBmpHandler::readHeader()
+{
+    state = Error;
+
+    QIODevice *d = device();
+    QDataStream s(d);
+    startpos = d->pos();
+
+    // Intel byte order
+    s.setByteOrder(QDataStream::LittleEndian);
+
+    // read BMP file header
+    if (!read_dib_fileheader(s, fileHeader))
+        return false;
+
+    // read BMP info header
+    if (!read_dib_infoheader(s, infoHeader))
+        return false;
+
+    state = ReadHeader;
+    return true;
+}
+
+bool QBmpHandler::canRead() const
+{
+    if (state == Ready) {
+        if (!canRead(device()))
+            return false;
+        setFormat("bmp");
+        return true;
+    }
+    return state != Error;
+}
+
+bool QBmpHandler::canRead(QIODevice *device)
+{
+    if (!device) {
+        qWarning("QBmpHandler::canRead() called with 0 pointer");
+        return false;
+    }
+
+    char head[2];
+    if (device->peek(head, sizeof(head)) != sizeof(head))
+        return false;
+
+    return (qstrncmp(head, "BM", 2) == 0);
+}
+
+bool QBmpHandler::read(QImage *image)
+{
+    if (state == Error)
+        return false;
+
+    if (!image) {
+        qWarning("QBmpHandler::read: cannot read into null pointer");
+        return false;
+    }
+
+    if (state == Ready && !readHeader()) {
+        state = Error;
+        return false;
+    }
+
+    QIODevice *d = device();
+    QDataStream s(d);
+
+    // Intel byte order
+    s.setByteOrder(QDataStream::LittleEndian);
+
+    // read image
+    if (!read_dib_body(s, infoHeader, fileHeader.bfOffBits, startpos, *image))
+        return false;
+
+    state = Ready;
+    return true;
+}
+
+bool QBmpHandler::write(const QImage &img)
+{
+    QImage image;
+    switch (img.format()) {
+    case QImage::Format_ARGB8565_Premultiplied:
+    case QImage::Format_ARGB8555_Premultiplied:
+    case QImage::Format_ARGB6666_Premultiplied:
+    case QImage::Format_ARGB4444_Premultiplied:
+        image = img.convertToFormat(QImage::Format_ARGB32);
+        break;
+    case QImage::Format_RGB16:
+    case QImage::Format_RGB888:
+    case QImage::Format_RGB666:
+    case QImage::Format_RGB555:
+    case QImage::Format_RGB444:
+        image = img.convertToFormat(QImage::Format_RGB32);
+        break;
+    default:
+        image = img;
+    }
+
+    QIODevice *d = device();
+    QDataStream s(d);
+    BMP_FILEHDR bf;
+    int bpl_bmp;
+    int bpl = image.bytesPerLine();
+
+    // Code partially repeated in qt_write_dib
+    if (image.depth() == 8 && image.numColors() <= 16) {
+        bpl_bmp = (((bpl+1)/2+3)/4)*4;
+    } else if (image.depth() == 32) {
+        bpl_bmp = ((image.width()*24+31)/32)*4;
+    } else {
+        bpl_bmp = bpl;
+    }
+
+    // Intel byte order
+    s.setByteOrder(QDataStream::LittleEndian);
+
+    // build file header
+    memcpy(bf.bfType, "BM", 2);
+
+    // write file header
+    bf.bfReserved1 = 0;
+    bf.bfReserved2 = 0;
+    bf.bfOffBits = BMP_FILEHDR_SIZE + BMP_WIN + image.numColors() * 4;
+    bf.bfSize = bf.bfOffBits + bpl_bmp*image.height();
+    s << bf;
+
+    // write image
+    return qt_write_dib(s, image);
+}
+
+bool QBmpHandler::supportsOption(ImageOption option) const
+{
+    return option == Size
+            || option == ImageFormat;
+}
+
+QVariant QBmpHandler::option(ImageOption option) const
+{
+    if (option == Size) {
+        if (state == Error)
+            return QVariant();
+        if (state == Ready && !const_cast<QBmpHandler*>(this)->readHeader())
+            return QVariant();
+        return QSize(infoHeader.biWidth, infoHeader.biHeight);
+    } else if (option == ImageFormat) {
+        if (state == Error)
+            return QVariant();
+        if (state == Ready && !const_cast<QBmpHandler*>(this)->readHeader())
+            return QVariant();
+        QImage::Format format;
+        switch (infoHeader.biBitCount) {
+            case 32:
+            case 24:
+            case 16:
+                format = QImage::Format_RGB32;
+                break;
+            case 8:
+            case 4:
+                format = QImage::Format_Indexed8;
+                break;
+            default:
+                format = QImage::Format_Mono;
+            }
+        return format;
+    }
+    return QVariant();
+}
+
+void QBmpHandler::setOption(ImageOption option, const QVariant &value)
+{
+    Q_UNUSED(option);
+    Q_UNUSED(value);
+}
+
+QByteArray QBmpHandler::name() const
+{
+    return "bmp";
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_IMAGEFORMAT_BMP
diff --git a/src/gui/image/qbmphandler_p.h b/src/gui/image/qbmphandler_p.h
new file mode 100644
index 0000000..6e953a5
--- /dev/null
+++ b/src/gui/image/qbmphandler_p.h
@@ -0,0 +1,117 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QBMPHANDLER_P_H
+#define QBMPHANDLER_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/qimageiohandler.h"
+
+#ifndef QT_NO_IMAGEFORMAT_BMP
+
+QT_BEGIN_NAMESPACE
+
+struct BMP_FILEHDR {                     // BMP file header
+    char   bfType[2];                    // "BM"
+    qint32  bfSize;                      // size of file
+    qint16  bfReserved1;
+    qint16  bfReserved2;
+    qint32  bfOffBits;                   // pointer to the pixmap bits
+};
+
+struct BMP_INFOHDR {                     // BMP information header
+    qint32  biSize;                      // size of this struct
+    qint32  biWidth;                     // pixmap width
+    qint32  biHeight;                    // pixmap height
+    qint16  biPlanes;                    // should be 1
+    qint16  biBitCount;                  // number of bits per pixel
+    qint32  biCompression;               // compression method
+    qint32  biSizeImage;                 // size of image
+    qint32  biXPelsPerMeter;             // horizontal resolution
+    qint32  biYPelsPerMeter;             // vertical resolution
+    qint32  biClrUsed;                   // number of colors used
+    qint32  biClrImportant;              // number of important colors
+};
+
+class QBmpHandler : public QImageIOHandler
+{
+public:
+    QBmpHandler();
+    bool canRead() const;
+    bool read(QImage *image);
+    bool write(const QImage &image);
+
+    QByteArray name() const;
+
+    static bool canRead(QIODevice *device);
+
+    QVariant option(ImageOption option) const;
+    void setOption(ImageOption option, const QVariant &value);
+    bool supportsOption(ImageOption option) const;
+
+private:
+    bool readHeader();
+    enum State {
+        Ready,
+        ReadHeader,
+        Error
+    };
+    State state;
+    BMP_FILEHDR fileHeader;
+    BMP_INFOHDR infoHeader;
+    int startpos;
+};
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_IMAGEFORMAT_BMP
+
+#endif // QBMPHANDLER_P_H
diff --git a/src/gui/image/qicon.cpp b/src/gui/image/qicon.cpp
new file mode 100644
index 0000000..3c71f15
--- /dev/null
+++ b/src/gui/image/qicon.cpp
@@ -0,0 +1,1128 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qicon.h"
+#include "qiconengine.h"
+#include "qiconengineplugin.h"
+#include "private/qfactoryloader_p.h"
+#include "qapplication.h"
+#include "qstyleoption.h"
+#include "qpainter.h"
+#include "qfileinfo.h"
+#include "qstyle.h"
+#include "qpixmapcache.h"
+#include "qvariant.h"
+#include "qdebug.h"
+
+#ifdef Q_WS_MAC
+#include <private/qt_mac_p.h>
+#include <Carbon/Carbon.h>
+#endif
+
+QT_BEGIN_NAMESPACE
+
+/*!
+    \enum QIcon::Mode
+
+    This enum type describes the mode for which a pixmap is intended
+    to be used. The currently defined modes are:
+
+    \value Normal
+         Display the pixmap when the user is
+        not interacting with the icon, but the
+        functionality represented by the icon is available.
+    \value Disabled
+         Display the pixmap when the
+        functionality represented by the icon is not available.
+    \value Active
+         Display the pixmap when the
+        functionality represented by the icon is available and
+        the user is interacting with the icon, for example, moving the
+        mouse over it or clicking it.
+   \value Selected
+        Display the pixmap when the item represented by the icon is
+        selected.
+*/
+
+/*!
+  \enum QIcon::State
+
+  This enum describes the state for which a pixmap is intended to be
+  used. The \e state can be:
+
+  \value Off  Display the pixmap when the widget is in an "off" state
+  \value On  Display the pixmap when the widget is in an "on" state
+*/
+
+static QBasicAtomicInt serialNumCounter = Q_BASIC_ATOMIC_INITIALIZER(1);
+
+class QIconPrivate
+{
+public:
+    QIconPrivate(): engine(0), ref(1), serialNum(serialNumCounter.fetchAndAddRelaxed(1)), detach_no(0), engine_version(2), v1RefCount(0) {}
+
+    ~QIconPrivate() {
+        if (engine_version == 1) {
+            if (!v1RefCount->deref()) {
+                delete engine;
+                delete v1RefCount;
+            }
+        } else if (engine_version == 2) {
+            delete engine;
+        }
+    }
+
+    QIconEngine *engine;
+
+    QAtomicInt ref;
+    int serialNum;
+    int detach_no;
+    int engine_version;
+
+    QAtomicInt *v1RefCount;
+};
+
+
+struct QPixmapIconEngineEntry
+{
+    QPixmapIconEngineEntry():mode(QIcon::Normal), state(QIcon::Off){}
+    QPixmapIconEngineEntry(const QPixmap &pm, QIcon::Mode m = QIcon::Normal, QIcon::State s = QIcon::Off)
+        :pixmap(pm), size(pm.size()), mode(m), state(s){}
+    QPixmapIconEngineEntry(const QString &file, const QSize &sz = QSize(), QIcon::Mode m = QIcon::Normal, QIcon::State s = QIcon::Off)
+        :fileName(file), size(sz), mode(m), state(s){}
+    QPixmap pixmap;
+    QString fileName;
+    QSize size;
+    QIcon::Mode mode;
+    QIcon::State state;
+    bool isNull() const {return (fileName.isEmpty() && pixmap.isNull()); }
+};
+
+class QPixmapIconEngine : public QIconEngineV2 {
+public:
+    QPixmapIconEngine();
+    QPixmapIconEngine(const QPixmapIconEngine &);
+    ~QPixmapIconEngine();
+    void paint(QPainter *painter, const QRect &rect, QIcon::Mode mode, QIcon::State state);
+    QPixmap pixmap(const QSize &size, QIcon::Mode mode, QIcon::State state);
+    QPixmapIconEngineEntry *bestMatch(const QSize &size, QIcon::Mode mode, QIcon::State state, bool sizeOnly);
+    QSize actualSize(const QSize &size, QIcon::Mode mode, QIcon::State state);
+    void addPixmap(const QPixmap &pixmap, QIcon::Mode mode, QIcon::State state);
+    void addFile(const QString &fileName, const QSize &size, QIcon::Mode mode, QIcon::State state);
+
+    // v2 functions
+    QString key() const;
+    QIconEngineV2 *clone() const;
+    bool read(QDataStream &in);
+    bool write(QDataStream &out) const;
+    void virtual_hook(int id, void *data);
+
+private:
+    QPixmapIconEngineEntry *tryMatch(const QSize &size, QIcon::Mode mode, QIcon::State state);
+    QVector<QPixmapIconEngineEntry> pixmaps;
+
+    friend QDataStream &operator<<(QDataStream &s, const QIcon &icon);
+};
+
+QPixmapIconEngine::QPixmapIconEngine()
+{
+}
+
+QPixmapIconEngine::QPixmapIconEngine(const QPixmapIconEngine &other)
+    : QIconEngineV2(other), pixmaps(other.pixmaps)
+{
+}
+
+QPixmapIconEngine::~QPixmapIconEngine()
+{
+}
+
+void QPixmapIconEngine::paint(QPainter *painter, const QRect &rect, QIcon::Mode mode, QIcon::State state)
+{
+    QSize pixmapSize = rect.size();
+#if defined(Q_WS_MAC) && !defined(Q_WS_MAC64)
+    pixmapSize *= (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_4) ? HIGetScaleFactor() : 1;
+#endif
+    painter->drawPixmap(rect, pixmap(pixmapSize, mode, state));
+}
+
+static inline int area(const QSize &s) { return s.width() * s.height(); }
+
+// returns the smallest of the two that is still larger than or equal to size.
+static QPixmapIconEngineEntry *bestSizeMatch( const QSize &size, QPixmapIconEngineEntry *pa, QPixmapIconEngineEntry *pb)
+{
+    int s = area(size);
+    if (pa->size == QSize() && pa->pixmap.isNull()) {
+        pa->pixmap = QPixmap(pa->fileName);
+        pa->size = pa->pixmap.size();
+    }
+    int a = area(pa->size);
+    if (pb->size == QSize() && pb->pixmap.isNull()) {
+        pb->pixmap = QPixmap(pb->fileName);
+        pb->size = pb->pixmap.size();
+    }
+    int b = area(pb->size);
+    int res = a;
+    if (qMin(a,b) >= s)
+        res = qMin(a,b);
+    else
+        res = qMax(a,b);
+    if (res == a)
+        return pa;
+    return pb;
+}
+
+QPixmapIconEngineEntry *QPixmapIconEngine::tryMatch(const QSize &size, QIcon::Mode mode, QIcon::State state)
+{
+    QPixmapIconEngineEntry *pe = 0;
+    for (int i = 0; i < pixmaps.count(); ++i)
+        if (pixmaps.at(i).mode == mode && pixmaps.at(i).state == state) {
+            if (pe)
+                pe = bestSizeMatch(size, &pixmaps[i], pe);
+            else
+                pe = &pixmaps[i];
+        }
+    return pe;
+}
+
+
+QPixmapIconEngineEntry *QPixmapIconEngine::bestMatch(const QSize &size, QIcon::Mode mode, QIcon::State state, bool sizeOnly)
+{
+    QPixmapIconEngineEntry *pe = tryMatch(size, mode, state);
+    while (!pe){
+        QIcon::State oppositeState = (state == QIcon::On) ? QIcon::Off : QIcon::On;
+        if (mode == QIcon::Disabled || mode == QIcon::Selected) {
+            QIcon::Mode oppositeMode = (mode == QIcon::Disabled) ? QIcon::Selected : QIcon::Disabled;
+            if ((pe = tryMatch(size, QIcon::Normal, state)))
+                break;
+            if ((pe = tryMatch(size, QIcon::Active, state)))
+                break;
+            if ((pe = tryMatch(size, mode, oppositeState)))
+                break;
+            if ((pe = tryMatch(size, QIcon::Normal, oppositeState)))
+                break;
+            if ((pe = tryMatch(size, QIcon::Active, oppositeState)))
+                break;
+            if ((pe = tryMatch(size, oppositeMode, state)))
+                break;
+            if ((pe = tryMatch(size, oppositeMode, oppositeState)))
+                break;
+        } else {
+            QIcon::Mode oppositeMode = (mode == QIcon::Normal) ? QIcon::Active : QIcon::Normal;
+            if ((pe = tryMatch(size, oppositeMode, state)))
+                break;
+            if ((pe = tryMatch(size, mode, oppositeState)))
+                break;
+            if ((pe = tryMatch(size, oppositeMode, oppositeState)))
+                break;
+            if ((pe = tryMatch(size, QIcon::Disabled, state)))
+                break;
+            if ((pe = tryMatch(size, QIcon::Selected, state)))
+                break;
+            if ((pe = tryMatch(size, QIcon::Disabled, oppositeState)))
+                break;
+            if ((pe = tryMatch(size, QIcon::Selected, oppositeState)))
+                break;
+        }
+
+        if (!pe)
+            return pe;
+    }
+
+    if (sizeOnly ? (pe->size.isNull() || !pe->size.isValid()) : pe->pixmap.isNull()) {
+        pe->pixmap = QPixmap(pe->fileName);
+        if (!pe->pixmap.isNull())
+            pe->size = pe->pixmap.size();
+    }
+
+    return pe;
+}
+
+QPixmap QPixmapIconEngine::pixmap(const QSize &size, QIcon::Mode mode, QIcon::State state)
+{
+    QPixmap pm;
+    QPixmapIconEngineEntry *pe = bestMatch(size, mode, state, false);
+    if (pe)
+        pm = pe->pixmap;
+
+    if (pm.isNull()) {
+        int idx = pixmaps.count();
+        while (--idx >= 0) {
+            if (pe == &pixmaps[idx]) {
+                pixmaps.remove(idx);
+                break;
+            }
+        }
+        if (pixmaps.isEmpty())
+            return pm;
+        else
+            return pixmap(size, mode, state);
+    }
+
+    QSize actualSize = pm.size();
+    if (!actualSize.isNull() && (actualSize.width() > size.width() || actualSize.height() > size.height()))
+        actualSize.scale(size, Qt::KeepAspectRatio);
+
+    QString key = QLatin1String("$qt_icon_")
+                  + QString::number(pm.cacheKey())
+                  + QString::number(pe->mode)
+                  + QString::number(actualSize.width())
+                  + QLatin1Char('_')
+                  + QString::number(actualSize.height())
+                  + QLatin1Char('_');
+
+
+    if (mode == QIcon::Active) {
+        if (QPixmapCache::find(key + QString::number(mode), pm))
+            return pm; // horray
+        if (QPixmapCache::find(key + QString::number(QIcon::Normal), pm)) {
+            QStyleOption opt(0);
+            opt.palette = QApplication::palette();
+            QPixmap active = QApplication::style()->generatedIconPixmap(QIcon::Active, pm, &opt);
+            if (pm.cacheKey() == active.cacheKey())
+                return pm;
+        }
+    }
+
+    if (!QPixmapCache::find(key + QString::number(mode), pm)) {
+        if (pm.size() != actualSize)
+            pm = pm.scaled(actualSize, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
+        if (pe->mode != mode && mode != QIcon::Normal) {
+            QStyleOption opt(0);
+            opt.palette = QApplication::palette();
+            QPixmap generated = QApplication::style()->generatedIconPixmap(mode, pm, &opt);
+            if (!generated.isNull())
+                pm = generated;
+        }
+        QPixmapCache::insert(key + QString::number(mode), pm);
+    }
+    return pm;
+}
+
+QSize QPixmapIconEngine::actualSize(const QSize &size, QIcon::Mode mode, QIcon::State state)
+{
+    QSize actualSize;
+    if (QPixmapIconEngineEntry *pe = bestMatch(size, mode, state, true))
+        actualSize = pe->size;
+
+    if (actualSize.isNull())
+        return actualSize;
+
+    if (!actualSize.isNull() && (actualSize.width() > size.width() || actualSize.height() > size.height()))
+        actualSize.scale(size, Qt::KeepAspectRatio);
+    return actualSize;
+}
+
+void QPixmapIconEngine::addPixmap(const QPixmap &pixmap, QIcon::Mode mode, QIcon::State state)
+{
+    if (!pixmap.isNull()) {
+        QPixmapIconEngineEntry *pe = tryMatch(pixmap.size(), mode, state);
+        if(pe && pe->size == pixmap.size()) {
+            pe->pixmap = pixmap;
+            pe->fileName.clear();
+        } else {
+            pixmaps += QPixmapIconEngineEntry(pixmap, mode, state);
+        }
+    }
+}
+
+void QPixmapIconEngine::addFile(const QString &fileName, const QSize &_size, QIcon::Mode mode, QIcon::State state)
+{
+    if (!fileName.isEmpty()) {
+        QSize size = _size;
+        QPixmap pixmap;
+
+        QString abs = fileName;
+        if (fileName.at(0) != QLatin1Char(':'))
+            abs = QFileInfo(fileName).absoluteFilePath();
+
+        for (int i = 0; i < pixmaps.count(); ++i) {
+            if (pixmaps.at(i).mode == mode && pixmaps.at(i).state == state) {
+                QPixmapIconEngineEntry *pe = &pixmaps[i];
+                if(size == QSize()) {
+                    pixmap = QPixmap(abs);
+                    size = pixmap.size();
+                }
+                if (pe->size == QSize() && pe->pixmap.isNull()) {
+                    pe->pixmap = QPixmap(pe->fileName);
+                    pe->size = pe->pixmap.size();
+                }
+                if(pe->size == size) {
+                    pe->pixmap = pixmap;
+                    pe->fileName = abs;
+                    return;
+                }
+            }
+        }
+        QPixmapIconEngineEntry e(abs, size, mode, state);
+        e.pixmap = pixmap;
+        pixmaps += e;
+    }
+}
+
+QString QPixmapIconEngine::key() const
+{
+    return QLatin1String("QPixmapIconEngine");
+}
+
+QIconEngineV2 *QPixmapIconEngine::clone() const
+{
+    return new QPixmapIconEngine(*this);
+}
+
+bool QPixmapIconEngine::read(QDataStream &in)
+{
+    int num_entries;
+    QPixmap pm;
+    QString fileName;
+    QSize sz;
+    uint mode;
+    uint state;
+
+    in >> num_entries;
+    for (int i=0; i < num_entries; ++i) {
+        if (in.atEnd()) {
+            pixmaps.clear();
+            return false;
+        }
+        in >> pm;
+        in >> fileName;
+        in >> sz;
+        in >> mode;
+        in >> state;
+        if (pm.isNull())
+            addFile(fileName, sz, QIcon::Mode(mode), QIcon::State(state));
+        else
+            addPixmap(pm, QIcon::Mode(mode), QIcon::State(state));
+    }
+    return true;
+}
+
+bool QPixmapIconEngine::write(QDataStream &out) const
+{
+    int num_entries = pixmaps.size();
+    out << num_entries;
+    for (int i=0; i < num_entries; ++i) {
+        if (pixmaps.at(i).pixmap.isNull())
+            out << QPixmap(pixmaps.at(i).fileName);
+        else
+            out << pixmaps.at(i).pixmap;
+        out << pixmaps.at(i).fileName;
+        out << pixmaps.at(i).size;
+        out << (uint) pixmaps.at(i).mode;
+        out << (uint) pixmaps.at(i).state;
+    }
+    return true;
+}
+
+void QPixmapIconEngine::virtual_hook(int id, void *data)
+{
+    switch (id) {
+    case QIconEngineV2::AvailableSizesHook: {
+        QIconEngineV2::AvailableSizesArgument &arg =
+            *reinterpret_cast<QIconEngineV2::AvailableSizesArgument*>(data);
+        arg.sizes.clear();
+        for (int i = 0; i < pixmaps.size(); ++i) {
+            QPixmapIconEngineEntry &pe = pixmaps[i];
+            if (pe.size == QSize() && pe.pixmap.isNull()) {
+                pe.pixmap = QPixmap(pe.fileName);
+                pe.size = pe.pixmap.size();
+            }
+            if (pe.mode == arg.mode && pe.state == arg.state && !pe.size.isEmpty())
+                arg.sizes.push_back(pe.size);
+        }
+        break;
+    }
+    default:
+        QIconEngineV2::virtual_hook(id, data);
+    }
+}
+
+#if !defined (QT_NO_LIBRARY) && !defined(QT_NO_SETTINGS)
+Q_GLOBAL_STATIC_WITH_ARGS(QFactoryLoader, loader,
+    (QIconEngineFactoryInterface_iid, QLatin1String("/iconengines"), Qt::CaseInsensitive))
+Q_GLOBAL_STATIC_WITH_ARGS(QFactoryLoader, loaderV2,
+    (QIconEngineFactoryInterfaceV2_iid, QLatin1String("/iconengines"), Qt::CaseInsensitive))
+#endif
+
+
+
+/*!
+  \class QIcon
+
+  \brief The QIcon class provides scalable icons in different modes
+  and states.
+
+  \ingroup multimedia
+  \ingroup shared
+  \mainclass
+
+  A QIcon can generate smaller, larger, active, and disabled pixmaps
+  from the set of pixmaps it is given. Such pixmaps are used by Qt
+  widgets to show an icon representing a particular action.
+
+  The simplest use of QIcon is to create one from a QPixmap file or
+  resource, and then use it, allowing Qt to work out all the required
+  icon styles and sizes. For example:
+
+  \snippet doc/src/snippets/code/src_gui_image_qicon.cpp 0
+
+  To undo a QIcon, simply set a null icon in its place:
+
+  \snippet doc/src/snippets/code/src_gui_image_qicon.cpp 1
+
+  Use the QImageReader::supportedImageFormats() and
+  QImageWriter::supportedImageFormats() functions to retrieve a
+  complete list of the supported file formats.
+
+  When you retrieve a pixmap using pixmap(QSize, Mode, State), and no
+  pixmap for this given size, mode and state has been added with
+  addFile() or addPixmap(), then QIcon will generate one on the
+  fly. This pixmap generation happens in a QIconEngineV2. The default
+  engine scales pixmaps down if required, but never up, and it uses
+  the current style to calculate a disabled appearance. By using
+  custom icon engines, you can customize every aspect of generated
+  icons. With QIconEnginePluginV2 it is possible to register different
+  icon engines for different file suffixes, making it possible for
+  third parties to provide additional icon engines to those included
+  with Qt.
+
+  \note Since Qt 4.2, an icon engine that supports SVG is included.
+
+  \section1 Making Classes that Use QIcon
+
+  If you write your own widgets that have an option to set a small
+  pixmap, consider allowing a QIcon to be set for that pixmap.  The
+  Qt class QToolButton is an example of such a widget.
+
+  Provide a method to set a QIcon, and when you draw the icon, choose
+  whichever pixmap is appropriate for the current state of your widget.
+  For example:
+  \snippet doc/src/snippets/code/src_gui_image_qicon.cpp 2
+
+  You might also make use of the \c Active mode, perhaps making your
+  widget \c Active when the mouse is over the widget (see \l
+  QWidget::enterEvent()), while the mouse is pressed pending the
+  release that will activate the function, or when it is the currently
+  selected item. If the widget can be toggled, the "On" mode might be
+  used to draw a different icon.
+
+  \img icon.png QIcon
+
+  \sa {fowler}{GUI Design Handbook: Iconic Label}, {Icons Example}
+*/
+
+
+/*!
+  Constructs a null icon.
+*/
+QIcon::QIcon()
+    : d(0)
+{
+}
+
+/*!
+  Constructs an icon from a \a pixmap.
+ */
+QIcon::QIcon(const QPixmap &pixmap)
+    :d(0)
+{
+    addPixmap(pixmap);
+}
+
+/*!
+  Constructs a copy of \a other. This is very fast.
+*/
+QIcon::QIcon(const QIcon &other)
+    :d(other.d)
+{
+    if (d)
+        d->ref.ref();
+}
+
+/*!
+    Constructs an icon from the file with the given \a fileName. The
+    file will be loaded on demand.
+
+    If \a fileName contains a relative path (e.g. the filename only)
+    the relevant file must be found relative to the runtime working
+    directory.
+
+    The file name can be either refer to an actual file on disk or to
+    one of the application's embedded resources.  See the
+    \l{resources.html}{Resource System} overview for details on how to
+    embed images and other resource files in the application's
+    executable.
+
+    Use the QImageReader::supportedImageFormats() and
+    QImageWriter::supportedImageFormats() functions to retrieve a
+    complete list of the supported file formats.
+*/
+QIcon::QIcon(const QString &fileName)
+    : d(0)
+{
+    addFile(fileName);
+}
+
+
+/*!
+    Creates an icon with a specific icon \a engine. The icon takes
+    ownership of the engine.
+*/
+QIcon::QIcon(QIconEngine *engine)
+    :d(new QIconPrivate)
+{
+    d->engine_version = 1;
+    d->engine = engine;
+    d->v1RefCount = new QAtomicInt(1);
+}
+
+/*!
+    Creates an icon with a specific icon \a engine. The icon takes
+    ownership of the engine.
+*/
+QIcon::QIcon(QIconEngineV2 *engine)
+    :d(new QIconPrivate)
+{
+    d->engine_version = 2;
+    d->engine = engine;
+}
+
+/*!
+    Destroys the icon.
+*/
+QIcon::~QIcon()
+{
+    if (d && !d->ref.deref())
+        delete d;
+}
+
+/*!
+    Assigns the \a other icon to this icon and returns a reference to
+    this icon.
+*/
+QIcon &QIcon::operator=(const QIcon &other)
+{
+    if (other.d)
+        other.d->ref.ref();
+    if (d && !d->ref.deref())
+        delete d;
+    d = other.d;
+    return *this;
+}
+
+/*!
+   Returns the icon as a QVariant.
+*/
+QIcon::operator QVariant() const
+{
+    return QVariant(QVariant::Icon, this);
+}
+
+/*! \obsolete
+
+    Returns a number that identifies the contents of this
+    QIcon object. Distinct QIcon objects can have
+    the same serial number if they refer to the same contents
+    (but they don't have to). Also, the serial number of
+    a QIcon object may change during its lifetime.
+
+    Use cacheKey() instead.
+
+    A null icon always has a serial number of 0.
+
+    Serial numbers are mostly useful in conjunction with caching.
+
+    \sa QPixmap::serialNumber()
+*/
+
+int QIcon::serialNumber() const
+{
+    return d ? d->serialNum : 0;
+}
+
+/*!
+    Returns a number that identifies the contents of this QIcon
+    object. Distinct QIcon objects can have the same key if
+    they refer to the same contents.
+    \since 4.3
+
+    The cacheKey() will change when the icon is altered via
+    addPixmap() or addFile().
+
+    Cache keys are mostly useful in conjunction with caching.
+
+    \sa QPixmap::cacheKey()
+*/
+qint64 QIcon::cacheKey() const
+{
+    if (!d)
+        return 0;
+    return (((qint64) d->serialNum) << 32) | ((qint64) (d->detach_no));
+}
+
+/*!
+  Returns a pixmap with the requested \a size, \a mode, and \a
+  state, generating one if necessary. The pixmap might be smaller than
+  requested, but never larger.
+
+  \sa actualSize(), paint()
+*/
+QPixmap QIcon::pixmap(const QSize &size, Mode mode, State state) const
+{
+    if (!d)
+        return QPixmap();
+    return d->engine->pixmap(size, mode, state);
+}
+
+/*!
+    \fn QPixmap QIcon::pixmap(int w, int h, Mode mode = Normal, State state = Off) const
+
+    \overload
+
+    Returns a pixmap of size QSize(\a w, \a h). The pixmap might be smaller than
+    requested, but never larger.
+*/
+
+/*!
+    \fn QPixmap QIcon::pixmap(int extent, Mode mode = Normal, State state = Off) const
+
+    \overload
+
+    Returns a pixmap of size QSize(\a extent, \a extent). The pixmap might be smaller
+    than requested, but never larger.
+*/
+
+/*!  Returns the actual size of the icon for the requested \a size, \a
+  mode, and \a state. The result might be smaller than requested, but
+  never larger.
+
+  \sa pixmap(), paint()
+*/
+QSize QIcon::actualSize(const QSize &size, Mode mode, State state) const
+{
+    if (!d)
+        return QSize();
+    return d->engine->actualSize(size, mode, state);
+}
+
+
+/*!
+    Uses the \a painter to paint the icon with specified \a alignment,
+    required \a mode, and \a state into the rectangle \a rect.
+
+    \sa actualSize(), pixmap()
+*/
+void QIcon::paint(QPainter *painter, const QRect &rect, Qt::Alignment alignment, Mode mode, State state) const
+{
+    if (!d || !painter)
+        return;
+    QRect alignedRect = QStyle::alignedRect(painter->layoutDirection(), alignment, d->engine->actualSize(rect.size(), mode, state), rect);
+    d->engine->paint(painter, alignedRect, mode, state);
+}
+
+/*!
+    \fn void QIcon::paint(QPainter *painter, int x, int y, int w, int h, Qt::Alignment alignment,
+                          Mode mode, State state) const
+
+    \overload
+
+    Paints the icon into the rectangle QRect(\a x, \a y, \a w, \a h).
+*/
+
+/*!
+    Returns true if the icon is empty; otherwise returns false.
+
+    An icon is empty if it has neither a pixmap nor a filename.
+
+    Note: Even a non-null icon might not be able to create valid
+    pixmaps, eg. if the file does not exist or cannot be read.
+*/
+bool QIcon::isNull() const
+{
+    return !d;
+}
+
+/*!\internal
+ */
+bool QIcon::isDetached() const
+{
+    return !d || d->ref == 1;
+}
+
+/*! \internal
+ */
+void QIcon::detach()
+{
+    if (d) {
+        if (d->ref != 1) {
+            QIconPrivate *x = new QIconPrivate;
+            if (d->engine_version > 1) {
+                QIconEngineV2 *engine = static_cast<QIconEngineV2 *>(d->engine);
+                x->engine = engine->clone();
+            } else {
+                x->engine = d->engine;
+                x->v1RefCount = d->v1RefCount;
+                x->v1RefCount->ref();
+            }
+            x->engine_version = d->engine_version;
+            if (!d->ref.deref())
+                delete d;
+            d = x;
+        }
+        ++d->detach_no;
+    }
+}
+
+/*!
+    Adds \a pixmap to the icon, as a specialization for \a mode and
+    \a state.
+
+    Custom icon engines are free to ignore additionally added
+    pixmaps.
+
+    \sa addFile()
+*/
+void QIcon::addPixmap(const QPixmap &pixmap, Mode mode, State state)
+{
+    if (pixmap.isNull())
+        return;
+    if (!d) {
+        d = new QIconPrivate;
+        d->engine = new QPixmapIconEngine;
+    } else {
+        detach();
+    }
+    d->engine->addPixmap(pixmap, mode, state);
+}
+
+
+/*!  Adds an image from the file with the given \a fileName to the
+     icon, as a specialization for \a size, \a mode and \a state. The
+     file will be loaded on demand. Note: custom icon engines are free
+     to ignore additionally added pixmaps.
+
+     If \a fileName contains a relative path (e.g. the filename only)
+     the relevant file must be found relative to the runtime working
+     directory.
+
+    The file name can be either refer to an actual file on disk or to
+    one of the application's embedded resources. See the
+    \l{resources.html}{Resource System} overview for details on how to
+    embed images and other resource files in the application's
+    executable.
+
+    Use the QImageReader::supportedImageFormats() and
+    QImageWriter::supportedImageFormats() functions to retrieve a
+    complete list of the supported file formats.
+
+    \sa addPixmap()
+ */
+void QIcon::addFile(const QString &fileName, const QSize &size, Mode mode, State state)
+{
+    if (fileName.isEmpty())
+        return;
+    if (!d) {
+#if !defined (QT_NO_LIBRARY) && !defined(QT_NO_SETTINGS)
+        QFileInfo info(fileName);
+        QString suffix = info.suffix();
+        if (!suffix.isEmpty()) {
+            // first try version 2 engines..
+            if (QIconEngineFactoryInterfaceV2 *factory = qobject_cast<QIconEngineFactoryInterfaceV2*>(loaderV2()->instance(suffix))) {
+                if (QIconEngine *engine = factory->create(fileName)) {
+                    d = new QIconPrivate;
+                    d->engine = engine;
+                }
+            }
+            // ..then fall back and try to load version 1 engines
+            if (!d) {
+                if (QIconEngineFactoryInterface *factory = qobject_cast<QIconEngineFactoryInterface*>(loader()->instance(suffix))) {
+                    if (QIconEngine *engine = factory->create(fileName)) {
+                        d = new QIconPrivate;
+                        d->engine = engine;
+                        d->engine_version = 1;
+                        d->v1RefCount = new QAtomicInt(1);
+                    }
+                }
+            }
+        }
+#endif
+        // ...then fall back to the default engine
+        if (!d) {
+            d = new QIconPrivate;
+            d->engine = new QPixmapIconEngine;
+        }
+    } else {
+        detach();
+    }
+    d->engine->addFile(fileName, size, mode, state);
+}
+
+/*!
+    \since 4.5
+
+    Returns a list of available icon sizes for the specified \a mode and
+    \a state.
+*/
+QList<QSize> QIcon::availableSizes(Mode mode, State state) const
+{
+    if (!d || !d->engine || d->engine_version < 2)
+        return QList<QSize>();
+    QIconEngineV2 *engine = static_cast<QIconEngineV2*>(d->engine);
+    return engine->availableSizes(mode, state);
+}
+
+/*****************************************************************************
+  QIcon stream functions
+ *****************************************************************************/
+#if !defined(QT_NO_DATASTREAM)
+/*!
+    \fn QDataStream &operator<<(QDataStream &stream, const QIcon &icon)
+    \relates QIcon
+    \since 4.2
+
+    Writes the given \a icon to the the given \a stream as a PNG
+    image. If the icon contains more than one image, all images will
+    be written to the stream. Note that writing the stream to a file
+    will not produce a valid image file.
+*/
+
+QDataStream &operator<<(QDataStream &s, const QIcon &icon)
+{
+    if (s.version() >= QDataStream::Qt_4_3) {
+        if (icon.isNull()) {
+            s << QString();
+        } else {
+            if (icon.d->engine_version > 1) {
+                QIconEngineV2 *engine = static_cast<QIconEngineV2 *>(icon.d->engine);
+                s << engine->key();
+                engine->write(s);
+            } else {
+                // not really supported
+                qWarning("QIcon: Cannot stream QIconEngine. Use QIconEngineV2 instead.");
+            }
+        }
+    } else if (s.version() == QDataStream::Qt_4_2) {
+        if (icon.isNull()) {
+            s << 0;
+        } else {
+            QPixmapIconEngine *engine = static_cast<QPixmapIconEngine *>(icon.d->engine);
+            int num_entries = engine->pixmaps.size();
+            s << num_entries;
+            for (int i=0; i < num_entries; ++i) {
+                s << engine->pixmaps.at(i).pixmap;
+                s << engine->pixmaps.at(i).fileName;
+                s << engine->pixmaps.at(i).size;
+                s << (uint) engine->pixmaps.at(i).mode;
+                s << (uint) engine->pixmaps.at(i).state;
+            }
+        }
+    } else {
+        s << QPixmap(icon.pixmap(22,22));
+    }
+    return s;
+}
+
+/*!
+    \fn QDataStream &operator>>(QDataStream &stream, QIcon &icon)
+    \relates QIcon
+    \since 4.2
+
+    Reads an image, or a set of images, from the given \a stream into
+    the given \a icon.
+*/
+
+QDataStream &operator>>(QDataStream &s, QIcon &icon)
+{
+    if (s.version() >= QDataStream::Qt_4_3) {
+        icon = QIcon();
+        QString key;
+        s >> key;
+        if (key == QLatin1String("QPixmapIconEngine")) {
+            icon.d = new QIconPrivate;
+            QIconEngineV2 *engine = new QPixmapIconEngine;
+            icon.d->engine = engine;
+            engine->read(s);
+#if !defined (QT_NO_LIBRARY) && !defined(QT_NO_SETTINGS)
+        } else if (QIconEngineFactoryInterfaceV2 *factory = qobject_cast<QIconEngineFactoryInterfaceV2*>(loaderV2()->instance(key))) {
+            if (QIconEngineV2 *engine= factory->create()) {
+                icon.d = new QIconPrivate;
+                icon.d->engine = engine;
+                engine->read(s);
+            }
+#endif
+        }
+    } else if (s.version() == QDataStream::Qt_4_2) {
+        icon = QIcon();
+        int num_entries;
+        QPixmap pm;
+        QString fileName;
+        QSize sz;
+        uint mode;
+        uint state;
+
+        s >> num_entries;
+        for (int i=0; i < num_entries; ++i) {
+            s >> pm;
+            s >> fileName;
+            s >> sz;
+            s >> mode;
+            s >> state;
+            if (pm.isNull())
+                icon.addFile(fileName, sz, QIcon::Mode(mode), QIcon::State(state));
+            else
+                icon.addPixmap(pm, QIcon::Mode(mode), QIcon::State(state));
+        }
+    } else {
+        QPixmap pm;
+        s >> pm;
+        icon.addPixmap(pm);
+    }
+    return s;
+}
+
+#endif //QT_NO_DATASTREAM
+
+
+#ifdef QT3_SUPPORT
+
+static int widths[2] = { 22, 32 };
+static int heights[2] = { 22, 32 };
+
+static QSize pixmapSizeHelper(QIcon::Size which)
+{
+    int i = 0;
+    if (which == QIcon::Large)
+        i = 1;
+    return QSize(widths[i], heights[i]);
+}
+
+/*!
+    \enum QIcon::Size
+    \compat
+
+    \value Small  Use QStyle::pixelMetric(QStyle::PM_SmallIconSize) instead.
+    \value Large  Use QStyle::pixelMetric(QStyle::PM_LargeIconSize) instead.
+    \value Automatic  N/A.
+*/
+
+/*!
+    Use pixmap(QSize(...), \a mode, \a state), where the first
+    argument is an appropriate QSize instead of a \l Size value.
+
+    \sa pixmapSize()
+*/
+QPixmap QIcon::pixmap(Size size, Mode mode, State state) const
+{ return pixmap(pixmapSizeHelper(size), mode, state); }
+
+/*!
+    Use pixmap(QSize(...), mode, \a state), where the first argument
+    is an appropriate QSize instead of a \l Size value, and the
+    second argument is QIcon::Normal or QIcon::Disabled, depending on
+    the value of \a enabled.
+
+    \sa pixmapSize()
+*/
+QPixmap QIcon::pixmap(Size size, bool enabled, State state) const
+{ return pixmap(pixmapSizeHelper(size), enabled ? Normal : Disabled, state); }
+
+/*!
+    Use one of the other pixmap() overloads.
+*/
+QPixmap QIcon::pixmap() const
+{ return pixmap(pixmapSizeHelper(Small), Normal, Off); }
+
+/*!
+    The pixmap() function now takes a QSize instead of a QIcon::Size,
+    so there is no need for this function in new code.
+*/
+void QIcon::setPixmapSize(Size which, const QSize &size)
+{
+    int i = 0;
+    if (which == Large)
+        i = 1;
+    widths[i] = size.width();
+    heights[i] = size.height();
+}
+
+/*!
+    Use QStyle::pixelMetric() with QStyle::PM_SmallIconSize or
+    QStyle::PM_LargeIconSize as the first argument, depending on \a
+    which.
+*/
+QSize QIcon::pixmapSize(Size which)
+{
+    return pixmapSizeHelper(which);
+}
+
+/*!
+    \fn void QIcon::reset(const QPixmap &pixmap, Size size)
+
+    Use the constructor that takes a QPixmap and operator=().
+*/
+
+/*!
+    \fn void QIcon::setPixmap(const QPixmap &pixmap, Size size, Mode mode, State state)
+
+    Use addPixmap(\a pixmap, \a mode, \a state) instead. The \a size
+    parameter is ignored.
+*/
+
+/*!
+    \fn void QIcon::setPixmap(const QString &fileName, Size size, Mode mode, State state)
+
+    Use addFile(\a fileName, \a mode, \a state) instead. The \a size
+    parameter is ignored.
+*/
+
+#endif // QT3_SUPPORT
+
+/*!
+    \fn DataPtr &QIcon::data_ptr()
+    \internal
+*/
+
+/*!
+    \typedef QIcon::DataPtr
+    \internal
+*/
+
+QT_END_NAMESPACE
diff --git a/src/gui/image/qicon.h b/src/gui/image/qicon.h
new file mode 100644
index 0000000..5a606d4
--- /dev/null
+++ b/src/gui/image/qicon.h
@@ -0,0 +1,144 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QICON_H
+#define QICON_H
+
+#include <QtCore/qglobal.h>
+#include <QtCore/qsize.h>
+#include <QtCore/qlist.h>
+#include <QtGui/qpixmap.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+class QIconPrivate;
+class QIconEngine;
+class QIconEngineV2;
+
+class Q_GUI_EXPORT QIcon
+{
+public:
+    enum Mode { Normal, Disabled, Active, Selected };
+    enum State { On, Off };
+
+    QIcon();
+    QIcon(const QPixmap &pixmap);
+    QIcon(const QIcon &other);
+    explicit QIcon(const QString &fileName); // file or resource name
+    explicit QIcon(QIconEngine *engine);
+    explicit QIcon(QIconEngineV2 *engine);
+    ~QIcon();
+    QIcon &operator=(const QIcon &other);
+    operator QVariant() const;
+
+    QPixmap pixmap(const QSize &size, Mode mode = Normal, State state = Off) const;
+    inline QPixmap pixmap(int w, int h, Mode mode = Normal, State state = Off) const
+        { return pixmap(QSize(w, h), mode, state); }
+    inline QPixmap pixmap(int extent, Mode mode = Normal, State state = Off) const
+        { return pixmap(QSize(extent, extent), mode, state); }
+
+    QSize actualSize(const QSize &size, Mode mode = Normal, State state = Off) const;
+
+    void paint(QPainter *painter, const QRect &rect, Qt::Alignment alignment = Qt::AlignCenter, Mode mode = Normal, State state = Off) const;
+    inline void paint(QPainter *painter, int x, int y, int w, int h, Qt::Alignment alignment = Qt::AlignCenter, Mode mode = Normal, State state = Off) const
+        { paint(painter, QRect(x, y, w, h), alignment, mode, state); }
+
+    bool isNull() const;
+    bool isDetached() const;
+    void detach();
+
+    int serialNumber() const;
+    qint64 cacheKey() const;
+
+    void addPixmap(const QPixmap &pixmap, Mode mode = Normal, State state = Off);
+    void addFile(const QString &fileName, const QSize &size = QSize(), Mode mode = Normal, State state = Off);
+
+    QList<QSize> availableSizes(Mode mode = Normal, State state = Off) const;
+
+#ifdef QT3_SUPPORT
+    enum Size { Small, Large, Automatic = Small };
+    static QT3_SUPPORT void setPixmapSize(Size which, const QSize &size);
+    static QT3_SUPPORT QSize pixmapSize(Size which);
+    inline QT3_SUPPORT void reset(const QPixmap &pixmap, Size /*size*/) { *this = QIcon(pixmap); }
+    inline QT3_SUPPORT void setPixmap(const QPixmap &pixmap, Size, Mode mode = Normal, State state = Off)
+        { addPixmap(pixmap, mode, state); }
+    inline QT3_SUPPORT void setPixmap(const QString &fileName, Size, Mode mode = Normal, State state = Off)
+        { addPixmap(QPixmap(fileName), mode, state); }
+    QT3_SUPPORT QPixmap pixmap(Size size, Mode mode, State state = Off) const;
+    QT3_SUPPORT QPixmap pixmap(Size size, bool enabled, State state = Off) const;
+    QT3_SUPPORT QPixmap pixmap() const;
+#endif
+
+    Q_DUMMY_COMPARISON_OPERATOR(QIcon)
+
+private:
+    QIconPrivate *d;
+#if !defined(QT_NO_DATASTREAM)
+    friend Q_GUI_EXPORT QDataStream &operator<<(QDataStream &, const QIcon &);
+    friend Q_GUI_EXPORT QDataStream &operator>>(QDataStream &, QIcon &);
+#endif
+
+public:
+    typedef QIconPrivate * DataPtr;
+    inline DataPtr &data_ptr() { return d; }
+};
+
+Q_DECLARE_SHARED(QIcon)
+Q_DECLARE_TYPEINFO(QIcon, Q_MOVABLE_TYPE);
+
+#if !defined(QT_NO_DATASTREAM)
+Q_GUI_EXPORT QDataStream &operator<<(QDataStream &, const QIcon &);
+Q_GUI_EXPORT QDataStream &operator>>(QDataStream &, QIcon &);
+#endif
+
+#ifdef QT3_SUPPORT
+typedef QIcon QIconSet;
+#endif
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QICON_H
diff --git a/src/gui/image/qiconengine.cpp b/src/gui/image/qiconengine.cpp
new file mode 100644
index 0000000..866a82e
--- /dev/null
+++ b/src/gui/image/qiconengine.cpp
@@ -0,0 +1,304 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qiconengine.h"
+#include "qpainter.h"
+
+QT_BEGIN_NAMESPACE
+
+/*!
+  \class QIconEngine
+
+  \brief The QIconEngine class provides an abstract base class for QIcon renderers.
+
+  \ingroup multimedia
+
+  \bold {Use QIconEngineV2 instead.}
+
+  An icon engine provides the rendering functions for a QIcon. Each icon has a
+  corresponding icon engine that is responsible for drawing the icon with a
+  requested size, mode and state.
+
+  The icon is rendered by the paint() function, and the icon can additionally be
+  obtained as a pixmap with the pixmap() function (the default implementation
+  simply uses paint() to achieve this). The addPixmap() function can be used to
+  add new pixmaps to the icon engine, and is used by QIcon to add specialized
+  custom pixmaps.
+
+  The paint(), pixmap(), and addPixmap() functions are all virtual, and can
+  therefore be reimplemented in subclasses of QIconEngine.
+
+  \sa QIconEngineV2, QIconEnginePlugin
+
+*/
+
+/*!
+  \fn virtual void QIconEngine::paint(QPainter *painter, const QRect &rect, QIcon::Mode mode, QIcon::State state) = 0;
+
+  Uses the given \a painter to paint the icon with the required \a mode and
+  \a state into the rectangle \a rect.
+*/
+
+/*!  Returns the actual size of the icon the engine provides for the
+  requested \a size, \a mode and \a state. The default implementation
+  returns the given \a size.
+ */
+QSize QIconEngine::actualSize(const QSize &size, QIcon::Mode /*mode*/, QIcon::State /*state*/)
+{
+    return size;
+}
+
+
+/*!
+  Destroys the icon engine.
+ */
+QIconEngine::~QIconEngine()
+{
+}
+
+
+/*!
+  Returns the icon as a pixmap with the required \a size, \a mode,
+  and \a state. The default implementation creates a new pixmap and
+  calls paint() to fill it.
+*/
+QPixmap QIconEngine::pixmap(const QSize &size, QIcon::Mode mode, QIcon::State state)
+{
+    QPixmap pm(size);
+    {
+        QPainter p(&pm);
+        paint(&p, QRect(QPoint(0,0),size), mode, state);
+    }
+    return pm;
+}
+
+/*!
+  Called by QIcon::addPixmap(). Adds a specialized \a pixmap for the given
+  \a mode and \a state. The default pixmap-based engine stores any supplied
+  pixmaps, and it uses them instead of scaled pixmaps if the size of a pixmap
+  matches the size of icon requested. Custom icon engines that implement
+  scalable vector formats are free to ignores any extra pixmaps.
+ */
+void QIconEngine::addPixmap(const QPixmap &/*pixmap*/, QIcon::Mode /*mode*/, QIcon::State /*state*/)
+{
+}
+
+
+/*!  Called by QIcon::addFile(). Adds a specialized pixmap from the
+  file with the given \a fileName, \a size, \a mode and \a state. The
+  default pixmap-based engine stores any supplied file names, and it
+  loads the pixmaps on demand instead of using scaled pixmaps if the
+  size of a pixmap matches the size of icon requested. Custom icon
+  engines that implement scalable vector formats are free to ignores
+  any extra files.
+ */
+void QIconEngine::addFile(const QString &/*fileName*/, const QSize &/*size*/, QIcon::Mode /*mode*/, QIcon::State /*state*/)
+{
+}
+
+
+
+// version 2 functions
+
+
+/*!
+    \class QIconEngineV2
+
+    \brief The QIconEngineV2 class provides an abstract base class for QIcon renderers.
+
+    \ingroup multimedia
+    \since 4.3
+
+    An icon engine renders \l{QIcon}s. With icon engines, you can
+    customize icons. Qt provides a default engine that makes icons
+    adhere to the current style by scaling the icons and providing a
+    disabled appearance.
+
+    An engine is installed on an icon either through a QIcon
+    constructor or through a QIconEnginePluginV2. The plugins are used
+    by Qt if a specific engine is not given when the icon is created.
+    See the QIconEngineV2 class description to learn how to create
+    icon engine plugins.
+
+    An icon engine provides the rendering functions for a QIcon. Each
+    icon has a corresponding icon engine that is responsible for drawing
+    the icon with a requested size, mode and state.
+
+    QIconEngineV2 extends the API of QIconEngine to allow streaming of
+    the icon engine contents, and should be used instead of QIconEngine
+    for implementing new icon engines.
+
+    \sa QIconEnginePluginV2
+
+*/
+
+/*!
+    \enum QIconEngineV2::IconEngineHook
+    \since 4.5
+
+    These enum values are used for virtual_hook() to allow additional
+    queries to icon engine without breaking binary compatibility.
+
+    \value AvailableSizesHook Allows to query the sizes of the
+    contained pixmaps for pixmap-based engines. The \a data argument
+    of the virtual_hook() function is a AvailableSizesArgument pointer
+    that should be filled with icon sizes. Engines that work in terms
+    of a scalable, vectorial format normally return an empty list.
+
+    \sa virtual_hook()
+ */
+
+/*!
+    \class QIconEngineV2::AvailableSizesArgument
+    \since 4.5
+
+    This struct represents arguments to virtual_hook() function when
+    \a id parameter is QIconEngineV2::AvailableSizesHook.
+
+    \sa virtual_hook(), QIconEngineV2::IconEngineHook
+ */
+
+/*!
+    \variable QIconEngineV2::AvailableSizesArgument::mode
+    \brief the requested mode of an image.
+
+    \sa QIcon::Mode
+*/
+
+/*!
+    \variable QIconEngineV2::AvailableSizesArgument::state
+    \brief the requested state of an image.
+
+    \sa QIcon::State
+*/
+
+/*!
+    \variable QIconEngineV2::AvailableSizesArgument::sizes
+
+    \brief image sizes that are available with specified \a mode and
+    \a state. This is an output parameter and is filled after call to
+    virtual_hook(). Engines that work in terms of a scalable,
+    vectorial format normally return an empty list.
+*/
+
+
+/*!
+    Returns a key that identifies this icon engine.
+ */
+QString QIconEngineV2::key() const
+{
+    return QString();
+}
+
+/*!
+    Returns a clone of this icon engine.
+ */
+QIconEngineV2 *QIconEngineV2::clone() const
+{
+    return 0;
+}
+
+/*!
+    Reads icon engine contents from the QDataStream \a in. Returns
+    true if the contents were read; otherwise returns false.
+
+    QIconEngineV2's default implementation always return false.
+ */
+bool QIconEngineV2::read(QDataStream &)
+{
+    return false;
+}
+
+/*!
+    Writes the contents of this engine to the QDataStream \a out.
+    Returns true if the contents were written; otherwise returns false.
+
+    QIconEngineV2's default implementation always return false.
+ */
+bool QIconEngineV2::write(QDataStream &) const
+{
+    return false;
+}
+
+/*!
+    \since 4.5
+
+    Additional method to allow extending QIconEngineV2 without
+    adding new virtual methods (and without breaking binary compatibility).
+    The actual action and format of \a data depends on \a id argument
+    which is in fact a constant from IconEngineHook enum.
+
+    \sa IconEngineHook
+*/
+void QIconEngineV2::virtual_hook(int id, void *data)
+{
+    switch (id) {
+    case QIconEngineV2::AvailableSizesHook: {
+        QIconEngineV2::AvailableSizesArgument &arg =
+            *reinterpret_cast<QIconEngineV2::AvailableSizesArgument*>(data);
+        arg.sizes.clear();
+        break;
+    }
+    default:
+        break;
+    }
+}
+
+/*!
+    \since 4.5
+
+    Returns sizes of all images that are contained in the engine for the
+    specific \a mode and \a state.
+
+    \note This is a helper method and the actual work is done by
+    virtual_hook() method, hence this method depends on icon engine support
+    and may not work with all icon engines.
+ */
+QList<QSize> QIconEngineV2::availableSizes(QIcon::Mode mode, QIcon::State state)
+{
+    AvailableSizesArgument arg;
+    arg.mode = mode;
+    arg.state = state;
+    virtual_hook(QIconEngineV2::AvailableSizesHook, reinterpret_cast<void*>(&arg));
+    return arg.sizes;
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/image/qiconengine.h b/src/gui/image/qiconengine.h
new file mode 100644
index 0000000..71c8927
--- /dev/null
+++ b/src/gui/image/qiconengine.h
@@ -0,0 +1,101 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QICONENGINE_H
+#define QICONENGINE_H
+
+#include <QtCore/qglobal.h>
+#include <QtCore/qlist.h>
+#include <QtGui/qicon.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+class Q_GUI_EXPORT QIconEngine
+{
+public:
+    virtual ~QIconEngine();
+    virtual void paint(QPainter *painter, const QRect &rect, QIcon::Mode mode, QIcon::State state) = 0;
+    virtual QSize actualSize(const QSize &size, QIcon::Mode mode, QIcon::State state);
+    virtual QPixmap pixmap(const QSize &size, QIcon::Mode mode, QIcon::State state);
+
+    virtual void addPixmap(const QPixmap &pixmap, QIcon::Mode mode, QIcon::State state);
+    virtual void addFile(const QString &fileName, const QSize &size, QIcon::Mode mode, QIcon::State state);
+
+#if 0
+    virtual int frameCount(QIcon::Mode fromMode, QIcon::State fromState, QIcon::Mode toMode, QIcon::State toState);
+    virtual void paintFrame(QPainter *painter, const QRect &rect, int frameNumber, QIcon::Mode fromMode, QIcon::State fromState, QIcon::Mode toMode, QIcon::State toState);
+#endif
+};
+
+// ### Qt 5: move the below into QIconEngine
+class Q_GUI_EXPORT QIconEngineV2 : public QIconEngine
+{
+public:
+    virtual QString key() const;
+    virtual QIconEngineV2 *clone() const;
+    virtual bool read(QDataStream &in);
+    virtual bool write(QDataStream &out) const;
+    virtual void virtual_hook(int id, void *data);
+
+public:
+    enum IconEngineHook { AvailableSizesHook = 1 };
+
+    struct AvailableSizesArgument
+    {
+        QIcon::Mode mode;
+        QIcon::State state;
+        QList<QSize> sizes;
+    };
+
+    // ### Qt 5: make this function const and virtual.
+    QList<QSize> availableSizes(QIcon::Mode mode = QIcon::Normal,
+                                QIcon::State state = QIcon::Off);
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QICONENGINE_H
diff --git a/src/gui/image/qiconengineplugin.cpp b/src/gui/image/qiconengineplugin.cpp
new file mode 100644
index 0000000..22f62cf
--- /dev/null
+++ b/src/gui/image/qiconengineplugin.cpp
@@ -0,0 +1,171 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qiconengineplugin.h"
+#include "qiconengine.h"
+
+QT_BEGIN_NAMESPACE
+
+/*!
+    \class QIconEnginePlugin
+    \brief The QIconEnginePlugin class provides an abstract base for custom QIconEngine plugins.
+
+    \ingroup plugins
+
+    \bold {Use QIconEnginePluginV2 instead.}
+
+    The icon engine plugin is a simple plugin interface that makes it easy to
+    create custom icon engines that can be loaded dynamically into applications
+    through QIcon. QIcon uses the file or resource name's suffix to determine
+    what icon engine to use.
+
+    Writing a icon engine plugin is achieved by subclassing this base class,
+    reimplementing the pure virtual functions keys() and create(), and
+    exporting the class with the Q_EXPORT_PLUGIN2() macro.
+
+    \sa {How to Create Qt Plugins}
+*/
+
+/*!
+    \fn QStringList QIconEnginePlugin::keys() const
+
+    Returns a list of icon engine keys that this plugin supports. The keys correspond
+    to the suffix of the file or resource name used when the plugin was created.
+    Keys are case insensitive.
+
+    \sa create()
+*/
+
+/*!
+    \fn QIconEngine* QIconEnginePlugin::create(const QString& filename)
+
+    Creates and returns a QIconEngine object for the icon with the given
+    \a filename.
+
+    \sa keys()
+*/
+
+/*!
+    Constructs a icon engine plugin with the given \a parent. This is invoked
+    automatically by the Q_EXPORT_PLUGIN2() macro.
+*/
+QIconEnginePlugin::QIconEnginePlugin(QObject *parent)
+    : QObject(parent)
+{
+}
+
+/*!
+    Destroys the icon engine plugin.
+
+    You never have to call this explicitly. Qt destroys a plugin
+    automatically when it is no longer used.
+*/
+QIconEnginePlugin::~QIconEnginePlugin()
+{
+}
+
+// version 2
+
+/*!
+    \class QIconEnginePluginV2
+    \brief The QIconEnginePluginV2 class provides an abstract base for custom QIconEngineV2 plugins.
+
+    \ingroup plugins
+    \since 4.3
+ 
+    Icon engine plugins produces \l{QIconEngine}s for \l{QIcon}s; an
+    icon engine is used to render the icon. The keys that identifies
+    the engines the plugin can create are suffixes of 
+    icon filenames; they are returned by keys(). The create() function
+    receives the icon filename to return an engine for; it should
+    return 0 if it cannot produce an engine for the file.
+
+    Writing an icon engine plugin is achieved by inheriting
+    QIconEnginePluginV2, reimplementing keys() and create(), and
+    adding the Q_EXPORT_PLUGIN2() macro.
+
+    You should ensure that you do not duplicate keys. Qt will query
+    the plugins for icon engines in the order in which the plugins are
+    found during plugin search (see the plugins \l{How to Create Qt
+    Plugins}{overview document}).
+
+    \sa {How to Create Qt Plugins}
+*/
+
+/*!
+    \fn QStringList QIconEnginePluginV2::keys() const
+
+    Returns a list of icon engine keys that this plugin supports. The keys correspond
+    to the suffix of the file or resource name used when the plugin was created.
+    Keys are case insensitive.
+
+    \sa create()
+*/
+
+/*!
+    \fn QIconEngineV2* QIconEnginePluginV2::create(const QString& filename = QString())
+
+    Creates and returns a QIconEngine object for the icon with the given
+    \a filename.
+
+    \sa keys()
+*/
+
+/*!
+    Constructs a icon engine plugin with the given \a parent. This is invoked
+    automatically by the Q_EXPORT_PLUGIN2() macro.
+*/
+QIconEnginePluginV2::QIconEnginePluginV2(QObject *parent)
+    : QObject(parent)
+{
+}
+
+/*!
+    Destroys the icon engine plugin.
+
+    You never have to call this explicitly. Qt destroys a plugin
+    automatically when it is no longer used.
+*/
+QIconEnginePluginV2::~QIconEnginePluginV2()
+{
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/image/qiconengineplugin.h b/src/gui/image/qiconengineplugin.h
new file mode 100644
index 0000000..5c7f8b5
--- /dev/null
+++ b/src/gui/image/qiconengineplugin.h
@@ -0,0 +1,104 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QICONENGINEPLUGIN_H
+#define QICONENGINEPLUGIN_H
+
+#include <QtCore/qplugin.h>
+#include <QtCore/qfactoryinterface.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+class QIconEngine;
+class QIconEngineV2;
+
+struct Q_GUI_EXPORT QIconEngineFactoryInterface : public QFactoryInterface
+{
+    virtual QIconEngine *create(const QString &filename) = 0;
+};
+
+#define QIconEngineFactoryInterface_iid \
+    "com.trolltech.Qt.QIconEngineFactoryInterface"
+Q_DECLARE_INTERFACE(QIconEngineFactoryInterface, QIconEngineFactoryInterface_iid)
+
+class Q_GUI_EXPORT QIconEnginePlugin : public QObject, public QIconEngineFactoryInterface
+{
+    Q_OBJECT
+    Q_INTERFACES(QIconEngineFactoryInterface:QFactoryInterface)
+public:
+    QIconEnginePlugin(QObject *parent = 0);
+    ~QIconEnginePlugin();
+
+    virtual QStringList keys() const = 0;
+    virtual QIconEngine *create(const QString &filename) = 0;
+};
+
+// ### Qt 5: remove version 2
+struct Q_GUI_EXPORT QIconEngineFactoryInterfaceV2 : public QFactoryInterface
+{
+    virtual QIconEngineV2 *create(const QString &filename = QString()) = 0;
+};
+
+#define QIconEngineFactoryInterfaceV2_iid \
+    "com.trolltech.Qt.QIconEngineFactoryInterfaceV2"
+Q_DECLARE_INTERFACE(QIconEngineFactoryInterfaceV2, QIconEngineFactoryInterfaceV2_iid)
+
+class Q_GUI_EXPORT QIconEnginePluginV2 : public QObject, public QIconEngineFactoryInterfaceV2
+{
+    Q_OBJECT
+    Q_INTERFACES(QIconEngineFactoryInterfaceV2:QFactoryInterface)
+public:
+    QIconEnginePluginV2(QObject *parent = 0);
+    ~QIconEnginePluginV2();
+
+    virtual QStringList keys() const = 0;
+    virtual QIconEngineV2 *create(const QString &filename = QString()) = 0;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QICONENGINEPLUGIN_H
diff --git a/src/gui/image/qimage.cpp b/src/gui/image/qimage.cpp
new file mode 100644
index 0000000..558d574
--- /dev/null
+++ b/src/gui/image/qimage.cpp
@@ -0,0 +1,6119 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qimage.h"
+#include "qdatastream.h"
+#include "qbuffer.h"
+#include "qmap.h"
+#include "qmatrix.h"
+#include "qtransform.h"
+#include "qimagereader.h"
+#include "qimagewriter.h"
+#include "qstringlist.h"
+#include "qvariant.h"
+#include <ctype.h>
+#include <stdlib.h>
+#include <limits.h>
+#include <math.h>
+#include <private/qdrawhelper_p.h>
+#include <private/qmemrotate_p.h>
+#include <private/qpixmapdata_p.h>
+#include <private/qimagescale_p.h>
+
+#include <qhash.h>
+
+#ifdef QT_RASTER_IMAGEENGINE
+#include <private/qpaintengine_raster_p.h>
+#else
+#include <qpaintengine.h>
+#endif
+
+#include <private/qimage_p.h>
+
+QT_BEGIN_NAMESPACE
+
+static inline bool checkPixelSize(const QImage::Format format)
+{
+    switch (format) {
+    case QImage::Format_ARGB8565_Premultiplied:
+        return (sizeof(qargb8565) == 3);
+    case QImage::Format_RGB666:
+        return (sizeof(qrgb666) == 3);
+    case QImage::Format_ARGB6666_Premultiplied:
+        return (sizeof(qargb6666) == 3);
+    case QImage::Format_RGB555:
+        return (sizeof(qrgb555) == 2);
+    case QImage::Format_ARGB8555_Premultiplied:
+        return (sizeof(qargb8555) == 3);
+    case QImage::Format_RGB888:
+        return (sizeof(qrgb888) == 3);
+    case QImage::Format_RGB444:
+        return (sizeof(qrgb444) == 2);
+    case QImage::Format_ARGB4444_Premultiplied:
+        return (sizeof(qargb4444) == 2);
+    default:
+        return true;
+    }
+}
+
+#if defined(Q_CC_DEC) && defined(__alpha) && (__DECCXX_VER-0 >= 50190001)
+#pragma message disable narrowptr
+#endif
+
+
+#define QIMAGE_SANITYCHECK_MEMORY(image) \
+    if ((image).isNull()) { \
+        qWarning("QImage: out of memory, returning null image"); \
+        return QImage(); \
+    }
+
+
+// ### Qt 5: remove
+typedef void (*_qt_image_cleanup_hook)(int);
+Q_GUI_EXPORT _qt_image_cleanup_hook qt_image_cleanup_hook = 0;
+
+// ### Qt 5: rename
+typedef void (*_qt_image_cleanup_hook_64)(qint64);
+Q_GUI_EXPORT _qt_image_cleanup_hook_64 qt_image_cleanup_hook_64 = 0;
+
+static QImage rotated90(const QImage &src);
+static QImage rotated180(const QImage &src);
+static QImage rotated270(const QImage &src);
+
+// ### Qt 5: remove
+Q_GUI_EXPORT qint64 qt_image_id(const QImage &image)
+{
+    return image.cacheKey();
+}
+
+const QVector<QRgb> *qt_image_colortable(const QImage &image)
+{
+    return &image.d->colortable;
+}
+
+extern int qt_defaultDpiX();
+extern int qt_defaultDpiY();
+
+QBasicAtomicInt qimage_serial_number = Q_BASIC_ATOMIC_INITIALIZER(1);
+
+QImageData::QImageData()
+    : ref(0), width(0), height(0), depth(0), nbytes(0), data(0),
+#ifdef QT3_SUPPORT
+      jumptable(0),
+#endif
+      format(QImage::Format_ARGB32), bytes_per_line(0),
+      ser_no(qimage_serial_number.fetchAndAddRelaxed(1)),
+      detach_no(0),
+      dpmx(qt_defaultDpiX() * 100 / qreal(2.54)),
+      dpmy(qt_defaultDpiY() * 100 / qreal(2.54)),
+      offset(0, 0), own_data(true), ro_data(false), has_alpha_clut(false),
+      is_cached(false), paintEngine(0)
+{
+}
+
+static int depthForFormat(QImage::Format format)
+{
+    int depth = 0;
+    switch(format) {
+    case QImage::Format_Invalid:
+    case QImage::NImageFormats:
+        Q_ASSERT(false);
+    case QImage::Format_Mono:
+    case QImage::Format_MonoLSB:
+        depth = 1;
+        break;
+    case QImage::Format_Indexed8:
+        depth = 8;
+        break;
+    case QImage::Format_RGB32:
+    case QImage::Format_ARGB32:
+    case QImage::Format_ARGB32_Premultiplied:
+        depth = 32;
+        break;
+    case QImage::Format_RGB555:
+    case QImage::Format_RGB16:
+    case QImage::Format_RGB444:
+    case QImage::Format_ARGB4444_Premultiplied:
+        depth = 16;
+        break;
+    case QImage::Format_RGB666:
+    case QImage::Format_ARGB6666_Premultiplied:
+    case QImage::Format_ARGB8565_Premultiplied:
+    case QImage::Format_ARGB8555_Premultiplied:
+    case QImage::Format_RGB888:
+        depth = 24;
+        break;
+    }
+    return depth;
+}
+
+QImageData * QImageData::create(const QSize &size, QImage::Format format, int numColors)
+{
+    if (!size.isValid() || numColors < 0 || format == QImage::Format_Invalid)
+        return 0;                                // invalid parameter(s)
+
+    if (!checkPixelSize(format)) {
+        qWarning("QImageData::create(): Invalid pixel size for format %i",
+                 format);
+        return 0;
+    }
+
+    uint width = size.width();
+    uint height = size.height();
+    uint depth = depthForFormat(format);
+
+    switch (format) {
+    case QImage::Format_Mono:
+    case QImage::Format_MonoLSB:
+        numColors = 2;
+        break;
+    case QImage::Format_Indexed8:
+        numColors = qBound(0, numColors, 256);
+        break;
+    default:
+        numColors = 0;
+        break;
+    }
+
+    const int bytes_per_line = ((width * depth + 31) >> 5) << 2; // bytes per scanline (must be multiple of 8)
+
+    // sanity check for potential overflows
+    if (INT_MAX/depth < width
+        || bytes_per_line <= 0
+        || height <= 0
+        || INT_MAX/uint(bytes_per_line) < height
+        || INT_MAX/sizeof(uchar *) < uint(height))
+        return 0;
+
+    QImageData *d = new QImageData;
+    d->colortable.resize(numColors);
+    if (depth == 1) {
+        d->colortable[0] = QColor(Qt::black).rgba();
+        d->colortable[1] = QColor(Qt::white).rgba();
+    } else {
+        for (int i = 0; i < numColors; ++i)
+            d->colortable[i] = 0;
+    }
+
+    d->width = width;
+    d->height = height;
+    d->depth = depth;
+    d->format = format;
+    d->has_alpha_clut = false;
+    d->is_cached = false;
+
+    d->bytes_per_line = bytes_per_line;
+
+    d->nbytes = d->bytes_per_line*height;
+    d->data  = (uchar *)malloc(d->nbytes);
+
+    if (!d->data) {
+        delete d;
+        return 0;
+    }
+
+    d->ref.ref();
+    return d;
+
+}
+
+QImageData::~QImageData()
+{
+    if (is_cached && qt_image_cleanup_hook_64)
+        qt_image_cleanup_hook_64((((qint64) ser_no) << 32) | ((qint64) detach_no));
+    delete paintEngine;
+    if (data && own_data)
+        free(data);
+#ifdef QT3_SUPPORT
+    if (jumptable)
+        free(jumptable);
+    jumptable = 0;
+#endif
+    data = 0;
+}
+
+
+bool QImageData::checkForAlphaPixels() const
+{
+    bool has_alpha_pixels = false;
+
+    switch (format) {
+
+    case QImage::Format_Indexed8:
+        has_alpha_pixels = has_alpha_clut;
+        break;
+
+    case QImage::Format_ARGB32:
+    case QImage::Format_ARGB32_Premultiplied: {
+        uchar *bits = data;
+        for (int y=0; y<height && !has_alpha_pixels; ++y) {
+            for (int x=0; x<width; ++x)
+                has_alpha_pixels |= (((uint *)bits)[x] & 0xff000000) != 0xff000000;
+            bits += bytes_per_line;
+        }
+    } break;
+
+    case QImage::Format_ARGB8555_Premultiplied:
+    case QImage::Format_ARGB8565_Premultiplied: {
+        uchar *bits = data;
+        uchar *end_bits = data + bytes_per_line;
+
+        for (int y=0; y<height && !has_alpha_pixels; ++y) {
+            while (bits < end_bits) {
+                has_alpha_pixels |= bits[0] != 0;
+                bits += 3;
+            }
+            bits = end_bits;
+            end_bits += bytes_per_line;
+        }
+    } break;
+
+    case QImage::Format_ARGB6666_Premultiplied: {
+        uchar *bits = data;
+        uchar *end_bits = data + bytes_per_line;
+
+        for (int y=0; y<height && !has_alpha_pixels; ++y) {
+            while (bits < end_bits) {
+                has_alpha_pixels |= (bits[0] & 0xfc) != 0;
+                bits += 3;
+            }
+            bits = end_bits;
+            end_bits += bytes_per_line;
+        }
+    } break;
+
+    case QImage::Format_ARGB4444_Premultiplied: {
+        uchar *bits = data;
+        uchar *end_bits = data + bytes_per_line;
+
+        for (int y=0; y<height && !has_alpha_pixels; ++y) {
+            while (bits < end_bits) {
+                has_alpha_pixels |= (bits[0] & 0xf0) != 0;
+                bits += 2;
+            }
+            bits = end_bits;
+            end_bits += bytes_per_line;
+        }
+    } break;
+
+    default:
+        break;
+    }
+
+    return has_alpha_pixels;
+}
+
+/*!
+    \class QImage
+
+    \ingroup multimedia
+    \ingroup shared
+    \mainclass
+    \reentrant
+
+    \brief The QImage class provides a hardware-independent image
+    representation that allows direct access to the pixel data, and
+    can be used as a paint device.
+
+    Qt provides four classes for handling image data: QImage, QPixmap,
+    QBitmap and QPicture.  QImage is designed and optimized for I/O,
+    and for direct pixel access and manipulation, while QPixmap is
+    designed and optimized for showing images on screen. QBitmap is
+    only a convenience class that inherits QPixmap, ensuring a
+    depth of 1. Finally, the QPicture class is a paint device that
+    records and replays QPainter commands.
+
+    Because QImage is a QPaintDevice subclass, QPainter can be used to
+    draw directly onto images.  When using QPainter on a QImage, the
+    painting can be performed in another thread than the current GUI
+    thread.
+
+    The QImage class supports several image formats described by the
+    \l Format enum. These include monochrome, 8-bit, 32-bit and
+    alpha-blended images which are available in all versions of Qt
+    4.x.
+
+    QImage provides a collection of functions that can be used to
+    obtain a variety of information about the image. There are also
+    several functions that enables transformation of the image.
+
+    QImage objects can be passed around by value since the QImage
+    class uses \l{Implicit Data Sharing}{implicit data
+    sharing}. QImage objects can also be streamed and compared.
+
+    \note If you would like to load QImage objects in a static build of Qt,
+    refer to the \l{How To Create Qt Plugins#Static Plugins}{Plugin HowTo}.
+
+    \tableofcontents
+
+    \section1 Reading and Writing Image Files
+
+    QImage provides several ways of loading an image file: The file
+    can be loaded when constructing the QImage object, or by using the
+    load() or loadFromData() functions later on. QImage also provides
+    the static fromData() function, constructing a QImage from the
+    given data.  When loading an image, the file name can either refer
+    to an actual file on disk or to one of the application's embedded
+    resources. See \l{The Qt Resource System} overview for details
+    on how to embed images and other resource files in the
+    application's executable.
+
+    Simply call the save() function to save a QImage object.
+
+    The complete list of supported file formats are available through
+    the QImageReader::supportedImageFormats() and
+    QImageWriter::supportedImageFormats() functions. New file formats
+    can be added as plugins. By default, Qt supports the following
+    formats:
+
+    \table
+    \header \o Format \o Description                      \o Qt's support
+    \row    \o BMP    \o Windows Bitmap                   \o Read/write
+    \row    \o GIF    \o Graphic Interchange Format (optional) \o Read
+    \row    \o JPG    \o Joint Photographic Experts Group \o Read/write
+    \row    \o JPEG   \o Joint Photographic Experts Group \o Read/write
+    \row    \o PNG    \o Portable Network Graphics        \o Read/write
+    \row    \o PBM    \o Portable Bitmap                  \o Read
+    \row    \o PGM    \o Portable Graymap                 \o Read
+    \row    \o PPM    \o Portable Pixmap                  \o Read/write
+    \row    \o TIFF   \o Tagged Image File Format         \o Read/write
+    \row    \o XBM    \o X11 Bitmap                       \o Read/write
+    \row    \o XPM    \o X11 Pixmap                       \o Read/write
+    \endtable
+
+    \section1 Image Information
+
+    QImage provides a collection of functions that can be used to
+    obtain a variety of information about the image:
+
+    \table
+    \header
+    \o \o Available Functions
+
+    \row
+    \o Geometry
+    \o
+
+    The size(), width(), height(), dotsPerMeterX(), and
+    dotsPerMeterY() functions provide information about the image size
+    and aspect ratio.
+
+    The rect() function returns the image's enclosing rectangle. The
+    valid() function tells if a given pair of coordinates is within
+    this rectangle. The offset() function returns the number of pixels
+    by which the image is intended to be offset by when positioned
+    relative to other images, which also can be manipulated using the
+    setOffset() function.
+
+    \row
+    \o Colors
+    \o
+
+    The color of a pixel can be retrieved by passing its coordinates
+    to the pixel() function.  The pixel() function returns the color
+    as a QRgb value indepedent of the image's format.
+
+    In case of monochrome and 8-bit images, the numColors() and
+    colorTable() functions provide information about the color
+    components used to store the image data: The colorTable() function
+    returns the image's entire color table. To obtain a single entry,
+    use the pixelIndex() function to retrieve the pixel index for a
+    given pair of coordinates, then use the color() function to
+    retrieve the color. Note that if you create an 8-bit image
+    manually, you have to set a valid color table on the image as
+    well.
+
+    The hasAlphaChannel() function tells if the image's format
+    respects the alpha channel, or not. The allGray() and
+    isGrayscale() functions tell whether an image's colors are all
+    shades of gray.
+
+    See also the \l {QImage#Pixel Manipulation}{Pixel Manipulation}
+    and \l {QImage#Image Transformations}{Image Transformations}
+    sections.
+
+    \row
+    \o Text
+    \o
+
+    The text() function returns the image text associated with the
+    given text key. An image's text keys can be retrieved using the
+    textKeys() function. Use the setText() function to alter an
+    image's text.
+
+    \row
+    \o Low-level information
+    \o
+    The depth() function returns the depth of the image. The supported
+    depths are 1 (monochrome), 8 and 32 (for more information see the
+    \l {QImage#Image Formats}{Image Formats} section).
+
+    The format(), bytesPerLine(), and numBytes() functions provide
+    low-level information about the data stored in the image.
+
+    The cacheKey() function returns a number that uniquely
+    identifies the contents of this QImage object.
+    \endtable
+
+    \section1 Pixel Manipulation
+
+    The functions used to manipulate an image's pixels depend on the
+    image format. The reason is that monochrome and 8-bit images are
+    index-based and use a color lookup table, while 32-bit images
+    store ARGB values directly. For more information on image formats,
+    see the \l {Image Formats} section.
+
+    In case of a 32-bit image, the setPixel() function can be used to
+    alter the color of the pixel at the given coordinates to any other
+    color specified as an ARGB quadruplet. To make a suitable QRgb
+    value, use the qRgb() (adding a default alpha component to the
+    given RGB values, i.e. creating an opaque color) or qRgba()
+    function. For example:
+
+    \table
+    \row
+    \o \inlineimage qimage-32bit_scaled.png
+    \o
+    \snippet doc/src/snippets/code/src_gui_image_qimage.cpp 0
+    \header
+    \o {2,1}32-bit
+    \endtable
+
+    In case of a 8-bit and monchrome images, the pixel value is only
+    an index from the image's color table. So the setPixel() function
+    can only be used to alter the color of the pixel at the given
+    coordinates to a predefined color from the image's color table,
+    i.e. it can only change the pixel's index value. To alter or add a
+    color to an image's color table, use the setColor() function.
+
+    An entry in the color table is an ARGB quadruplet encoded as an
+    QRgb value. Use the qRgb() and qRgba() functions to make a
+    suitable QRgb value for use with the setColor() function. For
+    example:
+
+    \table
+    \row
+    \o \inlineimage qimage-8bit_scaled.png
+    \o
+    \snippet doc/src/snippets/code/src_gui_image_qimage.cpp 1
+    \header
+    \o {2,1} 8-bit
+    \endtable
+
+    QImage also provide the scanLine() function which returns a
+    pointer to the pixel data at the scanline with the given index,
+    and the bits() function which returns a pointer to the first pixel
+    data (this is equivalent to \c scanLine(0)).
+
+    \section1 Image Formats
+
+    Each pixel stored in a QImage is represented by an integer. The
+    size of the integer varies depending on the format. QImage
+    supports several image formats described by the \l Format
+    enum. The monochrome (1-bit), 8-bit and 32-bit images are
+    available in all versions of Qt. In addition Qt for Embedded Linux
+    also supports 2-bit, 4-bit, and 16-bit images. For more information
+    about the Qt Extended specific formats, see the documentation of the \l
+    Format enum.
+
+    Monochrome images are stored using 1-bit indexes into a color table
+    with at most two colors. There are two different types of
+    monochrome images: big endian (MSB first) or little endian (LSB
+    first) bit order.
+
+    8-bit images are stored using 8-bit indexes into a color table,
+    i.e.  they have a single byte per pixel. The color table is a
+    QVector<QRgb>, and the QRgb typedef is equivalent to an unsigned
+    int containing an ARGB quadruplet on the format 0xAARRGGBB.
+
+    32-bit images have no color table; instead, each pixel contains an
+    QRgb value. There are three different types of 32-bit images
+    storing RGB (i.e. 0xffRRGGBB), ARGB and premultiplied ARGB
+    values respectively. In the premultiplied format the red, green,
+    and blue channels are multiplied by the alpha component divided by
+    255.
+
+    An image's format can be retrieved using the format()
+    function. Use the convertToFormat() functions to convert an image
+    into another format. The allGray() and isGrayscale() functions
+    tell whether a color image can safely be converted to a grayscale
+    image.
+
+    \section1 Image Transformations
+
+    QImage supports a number of functions for creating a new image
+    that is a transformed version of the original: The
+    createAlphaMask() function builds and returns a 1-bpp mask from
+    the alpha buffer in this image, and the createHeuristicMask()
+    function creates and returns a 1-bpp heuristic mask for this
+    image. The latter function works by selecting a color from one of
+    the corners, then chipping away pixels of that color starting at
+    all the edges.
+
+    The mirrored() function returns a mirror of the image in the
+    desired direction, the scaled() returns a copy of the image scaled
+    to a rectangle of the desired measures, the rgbSwapped() function
+    constructs a BGR image from a RGB image, and the alphaChannel()
+    function constructs an image from this image's alpha channel.
+
+    The scaledToWidth() and scaledToHeight() functions return scaled
+    copies of the image.
+
+    The transformed() function returns a copy of the image that is
+    transformed with the given transformation matrix and
+    transformation mode: Internally, the transformation matrix is
+    adjusted to compensate for unwanted translation,
+    i.e. transformed() returns the smallest image containing all
+    transformed points of the original image. The static trueMatrix()
+    function returns the actual matrix used for transforming the
+    image.
+
+    There are also functions for changing attributes of an image
+    in-place:
+
+    \table
+    \header \o Function \o Description
+    \row
+    \o setAlphaChannel()
+    \o Sets the alpha channel of the image.
+    \row
+    \o setDotsPerMeterX()
+    \o Defines the aspect ratio by setting the number of pixels that fit
+    horizontally in a physical meter.
+    \row
+    \o setDotsPerMeterY()
+    \o Defines the aspect ratio by setting the number of pixels that fit
+    vertically in a physical meter.
+    \row
+    \o fill()
+    \o Fills the entire image with the given pixel value.
+    \row
+    \o invertPixels()
+    \o Inverts all pixel values in the image using the given InvertMode value.
+    \row
+    \o setColorTable()
+    \o Sets the color table used to translate color indexes. Only
+    monochrome and 8-bit formats.
+    \row
+    \o setNumColors()
+    \o Resizes the color table. Only monochrome and 8-bit formats.
+
+    \endtable
+
+    \section1 Legal Information
+
+    For smooth scaling, the transformed() functions use code based on
+    smooth scaling algorithm by Daniel M. Duley.
+
+    \legalese
+     Copyright (C) 2004, 2005 Daniel M. Duley
+
+     Redistribution and use in source and binary forms, with or without
+        modification, are permitted provided that the following conditions
+        are met:
+
+     1. Redistributions of source code must retain the above copyright
+        notice, this list of conditions and the following disclaimer.
+     2. Redistributions in binary form must reproduce the above copyright
+        notice, this list of conditions and the following disclaimer in the
+        documentation and/or other materials provided with the distribution.
+
+     THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+     IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+     OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+     IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+     INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+     DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+     THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+     (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+     THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+    \endlegalese
+
+    \sa QImageReader, QImageWriter, QPixmap, QSvgRenderer, {Image Composition Example},
+        {Image Viewer Example}, {Scribble Example}, {Pixelator Example}
+*/
+
+/*!
+    \enum QImage::Endian
+    \compat
+
+    This enum type is used to describe the endianness of the CPU and
+    graphics hardware. It is provided here for compatibility with earlier versions of Qt.
+
+    Use the \l Format enum instead. The \l Format enum specify the
+    endianess for monchrome formats, but for other formats the
+    endianess is not relevant.
+
+    \value IgnoreEndian  Endianness does not matter. Useful for some
+                         operations that are independent of endianness.
+    \value BigEndian     Most significant bit first or network byte order, as on SPARC, PowerPC, and Motorola CPUs.
+    \value LittleEndian  Least significant bit first or little endian byte order, as on Intel x86.
+*/
+
+/*!
+    \enum QImage::InvertMode
+
+    This enum type is used to describe how pixel values should be
+    inverted in the invertPixels() function.
+
+    \value InvertRgb    Invert only the RGB values and leave the alpha
+                        channel unchanged.
+
+    \value InvertRgba   Invert all channels, including the alpha channel.
+
+    \sa invertPixels()
+*/
+
+/*!
+    \enum QImage::Format
+
+    The following image formats are available in all versions of Qt:
+
+    \value Format_Invalid   The image is invalid.
+    \value Format_Mono      The image is stored using 1-bit per pixel. Bytes are
+                            packed with the most significant bit (MSB) first.
+    \value Format_MonoLSB   The image is stored using 1-bit per pixel. Bytes are
+                            packed with the less significant bit (LSB) first.
+    \value Format_Indexed8  The image is stored using 8-bit indexes into a colormap.
+    \value Format_RGB32     The image is stored using a 32-bit RGB format (0xffRRGGBB).
+    \value Format_ARGB32    The image is stored using a 32-bit ARGB format (0xAARRGGBB).
+    \value Format_ARGB32_Premultiplied  The image is stored using a premultiplied 32-bit
+                            ARGB format (0xAARRGGBB), i.e. the red,
+                            green, and blue channels are multiplied
+                            by the alpha component divided by 255. (If RR, GG, or BB
+                            has a higher value than the alpha channel, the results are
+                            undefined.) Certain operations (such as image composition
+                            using alpha blending) are faster using premultiplied ARGB32
+                            than with plain ARGB32.
+    \value Format_RGB16     The image is stored using a 16-bit RGB format (5-6-5).
+    \value Format_ARGB8565_Premultiplied  The image is stored using a
+                            premultiplied 24-bit ARGB format (8-5-6-5).
+    \value Format_RGB666    The image is stored using a 24-bit RGB format (6-6-6).
+                            The unused most significant bits is always zero.
+    \value Format_ARGB6666_Premultiplied  The image is stored using a
+                            premultiplied 24-bit ARGB format (6-6-6-6).
+    \value Format_RGB555    The image is stored using a 16-bit RGB format (5-5-5).
+                            The unused most significant bit is always zero.
+    \value Format_ARGB8555_Premultiplied  The image is stored using a
+                            premultiplied 24-bit ARGB format (8-5-5-5).
+    \value Format_RGB888    The image is stored using a 24-bit RGB format (8-8-8).
+    \value Format_RGB444    The image is stored using a 16-bit RGB format (4-4-4).
+                            The unused bits are always zero.
+    \value Format_ARGB4444_Premultiplied  The image is stored using a
+                            premultiplied 16-bit ARGB format (4-4-4-4).
+
+    \sa format(), convertToFormat()
+*/
+
+/*****************************************************************************
+  QImage member functions
+ *****************************************************************************/
+
+// table to flip bits
+static const uchar bitflip[256] = {
+    /*
+        open OUT, "| fmt";
+        for $i (0..255) {
+            print OUT (($i >> 7) & 0x01) | (($i >> 5) & 0x02) |
+                      (($i >> 3) & 0x04) | (($i >> 1) & 0x08) |
+                      (($i << 7) & 0x80) | (($i << 5) & 0x40) |
+                      (($i << 3) & 0x20) | (($i << 1) & 0x10), ", ";
+        }
+        close OUT;
+    */
+    0, 128, 64, 192, 32, 160, 96, 224, 16, 144, 80, 208, 48, 176, 112, 240,
+    8, 136, 72, 200, 40, 168, 104, 232, 24, 152, 88, 216, 56, 184, 120, 248,
+    4, 132, 68, 196, 36, 164, 100, 228, 20, 148, 84, 212, 52, 180, 116, 244,
+    12, 140, 76, 204, 44, 172, 108, 236, 28, 156, 92, 220, 60, 188, 124, 252,
+    2, 130, 66, 194, 34, 162, 98, 226, 18, 146, 82, 210, 50, 178, 114, 242,
+    10, 138, 74, 202, 42, 170, 106, 234, 26, 154, 90, 218, 58, 186, 122, 250,
+    6, 134, 70, 198, 38, 166, 102, 230, 22, 150, 86, 214, 54, 182, 118, 246,
+    14, 142, 78, 206, 46, 174, 110, 238, 30, 158, 94, 222, 62, 190, 126, 254,
+    1, 129, 65, 193, 33, 161, 97, 225, 17, 145, 81, 209, 49, 177, 113, 241,
+    9, 137, 73, 201, 41, 169, 105, 233, 25, 153, 89, 217, 57, 185, 121, 249,
+    5, 133, 69, 197, 37, 165, 101, 229, 21, 149, 85, 213, 53, 181, 117, 245,
+    13, 141, 77, 205, 45, 173, 109, 237, 29, 157, 93, 221, 61, 189, 125, 253,
+    3, 131, 67, 195, 35, 163, 99, 227, 19, 147, 83, 211, 51, 179, 115, 243,
+    11, 139, 75, 203, 43, 171, 107, 235, 27, 155, 91, 219, 59, 187, 123, 251,
+    7, 135, 71, 199, 39, 167, 103, 231, 23, 151, 87, 215, 55, 183, 119, 247,
+    15, 143, 79, 207, 47, 175, 111, 239, 31, 159, 95, 223, 63, 191, 127, 255
+};
+
+const uchar *qt_get_bitflip_array()                        // called from QPixmap code
+{
+    return bitflip;
+}
+
+#if defined(QT3_SUPPORT)
+static QImage::Format formatFor(int depth, QImage::Endian bitOrder)
+{
+    QImage::Format format;
+    if (depth == 1) {
+        format = bitOrder == QImage::BigEndian ? QImage::Format_Mono : QImage::Format_MonoLSB;
+    } else if (depth == 8) {
+        format = QImage::Format_Indexed8;
+    } else if (depth == 32) {
+        format = QImage::Format_RGB32;
+    } else if (depth == 24) {
+        format = QImage::Format_RGB888;
+    } else if (depth == 16) {
+        format = QImage::Format_RGB16;
+    } else {
+        qWarning("QImage: Depth %d not supported", depth);
+        format = QImage::Format_Invalid;
+    }
+    return format;
+}
+#endif
+
+/*!
+    Constructs a null image.
+
+    \sa isNull()
+*/
+
+QImage::QImage()
+    : QPaintDevice()
+{
+    d = 0;
+}
+
+/*!
+    Constructs an image with the given \a width, \a height and \a
+    format.
+
+    \warning This will create a QImage with uninitialized data. Call
+    fill() to fill the image with an appropriate pixel value before
+    drawing onto it with QPainter.
+*/
+QImage::QImage(int width, int height, Format format)
+    : QPaintDevice()
+{
+    d = QImageData::create(QSize(width, height), format, 0);
+}
+
+/*!
+    Constructs an image with the given \a size and \a format.
+
+    \warning This will create a QImage with uninitialized data. Call
+    fill() to fill the image with an appropriate pixel value before
+    drawing onto it with QPainter.
+*/
+QImage::QImage(const QSize &size, Format format)
+    : QPaintDevice()
+{
+    d = QImageData::create(size, format, 0);
+}
+
+
+
+QImageData *QImageData::create(uchar *data, int width, int height,  int bpl, QImage::Format format, bool readOnly)
+{
+    QImageData *d = 0;
+
+    if (format == QImage::Format_Invalid)
+        return d;
+
+    if (!checkPixelSize(format)) {
+        qWarning("QImageData::create(): Invalid pixel size for format %i",
+                 format);
+        return 0;
+    }
+
+    const int depth = depthForFormat(format);
+    const int calc_bytes_per_line = ((width * depth + 31)/32) * 4;
+    const int min_bytes_per_line = (width * depth + 7)/8;
+
+    if (bpl <= 0)
+        bpl = calc_bytes_per_line;
+
+    if (width <= 0 || height <= 0 || !data
+        || INT_MAX/sizeof(uchar *) < uint(height)
+        || INT_MAX/uint(depth) < uint(width)
+        || bpl <= 0
+        || height <= 0
+        || bpl < min_bytes_per_line
+        || INT_MAX/uint(bpl) < uint(height))
+        return d;                                        // invalid parameter(s)
+
+    d = new QImageData;
+    d->ref.ref();
+
+    d->own_data = false;
+    d->ro_data = readOnly;
+    d->data = data;
+    d->width = width;
+    d->height = height;
+    d->depth = depth;
+    d->format = format;
+
+    d->bytes_per_line = bpl;
+    d->nbytes = d->bytes_per_line * height;
+
+    return d;
+}
+
+/*!
+    Constructs an image with the given \a width, \a height and \a
+    format, that uses an existing memory buffer, \a data. The \a width
+    and \a height must be specified in pixels, \a data must be 32-bit aligned,
+    and each scanline of data in the image must also be 32-bit aligned.
+
+    The buffer must remain valid throughout the life of the
+    QImage. The image does not delete the buffer at destruction.
+
+    If \a format is an indexed color format, the image color table is
+    initially empty and must be sufficiently expanded with
+    setNumColors() or setColorTable() before the image is used.
+*/
+QImage::QImage(uchar* data, int width, int height, Format format)
+    : QPaintDevice()
+{
+    d = QImageData::create(data, width, height, 0, format, false);
+}
+
+/*!
+    Constructs an image with the given \a width, \a height and \a
+    format, that uses an existing read-only memory buffer, \a
+    data. The \a width and \a height must be specified in pixels, \a
+    data must be 32-bit aligned, and each scanline of data in the
+    image must also be 32-bit aligned.
+
+    The buffer must remain valid throughout the life of the QImage and
+    all copies that have not been modified or otherwise detached from
+    the original buffer. The image does not delete the buffer at
+    destruction.
+
+    If \a format is an indexed color format, the image color table is
+    initially empty and must be sufficiently expanded with
+    setNumColors() or setColorTable() before the image is used.
+
+    Unlike the similar QImage constructor that takes a non-const data buffer,
+    this version will never alter the contents of the buffer.  For example,
+    calling QImage::bits() will return a deep copy of the image, rather than
+    the buffer passed to the constructor.  This allows for the efficiency of
+    constructing a QImage from raw data, without the possibility of the raw
+    data being changed.
+*/
+QImage::QImage(const uchar* data, int width, int height, Format format)
+    : QPaintDevice()
+{
+    d = QImageData::create(const_cast<uchar*>(data), width, height, 0, format, true);
+}
+
+/*!
+    Constructs an image with the given \a width, \a height and \a
+    format, that uses an existing memory buffer, \a data. The \a width
+    and \a height must be specified in pixels. \a bytesPerLine
+    specifies the number of bytes per line (stride).
+
+    The buffer must remain valid throughout the life of the
+    QImage. The image does not delete the buffer at destruction.
+
+    If \a format is an indexed color format, the image color table is
+    initially empty and must be sufficiently expanded with
+    setNumColors() or setColorTable() before the image is used.
+*/
+QImage::QImage(uchar *data, int width, int height, int bytesPerLine, Format format)
+    :QPaintDevice()
+{
+    d = QImageData::create(data, width, height, bytesPerLine, format, false);
+}
+
+
+/*!
+    Constructs an image with the given \a width, \a height and \a
+    format, that uses an existing memory buffer, \a data. The \a width
+    and \a height must be specified in pixels. \a bytesPerLine
+    specifies the number of bytes per line (stride).
+
+    The buffer must remain valid throughout the life of the
+    QImage. The image does not delete the buffer at destruction.
+
+    If \a format is an indexed color format, the image color table is
+    initially empty and must be sufficiently expanded with
+    setNumColors() or setColorTable() before the image is used.
+
+    Unlike the similar QImage constructor that takes a non-const data buffer,
+    this version will never alter the contents of the buffer.  For example,
+    calling QImage::bits() will return a deep copy of the image, rather than
+    the buffer passed to the constructor.  This allows for the efficiency of
+    constructing a QImage from raw data, without the possibility of the raw
+    data being changed.
+*/
+
+QImage::QImage(const uchar *data, int width, int height, int bytesPerLine, Format format)
+    :QPaintDevice()
+{
+    d = QImageData::create(const_cast<uchar*>(data), width, height, bytesPerLine, format, true);
+}
+
+/*!
+    Constructs an image and tries to load the image from the file with
+    the given \a fileName.
+
+    The loader attempts to read the image using the specified \a
+    format. If the \a format is not specified (which is the default),
+    the loader probes the file for a header to guess the file format.
+
+    If the loading of the image failed, this object is a null image.
+
+    The file name can either refer to an actual file on disk or to one
+    of the application's embedded resources. See the
+    \l{resources.html}{Resource System} overview for details on how to
+    embed images and other resource files in the application's
+    executable.
+
+    \sa isNull(), {QImage#Reading and Writing Image Files}{Reading and Writing Image Files}
+*/
+
+QImage::QImage(const QString &fileName, const char *format)
+    : QPaintDevice()
+{
+    d = 0;
+    load(fileName, format);
+}
+
+/*!
+    Constructs an image and tries to load the image from the file with
+    the given \a fileName.
+
+    The loader attempts to read the image using the specified \a
+    format. If the \a format is not specified (which is the default),
+    the loader probes the file for a header to guess the file format.
+
+    If the loading of the image failed, this object is a null image.
+
+    The file name can either refer to an actual file on disk or to one
+    of the application's embedded resources. See the
+    \l{resources.html}{Resource System} overview for details on how to
+    embed images and other resource files in the application's
+    executable.
+
+    You can disable this constructor by defining \c
+    QT_NO_CAST_FROM_ASCII when you compile your applications. This can
+    be useful, for example, if you want to ensure that all
+    user-visible strings go through QObject::tr().
+
+    \sa QString::fromAscii(), isNull(), {QImage#Reading and Writing
+    Image Files}{Reading and Writing Image Files}
+*/
+#ifndef QT_NO_CAST_FROM_ASCII
+QImage::QImage(const char *fileName, const char *format)
+    : QPaintDevice()
+{
+    // ### Qt 5: if you remove the QImage(const QByteArray &) QT3_SUPPORT
+    // constructor, remove this constructor as well. The constructor here
+    // exists so that QImage("foo.png") compiles without ambiguity.
+    d = 0;
+    load(QString::fromAscii(fileName), format);
+}
+#endif
+
+#ifndef QT_NO_IMAGEFORMAT_XPM
+extern bool qt_read_xpm_image_or_array(QIODevice *device, const char * const *source, QImage &image);
+
+/*!
+    Constructs an image from the given \a xpm image.
+
+    Make sure that the image is a valid XPM image. Errors are silently
+    ignored.
+
+    Note that it's possible to squeeze the XPM variable a little bit
+    by using an unusual declaration:
+
+    \snippet doc/src/snippets/code/src_gui_image_qimage.cpp 2
+
+    The extra \c const makes the entire definition read-only, which is
+    slightly more efficient (e.g., when the code is in a shared
+    library) and able to be stored in ROM with the application.
+*/
+
+QImage::QImage(const char * const xpm[])
+    : QPaintDevice()
+{
+    d = 0;
+    if (!xpm)
+        return;
+    if (!qt_read_xpm_image_or_array(0, xpm, *this))
+        // Issue: Warning because the constructor may be ambigious
+        qWarning("QImage::QImage(), XPM is not supported");
+}
+#endif // QT_NO_IMAGEFORMAT_XPM
+
+/*!
+    \fn QImage::QImage(const QByteArray &data)
+
+    Use the static fromData() function instead.
+
+    \oldcode
+        QByteArray data;
+        ...
+        QImage image(data);
+    \newcode
+        QByteArray data;
+        ...
+        QImage image = QImage::fromData(data);
+    \endcode
+*/
+
+
+/*!
+    Constructs a shallow copy of the given \a image.
+
+    For more information about shallow copies, see the \l {Implicit
+    Data Sharing} documentation.
+
+    \sa copy()
+*/
+
+QImage::QImage(const QImage &image)
+    : QPaintDevice()
+{
+    d = image.d;
+    if (d)
+        d->ref.ref();
+}
+
+#ifdef QT3_SUPPORT
+/*!
+    \fn QImage::QImage(int width, int height, int depth, int numColors, Endian bitOrder)
+
+    Constructs an image with the given \a width, \a height, \a depth,
+    \a numColors colors and \a bitOrder.
+
+    Use the constructor that accepts a width, a height and a format
+    (i.e. specifying the depth and bit order), in combination with the
+    setNumColors() function, instead.
+
+    \oldcode
+        QImage image(width, height, depth, numColors);
+    \newcode
+        QImage image(width, height, format);
+
+        // For 8 bit images the default number of colors is 256. If
+        // another number of colors is required it can be specified
+        // using the setNumColors() function.
+        image.setNumColors(numColors);
+    \endcode
+*/
+
+QImage::QImage(int w, int h, int depth, int numColors, Endian bitOrder)
+    : QPaintDevice()
+{
+    d = QImageData::create(QSize(w, h), formatFor(depth, bitOrder), numColors);
+}
+
+/*!
+    Constructs an image with the given \a size, \a depth, \a numColors
+    and \a bitOrder.
+
+    Use the constructor that accepts a size and a format
+    (i.e. specifying the depth and bit order), in combination with the
+    setNumColors() function, instead.
+
+    \oldcode
+        QSize mySize(width, height);
+        QImage image(mySize, depth, numColors);
+    \newcode
+        QSize mySize(width, height);
+        QImage image(mySize, format);
+
+        // For 8 bit images the default number of colors is 256. If
+        // another number of colors is required it can be specified
+        // using the setNumColors() function.
+        image.setNumColors(numColors);
+    \endcode
+*/
+QImage::QImage(const QSize& size, int depth, int numColors, Endian bitOrder)
+    : QPaintDevice()
+{
+    d = QImageData::create(size, formatFor(depth, bitOrder), numColors);
+}
+
+/*!
+    \fn QImage::QImage(uchar* data, int width, int height, int depth, const QRgb* colortable, int numColors, Endian bitOrder)
+
+    Constructs an image with the given \a width, \a height, depth, \a
+    colortable, \a numColors and \a bitOrder, that uses an existing
+    memory buffer, \a data.
+
+    Use the constructor that accepts a uchar pointer, a width, a
+    height and a format (i.e. specifying the depth and bit order), in
+    combination with the setColorTable() function, instead.
+
+    \oldcode
+        uchar *myData;
+        QRgb *myColorTable;
+
+        QImage image(myData, width, height, depth,
+                               myColorTable, numColors, IgnoreEndian);
+    \newcode
+        uchar *myData;
+        QVector<QRgb> myColorTable;
+
+        QImage image(myData, width, height, format);
+        image.setColorTable(myColorTable);
+    \endcode
+*/
+QImage::QImage(uchar* data, int w, int h, int depth, const QRgb* colortable, int numColors, Endian bitOrder)
+    : QPaintDevice()
+{
+    d = 0;
+    Format f = formatFor(depth, bitOrder);
+    if (f == Format_Invalid)
+        return;
+
+    const int bytes_per_line = ((w*depth+31)/32)*4;        // bytes per scanline
+    if (w <= 0 || h <= 0 || numColors < 0 || !data
+        || INT_MAX/sizeof(uchar *) < uint(h)
+        || INT_MAX/uint(depth) < uint(w)
+        || bytes_per_line <= 0
+        || INT_MAX/uint(bytes_per_line) < uint(h))
+        return;                                        // invalid parameter(s)
+    d = new QImageData;
+    d->ref.ref();
+
+    d->own_data = false;
+    d->data = data;
+    d->width = w;
+    d->height = h;
+    d->depth = depth;
+    d->format = f;
+    if (depth == 32)
+        numColors = 0;
+
+    d->bytes_per_line = bytes_per_line;
+    d->nbytes = d->bytes_per_line * h;
+    if (colortable) {
+        d->colortable.resize(numColors);
+        for (int i = 0; i < numColors; ++i)
+            d->colortable[i] = colortable[i];
+    } else if (numColors) {
+        setNumColors(numColors);
+    }
+}
+
+#ifdef Q_WS_QWS
+
+/*!
+    \fn QImage::QImage(uchar* data, int width, int height, int depth, int bytesPerLine, const QRgb* colortable, int numColors, Endian bitOrder)
+
+    Constructs an image with the given \a width, \a height, \a depth,
+    \a bytesPerLine, \a colortable, \a numColors and \a bitOrder, that
+    uses an existing memory buffer, \a data. The image does not delete
+    the buffer at destruction.
+
+    \warning This constructor is only available in Qt for Embedded Linux.
+
+    The data has to be 32-bit aligned, and each scanline of data in the image
+    must also be 32-bit aligned, so it's no longer possible to specify a custom
+    \a bytesPerLine value.
+*/
+QImage::QImage(uchar* data, int w, int h, int depth, int bpl, const QRgb* colortable, int numColors, Endian bitOrder)
+    : QPaintDevice()
+{
+    d = 0;
+    Format f = formatFor(depth, bitOrder);
+    if (f == Format_Invalid)
+        return;
+    if (!data || w <= 0 || h <= 0 || depth <= 0 || numColors < 0
+        || INT_MAX/sizeof(uchar *) < uint(h)
+        || INT_MAX/uint(depth) < uint(w)
+        || bpl <= 0
+        || INT_MAX/uint(bpl) < uint(h))
+        return;                                        // invalid parameter(s)
+
+    d = new QImageData;
+    d->ref.ref();
+    d->own_data = false;
+    d->data = data;
+    d->width = w;
+    d->height = h;
+    d->depth = depth;
+    d->format = f;
+    if (depth == 32)
+        numColors = 0;
+    d->bytes_per_line = bpl;
+    d->nbytes = d->bytes_per_line * h;
+    if (colortable) {
+        d->colortable.resize(numColors);
+        for (int i = 0; i < numColors; ++i)
+            d->colortable[i] = colortable[i];
+    } else if (numColors) {
+        setNumColors(numColors);
+    }
+}
+#endif // Q_WS_QWS
+#endif // QT3_SUPPORT
+
+/*!
+    Destroys the image and cleans up.
+*/
+
+QImage::~QImage()
+{
+    if (d && !d->ref.deref())
+        delete d;
+}
+
+/*!
+    Assigns a shallow copy of the given \a image to this image and
+    returns a reference to this image.
+
+    For more information about shallow copies, see the \l {Implicit
+    Data Sharing} documentation.
+
+    \sa copy(), QImage()
+*/
+
+QImage &QImage::operator=(const QImage &image)
+{
+    if (image.d)
+        image.d->ref.ref();
+    if (d && !d->ref.deref())
+        delete d;
+    d = image.d;
+    return *this;
+}
+
+/*!
+  \internal
+*/
+int QImage::devType() const
+{
+    return QInternal::Image;
+}
+
+/*!
+   Returns the image as a QVariant.
+*/
+QImage::operator QVariant() const
+{
+    return QVariant(QVariant::Image, this);
+}
+
+/*!
+    \internal
+
+    If multiple images share common data, this image makes a copy of
+    the data and detaches itself from the sharing mechanism, making
+    sure that this image is the only one referring to the data.
+
+    Nothing is done if there is just a single reference.
+
+    \sa copy(), isDetached(), {Implicit Data Sharing}
+*/
+void QImage::detach()
+{
+    if (d) {
+        if (d->is_cached && qt_image_cleanup_hook_64 && d->ref == 1)
+            qt_image_cleanup_hook_64(cacheKey());
+
+        if (d->ref != 1 || d->ro_data)
+            *this = copy();
+
+        if (d)
+            ++d->detach_no;
+    }
+}
+
+
+/*!
+    \fn QImage QImage::copy(int x, int y, int width, int height) const
+    \overload
+
+    The returned image is copied from the position (\a x, \a y) in
+    this image, and will always have the given \a width and \a height.
+    In areas beyond this image, pixels are set to 0.
+
+*/
+
+/*!
+    \fn QImage QImage::copy(const QRect& rectangle) const
+
+    Returns a sub-area of the image as a new image.
+
+    The returned image is copied from the position (\a
+    {rectangle}.x(), \a{rectangle}.y()) in this image, and will always
+    have the size of the given \a rectangle.
+
+    In areas beyond this image, pixels are set to 0. For 32-bit RGB
+    images, this means black; for 32-bit ARGB images, this means
+    transparent black; for 8-bit images, this means the color with
+    index 0 in the color table which can be anything; for 1-bit
+    images, this means Qt::color0.
+
+    If the given \a rectangle is a null rectangle the entire image is
+    copied.
+
+    \sa QImage()
+*/
+QImage QImage::copy(const QRect& r) const
+{
+    if (!d)
+        return QImage();
+
+    if (r.isNull()) {
+        QImage image(d->width, d->height, d->format);
+        if (image.isNull())
+            return image;
+
+        // Qt for Embedded Linux can create images with non-default bpl
+        // make sure we don't crash.
+        if (image.d->nbytes != d->nbytes) {
+            int bpl = image.bytesPerLine();
+            for (int i = 0; i < height(); i++)
+                memcpy(image.scanLine(i), scanLine(i), bpl);
+        } else
+            memcpy(image.bits(), bits(), d->nbytes);
+        image.d->colortable = d->colortable;
+        image.d->dpmx = d->dpmx;
+        image.d->dpmy = d->dpmy;
+        image.d->offset = d->offset;
+        image.d->has_alpha_clut = d->has_alpha_clut;
+#ifndef QT_NO_IMAGE_TEXT
+        image.d->text = d->text;
+#endif
+        return image;
+    }
+
+    int x = r.x();
+    int y = r.y();
+    int w = r.width();
+    int h = r.height();
+
+    int dx = 0;
+    int dy = 0;
+    if (w <= 0 || h <= 0)
+        return QImage();
+
+    QImage image(w, h, d->format);
+    if (image.isNull())
+        return image;
+
+    if (x < 0 || y < 0 || x + w > d->width || y + h > d->height) {
+        // bitBlt will not cover entire image - clear it.
+        image.fill(0);
+        if (x < 0) {
+            dx = -x;
+            x = 0;
+        }
+        if (y < 0) {
+            dy = -y;
+            y = 0;
+        }
+    }
+
+    image.d->colortable = d->colortable;
+
+    int pixels_to_copy = qMax(w - dx, 0);
+    if (x > d->width)
+        pixels_to_copy = 0;
+    else if (pixels_to_copy > d->width - x)
+        pixels_to_copy = d->width - x;
+    int lines_to_copy = qMax(h - dy, 0);
+    if (y > d->height)
+        lines_to_copy = 0;
+    else if (lines_to_copy > d->height - y)
+        lines_to_copy = d->height - y;
+
+    bool byteAligned = true;
+    if (d->format == Format_Mono || d->format == Format_MonoLSB)
+        byteAligned = !(dx & 7) && !(x & 7) && !(pixels_to_copy & 7);
+
+    if (byteAligned) {
+        const uchar *src = d->data + ((x * d->depth) >> 3) + y * d->bytes_per_line;
+        uchar *dest = image.d->data + ((dx * d->depth) >> 3) + dy * image.d->bytes_per_line;
+        const int bytes_to_copy = (pixels_to_copy * d->depth) >> 3;
+        for (int i = 0; i < lines_to_copy; ++i) {
+            memcpy(dest, src, bytes_to_copy);
+            src += d->bytes_per_line;
+            dest += image.d->bytes_per_line;
+        }
+    } else if (d->format == Format_Mono) {
+        const uchar *src = d->data + y * d->bytes_per_line;
+        uchar *dest = image.d->data + dy * image.d->bytes_per_line;
+        for (int i = 0; i < lines_to_copy; ++i) {
+            for (int j = 0; j < pixels_to_copy; ++j) {
+                if (src[(x + j) >> 3] & (0x80 >> ((x + j) & 7)))
+                    dest[(dx + j) >> 3] |= (0x80 >> ((dx + j) & 7));
+                else
+                    dest[(dx + j) >> 3] &= ~(0x80 >> ((dx + j) & 7));
+            }
+            src += d->bytes_per_line;
+            dest += image.d->bytes_per_line;
+        }
+    } else { // Format_MonoLSB
+        Q_ASSERT(d->format == Format_MonoLSB);
+        const uchar *src = d->data + y * d->bytes_per_line;
+        uchar *dest = image.d->data + dy * image.d->bytes_per_line;
+        for (int i = 0; i < lines_to_copy; ++i) {
+            for (int j = 0; j < pixels_to_copy; ++j) {
+                if (src[(x + j) >> 3] & (0x1 << ((x + j) & 7)))
+                    dest[(dx + j) >> 3] |= (0x1 << ((dx + j) & 7));
+                else
+                    dest[(dx + j) >> 3] &= ~(0x1 << ((dx + j) & 7));
+            }
+            src += d->bytes_per_line;
+            dest += image.d->bytes_per_line;
+        }
+    }
+
+    image.d->dpmx = dotsPerMeterX();
+    image.d->dpmy = dotsPerMeterY();
+    image.d->offset = offset();
+    image.d->has_alpha_clut = d->has_alpha_clut;
+#ifndef QT_NO_IMAGE_TEXT
+    image.d->text = d->text;
+#endif
+    return image;
+}
+
+
+/*!
+    \fn bool QImage::isNull() const
+
+    Returns true if it is a null image, otherwise returns false.
+
+    A null image has all parameters set to zero and no allocated data.
+*/
+bool QImage::isNull() const
+{
+    return !d;
+}
+
+/*!
+    \fn int QImage::width() const
+
+    Returns the width of the image.
+
+    \sa {QImage#Image Information}{Image Information}
+*/
+int QImage::width() const
+{
+    return d ? d->width : 0;
+}
+
+/*!
+    \fn int QImage::height() const
+
+    Returns the height of the image.
+
+    \sa {QImage#Image Information}{Image Information}
+*/
+int QImage::height() const
+{
+    return d ? d->height : 0;
+}
+
+/*!
+    \fn QSize QImage::size() const
+
+    Returns the size of the image, i.e. its width() and height().
+
+    \sa {QImage#Image Information}{Image Information}
+*/
+QSize QImage::size() const
+{
+    return d ? QSize(d->width, d->height) : QSize(0, 0);
+}
+
+/*!
+    \fn QRect QImage::rect() const
+
+    Returns the enclosing rectangle (0, 0, width(), height()) of the
+    image.
+
+    \sa {QImage#Image Information}{Image Information}
+*/
+QRect QImage::rect() const
+{
+    return d ? QRect(0, 0, d->width, d->height) : QRect();
+}
+
+/*!
+    Returns the depth of the image.
+
+    The image depth is the number of bits used to encode a single
+    pixel, also called bits per pixel (bpp).
+
+    The supported depths are 1, 8, 16, 24 and 32.
+
+    \sa convertToFormat(), {QImage#Image Formats}{Image Formats},
+    {QImage#Image Information}{Image Information}
+
+*/
+int QImage::depth() const
+{
+    return d ? d->depth : 0;
+}
+
+/*!
+    \fn int QImage::numColors() const
+
+    Returns the size of the color table for the image.
+
+    Notice that numColors() returns 0 for 32-bpp images because these
+    images do not use color tables, but instead encode pixel values as
+    ARGB quadruplets.
+
+    \sa setNumColors(), {QImage#Image Information}{Image Information}
+*/
+int QImage::numColors() const
+{
+    return d ? d->colortable.size() : 0;
+}
+
+
+#ifdef QT3_SUPPORT
+/*!
+    \fn QImage::Endian QImage::bitOrder() const
+
+    Returns the bit order for the image. If it is a 1-bpp image, this
+    function returns either QImage::BigEndian or
+    QImage::LittleEndian. Otherwise, this function returns
+    QImage::IgnoreEndian.
+
+    Use the format() function instead for the monochrome formats. For
+    non-monochrome formats the bit order is irrelevant.
+*/
+
+/*!
+    Returns a pointer to the scanline pointer table. This is the
+    beginning of the data block for the image.
+
+    Use the bits() or scanLine() function instead.
+*/
+uchar **QImage::jumpTable()
+{
+    if (!d)
+        return 0;
+    detach();
+
+    // in case detach() ran out of memory..
+    if (!d)
+        return 0;
+
+    if (!d->jumptable) {
+        d->jumptable = (uchar **)malloc(d->height*sizeof(uchar *));
+        uchar *data = d->data;
+        int height = d->height;
+        uchar **p = d->jumptable;
+        while (height--) {
+            *p++ = data;
+            data += d->bytes_per_line;
+        }
+    }
+    return d->jumptable;
+}
+
+/*!
+    \overload
+*/
+const uchar * const *QImage::jumpTable() const
+{
+    if (!d)
+        return 0;
+    if (!d->jumptable) {
+        d->jumptable = (uchar **)malloc(d->height*sizeof(uchar *));
+        uchar *data = d->data;
+        int height = d->height;
+        uchar **p = d->jumptable;
+        while (height--) {
+            *p++ = data;
+            data += d->bytes_per_line;
+        }
+    }
+    return d->jumptable;
+}
+#endif
+
+/*!
+    Sets the color table used to translate color indexes to QRgb
+    values, to the specified \a colors.
+
+    When the image is used, the color table must be large enough to
+    have entries for all the pixel/index values present in the image,
+    otherwise the results are undefined.
+
+    \sa colorTable(), setColor(), {QImage#Image Transformations}{Image
+    Transformations}
+*/
+void QImage::setColorTable(const QVector<QRgb> colors)
+{
+    if (!d)
+        return;
+    detach();
+
+    // In case detach() ran out of memory
+    if (!d)
+        return;
+
+    d->colortable = colors;
+    d->has_alpha_clut = false;
+    for (int i = 0; i < d->colortable.size(); ++i)
+        d->has_alpha_clut |= (qAlpha(d->colortable.at(i)) != 255);
+}
+
+/*!
+    Returns a list of the colors contained in the image's color table,
+    or an empty list if the image does not have a color table
+
+    \sa setColorTable(), numColors(), color()
+*/
+QVector<QRgb> QImage::colorTable() const
+{
+    return d ? d->colortable : QVector<QRgb>();
+}
+
+
+/*!
+    Returns the number of bytes occupied by the image data.
+
+    \sa bytesPerLine(), bits(), {QImage#Image Information}{Image
+    Information}
+*/
+int QImage::numBytes() const
+{
+    return d ? d->nbytes : 0;
+}
+
+/*!
+    Returns the number of bytes per image scanline.
+
+    This is equivalent to numBytes()/ height().
+
+    \sa scanLine()
+*/
+int QImage::bytesPerLine() const
+{
+    return (d && d->height) ? d->nbytes / d->height : 0;
+}
+
+
+/*!
+    Returns the color in the color table at index \a i. The first
+    color is at index 0.
+
+    The colors in an image's color table are specified as ARGB
+    quadruplets (QRgb). Use the qAlpha(), qRed(), qGreen(), and
+    qBlue() functions to get the color value components.
+
+    \sa setColor(), pixelIndex(), {QImage#Pixel Manipulation}{Pixel
+    Manipulation}
+*/
+QRgb QImage::color(int i) const
+{
+    Q_ASSERT(i < numColors());
+    return d ? d->colortable.at(i) : QRgb(uint(-1));
+}
+
+/*!
+    \fn void QImage::setColor(int index, QRgb colorValue)
+
+    Sets the color at the given \a index in the color table, to the
+    given to \a colorValue. The color value is an ARGB quadruplet.
+
+    If \a index is outside the current size of the color table, it is
+    expanded with setNumColors().
+
+    \sa color(), numColors(), setColorTable(), {QImage#Pixel Manipulation}{Pixel
+    Manipulation}
+*/
+void QImage::setColor(int i, QRgb c)
+{
+    if (!d)
+        return;
+    if (i < 0 || d->depth > 8 || i >= 1<<d->depth) {
+        qWarning("QImage::setColor: Index out of bound %d", i);
+        return;
+    }
+    detach();
+
+    // In case detach() run out of memory
+    if (!d)
+        return;
+
+    if (i >= d->colortable.size())
+        setNumColors(i+1);
+    d->colortable[i] = c;
+    d->has_alpha_clut |= (qAlpha(c) != 255);
+}
+
+/*!
+    Returns a pointer to the pixel data at the scanline with index \a
+    i. The first scanline is at index 0.
+
+    The scanline data is aligned on a 32-bit boundary.
+
+    \warning If you are accessing 32-bpp image data, cast the returned
+    pointer to \c{QRgb*} (QRgb has a 32-bit size) and use it to
+    read/write the pixel value. You cannot use the \c{uchar*} pointer
+    directly, because the pixel format depends on the byte order on
+    the underlying platform. Use qRed(), qGreen(), qBlue(), and
+    qAlpha() to access the pixels.
+
+    \sa bytesPerLine(), bits(), {QImage#Pixel Manipulation}{Pixel
+    Manipulation}
+*/
+uchar *QImage::scanLine(int i)
+{
+    if (!d)
+        return 0;
+
+    detach();
+
+    // In case detach() ran out of memory
+    if (!d)
+        return 0;
+
+    return d->data + i * d->bytes_per_line;
+}
+
+/*!
+    \overload
+*/
+const uchar *QImage::scanLine(int i) const
+{
+    if (!d)
+        return 0;
+
+    Q_ASSERT(i >= 0 && i < height());
+    return d->data + i * d->bytes_per_line;
+}
+
+
+/*!
+    Returns a pointer to the first pixel data. This is equivalent to
+    scanLine(0).
+
+    Note that QImage uses \l{Implicit Data Sharing} {implicit data
+    sharing}. This function performs a deep copy of the shared pixel
+    data, thus ensuring that this QImage is the only one using the
+    current return value.
+
+    \sa scanLine(), numBytes()
+*/
+uchar *QImage::bits()
+{
+    if (!d)
+        return 0;
+    detach();
+
+    // In case detach ran out of memory...
+    if (!d)
+        return 0;
+
+    return d->data;
+}
+
+/*!
+    \overload
+
+    Note that QImage uses \l{Implicit Data Sharing} {implicit data
+    sharing}, but this function does \e not perform a deep copy of the
+    shared pixel data, because the returned data is const.
+*/
+const uchar *QImage::bits() const
+{
+    return d ? d->data : 0;
+}
+
+
+
+/*!
+    \fn void QImage::reset()
+
+    Resets all image parameters and deallocates the image data.
+
+    Assign a null image instead.
+
+    \oldcode
+        QImage image;
+        image.reset();
+    \newcode
+        QImage image;
+        image = QImage();
+    \endcode
+*/
+
+/*!
+    \fn void QImage::fill(uint pixelValue)
+
+    Fills the entire image with the given \a pixelValue.
+
+    If the depth of this image is 1, only the lowest bit is used. If
+    you say fill(0), fill(2), etc., the image is filled with 0s. If
+    you say fill(1), fill(3), etc., the image is filled with 1s. If
+    the depth is 8, the lowest 8 bits are used and if the depth is 16
+    the lowest 16 bits are used.
+
+    Note: QImage::pixel() returns the color of the pixel at the given
+    coordinates while QColor::pixel() returns the pixel value of the
+    underlying window system (essentially an index value), so normally
+    you will want to use QImage::pixel() to use a color from an
+    existing image or QColor::rgb() to use a specific color.
+
+    \sa depth(), {QImage#Image Transformations}{Image Transformations}
+*/
+
+void QImage::fill(uint pixel)
+{
+    if (!d)
+        return;
+
+    detach();
+
+    // In case detach() ran out of memory
+    if (!d)
+        return;
+
+    if (d->depth == 1 || d->depth == 8) {
+        int w = d->width;
+        if (d->depth == 1) {
+            if (pixel & 1)
+                pixel = 0xffffffff;
+            else
+                pixel = 0;
+            w = (w + 7) / 8;
+        } else {
+            pixel &= 0xff;
+        }
+        qt_rectfill<quint8>(d->data, pixel, 0, 0,
+                            w, d->height, d->bytes_per_line);
+        return;
+    } else if (d->depth == 16) {
+        qt_rectfill<quint16>(reinterpret_cast<quint16*>(d->data), pixel,
+                             0, 0, d->width, d->height, d->bytes_per_line);
+        return;
+    } else if (d->depth == 24) {
+        qt_rectfill<quint24>(reinterpret_cast<quint24*>(d->data), pixel,
+                             0, 0, d->width, d->height, d->bytes_per_line);
+        return;
+    }
+
+    if (d->format == Format_RGB32)
+        pixel |= 0xff000000;
+
+    qt_rectfill<uint>(reinterpret_cast<uint*>(d->data), pixel,
+                      0, 0, d->width, d->height, d->bytes_per_line);
+}
+
+/*!
+    Inverts all pixel values in the image.
+
+    The given invert \a mode only have a meaning when the image's
+    depth is 32. The default \a mode is InvertRgb, which leaves the
+    alpha channel unchanged. If the \a mode is InvertRgba, the alpha
+    bits are also inverted.
+
+    Inverting an 8-bit image means to replace all pixels using color
+    index \e i with a pixel using color index 255 minus \e i. The same
+    is the case for a 1-bit image. Note that the color table is \e not
+    changed.
+
+    \sa {QImage#Image Transformations}{Image Transformations}
+*/
+
+void QImage::invertPixels(InvertMode mode)
+{
+    if (!d)
+        return;
+
+    detach();
+
+    // In case detach() ran out of memory
+    if (!d)
+        return;
+
+    if (depth() != 32) {
+        // number of used bytes pr line
+        int bpl = (d->width * d->depth + 7) / 8;
+        int pad = d->bytes_per_line - bpl;
+        uchar *sl = d->data;
+        for (int y=0; y<d->height; ++y) {
+            for (int x=0; x<bpl; ++x)
+                *sl++ ^= 0xff;
+            sl += pad;
+        }
+    } else {
+        quint32 *p = (quint32*)d->data;
+        quint32 *end = (quint32*)(d->data + d->nbytes);
+        uint xorbits = (mode == InvertRgba) ? 0xffffffff : 0x00ffffff;
+        while (p < end)
+            *p++ ^= xorbits;
+    }
+}
+
+/*!
+    \fn void QImage::invertPixels(bool invertAlpha)
+
+    Use the invertPixels() function that takes a QImage::InvertMode
+    parameter instead.
+*/
+
+/*! \fn QImage::Endian QImage::systemByteOrder()
+
+    Determines the host computer byte order. Returns
+    QImage::LittleEndian (LSB first) or QImage::BigEndian (MSB first).
+
+    This function is no longer relevant for QImage. Use QSysInfo
+    instead.
+*/
+
+// Windows defines these
+#if defined(write)
+# undef write
+#endif
+#if defined(close)
+# undef close
+#endif
+#if defined(read)
+# undef read
+#endif
+
+/*!
+    Resizes the color table to contain \a numColors entries.
+
+    If the color table is expanded, all the extra colors will be set to
+    transparent (i.e qRgba(0, 0, 0, 0)).
+
+    When the image is used, the color table must be large enough to
+    have entries for all the pixel/index values present in the image,
+    otherwise the results are undefined.
+
+    \sa numColors(), colorTable(), setColor(), {QImage#Image
+    Transformations}{Image Transformations}
+*/
+
+void QImage::setNumColors(int numColors)
+{
+    if (!d) {
+        qWarning("QImage::setNumColors: null image");
+        return;
+    }
+
+    detach();
+
+    // In case detach() ran out of memory
+    if (!d)
+        return;
+
+    if (numColors == d->colortable.size())
+        return;
+    if (numColors <= 0) {                        // use no color table
+        d->colortable = QVector<QRgb>();
+        return;
+    }
+    int nc = d->colortable.size();
+    d->colortable.resize(numColors);
+    for (int i = nc; i < numColors; ++i)
+        d->colortable[i] = 0;
+
+}
+
+/*!
+    Returns the format of the image.
+
+    \sa {QImage#Image Formats}{Image Formats}
+*/
+QImage::Format QImage::format() const
+{
+    return d ? d->format : Format_Invalid;
+}
+
+
+#ifdef QT3_SUPPORT
+/*!
+    Returns true if alpha buffer mode is enabled; otherwise returns
+    false.
+
+    Use the hasAlphaChannel() function instead.
+
+*/
+bool QImage::hasAlphaBuffer() const
+{
+    if (!d)
+        return false;
+
+    switch (d->format) {
+    case Format_ARGB32:
+    case Format_ARGB32_Premultiplied:
+    case Format_ARGB8565_Premultiplied:
+    case Format_ARGB8555_Premultiplied:
+    case Format_ARGB6666_Premultiplied:
+    case Format_ARGB4444_Premultiplied:
+        return true;
+    default:
+        return false;
+    }
+}
+
+/*!
+    Enables alpha buffer mode if \a enable is true, otherwise disables
+    it. The alpha buffer is used to set a mask when a QImage is
+    translated to a QPixmap.
+
+    If a monochrome or indexed 8-bit image has alpha channels in their
+    color tables they will automatically detect that they have an
+    alpha channel, so this function is not required.  To force alpha
+    channels on 32-bit images, use the convertToFormat() function.
+*/
+
+void QImage::setAlphaBuffer(bool enable)
+{
+    if (!d
+        || d->format == Format_Mono
+        || d->format == Format_MonoLSB
+        || d->format == Format_Indexed8)
+        return;
+    if (enable && (d->format == Format_ARGB32 ||
+                   d->format == Format_ARGB32_Premultiplied ||
+                   d->format == Format_ARGB8565_Premultiplied ||
+                   d->format == Format_ARGB6666_Premultiplied ||
+                   d->format == Format_ARGB8555_Premultiplied ||
+                   d->format == Format_ARGB4444_Premultiplied))
+    {
+        return;
+    }
+    if (!enable && (d->format == Format_RGB32 ||
+                    d->format == Format_RGB555 ||
+                    d->format == Format_RGB666 ||
+                    d->format == Format_RGB888 ||
+                    d->format == Format_RGB444))
+    {
+        return;
+    }
+    detach();
+    d->format = (enable ? Format_ARGB32 : Format_RGB32);
+}
+
+
+/*!
+  \fn bool QImage::create(int width, int height, int depth, int numColors, Endian bitOrder)
+
+    Sets the image \a width, \a height, \a depth, its number of colors
+    (in \a numColors), and bit order. Returns true if successful, or
+    false if the parameters are incorrect or if memory cannot be
+    allocated.
+
+    The \a width and \a height is limited to 32767. \a depth must be
+    1, 8, or 32. If \a depth is 1, \a bitOrder must be set to
+    either QImage::LittleEndian or QImage::BigEndian. For other depths
+    \a bitOrder must be QImage::IgnoreEndian.
+
+    This function allocates a color table and a buffer for the image
+    data. The image data is not initialized. The image buffer is
+    allocated as a single block that consists of a table of scanLine()
+    pointers (jumpTable()) and the image data (bits()).
+
+    Use a QImage constructor instead.
+*/
+bool QImage::create(int width, int height, int depth, int numColors, Endian bitOrder)
+{
+    if (d && !d->ref.deref())
+        delete d;
+    d = QImageData::create(QSize(width, height), formatFor(depth, bitOrder), numColors);
+    return true;
+}
+
+/*!
+    \fn bool QImage::create(const QSize& size, int depth, int numColors, Endian bitOrder)
+    \overload
+
+    The width and height are specified in the \a size argument.
+
+    Use a QImage constructor instead.
+*/
+bool QImage::create(const QSize& size, int depth, int numColors, QImage::Endian bitOrder)
+{
+    if (d && !d->ref.deref())
+        delete d;
+    d = QImageData::create(size, formatFor(depth, bitOrder), numColors);
+    return true;
+}
+#endif // QT3_SUPPORT
+
+/*****************************************************************************
+  Internal routines for converting image depth.
+ *****************************************************************************/
+
+typedef void (*Image_Converter)(QImageData *dest, const QImageData *src, Qt::ImageConversionFlags);
+
+static void convert_ARGB_to_ARGB_PM(QImageData *dest, const QImageData *src, Qt::ImageConversionFlags)
+{
+    Q_ASSERT(src->format == QImage::Format_ARGB32);
+    Q_ASSERT(dest->format == QImage::Format_ARGB32_Premultiplied);
+    Q_ASSERT(src->width == dest->width);
+    Q_ASSERT(src->height == dest->height);
+
+    const int src_pad = (src->bytes_per_line >> 2) - src->width;
+    const int dest_pad = (dest->bytes_per_line >> 2) - dest->width;
+    const QRgb *src_data = (QRgb *) src->data;
+    QRgb *dest_data = (QRgb *) dest->data;
+
+    for (int i = 0; i < src->height; ++i) {
+        const QRgb *end = src_data + src->width;
+        while (src_data < end) {
+            *dest_data = PREMUL(*src_data);
+            ++src_data;
+            ++dest_data;
+        }
+        src_data += src_pad;
+        dest_data += dest_pad;
+    }
+}
+
+static void convert_ARGB_PM_to_ARGB(QImageData *dest, const QImageData *src, Qt::ImageConversionFlags)
+{
+    Q_ASSERT(src->format == QImage::Format_ARGB32_Premultiplied);
+    Q_ASSERT(dest->format == QImage::Format_ARGB32);
+    Q_ASSERT(src->width == dest->width);
+    Q_ASSERT(src->height == dest->height);
+
+    const int src_pad = (src->bytes_per_line >> 2) - src->width;
+    const int dest_pad = (dest->bytes_per_line >> 2) - dest->width;
+    const QRgb *src_data = (QRgb *) src->data;
+    QRgb *dest_data = (QRgb *) dest->data;
+
+    for (int i = 0; i < src->height; ++i) {
+        const QRgb *end = src_data + src->width;
+        while (src_data < end) {
+            *dest_data = INV_PREMUL(*src_data);
+            ++src_data;
+            ++dest_data;
+        }
+        src_data += src_pad;
+        dest_data += dest_pad;
+    }
+}
+
+static void convert_ARGB_PM_to_RGB(QImageData *dest, const QImageData *src, Qt::ImageConversionFlags)
+{
+    Q_ASSERT(src->format == QImage::Format_ARGB32_Premultiplied);
+    Q_ASSERT(dest->format == QImage::Format_RGB32);
+    Q_ASSERT(src->width == dest->width);
+    Q_ASSERT(src->height == dest->height);
+
+    const int src_pad = (src->bytes_per_line >> 2) - src->width;
+    const int dest_pad = (dest->bytes_per_line >> 2) - dest->width;
+    const QRgb *src_data = (QRgb *) src->data;
+    QRgb *dest_data = (QRgb *) dest->data;
+
+    for (int i = 0; i < src->height; ++i) {
+        const QRgb *end = src_data + src->width;
+        while (src_data < end) {
+            *dest_data = 0xff000000 | INV_PREMUL(*src_data);
+            ++src_data;
+            ++dest_data;
+        }
+        src_data += src_pad;
+        dest_data += dest_pad;
+    }
+}
+
+static void swap_bit_order(QImageData *dest, const QImageData *src, Qt::ImageConversionFlags)
+{
+    Q_ASSERT(src->format == QImage::Format_Mono || src->format == QImage::Format_MonoLSB);
+    Q_ASSERT(dest->format == QImage::Format_Mono || dest->format == QImage::Format_MonoLSB);
+    Q_ASSERT(src->width == dest->width);
+    Q_ASSERT(src->height == dest->height);
+    Q_ASSERT(src->nbytes == dest->nbytes);
+    Q_ASSERT(src->bytes_per_line == dest->bytes_per_line);
+
+    dest->colortable = src->colortable;
+
+    const uchar *src_data = src->data;
+    const uchar *end = src->data + src->nbytes;
+    uchar *dest_data = dest->data;
+    while (src_data < end) {
+        *dest_data = bitflip[*src_data];
+        ++src_data;
+        ++dest_data;
+    }
+}
+
+static void mask_alpha_converter(QImageData *dest, const QImageData *src, Qt::ImageConversionFlags)
+{
+    Q_ASSERT(src->width == dest->width);
+    Q_ASSERT(src->height == dest->height);
+
+    const int src_pad = (src->bytes_per_line >> 2) - src->width;
+    const int dest_pad = (dest->bytes_per_line >> 2) - dest->width;
+    const uint *src_data = (const uint *)src->data;
+    uint *dest_data = (uint *)dest->data;
+
+    for (int i = 0; i < src->height; ++i) {
+        const uint *end = src_data + src->width;
+        while (src_data < end) {
+            *dest_data = *src_data | 0xff000000;
+            ++src_data;
+            ++dest_data;
+        }
+        src_data += src_pad;
+        dest_data += dest_pad;
+    }
+}
+
+static QVector<QRgb> fix_color_table(const QVector<QRgb> &ctbl, QImage::Format format)
+{
+    QVector<QRgb> colorTable = ctbl;
+    if (format == QImage::Format_RGB32) {
+        // check if the color table has alpha
+        for (int i = 0; i < colorTable.size(); ++i)
+            if (qAlpha(colorTable.at(i) != 0xff))
+                colorTable[i] = colorTable.at(i) | 0xff000000;
+    } else if (format == QImage::Format_ARGB32_Premultiplied) {
+        // check if the color table has alpha
+        for (int i = 0; i < colorTable.size(); ++i)
+            colorTable[i] = PREMUL(colorTable.at(i));
+    }
+    return colorTable;
+}
+
+//
+// dither_to_1:  Uses selected dithering algorithm.
+//
+
+static void dither_to_Mono(QImageData *dst, const QImageData *src,
+                           Qt::ImageConversionFlags flags, bool fromalpha)
+{
+    Q_ASSERT(src->width == dst->width);
+    Q_ASSERT(src->height == dst->height);
+    Q_ASSERT(dst->format == QImage::Format_Mono || dst->format == QImage::Format_MonoLSB);
+
+    dst->colortable.clear();
+    dst->colortable.append(0xffffffff);
+    dst->colortable.append(0xff000000);
+
+    enum { Threshold, Ordered, Diffuse } dithermode;
+
+    if (fromalpha) {
+        if ((flags & Qt::AlphaDither_Mask) == Qt::DiffuseAlphaDither)
+            dithermode = Diffuse;
+        else if ((flags & Qt::AlphaDither_Mask) == Qt::OrderedAlphaDither)
+            dithermode = Ordered;
+        else
+            dithermode = Threshold;
+    } else {
+        if ((flags & Qt::Dither_Mask) == Qt::ThresholdDither)
+            dithermode = Threshold;
+        else if ((flags & Qt::Dither_Mask) == Qt::OrderedDither)
+            dithermode = Ordered;
+        else
+            dithermode = Diffuse;
+    }
+
+    int          w = src->width;
+    int          h = src->height;
+    int          d = src->depth;
+    uchar gray[256];                                // gray map for 8 bit images
+    bool  use_gray = (d == 8);
+    if (use_gray) {                                // make gray map
+        if (fromalpha) {
+            // Alpha 0x00 -> 0 pixels (white)
+            // Alpha 0xFF -> 1 pixels (black)
+            for (int i = 0; i < src->colortable.size(); i++)
+                gray[i] = (255 - (src->colortable.at(i) >> 24));
+        } else {
+            // Pixel 0x00 -> 1 pixels (black)
+            // Pixel 0xFF -> 0 pixels (white)
+            for (int i = 0; i < src->colortable.size(); i++)
+                gray[i] = qGray(src->colortable.at(i));
+        }
+    }
+
+    uchar *dst_data = dst->data;
+    int dst_bpl = dst->bytes_per_line;
+    const uchar *src_data = src->data;
+    int src_bpl = src->bytes_per_line;
+
+    switch (dithermode) {
+    case Diffuse: {
+        int *line1 = new int[w];
+        int *line2 = new int[w];
+        int bmwidth = (w+7)/8;
+
+        int *b1, *b2;
+        int wbytes = w * (d/8);
+        register const uchar *p = src->data;
+        const uchar *end = p + wbytes;
+        b2 = line2;
+        if (use_gray) {                        // 8 bit image
+            while (p < end)
+                *b2++ = gray[*p++];
+        } else {                                // 32 bit image
+            if (fromalpha) {
+                while (p < end) {
+                    *b2++ = 255 - (*(uint*)p >> 24);
+                    p += 4;
+                }
+            } else {
+                while (p < end) {
+                    *b2++ = qGray(*(uint*)p);
+                    p += 4;
+                }
+            }
+        }
+        for (int y=0; y<h; y++) {                        // for each scan line...
+            int *tmp = line1; line1 = line2; line2 = tmp;
+            bool not_last_line = y < h - 1;
+            if (not_last_line) {                // calc. grayvals for next line
+                p = src->data + (y+1)*src->bytes_per_line;
+                end = p + wbytes;
+                b2 = line2;
+                if (use_gray) {                // 8 bit image
+                    while (p < end)
+                        *b2++ = gray[*p++];
+                } else {                        // 24 bit image
+                    if (fromalpha) {
+                        while (p < end) {
+                            *b2++ = 255 - (*(uint*)p >> 24);
+                            p += 4;
+                        }
+                    } else {
+                        while (p < end) {
+                            *b2++ = qGray(*(uint*)p);
+                            p += 4;
+                        }
+                    }
+                }
+            }
+
+            int err;
+            uchar *p = dst->data + y*dst->bytes_per_line;
+            memset(p, 0, bmwidth);
+            b1 = line1;
+            b2 = line2;
+            int bit = 7;
+            for (int x=1; x<=w; x++) {
+                if (*b1 < 128) {                // black pixel
+                    err = *b1++;
+                    *p |= 1 << bit;
+                } else {                        // white pixel
+                    err = *b1++ - 255;
+                }
+                if (bit == 0) {
+                    p++;
+                    bit = 7;
+                } else {
+                    bit--;
+                }
+                if (x < w)
+                    *b1 += (err*7)>>4;                // spread error to right pixel
+                if (not_last_line) {
+                    b2[0] += (err*5)>>4;        // pixel below
+                    if (x > 1)
+                        b2[-1] += (err*3)>>4;        // pixel below left
+                    if (x < w)
+                        b2[1] += err>>4;        // pixel below right
+                }
+                b2++;
+            }
+        }
+        delete [] line1;
+        delete [] line2;
+    } break;
+    case Ordered: {
+
+        memset(dst->data, 0, dst->nbytes);
+        if (d == 32) {
+            for (int i=0; i<h; i++) {
+                const uint *p = (const uint *)src_data;
+                const uint *end = p + w;
+                uchar *m = dst_data;
+                int bit = 7;
+                int j = 0;
+                if (fromalpha) {
+                    while (p < end) {
+                        if ((*p++ >> 24) >= qt_bayer_matrix[j++&15][i&15])
+                            *m |= 1 << bit;
+                        if (bit == 0) {
+                            m++;
+                            bit = 7;
+                        } else {
+                            bit--;
+                        }
+                    }
+                } else {
+                    while (p < end) {
+                        if ((uint)qGray(*p++) < qt_bayer_matrix[j++&15][i&15])
+                            *m |= 1 << bit;
+                        if (bit == 0) {
+                            m++;
+                            bit = 7;
+                        } else {
+                            bit--;
+                        }
+                    }
+                }
+                dst_data += dst_bpl;
+                src_data += src_bpl;
+            }
+        } else
+            /* (d == 8) */ {
+            for (int i=0; i<h; i++) {
+                const uchar *p = src_data;
+                const uchar *end = p + w;
+                uchar *m = dst_data;
+                int bit = 7;
+                int j = 0;
+                while (p < end) {
+                    if ((uint)gray[*p++] < qt_bayer_matrix[j++&15][i&15])
+                        *m |= 1 << bit;
+                    if (bit == 0) {
+                        m++;
+                        bit = 7;
+                    } else {
+                        bit--;
+                    }
+                }
+                dst_data += dst_bpl;
+                src_data += src_bpl;
+            }
+        }
+    } break;
+    default: { // Threshold:
+        memset(dst->data, 0, dst->nbytes);
+        if (d == 32) {
+            for (int i=0; i<h; i++) {
+                const uint *p = (const uint *)src_data;
+                const uint *end = p + w;
+                uchar *m = dst_data;
+                int bit = 7;
+                if (fromalpha) {
+                    while (p < end) {
+                        if ((*p++ >> 24) >= 128)
+                            *m |= 1 << bit;        // Set mask "on"
+                        if (bit == 0) {
+                            m++;
+                            bit = 7;
+                        } else {
+                            bit--;
+                        }
+                    }
+                } else {
+                    while (p < end) {
+                        if (qGray(*p++) < 128)
+                            *m |= 1 << bit;        // Set pixel "black"
+                        if (bit == 0) {
+                            m++;
+                            bit = 7;
+                        } else {
+                            bit--;
+                        }
+                    }
+                }
+                dst_data += dst_bpl;
+                src_data += src_bpl;
+            }
+        } else
+            if (d == 8) {
+                for (int i=0; i<h; i++) {
+                    const uchar *p = src_data;
+                    const uchar *end = p + w;
+                    uchar *m = dst_data;
+                    int bit = 7;
+                    while (p < end) {
+                        if (gray[*p++] < 128)
+                            *m |= 1 << bit;                // Set mask "on"/ pixel "black"
+                        if (bit == 0) {
+                            m++;
+                            bit = 7;
+                        } else {
+                            bit--;
+                        }
+                    }
+                    dst_data += dst_bpl;
+                    src_data += src_bpl;
+                }
+            }
+        }
+    }
+
+    if (dst->format == QImage::Format_MonoLSB) {
+        // need to swap bit order
+        uchar *sl = dst->data;
+        int bpl = (dst->width + 7) * dst->depth / 8;
+        int pad = dst->bytes_per_line - bpl;
+        for (int y=0; y<dst->height; ++y) {
+            for (int x=0; x<bpl; ++x) {
+                *sl = bitflip[*sl];
+                ++sl;
+            }
+            sl += pad;
+        }
+    }
+}
+
+static void convert_X_to_Mono(QImageData *dst, const QImageData *src, Qt::ImageConversionFlags flags)
+{
+    dither_to_Mono(dst, src, flags, false);
+}
+
+static void convert_ARGB_PM_to_Mono(QImageData *dst, const QImageData *src, Qt::ImageConversionFlags flags)
+{
+    QImageData *tmp = QImageData::create(QSize(src->width, src->height), QImage::Format_ARGB32);
+    convert_ARGB_PM_to_ARGB(tmp, src, flags);
+    dither_to_Mono(dst, tmp, flags, false);
+    delete tmp;
+}
+
+//
+// convert_32_to_8:  Converts a 32 bits depth (true color) to an 8 bit
+// image with a colormap. If the 32 bit image has more than 256 colors,
+// we convert the red,green and blue bytes into a single byte encoded
+// as 6 shades of each of red, green and blue.
+//
+// if dithering is needed, only 1 color at most is available for alpha.
+//
+struct QRgbMap {
+    inline QRgbMap() : used(0) { }
+    uchar  pix;
+    uchar used;
+    QRgb  rgb;
+};
+
+static void convert_RGB_to_Indexed8(QImageData *dst, const QImageData *src, Qt::ImageConversionFlags flags)
+{
+    Q_ASSERT(src->format == QImage::Format_RGB32 || src->format == QImage::Format_ARGB32);
+    Q_ASSERT(dst->format == QImage::Format_Indexed8);
+    Q_ASSERT(src->width == dst->width);
+    Q_ASSERT(src->height == dst->height);
+
+    bool    do_quant = (flags & Qt::DitherMode_Mask) == Qt::PreferDither
+                       || src->format == QImage::Format_ARGB32;
+    uint alpha_mask = src->format == QImage::Format_RGB32 ? 0xff000000 : 0;
+
+    const int tablesize = 997; // prime
+    QRgbMap table[tablesize];
+    int   pix=0;
+
+    if (!dst->colortable.isEmpty()) {
+        QVector<QRgb> ctbl = dst->colortable;
+        dst->colortable.resize(256);
+        // Preload palette into table.
+        // Almost same code as pixel insertion below
+        for (int i = 0; i < dst->colortable.size(); ++i) {
+            // Find in table...
+            QRgb p = ctbl.at(i) | alpha_mask;
+            int hash = p % tablesize;
+            for (;;) {
+                if (table[hash].used) {
+                    if (table[hash].rgb == p) {
+                        // Found previous insertion - use it
+                        break;
+                    } else {
+                        // Keep searching...
+                        if (++hash == tablesize) hash = 0;
+                    }
+                } else {
+                    // Cannot be in table
+                    Q_ASSERT (pix != 256);        // too many colors
+                    // Insert into table at this unused position
+                    dst->colortable[pix] = p;
+                    table[hash].pix = pix++;
+                    table[hash].rgb = p;
+                    table[hash].used = 1;
+                    break;
+                }
+            }
+        }
+    }
+
+    if ((flags & Qt::DitherMode_Mask) != Qt::PreferDither) {
+        dst->colortable.resize(256);
+        const uchar *src_data = src->data;
+        uchar *dest_data = dst->data;
+        for (int y = 0; y < src->height; y++) {        // check if <= 256 colors
+            const QRgb *s = (const QRgb *)src_data;
+            uchar *b = dest_data;
+            for (int x = 0; x < src->width; ++x) {
+                QRgb p = s[x] | alpha_mask;
+                int hash = p % tablesize;
+                for (;;) {
+                    if (table[hash].used) {
+                        if (table[hash].rgb == (p)) {
+                            // Found previous insertion - use it
+                            break;
+                        } else {
+                            // Keep searching...
+                            if (++hash == tablesize) hash = 0;
+                        }
+                    } else {
+                        // Cannot be in table
+                        if (pix == 256) {        // too many colors
+                            do_quant = true;
+                            // Break right out
+                            x = src->width;
+                            y = src->height;
+                        } else {
+                            // Insert into table at this unused position
+                            dst->colortable[pix] = p;
+                            table[hash].pix = pix++;
+                            table[hash].rgb = p;
+                            table[hash].used = 1;
+                        }
+                        break;
+                    }
+                }
+                *b++ = table[hash].pix;                // May occur once incorrectly
+            }
+            src_data += src->bytes_per_line;
+            dest_data += dst->bytes_per_line;
+        }
+    }
+    int numColors = do_quant ? 256 : pix;
+
+    dst->colortable.resize(numColors);
+
+    if (do_quant) {                                // quantization needed
+
+#define MAX_R 5
+#define MAX_G 5
+#define MAX_B 5
+#define INDEXOF(r,g,b) (((r)*(MAX_G+1)+(g))*(MAX_B+1)+(b))
+
+        for (int rc=0; rc<=MAX_R; rc++)                // build 6x6x6 color cube
+            for (int gc=0; gc<=MAX_G; gc++)
+                for (int bc=0; bc<=MAX_B; bc++)
+                    dst->colortable[INDEXOF(rc,gc,bc)] = 0xff000000 | qRgb(rc*255/MAX_R, gc*255/MAX_G, bc*255/MAX_B);
+
+        const uchar *src_data = src->data;
+        uchar *dest_data = dst->data;
+        if ((flags & Qt::Dither_Mask) == Qt::ThresholdDither) {
+            for (int y = 0; y < src->height; y++) {
+                const QRgb *p = (const QRgb *)src_data;
+                const QRgb *end = p + src->width;
+                uchar *b = dest_data;
+
+                while (p < end) {
+#define DITHER(p,m) ((uchar) ((p * (m) + 127) / 255))
+                    *b++ =
+                        INDEXOF(
+                            DITHER(qRed(*p), MAX_R),
+                            DITHER(qGreen(*p), MAX_G),
+                            DITHER(qBlue(*p), MAX_B)
+                            );
+#undef DITHER
+                    p++;
+                }
+                src_data += src->bytes_per_line;
+                dest_data += dst->bytes_per_line;
+            }
+        } else if ((flags & Qt::Dither_Mask) == Qt::DiffuseDither) {
+            int* line1[3];
+            int* line2[3];
+            int* pv[3];
+            line1[0] = new int[src->width];
+            line2[0] = new int[src->width];
+            line1[1] = new int[src->width];
+            line2[1] = new int[src->width];
+            line1[2] = new int[src->width];
+            line2[2] = new int[src->width];
+            pv[0] = new int[src->width];
+            pv[1] = new int[src->width];
+            pv[2] = new int[src->width];
+
+            int endian = (QSysInfo::ByteOrder == QSysInfo::BigEndian);
+            for (int y = 0; y < src->height; y++) {
+                const uchar* q = src_data;
+                const uchar* q2 = y < src->height - 1 ? q + src->bytes_per_line : src->data;
+                uchar *b = dest_data;
+                for (int chan = 0; chan < 3; chan++) {
+                    int *l1 = (y&1) ? line2[chan] : line1[chan];
+                    int *l2 = (y&1) ? line1[chan] : line2[chan];
+                    if (y == 0) {
+                        for (int i = 0; i < src->width; i++)
+                            l1[i] = q[i*4+chan+endian];
+                    }
+                    if (y+1 < src->height) {
+                        for (int i = 0; i < src->width; i++)
+                            l2[i] = q2[i*4+chan+endian];
+                    }
+                    // Bi-directional error diffusion
+                    if (y&1) {
+                        for (int x = 0; x < src->width; x++) {
+                            int pix = qMax(qMin(5, (l1[x] * 5 + 128)/ 255), 0);
+                            int err = l1[x] - pix * 255 / 5;
+                            pv[chan][x] = pix;
+
+                            // Spread the error around...
+                            if (x + 1< src->width) {
+                                l1[x+1] += (err*7)>>4;
+                                l2[x+1] += err>>4;
+                            }
+                            l2[x]+=(err*5)>>4;
+                            if (x>1)
+                                l2[x-1]+=(err*3)>>4;
+                        }
+                    } else {
+                        for (int x = src->width; x-- > 0;) {
+                            int pix = qMax(qMin(5, (l1[x] * 5 + 128)/ 255), 0);
+                            int err = l1[x] - pix * 255 / 5;
+                            pv[chan][x] = pix;
+
+                            // Spread the error around...
+                            if (x > 0) {
+                                l1[x-1] += (err*7)>>4;
+                                l2[x-1] += err>>4;
+                            }
+                            l2[x]+=(err*5)>>4;
+                            if (x + 1 < src->width)
+                                l2[x+1]+=(err*3)>>4;
+                        }
+                    }
+                }
+                if (endian) {
+                    for (int x = 0; x < src->width; x++) {
+                        *b++ = INDEXOF(pv[0][x],pv[1][x],pv[2][x]);
+                    }
+                } else {
+                    for (int x = 0; x < src->width; x++) {
+                        *b++ = INDEXOF(pv[2][x],pv[1][x],pv[0][x]);
+                    }
+                }
+                src_data += src->bytes_per_line;
+                dest_data += dst->bytes_per_line;
+            }
+            delete [] line1[0];
+            delete [] line2[0];
+            delete [] line1[1];
+            delete [] line2[1];
+            delete [] line1[2];
+            delete [] line2[2];
+            delete [] pv[0];
+            delete [] pv[1];
+            delete [] pv[2];
+        } else { // OrderedDither
+            for (int y = 0; y < src->height; y++) {
+                const QRgb *p = (const QRgb *)src_data;
+                const QRgb *end = p + src->width;
+                uchar *b = dest_data;
+
+                int x = 0;
+                while (p < end) {
+                    uint d = qt_bayer_matrix[y & 15][x & 15] << 8;
+
+#define DITHER(p, d, m) ((uchar) ((((256 * (m) + (m) + 1)) * (p) + (d)) >> 16))
+                    *b++ =
+                        INDEXOF(
+                            DITHER(qRed(*p), d, MAX_R),
+                            DITHER(qGreen(*p), d, MAX_G),
+                            DITHER(qBlue(*p), d, MAX_B)
+                            );
+#undef DITHER
+
+                    p++;
+                    x++;
+                }
+                src_data += src->bytes_per_line;
+                dest_data += dst->bytes_per_line;
+            }
+        }
+
+        if (src->format != QImage::Format_RGB32
+            && src->format != QImage::Format_RGB16) {
+            const int trans = 216;
+            Q_ASSERT(dst->colortable.size() > trans);
+            dst->colortable[trans] = 0;
+            QImageData *mask = QImageData::create(QSize(src->width, src->height), QImage::Format_Mono);
+            dither_to_Mono(mask, src, flags, true);
+            uchar *dst_data = dst->data;
+            const uchar *mask_data = mask->data;
+            for (int y = 0; y < src->height; y++) {
+                for (int x = 0; x < src->width ; x++) {
+                    if (!(mask_data[x>>3] & (0x80 >> (x & 7))))
+                        dst_data[x] = trans;
+                }
+                mask_data += mask->bytes_per_line;
+                dst_data += dst->bytes_per_line;
+            }
+            dst->has_alpha_clut = true;
+            delete mask;
+        }
+
+#undef MAX_R
+#undef MAX_G
+#undef MAX_B
+#undef INDEXOF
+
+    }
+}
+
+static void convert_ARGB_PM_to_Indexed8(QImageData *dst, const QImageData *src, Qt::ImageConversionFlags flags)
+{
+    QImageData *tmp = QImageData::create(QSize(src->width, src->height), QImage::Format_ARGB32);
+    convert_ARGB_PM_to_ARGB(tmp, src, flags);
+    convert_RGB_to_Indexed8(dst, tmp, flags);
+    delete tmp;
+}
+
+static void convert_ARGB_to_Indexed8(QImageData *dst, const QImageData *src, Qt::ImageConversionFlags flags)
+{
+    convert_RGB_to_Indexed8(dst, src, flags);
+}
+
+static void convert_Indexed8_to_X32(QImageData *dest, const QImageData *src, Qt::ImageConversionFlags)
+{
+    Q_ASSERT(src->format == QImage::Format_Indexed8);
+    Q_ASSERT(dest->format == QImage::Format_RGB32
+             || dest->format == QImage::Format_ARGB32
+             || dest->format == QImage::Format_ARGB32_Premultiplied);
+    Q_ASSERT(src->width == dest->width);
+    Q_ASSERT(src->height == dest->height);
+
+    QVector<QRgb> colorTable = fix_color_table(src->colortable, dest->format);
+
+    int w = src->width;
+    const uchar *src_data = src->data;
+    uchar *dest_data = dest->data;
+    for (int y = 0; y < src->height; y++) {
+        uint *p = (uint *)dest_data;
+        const uchar *b = src_data;
+        uint *end = p + w;
+
+        while (p < end)
+            *p++ = colorTable.at(*b++);
+
+        src_data += src->bytes_per_line;
+        dest_data += dest->bytes_per_line;
+    }
+}
+
+static void convert_Mono_to_X32(QImageData *dest, const QImageData *src, Qt::ImageConversionFlags)
+{
+    Q_ASSERT(src->format == QImage::Format_Mono || src->format == QImage::Format_MonoLSB);
+    Q_ASSERT(dest->format == QImage::Format_RGB32
+             || dest->format == QImage::Format_ARGB32
+             || dest->format == QImage::Format_ARGB32_Premultiplied);
+    Q_ASSERT(src->width == dest->width);
+    Q_ASSERT(src->height == dest->height);
+
+    QVector<QRgb> colorTable = fix_color_table(src->colortable, dest->format);
+
+    // Default to black / white colors
+    if (colorTable.size() < 2) {
+        if (colorTable.size() == 0)
+            colorTable << 0xff000000;
+        colorTable << 0xffffffff;
+    }
+
+    const uchar *src_data = src->data;
+    uchar *dest_data = dest->data;
+    if (src->format == QImage::Format_Mono) {
+        for (int y = 0; y < dest->height; y++) {
+            register uint *p = (uint *)dest_data;
+            for (int x = 0; x < dest->width; x++)
+                *p++ = colorTable.at((src_data[x>>3] >> (7 - (x & 7))) & 1);
+
+            src_data += src->bytes_per_line;
+            dest_data += dest->bytes_per_line;
+        }
+    } else {
+        for (int y = 0; y < dest->height; y++) {
+            register uint *p = (uint *)dest_data;
+            for (int x = 0; x < dest->width; x++)
+                *p++ = colorTable.at((src_data[x>>3] >> (x & 7)) & 1);
+
+            src_data += src->bytes_per_line;
+            dest_data += dest->bytes_per_line;
+        }
+    }
+}
+
+
+static void convert_Mono_to_Indexed8(QImageData *dest, const QImageData *src, Qt::ImageConversionFlags)
+{
+    Q_ASSERT(src->format == QImage::Format_Mono || src->format == QImage::Format_MonoLSB);
+    Q_ASSERT(dest->format == QImage::Format_Indexed8);
+    Q_ASSERT(src->width == dest->width);
+    Q_ASSERT(src->height == dest->height);
+
+    QVector<QRgb> ctbl = src->colortable;
+    if (ctbl.size() > 2) {
+        ctbl.resize(2);
+    } else if (ctbl.size() < 2) {
+        if (ctbl.size() == 0)
+            ctbl << 0xff000000;
+        ctbl << 0xffffffff;
+    }
+    dest->colortable = ctbl;
+    dest->has_alpha_clut = src->has_alpha_clut;
+
+
+    const uchar *src_data = src->data;
+    uchar *dest_data = dest->data;
+    if (src->format == QImage::Format_Mono) {
+        for (int y = 0; y < dest->height; y++) {
+            register uchar *p = dest_data;
+            for (int x = 0; x < dest->width; x++)
+                *p++ = (src_data[x>>3] >> (7 - (x & 7))) & 1;
+            src_data += src->bytes_per_line;
+            dest_data += dest->bytes_per_line;
+        }
+    } else {
+        for (int y = 0; y < dest->height; y++) {
+            register uchar *p = dest_data;
+            for (int x = 0; x < dest->width; x++)
+                *p++ = (src_data[x>>3] >> (x & 7)) & 1;
+            src_data += src->bytes_per_line;
+            dest_data += dest->bytes_per_line;
+        }
+    }
+}
+
+#define CONVERT_DECL(DST, SRC)                                          \
+    static void convert_##SRC##_to_##DST(QImageData *dest,              \
+                                         const QImageData *src,         \
+                                         Qt::ImageConversionFlags)      \
+    {                                                                   \
+        qt_rectconvert<DST, SRC>(reinterpret_cast<DST*>(dest->data),    \
+                                 reinterpret_cast<const SRC*>(src->data), \
+                                 0, 0, src->width, src->height,         \
+                                 dest->bytes_per_line, src->bytes_per_line); \
+    }
+
+CONVERT_DECL(quint32, quint16)
+CONVERT_DECL(quint16, quint32)
+CONVERT_DECL(quint32, qargb8565)
+CONVERT_DECL(qargb8565, quint32)
+CONVERT_DECL(quint32, qrgb555)
+CONVERT_DECL(qrgb666, quint32)
+CONVERT_DECL(quint32, qrgb666)
+CONVERT_DECL(qargb6666, quint32)
+CONVERT_DECL(quint32, qargb6666)
+CONVERT_DECL(qrgb555, quint32)
+#if !defined(Q_WS_QWS) || (defined(QT_QWS_DEPTH_15) && defined(QT_QWS_DEPTH_16))
+CONVERT_DECL(quint16, qrgb555)
+CONVERT_DECL(qrgb555, quint16)
+#endif
+CONVERT_DECL(quint32, qrgb888)
+CONVERT_DECL(qrgb888, quint32)
+CONVERT_DECL(quint32, qargb8555)
+CONVERT_DECL(qargb8555, quint32)
+CONVERT_DECL(quint32, qrgb444)
+CONVERT_DECL(qrgb444, quint32)
+CONVERT_DECL(quint32, qargb4444)
+CONVERT_DECL(qargb4444, quint32)
+#undef CONVERT_DECL
+#define CONVERT_PTR(DST, SRC) convert_##SRC##_to_##DST
+
+/*
+        Format_Invalid,
+        Format_Mono,
+        Format_MonoLSB,
+        Format_Indexed8,
+        Format_RGB32,
+        Format_ARGB32,
+        Format_ARGB32_Premultiplied,
+        Format_RGB16,
+        Format_ARGB8565_Premultiplied,
+        Format_RGB666,
+        Format_ARGB6666_Premultiplied,
+        Format_RGB555,
+        Format_ARGB8555_Premultiplied,
+        Format_RGB888
+        Format_RGB444
+        Format_ARGB4444_Premultiplied
+*/
+
+
+// first index source, second dest
+static const Image_Converter converter_map[QImage::NImageFormats][QImage::NImageFormats] =
+{
+    {
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+    },
+    {
+        0,
+        0,
+        swap_bit_order,
+        convert_Mono_to_Indexed8,
+        convert_Mono_to_X32,
+        convert_Mono_to_X32,
+        convert_Mono_to_X32,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+    }, // Format_Mono
+
+    {
+        0,
+        swap_bit_order,
+        0,
+        convert_Mono_to_Indexed8,
+        convert_Mono_to_X32,
+        convert_Mono_to_X32,
+        convert_Mono_to_X32,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+    }, // Format_MonoLSB
+
+    {
+        0,
+        convert_X_to_Mono,
+        convert_X_to_Mono,
+        0,
+        convert_Indexed8_to_X32,
+        convert_Indexed8_to_X32,
+        convert_Indexed8_to_X32,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+    }, // Format_Indexed8
+
+    {
+        0,
+        convert_X_to_Mono,
+        convert_X_to_Mono,
+        convert_RGB_to_Indexed8,
+        0,
+        mask_alpha_converter,
+        mask_alpha_converter,
+        CONVERT_PTR(quint16, quint32),
+        CONVERT_PTR(qargb8565, quint32),
+        CONVERT_PTR(qrgb666, quint32),
+        CONVERT_PTR(qargb6666, quint32),
+        CONVERT_PTR(qrgb555, quint32),
+        CONVERT_PTR(qargb8555, quint32),
+        CONVERT_PTR(qrgb888, quint32),
+        CONVERT_PTR(qrgb444, quint32),
+        CONVERT_PTR(qargb4444, quint32)
+    }, // Format_RGB32
+
+    {
+        0,
+        convert_X_to_Mono,
+        convert_X_to_Mono,
+        convert_ARGB_to_Indexed8,
+        mask_alpha_converter,
+        0,
+        convert_ARGB_to_ARGB_PM,
+        CONVERT_PTR(quint16, quint32),
+        CONVERT_PTR(qargb8565, quint32),
+        CONVERT_PTR(qrgb666, quint32),
+        CONVERT_PTR(qargb6666, quint32),
+        CONVERT_PTR(qrgb555, quint32),
+        CONVERT_PTR(qargb8555, quint32),
+        CONVERT_PTR(qrgb888, quint32),
+        CONVERT_PTR(qrgb444, quint32),
+        CONVERT_PTR(qargb4444, quint32)
+    }, // Format_ARGB32
+
+    {
+        0,
+        convert_ARGB_PM_to_Mono,
+        convert_ARGB_PM_to_Mono,
+        convert_ARGB_PM_to_Indexed8,
+        convert_ARGB_PM_to_RGB,
+        convert_ARGB_PM_to_ARGB,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+    },  // Format_ARGB32_Premultiplied
+
+    {
+        0,
+        0,
+        0,
+        0,
+        CONVERT_PTR(quint32, quint16),
+        CONVERT_PTR(quint32, quint16),
+        CONVERT_PTR(quint32, quint16),
+        0,
+        0,
+        0,
+        0,
+#if !defined(Q_WS_QWS) || (defined(QT_QWS_DEPTH_15) && defined(QT_QWS_DEPTH_16))
+        CONVERT_PTR(qrgb555, quint16),
+#else
+        0,
+#endif
+        0,
+        0,
+        0,
+        0
+    }, // Format_RGB16
+
+    {
+        0,
+        0,
+        0,
+        0,
+        CONVERT_PTR(quint32, qargb8565),
+        CONVERT_PTR(quint32, qargb8565),
+        CONVERT_PTR(quint32, qargb8565),
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+    }, // Format_ARGB8565_Premultiplied
+
+    {
+        0,
+        0,
+        0,
+        0,
+        CONVERT_PTR(quint32, qrgb666),
+        CONVERT_PTR(quint32, qrgb666),
+        CONVERT_PTR(quint32, qrgb666),
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+    }, // Format_RGB666
+
+    {
+        0,
+        0,
+        0,
+        0,
+        CONVERT_PTR(quint32, qargb6666),
+        CONVERT_PTR(quint32, qargb6666),
+        CONVERT_PTR(quint32, qargb6666),
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+    }, // Format_ARGB6666_Premultiplied
+
+    {
+        0,
+        0,
+        0,
+        0,
+        CONVERT_PTR(quint32, qrgb555),
+        CONVERT_PTR(quint32, qrgb555),
+        CONVERT_PTR(quint32, qrgb555),
+#if !defined(Q_WS_QWS) || (defined(QT_QWS_DEPTH_15) && defined(QT_QWS_DEPTH_16))
+        CONVERT_PTR(quint16, qrgb555),
+#else
+        0,
+#endif
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+    }, // Format_RGB555
+
+    {
+        0,
+        0,
+        0,
+        0,
+        CONVERT_PTR(quint32, qargb8555),
+        CONVERT_PTR(quint32, qargb8555),
+        CONVERT_PTR(quint32, qargb8555),
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+    }, // Format_ARGB8555_Premultiplied
+
+    {
+        0,
+        0,
+        0,
+        0,
+        CONVERT_PTR(quint32, qrgb888),
+        CONVERT_PTR(quint32, qrgb888),
+        CONVERT_PTR(quint32, qrgb888),
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+    }, // Format_RGB888
+
+    {
+        0,
+        0,
+        0,
+        0,
+        CONVERT_PTR(quint32, qrgb444),
+        CONVERT_PTR(quint32, qrgb444),
+        CONVERT_PTR(quint32, qrgb444),
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+    }, // Format_RGB444
+
+    {
+        0,
+        0,
+        0,
+        0,
+        CONVERT_PTR(quint32, qargb4444),
+        CONVERT_PTR(quint32, qargb4444),
+        CONVERT_PTR(quint32, qargb4444),
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+    } // Format_ARGB4444_Premultiplied
+};
+
+/*!
+    Returns a copy of the image in the given \a format.
+
+    The specified image conversion \a flags control how the image data
+    is handled during the conversion process.
+
+    \sa {QImage#Image Format}{Image Format}
+*/
+QImage QImage::convertToFormat(Format format, Qt::ImageConversionFlags flags) const
+{
+    if (!d || d->format == format)
+        return *this;
+
+    if (format == Format_Invalid || d->format == Format_Invalid)
+        return QImage();
+
+    const Image_Converter *converterPtr = &converter_map[d->format][format];
+    Image_Converter converter = *converterPtr;
+    if (converter) {
+        QImage image(d->width, d->height, format);
+
+        QIMAGE_SANITYCHECK_MEMORY(image);
+
+        image.setDotsPerMeterY(dotsPerMeterY());
+        image.setDotsPerMeterX(dotsPerMeterX());
+
+#if !defined(QT_NO_IMAGE_TEXT)
+        image.d->text = d->text;
+#endif // !QT_NO_IMAGE_TEXT
+
+        converter(image.d, d, flags);
+        return image;
+    }
+
+    Q_ASSERT(format != QImage::Format_ARGB32);
+    Q_ASSERT(d->format != QImage::Format_ARGB32);
+
+    QImage image = convertToFormat(Format_ARGB32, flags);
+    return image.convertToFormat(format, flags);
+}
+
+
+
+static inline int pixel_distance(QRgb p1, QRgb p2) {
+    int r1 = qRed(p1);
+    int g1 = qGreen(p1);
+    int b1 = qBlue(p1);
+    int a1 = qAlpha(p1);
+
+    int r2 = qRed(p2);
+    int g2 = qGreen(p2);
+    int b2 = qBlue(p2);
+    int a2 = qAlpha(p2);
+
+    return abs(r1 - r2) + abs(g1 - g2) + abs(b1 - b2) + abs(a1 - a2);
+}
+
+static inline int closestMatch(QRgb pixel, const QVector<QRgb> &clut) {
+    int idx = 0;
+    int current_distance = INT_MAX;
+    for (int i=0; i<clut.size(); ++i) {
+        int dist = pixel_distance(pixel, clut.at(i));
+        if (dist < current_distance) {
+            current_distance = dist;
+            idx = i;
+        }
+    }
+    return idx;
+}
+
+static QImage convertWithPalette(const QImage &src, QImage::Format format,
+                                 const QVector<QRgb> &clut) {
+    QImage dest(src.size(), format);
+    dest.setColorTable(clut);
+
+#if !defined(QT_NO_IMAGE_TEXT)
+    QString textsKeys = src.text();
+    QStringList textKeyList = textsKeys.split(QLatin1Char('\n'), QString::SkipEmptyParts);
+    foreach (const QString &textKey, textKeyList) {
+        QStringList textKeySplitted = textKey.split(QLatin1String(": "));
+        dest.setText(textKeySplitted[0], textKeySplitted[1]);
+    }
+#endif // !QT_NO_IMAGE_TEXT
+
+    int h = src.height();
+    int w = src.width();
+
+    QHash<QRgb, int> cache;
+
+    if (format == QImage::Format_Indexed8) {
+        for (int y=0; y<h; ++y) {
+            QRgb *src_pixels = (QRgb *) src.scanLine(y);
+            uchar *dest_pixels = (uchar *) dest.scanLine(y);
+            for (int x=0; x<w; ++x) {
+                int src_pixel = src_pixels[x];
+                int value = cache.value(src_pixel, -1);
+                if (value == -1) {
+                    value = closestMatch(src_pixel, clut);
+                    cache.insert(src_pixel, value);
+                }
+                dest_pixels[x] = (uchar) value;
+            }
+        }
+    } else {
+        QVector<QRgb> table = clut;
+        table.resize(2);
+        for (int y=0; y<h; ++y) {
+            QRgb *src_pixels = (QRgb *) src.scanLine(y);
+            for (int x=0; x<w; ++x) {
+                int src_pixel = src_pixels[x];
+                int value = cache.value(src_pixel, -1);
+                if (value == -1) {
+                    value = closestMatch(src_pixel, table);
+                    cache.insert(src_pixel, value);
+                }
+                dest.setPixel(x, y, value);
+            }
+        }
+    }
+
+    return dest;
+}
+
+/*!
+    \overload
+
+    Returns a copy of the image converted to the given \a format,
+    using the specified \a colorTable.
+
+    Conversion from 32 bit to 8 bit indexed is a slow operation and
+    will use a straightforward nearest color approach, with no
+    dithering.
+*/
+QImage QImage::convertToFormat(Format format, const QVector<QRgb> &colorTable, Qt::ImageConversionFlags flags) const
+{
+    if (d->format == format)
+        return *this;
+
+    if (format <= QImage::Format_Indexed8 && depth() == 32) {
+        return convertWithPalette(*this, format, colorTable);
+    }
+
+    const Image_Converter *converterPtr = &converter_map[d->format][format];
+    Image_Converter converter = *converterPtr;
+    if (!converter)
+        return QImage();
+
+    QImage image(d->width, d->height, format);
+    QIMAGE_SANITYCHECK_MEMORY(image);
+
+#if !defined(QT_NO_IMAGE_TEXT)
+        image.d->text = d->text;
+#endif // !QT_NO_IMAGE_TEXT
+
+    converter(image.d, d, flags);
+    return image;
+}
+
+#ifdef QT3_SUPPORT
+/*!
+    Converts the depth (bpp) of the image to the given \a depth and
+    returns the converted image. The original image is not changed.
+    Returns this image if \a depth is equal to the image depth, or a
+    null image if this image cannot be converted. The \a depth
+    argument must be 1, 8 or 32. If the image needs to be modified to
+    fit in a lower-resolution result (e.g. converting from 32-bit to
+    8-bit), use the \a flags to specify how you'd prefer this to
+    happen.
+
+    Use the convertToFormat() function instead.
+*/
+
+QImage QImage::convertDepth(int depth, Qt::ImageConversionFlags flags) const
+{
+    if (!d || d->depth == depth)
+        return *this;
+
+    Format format = formatFor (depth, QImage::LittleEndian);
+    return convertToFormat(format, flags);
+}
+#endif
+
+/*!
+    \fn bool QImage::valid(const QPoint &pos) const
+
+    Returns true if \a pos is a valid coordinate pair within the
+    image; otherwise returns false.
+
+    \sa rect(), QRect::contains()
+*/
+
+/*!
+    \overload
+
+    Returns true if QPoint(\a x, \a y) is a valid coordinate pair
+    within the image; otherwise returns false.
+*/
+bool QImage::valid(int x, int y) const
+{
+    return d
+        && x >= 0 && x < d->width
+        && y >= 0 && y < d->height;
+}
+
+/*!
+    \fn int QImage::pixelIndex(const QPoint &position) const
+
+    Returns the pixel index at the given \a position.
+
+    If \a position is not valid, or if the image is not a paletted
+    image (depth() > 8), the results are undefined.
+
+    \sa valid(), depth(), {QImage#Pixel Manipulation}{Pixel Manipulation}
+*/
+
+/*!
+    \overload
+
+    Returns the pixel index at (\a x, \a y).
+*/
+int QImage::pixelIndex(int x, int y) const
+{
+    if (!d || x < 0 || x >= d->width || y < 0 || y >= height()) {
+        qWarning("QImage::pixelIndex: coordinate (%d,%d) out of range", x, y);
+        return -12345;
+    }
+    const uchar * s = scanLine(y);
+    switch(d->format) {
+    case Format_Mono:
+        return (*(s + (x >> 3)) >> (7- (x & 7))) & 1;
+    case Format_MonoLSB:
+        return (*(s + (x >> 3)) >> (x & 7)) & 1;
+    case Format_Indexed8:
+        return (int)s[x];
+    default:
+        qWarning("QImage::pixelIndex: Not applicable for %d-bpp images (no palette)", d->depth);
+    }
+    return 0;
+}
+
+
+/*!
+    \fn QRgb QImage::pixel(const QPoint &position) const
+
+    Returns the color of the pixel at the given \a position.
+
+    If the \a position is not valid, the results are undefined.
+
+    \sa setPixel(), valid(), {QImage#Pixel Manipulation}{Pixel
+    Manipulation}
+*/
+
+/*!
+    \overload
+
+    Returns the color of the pixel at coordinates (\a x, \a y).
+*/
+QRgb QImage::pixel(int x, int y) const
+{
+    if (!d || x < 0 || x >= d->width || y < 0 || y >= height()) {
+        qWarning("QImage::pixel: coordinate (%d,%d) out of range", x, y);
+        return 12345;
+    }
+    const uchar * s = scanLine(y);
+    switch(d->format) {
+    case Format_Mono:
+        return d->colortable.at((*(s + (x >> 3)) >> (7- (x & 7))) & 1);
+    case Format_MonoLSB:
+        return d->colortable.at((*(s + (x >> 3)) >> (x & 7)) & 1);
+    case Format_Indexed8:
+        return d->colortable.at((int)s[x]);
+    case Format_ARGB8565_Premultiplied:
+        return qt_colorConvert<quint32, qargb8565>(reinterpret_cast<const qargb8565*>(s)[x], 0);
+    case Format_RGB666:
+        return qt_colorConvert<quint32, qrgb666>(reinterpret_cast<const qrgb666*>(s)[x], 0);
+    case Format_ARGB6666_Premultiplied:
+        return qt_colorConvert<quint32, qargb6666>(reinterpret_cast<const qargb6666*>(s)[x], 0);
+    case Format_RGB555:
+        return qt_colorConvert<quint32, qrgb555>(reinterpret_cast<const qrgb555*>(s)[x], 0);
+    case Format_ARGB8555_Premultiplied:
+        return qt_colorConvert<quint32, qargb8555>(reinterpret_cast<const qargb8555*>(s)[x], 0);
+    case Format_RGB888:
+        return qt_colorConvert<quint32, qrgb888>(reinterpret_cast<const qrgb888*>(s)[x], 0);
+    case Format_RGB444:
+        return qt_colorConvert<quint32, qrgb444>(reinterpret_cast<const qrgb444*>(s)[x], 0);
+    case Format_ARGB4444_Premultiplied:
+        return qt_colorConvert<quint32, qargb4444>(reinterpret_cast<const qargb4444*>(s)[x], 0);
+    case Format_RGB16:
+        return qt_colorConvert<quint32, quint16>(reinterpret_cast<const quint16*>(s)[x], 0);
+    default:
+        return ((QRgb*)s)[x];
+    }
+}
+
+
+/*!
+    \fn void QImage::setPixel(const QPoint &position, uint index_or_rgb)
+
+    Sets the pixel index or color at the given \a position to \a
+    index_or_rgb.
+
+    If the image's format is either monochrome or 8-bit, the given \a
+    index_or_rgb value must be an index in the image's color table,
+    otherwise the parameter must be a QRgb value.
+
+    If \a position is not a valid coordinate pair in the image, or if
+    \a index_or_rgb >= numColors() in the case of monochrome and
+    8-bit images, the result is undefined.
+
+    \warning This function is expensive due to the call of the internal
+    \c{detach()} function called within; if performance is a concern, we
+    recommend the use of \l{QImage::}{scanLine()} to access pixel data
+    directly.
+
+    \sa pixel(), {QImage#Pixel Manipulation}{Pixel Manipulation}
+*/
+
+/*!
+    \overload
+
+    Sets the pixel index or color at (\a x, \a y) to \a index_or_rgb.
+*/
+void QImage::setPixel(int x, int y, uint index_or_rgb)
+{
+    if (!d || x < 0 || x >= width() || y < 0 || y >= height()) {
+        qWarning("QImage::setPixel: coordinate (%d,%d) out of range", x, y);
+        return;
+    }
+    // detach is called from within scanLine
+    uchar * s = scanLine(y);
+    const quint32p p = quint32p::fromRawData(index_or_rgb);
+    switch(d->format) {
+    case Format_Mono:
+    case Format_MonoLSB:
+        if (index_or_rgb > 1) {
+            qWarning("QImage::setPixel: Index %d out of range", index_or_rgb);
+        } else if (format() == Format_MonoLSB) {
+            if (index_or_rgb==0)
+                *(s + (x >> 3)) &= ~(1 << (x & 7));
+            else
+                *(s + (x >> 3)) |= (1 << (x & 7));
+        } else {
+            if (index_or_rgb==0)
+                *(s + (x >> 3)) &= ~(1 << (7-(x & 7)));
+            else
+                *(s + (x >> 3)) |= (1 << (7-(x & 7)));
+        }
+        break;
+    case Format_Indexed8:
+        if (index_or_rgb > (uint)d->colortable.size()) {
+            qWarning("QImage::setPixel: Index %d out of range", index_or_rgb);
+            return;
+        }
+        s[x] = index_or_rgb;
+        break;
+    case Format_RGB32:
+        //make sure alpha is 255, we depend on it in qdrawhelper for cases
+        // when image is set as a texture pattern on a qbrush
+        ((uint *)s)[x] = uint(255 << 24) | index_or_rgb;
+        break;
+    case Format_ARGB32:
+    case Format_ARGB32_Premultiplied:
+        ((uint *)s)[x] = index_or_rgb;
+        break;
+    case Format_RGB16:
+        ((quint16 *)s)[x] = qt_colorConvert<quint16, quint32p>(p, 0);
+        break;
+    case Format_ARGB8565_Premultiplied:
+        ((qargb8565*)s)[x] = qt_colorConvert<qargb8565, quint32p>(p, 0);
+        break;
+    case Format_RGB666:
+        ((qrgb666*)s)[x] = qt_colorConvert<qrgb666, quint32p>(p, 0);
+        break;
+    case Format_ARGB6666_Premultiplied:
+        ((qargb6666*)s)[x] = qt_colorConvert<qargb6666, quint32p>(p, 0);
+        break;
+    case Format_RGB555:
+        ((qrgb555*)s)[x] = qt_colorConvert<qrgb555, quint32p>(p, 0);
+        break;
+    case Format_ARGB8555_Premultiplied:
+        ((qargb8555*)s)[x] = qt_colorConvert<qargb8555, quint32p>(p, 0);
+        break;
+    case Format_RGB888:
+        ((qrgb888*)s)[x] = qt_colorConvert<qrgb888, quint32p>(p, 0);
+        break;
+    case Format_RGB444:
+        ((qrgb444*)s)[x] = qt_colorConvert<qrgb444, quint32p>(p, 0);
+        break;
+    case Format_ARGB4444_Premultiplied:
+        ((qargb4444*)s)[x] = qt_colorConvert<qargb4444, quint32p>(p, 0);
+        break;
+    case Format_Invalid:
+    case NImageFormats:
+        Q_ASSERT(false);
+    }
+}
+
+#ifdef QT3_SUPPORT
+/*!
+    Converts the bit order of the image to the given \a bitOrder and
+    returns the converted image. The original image is not changed.
+    Returns this image if the given \a bitOrder is equal to the image
+    current bit order, or a null image if this image cannot be
+    converted.
+
+    Use convertToFormat() instead.
+*/
+
+QImage QImage::convertBitOrder(Endian bitOrder) const
+{
+    if (!d || isNull() || d->depth != 1 || !(bitOrder == BigEndian || bitOrder == LittleEndian))
+        return QImage();
+
+    if ((d->format == Format_Mono && bitOrder == BigEndian)
+        || (d->format == Format_MonoLSB && bitOrder == LittleEndian))
+        return *this;
+
+    QImage image(d->width, d->height, d->format == Format_Mono ? Format_MonoLSB : Format_Mono);
+
+    const uchar *data = d->data;
+    const uchar *end = data + d->nbytes;
+    uchar *ndata = image.d->data;
+    while (data < end)
+        *ndata++ = bitflip[*data++];
+
+    image.setDotsPerMeterX(dotsPerMeterX());
+    image.setDotsPerMeterY(dotsPerMeterY());
+
+    image.d->colortable = d->colortable;
+    return image;
+}
+#endif
+/*!
+    Returns true if all the colors in the image are shades of gray
+    (i.e. their red, green and blue components are equal); otherwise
+    false.
+
+    Note that this function is slow for images without color table.
+
+    \sa isGrayscale()
+*/
+bool QImage::allGray() const
+{
+    if (!d)
+        return true;
+
+    if (d->depth == 32) {
+        int p = width()*height();
+        const QRgb* b = (const QRgb*)bits();
+        while (p--)
+            if (!qIsGray(*b++))
+                return false;
+    } else if (d->depth == 16) {
+        int p = width()*height();
+        const ushort* b = (const ushort *)bits();
+        while (p--)
+            if (!qIsGray(qt_colorConvert<quint32, quint16>(*b++, 0)))
+                return false;
+    } else if (d->format == QImage::Format_RGB888) {
+        int p = width()*height();
+        const qrgb888* b = (const qrgb888 *)bits();
+        while (p--)
+            if (!qIsGray(qt_colorConvert<quint32, qrgb888>(*b++, 0)))
+                return false;
+    } else {
+        if (d->colortable.isEmpty())
+            return true;
+        for (int i = 0; i < numColors(); i++)
+            if (!qIsGray(d->colortable.at(i)))
+                return false;
+    }
+    return true;
+}
+
+/*!
+    For 32-bit images, this function is equivalent to allGray().
+
+    For 8-bpp images, this function returns true if color(i) is
+    QRgb(i, i, i) for all indexes of the color table; otherwise
+    returns false.
+
+    \sa allGray(), {QImage#Image Formats}{Image Formats}
+*/
+bool QImage::isGrayscale() const
+{
+    if (!d)
+        return false;
+
+    switch (depth()) {
+    case 32:
+    case 24:
+    case 16:
+        return allGray();
+    case 8: {
+        for (int i = 0; i < numColors(); i++)
+            if (d->colortable.at(i) != qRgb(i,i,i))
+                return false;
+        return true;
+        }
+    }
+    return false;
+}
+
+
+/*!
+    \fn QImage QImage::smoothScale(int width, int height, Qt::AspectRatioMode mode) const
+
+    Use scaled() instead.
+
+    \oldcode
+        QImage image;
+        image.smoothScale(width, height, mode);
+    \newcode
+        QImage image;
+        image.scaled(width, height, mode, Qt::SmoothTransformation);
+    \endcode
+*/
+
+/*!
+    \fn QImage QImage::smoothScale(const QSize &size, Qt::AspectRatioMode mode) const
+    \overload
+
+    Use scaled() instead.
+
+    \oldcode
+        QImage image;
+        image.smoothScale(size, mode);
+    \newcode
+        QImage image;
+        image.scaled(size, mode, Qt::SmoothTransformation);
+    \endcode
+*/
+
+/*!
+    \fn QImage QImage::scaled(int width, int height, Qt::AspectRatioMode aspectRatioMode,
+                             Qt::TransformationMode transformMode) const
+    \overload
+
+    Returns a copy of the image scaled to a rectangle with the given
+    \a width and \a height according to the given \a aspectRatioMode
+    and \a transformMode.
+
+    If either the \a width or the \a height is zero or negative, this
+    function returns a null image.
+*/
+
+/*!
+    \fn QImage QImage::scaled(const QSize &size, Qt::AspectRatioMode aspectRatioMode,
+                             Qt::TransformationMode transformMode) const
+
+    Returns a copy of the image scaled to a rectangle defined by the
+    given \a size according to the given \a aspectRatioMode and \a
+    transformMode.
+
+    \image qimage-scaling.png
+
+    \list
+    \i If \a aspectRatioMode is Qt::IgnoreAspectRatio, the image
+       is scaled to \a size.
+    \i If \a aspectRatioMode is Qt::KeepAspectRatio, the image is
+       scaled to a rectangle as large as possible inside \a size, preserving the aspect ratio.
+    \i If \a aspectRatioMode is Qt::KeepAspectRatioByExpanding,
+       the image is scaled to a rectangle as small as possible
+       outside \a size, preserving the aspect ratio.
+    \endlist
+
+    If the given \a size is empty, this function returns a null image.
+
+    \sa isNull(), {QImage#Image Transformations}{Image
+    Transformations}
+*/
+QImage QImage::scaled(const QSize& s, Qt::AspectRatioMode aspectMode, Qt::TransformationMode mode) const
+{
+    if (!d) {
+        qWarning("QImage::scaled: Image is a null image");
+        return QImage();
+    }
+    if (s.isEmpty())
+        return QImage();
+
+    QSize newSize = size();
+    newSize.scale(s, aspectMode);
+    if (newSize == size())
+        return copy();
+
+    QImage img;
+    QTransform wm;
+    wm.scale((qreal)newSize.width() / width(), (qreal)newSize.height() / height());
+    img = transformed(wm, mode);
+    return img;
+}
+
+/*!
+    \fn QImage QImage::scaledToWidth(int width, Qt::TransformationMode mode) const
+
+    Returns a scaled copy of the image. The returned image is scaled
+    to the given \a width using the specified transformation \a
+    mode.
+
+    This function automatically calculates the height of the image so
+    that its aspect ratio is preserved.
+
+    If the given \a width is 0 or negative, a null image is returned.
+
+    \sa {QImage#Image Transformations}{Image Transformations}
+*/
+QImage QImage::scaledToWidth(int w, Qt::TransformationMode mode) const
+{
+    if (!d) {
+        qWarning("QImage::scaleWidth: Image is a null image");
+        return QImage();
+    }
+    if (w <= 0)
+        return QImage();
+
+    QTransform wm;
+    qreal factor = (qreal) w / width();
+    wm.scale(factor, factor);
+    return transformed(wm, mode);
+}
+
+/*!
+    \fn QImage QImage::scaledToHeight(int height, Qt::TransformationMode mode) const
+
+    Returns a scaled copy of the image. The returned image is scaled
+    to the given \a height using the specified transformation \a
+    mode.
+
+    This function automatically calculates the width of the image so that
+    the ratio of the image is preserved.
+
+    If the given \a height is 0 or negative, a null image is returned.
+
+    \sa {QImage#Image Transformations}{Image Transformations}
+*/
+QImage QImage::scaledToHeight(int h, Qt::TransformationMode mode) const
+{
+    if (!d) {
+        qWarning("QImage::scaleHeight: Image is a null image");
+        return QImage();
+    }
+    if (h <= 0)
+        return QImage();
+
+    QTransform wm;
+    qreal factor = (qreal) h / height();
+    wm.scale(factor, factor);
+    return transformed(wm, mode);
+}
+
+
+/*!
+    \fn QMatrix QImage::trueMatrix(const QMatrix &matrix, int width, int height)
+
+    Returns the actual matrix used for transforming an image with the
+    given \a width, \a height and \a matrix.
+
+    When transforming an image using the transformed() function, the
+    transformation matrix is internally adjusted to compensate for
+    unwanted translation, i.e. transformed() returns the smallest
+    image containing all transformed points of the original image.
+    This function returns the modified matrix, which maps points
+    correctly from the original image into the new image.
+
+    \sa transformed(), {QImage#Image Transformations}{Image
+    Transformations}
+*/
+QMatrix QImage::trueMatrix(const QMatrix &matrix, int w, int h)
+{
+    return trueMatrix(QTransform(matrix), w, h).toAffine();
+}
+
+/*!
+    Returns a copy of the image that is transformed using the given
+    transformation \a matrix and transformation \a mode.
+
+    The transformation \a matrix is internally adjusted to compensate
+    for unwanted translation; i.e. the image produced is the smallest
+    image that contains all the transformed points of the original
+    image. Use the trueMatrix() function to retrieve the actual matrix
+    used for transforming an image.
+
+    \sa trueMatrix(), {QImage#Image Transformations}{Image
+    Transformations}
+*/
+QImage QImage::transformed(const QMatrix &matrix, Qt::TransformationMode mode) const
+{
+    return transformed(QTransform(matrix), mode);
+}
+
+/*!
+    Builds and returns a 1-bpp mask from the alpha buffer in this
+    image. Returns a null image if the image's format is
+    QImage::Format_RGB32.
+
+    The \a flags argument is a bitwise-OR of the
+    Qt::ImageConversionFlags, and controls the conversion
+    process. Passing 0 for flags sets all the default options.
+
+    The returned image has little-endian bit order (i.e. the image's
+    format is QImage::Format_MonoLSB), which you can convert to
+    big-endian (QImage::Format_Mono) using the convertToFormat()
+    function.
+
+    \sa createHeuristicMask(), {QImage#Image Transformations}{Image
+    Transformations}
+*/
+QImage QImage::createAlphaMask(Qt::ImageConversionFlags flags) const
+{
+    if (!d || d->format == QImage::Format_RGB32)
+        return QImage();
+
+    if (d->depth == 1) {
+        // A monochrome pixmap, with alpha channels on those two colors.
+        // Pretty unlikely, so use less efficient solution.
+        return convertToFormat(Format_Indexed8, flags).createAlphaMask(flags);
+    }
+
+    QImage mask(d->width, d->height, Format_MonoLSB);
+    dither_to_Mono(mask.d, d, flags, true);
+    return mask;
+}
+
+#ifndef QT_NO_IMAGE_HEURISTIC_MASK
+/*!
+    Creates and returns a 1-bpp heuristic mask for this image.
+
+    The function works by selecting a color from one of the corners,
+    then chipping away pixels of that color starting at all the edges.
+    The four corners vote for which color is to be masked away. In
+    case of a draw (this generally means that this function is not
+    applicable to the image), the result is arbitrary.
+
+    The returned image has little-endian bit order (i.e. the image's
+    format is QImage::Format_MonoLSB), which you can convert to
+    big-endian (QImage::Format_Mono) using the convertToFormat()
+    function.
+
+    If \a clipTight is true (the default) the mask is just large
+    enough to cover the pixels; otherwise, the mask is larger than the
+    data pixels.
+
+    Note that this function disregards the alpha buffer.
+
+    \sa createAlphaMask(), {QImage#Image Transformations}{Image
+    Transformations}
+*/
+
+QImage QImage::createHeuristicMask(bool clipTight) const
+{
+    if (!d)
+        return QImage();
+
+    if (d->depth != 32) {
+        QImage img32 = convertToFormat(Format_RGB32);
+        return img32.createHeuristicMask(clipTight);
+    }
+
+#define PIX(x,y)  (*((QRgb*)scanLine(y)+x) & 0x00ffffff)
+
+    int w = width();
+    int h = height();
+    QImage m(w, h, Format_MonoLSB);
+    m.setNumColors(2);
+    m.setColor(0, QColor(Qt::color0).rgba());
+    m.setColor(1, QColor(Qt::color1).rgba());
+    m.fill(0xff);
+
+    QRgb background = PIX(0,0);
+    if (background != PIX(w-1,0) &&
+         background != PIX(0,h-1) &&
+         background != PIX(w-1,h-1)) {
+        background = PIX(w-1,0);
+        if (background != PIX(w-1,h-1) &&
+             background != PIX(0,h-1) &&
+             PIX(0,h-1) == PIX(w-1,h-1)) {
+            background = PIX(w-1,h-1);
+        }
+    }
+
+    int x,y;
+    bool done = false;
+    uchar *ypp, *ypc, *ypn;
+    while(!done) {
+        done = true;
+        ypn = m.scanLine(0);
+        ypc = 0;
+        for (y = 0; y < h; y++) {
+            ypp = ypc;
+            ypc = ypn;
+            ypn = (y == h-1) ? 0 : m.scanLine(y+1);
+            QRgb *p = (QRgb *)scanLine(y);
+            for (x = 0; x < w; x++) {
+                // slowness here - it's possible to do six of these tests
+                // together in one go. oh well.
+                if ((x == 0 || y == 0 || x == w-1 || y == h-1 ||
+                       !(*(ypc + ((x-1) >> 3)) & (1 << ((x-1) & 7))) ||
+                       !(*(ypc + ((x+1) >> 3)) & (1 << ((x+1) & 7))) ||
+                       !(*(ypp + (x     >> 3)) & (1 << (x     & 7))) ||
+                       !(*(ypn + (x     >> 3)) & (1 << (x     & 7)))) &&
+                     (       (*(ypc + (x     >> 3)) & (1 << (x     & 7)))) &&
+                     ((*p & 0x00ffffff) == background)) {
+                    done = false;
+                    *(ypc + (x >> 3)) &= ~(1 << (x & 7));
+                }
+                p++;
+            }
+        }
+    }
+
+    if (!clipTight) {
+        ypn = m.scanLine(0);
+        ypc = 0;
+        for (y = 0; y < h; y++) {
+            ypp = ypc;
+            ypc = ypn;
+            ypn = (y == h-1) ? 0 : m.scanLine(y+1);
+            QRgb *p = (QRgb *)scanLine(y);
+            for (x = 0; x < w; x++) {
+                if ((*p & 0x00ffffff) != background) {
+                    if (x > 0)
+                        *(ypc + ((x-1) >> 3)) |= (1 << ((x-1) & 7));
+                    if (x < w-1)
+                        *(ypc + ((x+1) >> 3)) |= (1 << ((x+1) & 7));
+                    if (y > 0)
+                        *(ypp + (x >> 3)) |= (1 << (x & 7));
+                    if (y < h-1)
+                        *(ypn + (x >> 3)) |= (1 << (x & 7));
+                }
+                p++;
+            }
+        }
+    }
+
+#undef PIX
+
+    return m;
+}
+#endif //QT_NO_IMAGE_HEURISTIC_MASK
+
+/*!
+    Creates and returns a mask for this image based on the given \a
+    color value. If the \a mode is MaskInColor (the default value),
+    all pixels matching \a color will be opaque pixels in the mask. If
+    \a mode is MaskOutColor, all pixels matching the given color will
+    be transparent.
+
+    \sa createAlphaMask(), createHeuristicMask()
+*/
+
+QImage QImage::createMaskFromColor(QRgb color, Qt::MaskMode mode) const
+{
+    if (!d)
+        return QImage();
+    QImage maskImage(size(), QImage::Format_MonoLSB);
+    maskImage.fill(0);
+    uchar *s = maskImage.bits();
+
+    if (depth() == 32) {
+        for (int h = 0; h < d->height; h++) {
+            const uint *sl = (uint *) scanLine(h);
+            for (int w = 0; w < d->width; w++) {
+                if (sl[w] == color)
+                    *(s + (w >> 3)) |= (1 << (w & 7));
+            }
+            s += maskImage.bytesPerLine();
+        }
+    } else {
+        for (int h = 0; h < d->height; h++) {
+            for (int w = 0; w < d->width; w++) {
+                if ((uint) pixel(w, h) == color)
+                    *(s + (w >> 3)) |= (1 << (w & 7));
+            }
+            s += maskImage.bytesPerLine();
+        }
+    }
+    if  (mode == Qt::MaskOutColor)
+        maskImage.invertPixels();
+    return maskImage;
+}
+
+
+/*
+  This code is contributed by Philipp Lang,
+  GeneriCom Software Germany (www.generi.com)
+  under the terms of the QPL, Version 1.0
+*/
+
+/*!
+    \fn QImage QImage::mirror(bool horizontal, bool vertical) const
+
+    Use mirrored() instead.
+*/
+
+/*!
+    Returns a mirror of the image, mirrored in the horizontal and/or
+    the vertical direction depending on whether \a horizontal and \a
+    vertical are set to true or false.
+
+    Note that the original image is not changed.
+
+    \sa {QImage#Image Transformations}{Image Transformations}
+*/
+QImage QImage::mirrored(bool horizontal, bool vertical) const
+{
+    if (!d)
+        return QImage();
+
+    if ((d->width <= 1 && d->height <= 1) || (!horizontal && !vertical))
+        return *this;
+
+    int w = d->width;
+    int h = d->height;
+    // Create result image, copy colormap
+    QImage result(d->width, d->height, d->format);
+    result.d->colortable = d->colortable;
+    result.d->has_alpha_clut = d->has_alpha_clut;
+
+    if (depth() == 1)
+        w = (w+7)/8;
+    int dxi = horizontal ? -1 : 1;
+    int dxs = horizontal ? w-1 : 0;
+    int dyi = vertical ? -1 : 1;
+    int dy = vertical ? h-1: 0;
+
+    // 1 bit, 8 bit
+    if (d->depth == 1 || d->depth == 8) {
+        for (int sy = 0; sy < h; sy++, dy += dyi) {
+            quint8* ssl = (quint8*)(d->data + sy*d->bytes_per_line);
+            quint8* dsl = (quint8*)(result.d->data + dy*result.d->bytes_per_line);
+            int dx = dxs;
+            for (int sx = 0; sx < w; sx++, dx += dxi)
+                dsl[dx] = ssl[sx];
+        }
+    }
+    // 16 bit
+    else if (d->depth == 16) {
+        for (int sy = 0; sy < h; sy++, dy += dyi) {
+            quint16* ssl = (quint16*)(d->data + sy*d->bytes_per_line);
+            quint16* dsl = (quint16*)(result.d->data + dy*result.d->bytes_per_line);
+            int dx = dxs;
+            for (int sx = 0; sx < w; sx++, dx += dxi)
+                dsl[dx] = ssl[sx];
+        }
+    }
+    // 24 bit
+    else if (d->depth == 24) {
+        for (int sy = 0; sy < h; sy++, dy += dyi) {
+            quint24* ssl = (quint24*)(d->data + sy*d->bytes_per_line);
+            quint24* dsl = (quint24*)(result.d->data + dy*result.d->bytes_per_line);
+            int dx = dxs;
+            for (int sx = 0; sx < w; sx++, dx += dxi)
+                dsl[dx] = ssl[sx];
+        }
+    }
+    // 32 bit
+    else if (d->depth == 32) {
+        for (int sy = 0; sy < h; sy++, dy += dyi) {
+            quint32* ssl = (quint32*)(d->data + sy*d->bytes_per_line);
+            quint32* dsl = (quint32*)(result.d->data + dy*result.d->bytes_per_line);
+            int dx = dxs;
+            for (int sx = 0; sx < w; sx++, dx += dxi)
+                dsl[dx] = ssl[sx];
+        }
+    }
+
+    // special handling of 1 bit images for horizontal mirroring
+    if (horizontal && d->depth == 1) {
+        int shift = width() % 8;
+        for (int y = h-1; y >= 0; y--) {
+            quint8* a0 = (quint8*)(result.d->data + y*d->bytes_per_line);
+            // Swap bytes
+            quint8* a = a0+dxs;
+            while (a >= a0) {
+                *a = bitflip[*a];
+                a--;
+            }
+            // Shift bits if unaligned
+            if (shift != 0) {
+                a = a0+dxs;
+                quint8 c = 0;
+                if (format() == Format_MonoLSB) {
+                    while (a >= a0) {
+                        quint8 nc = *a << shift;
+                        *a = (*a >> (8-shift)) | c;
+                        --a;
+                        c = nc;
+                    }
+                } else {
+                    while (a >= a0) {
+                        quint8 nc = *a >> shift;
+                        *a = (*a << (8-shift)) | c;
+                        --a;
+                        c = nc;
+                    }
+                }
+            }
+        }
+    }
+
+    return result;
+}
+
+/*!
+    \fn QImage QImage::swapRGB() const
+
+    Use rgbSwapped() instead.
+
+    \omit
+    Returns a QImage in which the values of the red and blue
+    components of all pixels have been swapped, effectively converting
+    an RGB image to an BGR image. The original QImage is not changed.
+    \endomit
+*/
+
+/*!
+    Returns a QImage in which the values of the red and blue
+    components of all pixels have been swapped, effectively converting
+    an RGB image to an BGR image.
+
+    The original QImage is not changed.
+
+    \sa {QImage#Image Transformations}{Image Transformations}
+*/
+QImage QImage::rgbSwapped() const
+{
+    if (isNull())
+        return *this;
+    QImage res;
+    switch (d->format) {
+    case Format_Invalid:
+    case NImageFormats:
+        Q_ASSERT(false);
+        break;
+    case Format_Mono:
+    case Format_MonoLSB:
+    case Format_Indexed8:
+        res = copy();
+        for (int i = 0; i < res.d->colortable.size(); i++) {
+            QRgb c = res.d->colortable.at(i);
+            res.d->colortable[i] = QRgb(((c << 16) & 0xff0000) | ((c >> 16) & 0xff) | (c & 0xff00ff00));
+        }
+        break;
+    case Format_RGB32:
+    case Format_ARGB32:
+    case Format_ARGB32_Premultiplied:
+        res = QImage(d->width, d->height, d->format);
+        for (int i = 0; i < d->height; i++) {
+            uint *q = (uint*)res.scanLine(i);
+            uint *p = (uint*)scanLine(i);
+            uint *end = p + d->width;
+            while (p < end) {
+                *q = ((*p << 16) & 0xff0000) | ((*p >> 16) & 0xff) | (*p & 0xff00ff00);
+                p++;
+                q++;
+            }
+        }
+        break;
+    case Format_RGB16:
+        res = QImage(d->width, d->height, d->format);
+        for (int i = 0; i < d->height; i++) {
+            ushort *q = (ushort*)res.scanLine(i);
+            const ushort *p = (const ushort*)scanLine(i);
+            const ushort *end = p + d->width;
+            while (p < end) {
+                *q = ((*p << 11) & 0xf800) | ((*p >> 11) & 0x1f) | (*p & 0x07e0);
+                p++;
+                q++;
+            }
+        }
+        break;
+    case Format_ARGB8565_Premultiplied:
+        res = QImage(d->width, d->height, d->format);
+        for (int i = 0; i < d->height; i++) {
+            quint8 *p = (quint8*)scanLine(i);
+            const quint8 *end = p + d->width * sizeof(qargb8565);
+            while (p < end) {
+                quint16 *q = reinterpret_cast<quint16*>(p + 1);
+                *q = ((*q << 11) & 0xf800) | ((*q >> 11) & 0x1f) | (*q & 0x07e0);
+                p += sizeof(qargb8565);
+            }
+        }
+        break;
+    case Format_RGB666:
+        res = QImage(d->width, d->height, d->format);
+        for (int i = 0; i < d->height; i++) {
+            qrgb666 *q = reinterpret_cast<qrgb666*>(res.scanLine(i));
+            const qrgb666 *p = reinterpret_cast<const qrgb666*>(scanLine(i));
+            const qrgb666 *end = p + d->width;
+            while (p < end) {
+                const QRgb rgb = quint32(*p++);
+                *q++ = qRgb(qBlue(rgb), qGreen(rgb), qRed(rgb));
+            }
+        }
+        break;
+    case Format_ARGB6666_Premultiplied:
+        res = QImage(d->width, d->height, d->format);
+        for (int i = 0; i < d->height; i++) {
+            qargb6666 *q = reinterpret_cast<qargb6666*>(res.scanLine(i));
+            const qargb6666 *p = reinterpret_cast<const qargb6666*>(scanLine(i));
+            const qargb6666 *end = p + d->width;
+            while (p < end) {
+                const QRgb rgb = quint32(*p++);
+                *q++ = qRgba(qBlue(rgb), qGreen(rgb), qRed(rgb), qAlpha(rgb));
+            }
+        }
+        break;
+    case Format_RGB555:
+        res = QImage(d->width, d->height, d->format);
+        for (int i = 0; i < d->height; i++) {
+            ushort *q = (ushort*)res.scanLine(i);
+            const ushort *p = (const ushort*)scanLine(i);
+            const ushort *end = p + d->width;
+            while (p < end) {
+                *q = ((*p << 10) & 0x7800) | ((*p >> 10) & 0x1f) | (*p & 0x83e0);
+                p++;
+                q++;
+            }
+        }
+        break;
+    case Format_ARGB8555_Premultiplied:
+        res = QImage(d->width, d->height, d->format);
+        for (int i = 0; i < d->height; i++) {
+            quint8 *p = (quint8*)scanLine(i);
+            const quint8 *end = p + d->width * sizeof(qargb8555);
+            while (p < end) {
+                quint16 *q = reinterpret_cast<quint16*>(p + 1);
+                *q = ((*q << 10) & 0x7800) | ((*q >> 10) & 0x1f) | (*q & 0x83e0);
+                p += sizeof(qargb8555);
+            }
+        }
+        break;
+    case Format_RGB888:
+        res = QImage(d->width, d->height, d->format);
+        for (int i = 0; i < d->height; i++) {
+            quint8 *q = reinterpret_cast<quint8*>(res.scanLine(i));
+            const quint8 *p = reinterpret_cast<const quint8*>(scanLine(i));
+            const quint8 *end = p + d->width * sizeof(qrgb888);
+            while (p < end) {
+                q[0] = p[2];
+                q[1] = p[1];
+                q[2] = p[0];
+                q += sizeof(qrgb888);
+                p += sizeof(qrgb888);
+            }
+        }
+        break;
+    case Format_RGB444:
+        res = QImage(d->width, d->height, d->format);
+        for (int i = 0; i < d->height; i++) {
+            quint8 *q = reinterpret_cast<quint8*>(res.scanLine(i));
+            const quint8 *p = reinterpret_cast<const quint8*>(scanLine(i));
+            const quint8 *end = p + d->width * sizeof(qrgb444);
+            while (p < end) {
+                q[0] = (p[0] & 0xf0) | ((p[1] & 0x0f) << 8);
+                q[1] = ((p[0] & 0x0f) >> 8) | (p[1] & 0xf0);
+                q += sizeof(qrgb444);
+                p += sizeof(qrgb444);
+            }
+        }
+        break;
+    case Format_ARGB4444_Premultiplied:
+        res = QImage(d->width, d->height, d->format);
+        for (int i = 0; i < d->height; i++) {
+            quint8 *q = reinterpret_cast<quint8*>(res.scanLine(i));
+            const quint8 *p = reinterpret_cast<const quint8*>(scanLine(i));
+            const quint8 *end = p + d->width * sizeof(qargb4444);
+            while (p < end) {
+                q[0] = (p[0] & 0xf0) | ((p[1] & 0x0f) << 8);
+                q[1] = ((p[0] & 0x0f) >> 8) | (p[1] & 0xf0);
+                q += sizeof(qargb4444);
+                p += sizeof(qargb4444);
+            }
+        }
+        break;
+    }
+    return res;
+}
+
+/*!
+    Loads an image from the file with the given \a fileName. Returns true if
+    the image was successfully loaded; otherwise returns false.
+
+    The loader attempts to read the image using the specified \a format, e.g.,
+    PNG or JPG. If \a format is not specified (which is the default), the
+    loader probes the file for a header to guess the file format.
+
+    The file name can either refer to an actual file on disk or to one
+    of the application's embedded resources. See the
+    \l{resources.html}{Resource System} overview for details on how to
+    embed images and other resource files in the application's
+    executable.
+
+    \sa {QImage#Reading and Writing Image Files}{Reading and Writing Image Files}
+*/
+
+bool QImage::load(const QString &fileName, const char* format)
+{
+    if (fileName.isEmpty())
+        return false;
+
+    QImage image = QImageReader(fileName, format).read();
+    if (!image.isNull()) {
+        operator=(image);
+        return true;
+    }
+    return false;
+}
+
+/*!
+    \overload
+
+    This function reads a QImage from the given \a device. This can,
+    for example, be used to load an image directly into a QByteArray.
+*/
+
+bool QImage::load(QIODevice* device, const char* format)
+{
+    QImage image = QImageReader(device, format).read();
+    if(!image.isNull()) {
+        operator=(image);
+        return true;
+    }
+    return false;
+}
+
+/*!
+    \fn bool QImage::loadFromData(const uchar *data, int len, const char *format)
+
+    Loads an image from the first \a len bytes of the given binary \a
+    data. Returns true if the image was successfully loaded; otherwise
+    returns false.
+
+    The loader attempts to read the image using the specified \a format, e.g.,
+    PNG or JPG. If \a format is not specified (which is the default), the
+    loader probes the file for a header to guess the file format.
+
+    \sa {QImage#Reading and Writing Image Files}{Reading and Writing Image Files}
+*/
+
+bool QImage::loadFromData(const uchar *data, int len, const char *format)
+{
+    QImage image = fromData(data, len, format);
+    if (!image.isNull()) {
+        operator=(image);
+        return true;
+    }
+    return false;
+}
+
+/*!
+    \fn bool QImage::loadFromData(const QByteArray &data, const char *format)
+
+    \overload
+
+    Loads an image from the given QByteArray \a data.
+*/
+
+/*!
+    \fn QImage QImage::fromData(const uchar *data, int size, const char *format)
+
+    Constructs a QImage from the first \a size bytes of the given
+    binary \a data. The loader attempts to read the image using the
+    specified \a format. If \a format is not specified (which is the default),
+    the loader probes the file for a header to guess the file format.
+
+    If the loading of the image failed, this object is a null image.
+
+    \sa load(), save(), {QImage#Reading and Writing Image
+    Files}{Reading and Writing Image Files}
+*/
+QImage QImage::fromData(const uchar *data, int size, const char *format)
+{
+    QByteArray a = QByteArray::fromRawData(reinterpret_cast<const char *>(data), size);
+    QBuffer b;
+    b.setData(a);
+    b.open(QIODevice::ReadOnly);
+    return QImageReader(&b, format).read();
+}
+
+/*!
+    \fn QImage QImage::fromData(const QByteArray &data, const char *format)
+
+    \overload
+
+    Loads an image from the given QByteArray \a data.
+*/
+
+/*!
+    Saves the image to the file with the given \a fileName, using the
+    given image file \a format and \a quality factor. If \a format is
+    0, QImage will attempt to guess the format by looking at \a fileName's
+    suffix.
+
+    The \a quality factor must be in the range 0 to 100 or -1. Specify
+    0 to obtain small compressed files, 100 for large uncompressed
+    files, and -1 (the default) to use the default settings.
+
+    Returns true if the image was successfully saved; otherwise
+    returns false.
+
+    \sa {QImage#Reading and Writing Image Files}{Reading and Writing
+    Image Files}
+*/
+bool QImage::save(const QString &fileName, const char *format, int quality) const
+{
+    if (isNull())
+        return false;
+    QImageWriter writer(fileName, format);
+    return d->doImageIO(this, &writer, quality);
+}
+
+/*!
+    \overload
+
+    This function writes a QImage to the given \a device.
+
+    This can, for example, be used to save an image directly into a
+    QByteArray:
+
+    \snippet doc/src/snippets/image/image.cpp 0
+*/
+
+bool QImage::save(QIODevice* device, const char* format, int quality) const
+{
+    if (isNull())
+        return false;                                // nothing to save
+    QImageWriter writer(device, format);
+    return d->doImageIO(this, &writer, quality);
+}
+
+/* \internal
+*/
+
+bool QImageData::doImageIO(const QImage *image, QImageWriter *writer, int quality) const
+{
+    if (quality > 100  || quality < -1)
+        qWarning("QPixmap::save: Quality out of range [-1, 100]");
+    if (quality >= 0)
+        writer->setQuality(qMin(quality,100));
+    return writer->write(*image);
+}
+
+/*****************************************************************************
+  QImage stream functions
+ *****************************************************************************/
+#if !defined(QT_NO_DATASTREAM)
+/*!
+    \fn QDataStream &operator<<(QDataStream &stream, const QImage &image)
+    \relates QImage
+
+    Writes the given \a image to the given \a stream as a PNG image,
+    or as a BMP image if the stream's version is 1. Note that writing
+    the stream to a file will not produce a valid image file.
+
+    \sa QImage::save(), {Format of the QDataStream Operators}
+*/
+
+QDataStream &operator<<(QDataStream &s, const QImage &image)
+{
+    if (s.version() >= 5) {
+        if (image.isNull()) {
+            s << (qint32) 0; // null image marker
+            return s;
+        } else {
+            s << (qint32) 1;
+            // continue ...
+        }
+    }
+    QImageWriter writer(s.device(), s.version() == 1 ? "bmp" : "png");
+    writer.write(image);
+    return s;
+}
+
+/*!
+    \fn QDataStream &operator>>(QDataStream &stream, QImage &image)
+    \relates QImage
+
+    Reads an image from the given \a stream and stores it in the given
+    \a image.
+
+    \sa QImage::load(), {Format of the QDataStream Operators}
+*/
+
+QDataStream &operator>>(QDataStream &s, QImage &image)
+{
+    if (s.version() >= 5) {
+        qint32 nullMarker;
+        s >> nullMarker;
+        if (!nullMarker) {
+            image = QImage(); // null image
+            return s;
+        }
+    }
+    image = QImageReader(s.device(), 0).read();
+    return s;
+}
+#endif
+
+
+#ifdef QT3_SUPPORT
+/*!
+    \fn QImage QImage::convertDepthWithPalette(int depth, QRgb* palette, int palette_count, Qt::ImageConversionFlags flags) const
+
+    Returns an image with the given \a depth, using the \a
+    palette_count colors pointed to by \a palette. If \a depth is 1 or
+    8, the returned image will have its color table ordered in the
+    same way as \a palette.
+
+    If the image needs to be modified to fit in a lower-resolution
+    result (e.g. converting from 32-bit to 8-bit), use the \a flags to
+    specify how you'd prefer this to happen.
+
+    Note: currently no closest-color search is made. If colors are
+    found that are not in the palette, the palette may not be used at
+    all. This result should not be considered valid because it may
+    change in future implementations.
+
+    Currently inefficient for non-32-bit images.
+
+    Use the convertToFormat() function in combination with the
+    setColorTable() function instead.
+*/
+QImage QImage::convertDepthWithPalette(int d, QRgb* palette, int palette_count, Qt::ImageConversionFlags flags) const
+{
+    Format f = formatFor(d, QImage::LittleEndian);
+    QVector<QRgb> colortable;
+    for (int i = 0; i < palette_count; ++i)
+        colortable.append(palette[i]);
+    return convertToFormat(f, colortable, flags);
+}
+
+/*!
+    \relates QImage
+
+    Copies a block of pixels from \a src to \a dst. The pixels
+    copied from source (src) are converted according to
+    \a flags if it is incompatible with the destination
+    (\a dst).
+
+    \a sx, \a sy is the top-left pixel in \a src, \a dx, \a dy is the
+    top-left position in \a dst and \a sw, \a sh is the size of the
+    copied block. The copying is clipped if areas outside \a src or \a
+    dst are specified. If \a sw is -1, it is adjusted to
+    src->width(). Similarly, if \a sh is -1, it is adjusted to
+    src->height().
+
+    Currently inefficient for non 32-bit images.
+
+    Use copy() or QPainter::drawImage() instead.
+*/
+void bitBlt(QImage *dst, int dx, int dy, const QImage *src, int sx, int sy, int sw, int sh,
+            Qt::ImageConversionFlags flags)
+{
+    if (dst->isNull() || src->isNull())
+        return;
+    QPainter p(dst);
+    p.drawImage(QPoint(dx, dy), *src, QRect(sx, sy, sw, sh), flags);
+}
+#endif
+
+/*!
+    \fn bool QImage::operator==(const QImage & image) const
+
+    Returns true if this image and the given \a image have the same
+    contents; otherwise returns false.
+
+    The comparison can be slow, unless there is some obvious
+    difference (e.g. different size or format), in which case the
+    function will return quickly.
+
+    \sa operator=()
+*/
+
+bool QImage::operator==(const QImage & i) const
+{
+    // same object, or shared?
+    if (i.d == d)
+        return true;
+    if (!i.d || !d)
+        return false;
+
+    // obviously different stuff?
+    if (i.d->height != d->height || i.d->width != d->width || i.d->format != d->format)
+        return false;
+
+    if (d->format != Format_RGB32) {
+        if (d->colortable != i.d->colortable)
+            return false;
+        if (d->format >= Format_ARGB32) { // all bits defined
+            const int n = d->width * d->depth / 8;
+            if (n == d->bytes_per_line && n == i.d->bytes_per_line) {
+                if (memcmp(bits(), i.bits(), d->nbytes))
+                    return false;
+            } else {
+                for (int y = 0; y < d->height; ++y) {
+                    if (memcmp(scanLine(y), i.scanLine(y), n))
+                        return false;
+                }
+            }
+        } else {
+            int w = width();
+            int h = height();
+            for (int y=0; y<h; ++y) {
+                for (int x=0; x<w; ++x) {
+                    if (pixelIndex(x, y) != i.pixelIndex(x, y))
+                        return false;
+                }
+            }
+        }
+    } else {
+        //alpha channel undefined, so we must mask it out
+        for(int l = 0; l < d->height; l++) {
+            int w = d->width;
+            const uint *p1 = reinterpret_cast<const uint*>(scanLine(l));
+            const uint *p2 = reinterpret_cast<const uint*>(i.scanLine(l));
+            while (w--) {
+                if ((*p1++ & 0x00ffffff) != (*p2++ & 0x00ffffff))
+                    return false;
+            }
+        }
+    }
+    return true;
+}
+
+
+/*!
+    \fn bool QImage::operator!=(const QImage & image) const
+
+    Returns true if this image and the given \a image have different
+    contents; otherwise returns false.
+
+    The comparison can be slow, unless there is some obvious
+    difference, such as different widths, in which case the function
+    will return quickly.
+
+    \sa operator=()
+*/
+
+bool QImage::operator!=(const QImage & i) const
+{
+    return !(*this == i);
+}
+
+
+
+
+/*!
+    Returns the number of pixels that fit horizontally in a physical
+    meter. Together with dotsPerMeterY(), this number defines the
+    intended scale and aspect ratio of the image.
+
+    \sa setDotsPerMeterX(), {QImage#Image Information}{Image
+    Information}
+*/
+int QImage::dotsPerMeterX() const
+{
+    return d ? qRound(d->dpmx) : 0;
+}
+
+/*!
+    Returns the number of pixels that fit vertically in a physical
+    meter. Together with dotsPerMeterX(), this number defines the
+    intended scale and aspect ratio of the image.
+
+    \sa setDotsPerMeterY(), {QImage#Image Information}{Image
+    Information}
+*/
+int QImage::dotsPerMeterY() const
+{
+    return d ? qRound(d->dpmy) : 0;
+}
+
+/*!
+    Sets the number of pixels that fit horizontally in a physical
+    meter, to \a x.
+
+    Together with dotsPerMeterY(), this number defines the intended
+    scale and aspect ratio of the image.
+
+    \sa dotsPerMeterX(), {QImage#Image Information}{Image
+    Information}
+*/
+void QImage::setDotsPerMeterX(int x)
+{
+    if (!d || !x)
+        return;
+    detach();
+
+    if (d)
+        d->dpmx = x;
+}
+
+/*!
+    Sets the number of pixels that fit vertically in a physical meter,
+    to \a y.
+
+    Together with dotsPerMeterX(), this number defines the intended
+    scale and aspect ratio of the image.
+
+    \sa dotsPerMeterY(), {QImage#Image Information}{Image
+    Information}
+*/
+void QImage::setDotsPerMeterY(int y)
+{
+    if (!d || !y)
+        return;
+    detach();
+
+    if (d)
+        d->dpmy = y;
+}
+
+/*!
+    \fn QPoint QImage::offset() const
+
+    Returns the number of pixels by which the image is intended to be
+    offset by when positioning relative to other images.
+
+    \sa setOffset(), {QImage#Image Information}{Image Information}
+*/
+QPoint QImage::offset() const
+{
+    return d ? d->offset : QPoint();
+}
+
+
+/*!
+    \fn void QImage::setOffset(const QPoint& offset)
+
+    Sets the the number of pixels by which the image is intended to be
+    offset by when positioning relative to other images, to \a offset.
+
+    \sa offset(), {QImage#Image Information}{Image Information}
+*/
+void QImage::setOffset(const QPoint& p)
+{
+    if (!d)
+        return;
+    detach();
+
+    if (d)
+        d->offset = p;
+}
+#ifndef QT_NO_IMAGE_TEXT
+
+/*!
+    Returns the text keys for this image.
+
+    You can use these keys with text() to list the image text for a
+    certain key.
+
+    \sa text()
+*/
+QStringList QImage::textKeys() const
+{
+    return d ? QStringList(d->text.keys()) : QStringList();
+}
+
+/*!
+    Returns the image text associated with the given \a key. If the
+    specified \a key is an empty string, the whole image text is
+    returned, with each key-text pair separated by a newline.
+
+    \sa setText(), textKeys()
+*/
+QString QImage::text(const QString &key) const
+{
+    if (!d)
+        return QString();
+
+    if (!key.isEmpty())
+        return d->text.value(key);
+
+    QString tmp;
+    foreach (const QString &key, d->text.keys()) {
+        if (!tmp.isEmpty())
+            tmp += QLatin1String("\n\n");
+        tmp += key + QLatin1String(": ") + d->text.value(key).simplified();
+    }
+    return tmp;
+}
+
+/*!
+    \fn void QImage::setText(const QString &key, const QString &text)
+
+    Sets the image text to the given \a text and associate it with the
+    given \a key.
+
+    If you just want to store a single text block (i.e., a "comment"
+    or just a description), you can either pass an empty key, or use a
+    generic key like "Description".
+
+    The image text is embedded into the image data when you
+    call save() or QImageWriter::write().
+
+    Not all image formats support embedded text. You can find out
+    if a specific image or format supports embedding text
+    by using QImageWriter::supportsOption(). We give an example:
+
+    \snippet doc/src/snippets/image/supportedformat.cpp 0
+
+    You can use QImageWriter::supportedImageFormats() to find out
+    which image formats are available to you.
+
+    \sa text(), textKeys()
+*/
+void QImage::setText(const QString &key, const QString &value)
+{
+    if (!d)
+        return;
+    detach();
+
+    if (d)
+        d->text.insert(key, value);
+}
+
+/*!
+    \fn QString QImage::text(const char* key, const char* language) const
+    \obsolete
+
+    Returns the text recorded for the given \a key in the given \a
+    language, or in a default language if \a language is 0.
+
+    Use text() instead.
+
+    The language the text is recorded in is no longer relevant since
+    the text is always set using QString and UTF-8 representation.
+*/
+QString QImage::text(const char* key, const char* lang) const
+{
+    if (!d)
+        return QString();
+    QString k = QString::fromAscii(key);
+    if (lang && *lang)
+        k += QLatin1Char('/') + QString::fromAscii(lang);
+    return d->text.value(k);
+}
+
+/*!
+    \fn QString QImage::text(const QImageTextKeyLang& keywordAndLanguage) const
+    \overload
+    \obsolete
+
+    Returns the text recorded for the given \a keywordAndLanguage.
+
+    Use text() instead.
+
+    The language the text is recorded in is no longer relevant since
+    the text is always set using QString and UTF-8 representation.
+*/
+QString QImage::text(const QImageTextKeyLang& kl) const
+{
+    if (!d)
+        return QString();
+    QString k = QString::fromAscii(kl.key);
+    if (!kl.lang.isEmpty())
+        k += QLatin1Char('/') + QString::fromAscii(kl.lang);
+    return d->text.value(k);
+}
+
+/*!
+    \obsolete
+
+    Returns the language identifiers for which some texts are
+    recorded. Note that if you want to iterate over the list, you
+    should iterate over a copy.
+
+    The language the text is recorded in is no longer relevant since
+    the text is always set using QString and UTF-8 representation.
+*/
+QStringList QImage::textLanguages() const
+{
+    if (!d)
+        return QStringList();
+    QStringList keys = textKeys();
+    QStringList languages;
+    for (int i = 0; i < keys.size(); ++i) {
+        int index = keys.at(i).indexOf(QLatin1Char('/'));
+        if (index > 0)
+            languages += keys.at(i).mid(index+1);
+    }
+
+    return languages;
+}
+
+/*!
+    \obsolete
+
+    Returns a list of QImageTextKeyLang objects that enumerate all the
+    texts key/language pairs set for this image.
+
+    Use textKeys() instead.
+
+    The language the text is recorded in is no longer relevant since
+    the text is always set using QString and UTF-8 representation.
+*/
+QList<QImageTextKeyLang> QImage::textList() const
+{
+    QList<QImageTextKeyLang> imageTextKeys;
+    if (!d)
+        return imageTextKeys;
+    QStringList keys = textKeys();
+    for (int i = 0; i < keys.size(); ++i) {
+        int index = keys.at(i).indexOf(QLatin1Char('/'));
+        if (index > 0) {
+            QImageTextKeyLang tkl;
+            tkl.key = keys.at(i).left(index).toAscii();
+            tkl.lang = keys.at(i).mid(index+1).toAscii();
+            imageTextKeys += tkl;
+        }
+    }
+
+    return imageTextKeys;
+}
+
+/*!
+    \fn void QImage::setText(const char* key, const char* language, const QString& text)
+    \obsolete
+
+    Sets the image text to the given \a text and associate it with the
+    given \a key. The text is recorded in the specified \a language,
+    or in a default language if \a language is 0.
+
+    Use setText() instead.
+
+    The language the text is recorded in is no longer relevant since
+    the text is always set using QString and UTF-8 representation.
+
+    \omit
+    Records string \a  for the keyword \a key. The \a key should be
+    a portable keyword recognizable by other software - some suggested
+    values can be found in
+    \l{http://www.libpng.org/pub/png/spec/1.2/png-1.2-pdg.html#C.Anc-text}
+    {the PNG specification}. \a s can be any text. \a lang should
+    specify the language code (see
+    \l{http://www.rfc-editor.org/rfc/rfc1766.txt}{RFC 1766}) or 0.
+    \endomit
+*/
+void QImage::setText(const char* key, const char* lang, const QString& s)
+{
+    if (!d)
+        return;
+    detach();
+
+    // In case detach() ran out of memory
+    if (!d)
+        return;
+
+    QString k = QString::fromAscii(key);
+    if (lang && *lang)
+        k += QLatin1Char('/') + QString::fromAscii(lang);
+    d->text.insert(k, s);
+}
+
+#endif // QT_NO_IMAGE_TEXT
+
+/*
+    Sets the image bits to the \a pixmap contents and returns a
+    reference to the image.
+
+    If the image shares data with other images, it will first
+    dereference the shared data.
+
+    Makes a call to QPixmap::convertToImage().
+*/
+
+/*! \fn QImage::Endian QImage::systemBitOrder()
+
+    Determines the bit order of the display hardware. Returns
+    QImage::LittleEndian (LSB first) or QImage::BigEndian (MSB first).
+
+    This function is no longer relevant for QImage. Use QSysInfo
+    instead.
+*/
+
+
+/*!
+    \internal
+
+    Used by QPainter to retrieve a paint engine for the image.
+*/
+
+QPaintEngine *QImage::paintEngine() const
+{
+    if (!d)
+        return 0;
+
+#ifdef QT_RASTER_IMAGEENGINE
+    if (!d->paintEngine) {
+        d->paintEngine = new QRasterPaintEngine(const_cast<QImage *>(this));
+    }
+#endif
+    return d->paintEngine;
+}
+
+
+/*!
+    \reimp
+
+    Returns the size for the specified \a metric on the device.
+*/
+int QImage::metric(PaintDeviceMetric metric) const
+{
+    if (!d)
+        return 0;
+
+    switch (metric) {
+    case PdmWidth:
+        return d->width;
+        break;
+
+    case PdmHeight:
+        return d->height;
+        break;
+
+    case PdmWidthMM:
+        return qRound(d->width * 1000 / d->dpmx);
+        break;
+
+    case PdmHeightMM:
+        return qRound(d->height * 1000 / d->dpmy);
+        break;
+
+    case PdmNumColors:
+        return d->colortable.size();
+        break;
+
+    case PdmDepth:
+        return d->depth;
+        break;
+
+    case PdmDpiX:
+        return qRound(d->dpmx * 0.0254);
+        break;
+
+    case PdmDpiY:
+        return qRound(d->dpmy * 0.0254);
+        break;
+
+    case PdmPhysicalDpiX:
+        return qRound(d->dpmx * 0.0254);
+        break;
+
+    case PdmPhysicalDpiY:
+        return qRound(d->dpmy * 0.0254);
+        break;
+
+    default:
+        qWarning("QImage::metric(): Unhandled metric type %d", metric);
+        break;
+    }
+    return 0;
+}
+
+
+
+/*****************************************************************************
+  QPixmap (and QImage) helper functions
+ *****************************************************************************/
+/*
+  This internal function contains the common (i.e. platform independent) code
+  to do a transformation of pixel data. It is used by QPixmap::transform() and by
+  QImage::transform().
+
+  \a trueMat is the true transformation matrix (see QPixmap::trueMatrix()) and
+  \a xoffset is an offset to the matrix.
+
+  \a msbfirst specifies for 1bpp images, if the MSB or LSB comes first and \a
+  depth specifies the colordepth of the data.
+
+  \a dptr is a pointer to the destination data, \a dbpl specifies the bits per
+  line for the destination data, \a p_inc is the offset that we advance for
+  every scanline and \a dHeight is the height of the destination image.
+
+  \a sprt is the pointer to the source data, \a sbpl specifies the bits per
+  line of the source data, \a sWidth and \a sHeight are the width and height of
+  the source data.
+*/
+
+#undef IWX_MSB
+#define IWX_MSB(b)        if (trigx < maxws && trigy < maxhs) {                              \
+                            if (*(sptr+sbpl*(trigy>>12)+(trigx>>15)) &                      \
+                                 (1 << (7-((trigx>>12)&7))))                              \
+                                *dptr |= b;                                              \
+                        }                                                              \
+                        trigx += m11;                                                      \
+                        trigy += m12;
+        // END OF MACRO
+#undef IWX_LSB
+#define IWX_LSB(b)        if (trigx < maxws && trigy < maxhs) {                              \
+                            if (*(sptr+sbpl*(trigy>>12)+(trigx>>15)) &                      \
+                                 (1 << ((trigx>>12)&7)))                              \
+                                *dptr |= b;                                              \
+                        }                                                              \
+                        trigx += m11;                                                      \
+                        trigy += m12;
+        // END OF MACRO
+#undef IWX_PIX
+#define IWX_PIX(b)        if (trigx < maxws && trigy < maxhs) {                              \
+                            if ((*(sptr+sbpl*(trigy>>12)+(trigx>>15)) &              \
+                                 (1 << (7-((trigx>>12)&7)))) == 0)                      \
+                                *dptr &= ~b;                                              \
+                        }                                                              \
+                        trigx += m11;                                                      \
+                        trigy += m12;
+        // END OF MACRO
+bool qt_xForm_helper(const QTransform &trueMat, int xoffset, int type, int depth,
+                     uchar *dptr, int dbpl, int p_inc, int dHeight,
+                     const uchar *sptr, int sbpl, int sWidth, int sHeight)
+{
+    int m11 = int(trueMat.m11()*4096.0);
+    int m12 = int(trueMat.m12()*4096.0);
+    int m21 = int(trueMat.m21()*4096.0);
+    int m22 = int(trueMat.m22()*4096.0);
+    int dx  = qRound(trueMat.dx()*4096.0);
+    int dy  = qRound(trueMat.dy()*4096.0);
+
+    int m21ydx = dx + (xoffset<<16) + (m11 + m21) / 2;
+    int m22ydy = dy + (m12 + m22) / 2;
+    uint trigx;
+    uint trigy;
+    uint maxws = sWidth<<12;
+    uint maxhs = sHeight<<12;
+
+    for (int y=0; y<dHeight; y++) {                // for each target scanline
+        trigx = m21ydx;
+        trigy = m22ydy;
+        uchar *maxp = dptr + dbpl;
+        if (depth != 1) {
+            switch (depth) {
+                case 8:                                // 8 bpp transform
+                while (dptr < maxp) {
+                    if (trigx < maxws && trigy < maxhs)
+                        *dptr = *(sptr+sbpl*(trigy>>12)+(trigx>>12));
+                    trigx += m11;
+                    trigy += m12;
+                    dptr++;
+                }
+                break;
+
+                case 16:                        // 16 bpp transform
+                while (dptr < maxp) {
+                    if (trigx < maxws && trigy < maxhs)
+                        *((ushort*)dptr) = *((ushort *)(sptr+sbpl*(trigy>>12) +
+                                                     ((trigx>>12)<<1)));
+                    trigx += m11;
+                    trigy += m12;
+                    dptr++;
+                    dptr++;
+                }
+                break;
+
+                case 24:                        // 24 bpp transform
+                while (dptr < maxp) {
+                    if (trigx < maxws && trigy < maxhs) {
+                        const uchar *p2 = sptr+sbpl*(trigy>>12) + ((trigx>>12)*3);
+                        dptr[0] = p2[0];
+                        dptr[1] = p2[1];
+                        dptr[2] = p2[2];
+                    }
+                    trigx += m11;
+                    trigy += m12;
+                    dptr += 3;
+                }
+                break;
+
+                case 32:                        // 32 bpp transform
+                while (dptr < maxp) {
+                    if (trigx < maxws && trigy < maxhs)
+                        *((uint*)dptr) = *((uint *)(sptr+sbpl*(trigy>>12) +
+                                                   ((trigx>>12)<<2)));
+                    trigx += m11;
+                    trigy += m12;
+                    dptr += 4;
+                }
+                break;
+
+                default: {
+                return false;
+                }
+            }
+        } else  {
+            switch (type) {
+                case QT_XFORM_TYPE_MSBFIRST:
+                    while (dptr < maxp) {
+                        IWX_MSB(128);
+                        IWX_MSB(64);
+                        IWX_MSB(32);
+                        IWX_MSB(16);
+                        IWX_MSB(8);
+                        IWX_MSB(4);
+                        IWX_MSB(2);
+                        IWX_MSB(1);
+                        dptr++;
+                    }
+                    break;
+                case QT_XFORM_TYPE_LSBFIRST:
+                    while (dptr < maxp) {
+                        IWX_LSB(1);
+                        IWX_LSB(2);
+                        IWX_LSB(4);
+                        IWX_LSB(8);
+                        IWX_LSB(16);
+                        IWX_LSB(32);
+                        IWX_LSB(64);
+                        IWX_LSB(128);
+                        dptr++;
+                    }
+                    break;
+#  if defined(Q_WS_WIN)
+                case QT_XFORM_TYPE_WINDOWSPIXMAP:
+                    while (dptr < maxp) {
+                        IWX_PIX(128);
+                        IWX_PIX(64);
+                        IWX_PIX(32);
+                        IWX_PIX(16);
+                        IWX_PIX(8);
+                        IWX_PIX(4);
+                        IWX_PIX(2);
+                        IWX_PIX(1);
+                        dptr++;
+                    }
+                    break;
+#  endif
+            }
+        }
+        m21ydx += m21;
+        m22ydy += m22;
+        dptr += p_inc;
+    }
+    return true;
+}
+#undef IWX_MSB
+#undef IWX_LSB
+#undef IWX_PIX
+
+/*!
+    \fn QImage QImage::xForm(const QMatrix &matrix) const
+
+    Use transformed() instead.
+
+    \oldcode
+        QImage image;
+        ...
+        image.xForm(matrix);
+    \newcode
+        QImage image;
+        ...
+        image.transformed(matrix);
+    \endcode
+*/
+
+/*! \obsolete
+    Returns a number that identifies the contents of this
+    QImage object. Distinct QImage objects can only have the same
+    serial number if they refer to the same contents (but they don't
+    have to).
+
+    Use cacheKey() instead.
+
+    \warning The serial number doesn't necessarily change when the
+    image is altered. This means that it may be dangerous to use
+    it as a cache key.
+
+    \sa operator==()
+*/
+
+int QImage::serialNumber() const
+{
+    if (!d)
+        return 0;
+    else
+        return d->ser_no;
+}
+
+/*!
+    Returns a number that identifies the contents of this QImage
+    object. Distinct QImage objects can only have the same key if they
+    refer to the same contents.
+
+    The key will change when the image is altered.
+*/
+qint64 QImage::cacheKey() const
+{
+    if (!d)
+        return 0;
+    else
+        return (((qint64) d->ser_no) << 32) | ((qint64) d->detach_no);
+}
+
+/*!
+    \internal
+
+    Returns true if the image is detached; otherwise returns false.
+
+    \sa detach(), {Implicit Data Sharing}
+*/
+
+bool QImage::isDetached() const
+{
+    return d && d->ref == 1;
+}
+
+
+/*!
+    \obsolete
+    Sets the alpha channel of this image to the given \a alphaChannel.
+
+    If \a alphaChannel is an 8 bit grayscale image, the intensity values are
+    written into this buffer directly. Otherwise, \a alphaChannel is converted
+    to 32 bit and the intensity of the RGB pixel values is used.
+
+    Note that the image will be converted to the Format_ARGB32_Premultiplied
+    format if the function succeeds.
+
+    Use one of the composition mods in QPainter::CompositionMode instead.
+
+    \sa alphaChannel(), {QImage#Image Transformations}{Image
+    Transformations}, {QImage#Image Formats}{Image Formats}
+*/
+
+void QImage::setAlphaChannel(const QImage &alphaChannel)
+{
+    if (!d)
+        return;
+
+    int w = d->width;
+    int h = d->height;
+
+    if (w != alphaChannel.d->width || h != alphaChannel.d->height) {
+        qWarning("QImage::setAlphaChannel: "
+                 "Alpha channel must have same dimensions as the target image");
+        return;
+    }
+
+    if (d->paintEngine && d->paintEngine->isActive()) {
+        qWarning("QImage::setAlphaChannel: "
+                 "Unable to set alpha channel while image is being painted on");
+        return;
+    }
+
+    detach();
+
+    *this = convertToFormat(QImage::Format_ARGB32_Premultiplied);
+
+    // Slight optimization since alphachannels are returned as 8-bit grays.
+    if (alphaChannel.d->depth == 8 && alphaChannel.isGrayscale()) {
+        const uchar *src_data = alphaChannel.d->data;
+        const uchar *dest_data = d->data;
+        for (int y=0; y<h; ++y) {
+            const uchar *src = src_data;
+            QRgb *dest = (QRgb *)dest_data;
+            for (int x=0; x<w; ++x) {
+                int alpha = *src;
+                int destAlpha = qt_div_255(alpha * qAlpha(*dest));
+                *dest = ((destAlpha << 24)
+                         | (qt_div_255(qRed(*dest) * alpha) << 16)
+                         | (qt_div_255(qGreen(*dest) * alpha) << 8)
+                         | (qt_div_255(qBlue(*dest) * alpha)));
+                ++dest;
+                ++src;
+            }
+            src_data += alphaChannel.d->bytes_per_line;
+            dest_data += d->bytes_per_line;
+        }
+
+    } else {
+        const QImage sourceImage = alphaChannel.convertToFormat(QImage::Format_RGB32);
+        const uchar *src_data = sourceImage.d->data;
+        const uchar *dest_data = d->data;
+        for (int y=0; y<h; ++y) {
+            const QRgb *src = (const QRgb *) src_data;
+            QRgb *dest = (QRgb *) dest_data;
+            for (int x=0; x<w; ++x) {
+                int alpha = qGray(*src);
+                int destAlpha = qt_div_255(alpha * qAlpha(*dest));
+                *dest = ((destAlpha << 24)
+                         | (qt_div_255(qRed(*dest) * alpha) << 16)
+                         | (qt_div_255(qGreen(*dest) * alpha) << 8)
+                         | (qt_div_255(qBlue(*dest) * alpha)));
+                ++dest;
+                ++src;
+            }
+            src_data += sourceImage.d->bytes_per_line;
+            dest_data += d->bytes_per_line;
+        }
+    }
+}
+
+
+/*!
+    Returns the alpha channel of the image as a new grayscale QImage in which
+    each pixel's red, green, and blue values are given the alpha value of the
+    original image. The color depth of the returned image is 8-bit.
+
+    You can see an example of use of this function in QPixmap's
+    \l{QPixmap::}{alphaChannel()}, which works in the same way as
+    this function on QPixmaps.
+
+    \sa setAlphaChannel(), hasAlphaChannel(),
+    {QPixmap#Pixmap Information}{Pixmap},
+    {QImage#Image Transformations}{Image Transformations}
+*/
+
+QImage QImage::alphaChannel() const
+{
+    if (!d)
+        return QImage();
+
+    int w = d->width;
+    int h = d->height;
+
+    QImage image(w, h, Format_Indexed8);
+    image.setNumColors(256);
+
+    // set up gray scale table.
+    for (int i=0; i<256; ++i)
+        image.setColor(i, qRgb(i, i, i));
+
+    if (!hasAlphaChannel()) {
+        image.fill(255);
+        return image;
+    }
+
+    if (d->format == Format_Indexed8) {
+        const uchar *src_data = d->data;
+        uchar *dest_data = image.d->data;
+        for (int y=0; y<h; ++y) {
+            const uchar *src = src_data;
+            uchar *dest = dest_data;
+            for (int x=0; x<w; ++x) {
+                *dest = qAlpha(d->colortable.at(*src));
+                ++dest;
+                ++src;
+            }
+            src_data += d->bytes_per_line;
+            dest_data += image.d->bytes_per_line;
+        }
+    } else {
+        QImage alpha32 = *this;
+        if (d->format != Format_ARGB32 && d->format != Format_ARGB32_Premultiplied)
+            alpha32 = convertToFormat(Format_ARGB32);
+
+        const uchar *src_data = alpha32.d->data;
+        uchar *dest_data = image.d->data;
+        for (int y=0; y<h; ++y) {
+            const QRgb *src = (const QRgb *) src_data;
+            uchar *dest = dest_data;
+            for (int x=0; x<w; ++x) {
+                *dest = qAlpha(*src);
+                ++dest;
+                ++src;
+            }
+            src_data += alpha32.d->bytes_per_line;
+            dest_data += image.d->bytes_per_line;
+        }
+    }
+
+    return image;
+}
+
+/*!
+    Returns true if the image has a format that respects the alpha
+    channel, otherwise returns false.
+
+    \sa alphaChannel(), {QImage#Image Information}{Image Information}
+*/
+bool QImage::hasAlphaChannel() const
+{
+    return d && (d->format == Format_ARGB32_Premultiplied
+                 || d->format == Format_ARGB32
+                 || d->format == Format_ARGB8565_Premultiplied
+                 || d->format == Format_ARGB8555_Premultiplied
+                 || d->format == Format_ARGB6666_Premultiplied
+                 || d->format == Format_ARGB4444_Premultiplied
+                 || (d->has_alpha_clut && (d->format == Format_Indexed8
+                                           || d->format == Format_Mono
+                                           || d->format == Format_MonoLSB)));
+}
+
+
+#ifdef QT3_SUPPORT
+#if defined(Q_WS_X11)
+QT_BEGIN_INCLUDE_NAMESPACE
+#include <private/qt_x11_p.h>
+QT_END_INCLUDE_NAMESPACE
+#endif
+
+QImage::Endian QImage::systemBitOrder()
+{
+#if defined(Q_WS_X11)
+    return BitmapBitOrder(X11->display) == MSBFirst ? BigEndian : LittleEndian;
+#else
+    return BigEndian;
+#endif
+}
+#endif
+
+/*!
+    \fn QImage QImage::copy(const QRect &rect, Qt::ImageConversionFlags flags) const
+    \compat
+
+    Use copy() instead.
+*/
+
+/*!
+    \fn QImage QImage::copy(int x, int y, int w, int h, Qt::ImageConversionFlags flags) const
+    \compat
+
+    Use copy() instead.
+*/
+
+/*!
+    \fn QImage QImage::scaleWidth(int w) const
+    \compat
+
+    Use scaledToWidth() instead.
+*/
+
+/*!
+    \fn QImage QImage::scaleHeight(int h) const
+    \compat
+
+    Use scaledToHeight() instead.
+*/
+
+static QImage smoothScaled(const QImage &source, int w, int h) {
+    QImage src = source;
+    if (src.format() == QImage::Format_ARGB32)
+        src = src.convertToFormat(QImage::Format_ARGB32_Premultiplied);
+    else if (src.depth() < 32) {
+        if (src.hasAlphaChannel())
+            src = src.convertToFormat(QImage::Format_ARGB32_Premultiplied);
+        else
+            src = src.convertToFormat(QImage::Format_RGB32);
+    }
+
+    return qSmoothScaleImage(src, w, h);
+}
+
+
+static QImage rotated90(const QImage &image) {
+    QImage out(image.height(), image.width(), image.format());
+    if (image.numColors() > 0)
+        out.setColorTable(image.colorTable());
+    int w = image.width();
+    int h = image.height();
+    switch (image.format()) {
+    case QImage::Format_RGB32:
+    case QImage::Format_ARGB32:
+    case QImage::Format_ARGB32_Premultiplied:
+        qt_memrotate270(reinterpret_cast<const quint32*>(image.bits()),
+                        w, h, image.bytesPerLine(),
+                        reinterpret_cast<quint32*>(out.bits()),
+                        out.bytesPerLine());
+        break;
+    case QImage::Format_RGB666:
+    case QImage::Format_ARGB6666_Premultiplied:
+    case QImage::Format_ARGB8565_Premultiplied:
+    case QImage::Format_ARGB8555_Premultiplied:
+    case QImage::Format_RGB888:
+        qt_memrotate270(reinterpret_cast<const quint24*>(image.bits()),
+                        w, h, image.bytesPerLine(),
+                        reinterpret_cast<quint24*>(out.bits()),
+                        out.bytesPerLine());
+        break;
+    case QImage::Format_RGB555:
+    case QImage::Format_RGB16:
+    case QImage::Format_ARGB4444_Premultiplied:
+        qt_memrotate270(reinterpret_cast<const quint16*>(image.bits()),
+                        w, h, image.bytesPerLine(),
+                        reinterpret_cast<quint16*>(out.bits()),
+                        out.bytesPerLine());
+        break;
+    case QImage::Format_Indexed8:
+        qt_memrotate270(reinterpret_cast<const quint8*>(image.bits()),
+                        w, h, image.bytesPerLine(),
+                        reinterpret_cast<quint8*>(out.bits()),
+                        out.bytesPerLine());
+        break;
+    default:
+        for (int y=0; y<h; ++y) {
+            if (image.numColors())
+                for (int x=0; x<w; ++x)
+                    out.setPixel(h-y-1, x, image.pixelIndex(x, y));
+            else
+                for (int x=0; x<w; ++x)
+                    out.setPixel(h-y-1, x, image.pixel(x, y));
+        }
+        break;
+    }
+    return out;
+}
+
+
+static QImage rotated180(const QImage &image) {
+    return image.mirrored(true, true);
+}
+
+
+static QImage rotated270(const QImage &image) {
+    QImage out(image.height(), image.width(), image.format());
+    if (image.numColors() > 0)
+        out.setColorTable(image.colorTable());
+    int w = image.width();
+    int h = image.height();
+    switch (image.format()) {
+    case QImage::Format_RGB32:
+    case QImage::Format_ARGB32:
+    case QImage::Format_ARGB32_Premultiplied:
+        qt_memrotate90(reinterpret_cast<const quint32*>(image.bits()),
+                       w, h, image.bytesPerLine(),
+                       reinterpret_cast<quint32*>(out.bits()),
+                       out.bytesPerLine());
+        break;
+    case QImage::Format_RGB666:
+    case QImage::Format_ARGB6666_Premultiplied:
+    case QImage::Format_ARGB8565_Premultiplied:
+    case QImage::Format_ARGB8555_Premultiplied:
+    case QImage::Format_RGB888:
+        qt_memrotate90(reinterpret_cast<const quint24*>(image.bits()),
+                       w, h, image.bytesPerLine(),
+                       reinterpret_cast<quint24*>(out.bits()),
+                       out.bytesPerLine());
+        break;
+    case QImage::Format_RGB555:
+    case QImage::Format_RGB16:
+    case QImage::Format_ARGB4444_Premultiplied:
+       qt_memrotate90(reinterpret_cast<const quint16*>(image.bits()),
+                       w, h, image.bytesPerLine(),
+                       reinterpret_cast<quint16*>(out.bits()),
+                       out.bytesPerLine());
+        break;
+    case QImage::Format_Indexed8:
+        qt_memrotate90(reinterpret_cast<const quint8*>(image.bits()),
+                       w, h, image.bytesPerLine(),
+                       reinterpret_cast<quint8*>(out.bits()),
+                       out.bytesPerLine());
+        break;
+    default:
+        for (int y=0; y<h; ++y) {
+            if (image.numColors())
+                for (int x=0; x<w; ++x)
+                    out.setPixel(y, w-x-1, image.pixelIndex(x, y));
+            else
+                for (int x=0; x<w; ++x)
+                    out.setPixel(y, w-x-1, image.pixel(x, y));
+        }
+        break;
+    }
+    return out;
+}
+
+/*!
+    Returns a copy of the image that is transformed using the given
+    transformation \a matrix and transformation \a mode.
+
+    The transformation \a matrix is internally adjusted to compensate
+    for unwanted translation; i.e. the image produced is the smallest
+    image that contains all the transformed points of the original
+    image. Use the trueMatrix() function to retrieve the actual matrix
+    used for transforming an image.
+
+    Unlike the other overload, this function can be used to perform perspective
+    transformations on images.
+
+    \sa trueMatrix(), {QImage#Image Transformations}{Image
+    Transformations}
+*/
+
+QImage QImage::transformed(const QTransform &matrix, Qt::TransformationMode mode ) const
+{
+    if (!d)
+        return QImage();
+
+    // source image data
+    int ws = width();
+    int hs = height();
+
+    // target image data
+    int wd;
+    int hd;
+
+    // compute size of target image
+    QTransform mat = trueMatrix(matrix, ws, hs);
+    bool complex_xform = false;
+    bool scale_xform = false;
+    if (mat.type() <= QTransform::TxScale) {
+        if (mat.type() == QTransform::TxNone) // identity matrix
+            return *this;
+        else if (mat.m11() == -1. && mat.m22() == -1.)
+            return rotated180(*this);
+
+        if (mode == Qt::FastTransformation) {
+            hd = qRound(qAbs(mat.m22()) * hs);
+            wd = qRound(qAbs(mat.m11()) * ws);
+        } else {
+            hd = int(qAbs(mat.m22()) * hs + 0.9999);
+            wd = int(qAbs(mat.m11()) * ws + 0.9999);
+        }
+        scale_xform = true;
+    } else {
+        if (mat.type() <= QTransform::TxRotate && mat.m11() == 0 && mat.m22() == 0) {
+            if (mat.m12() == 1. && mat.m21() == -1.)
+                return rotated90(*this);
+            else if (mat.m12() == -1. && mat.m21() == 1.)
+                return rotated270(*this);
+        }
+
+        QPolygonF a(QRectF(0, 0, ws, hs));
+        a = mat.map(a);
+        QRect r = a.boundingRect().toAlignedRect();
+        wd = r.width();
+        hd = r.height();
+        complex_xform = true;
+    }
+
+    if (wd == 0 || hd == 0)
+        return QImage();
+
+    // Make use of the optimized algorithm when we're scaling
+    if (scale_xform && mode == Qt::SmoothTransformation) {
+        if (mat.m11() < 0.0F && mat.m22() < 0.0F) { // horizontal/vertical flip
+            return smoothScaled(mirrored(true, true), wd, hd);
+        } else if (mat.m11() < 0.0F) { // horizontal flip
+            return smoothScaled(mirrored(true, false), wd, hd);
+        } else if (mat.m22() < 0.0F) { // vertical flip
+            return smoothScaled(mirrored(false, true), wd, hd);
+        } else { // no flipping
+            return smoothScaled(*this, wd, hd);
+        }
+    }
+
+    int bpp = depth();
+
+    int sbpl = bytesPerLine();
+    const uchar *sptr = bits();
+
+    QImage::Format target_format = d->format;
+
+    if (complex_xform || mode == Qt::SmoothTransformation) {
+        if (d->format < QImage::Format_RGB32 || !hasAlphaChannel()) {
+            switch(d->format) {
+            case QImage::Format_RGB16:
+                target_format = Format_ARGB8565_Premultiplied;
+                break;
+            case QImage::Format_RGB555:
+                target_format = Format_ARGB8555_Premultiplied;
+                break;
+            case QImage::Format_RGB666:
+                target_format = Format_ARGB6666_Premultiplied;
+                break;
+            case QImage::Format_RGB444:
+                target_format = Format_ARGB4444_Premultiplied;
+                break;
+            default:
+                target_format = Format_ARGB32_Premultiplied;
+                break;
+            }
+        }
+    }
+
+    QImage dImage(wd, hd, target_format);
+    QIMAGE_SANITYCHECK_MEMORY(dImage);
+
+    if (target_format == QImage::Format_MonoLSB
+        || target_format == QImage::Format_Mono
+        || target_format == QImage::Format_Indexed8) {
+        dImage.d->colortable = d->colortable;
+        dImage.d->has_alpha_clut = d->has_alpha_clut | complex_xform;
+    }
+
+    dImage.d->dpmx = dotsPerMeterX();
+    dImage.d->dpmy = dotsPerMeterY();
+
+    switch (bpp) {
+        // initizialize the data
+        case 8:
+            if (dImage.d->colortable.size() < 256) {
+                // colors are left in the color table, so pick that one as transparent
+                dImage.d->colortable.append(0x0);
+                memset(dImage.bits(), dImage.d->colortable.size() - 1, dImage.numBytes());
+            } else {
+                memset(dImage.bits(), 0, dImage.numBytes());
+            }
+            break;
+        case 1:
+        case 16:
+        case 24:
+        case 32:
+            memset(dImage.bits(), 0x00, dImage.numBytes());
+            break;
+    }
+
+    if (target_format >= QImage::Format_RGB32) {
+        QPainter p(&dImage);
+        if (mode == Qt::SmoothTransformation) {
+            p.setRenderHint(QPainter::Antialiasing);
+            p.setRenderHint(QPainter::SmoothPixmapTransform);
+        }
+        p.setTransform(mat);
+        p.drawImage(QPoint(0, 0), *this);
+    } else {
+        bool invertible;
+        mat = mat.inverted(&invertible);                // invert matrix
+        if (!invertible)        // error, return null image
+            return QImage();
+
+        // create target image (some of the code is from QImage::copy())
+        int type = format() == Format_Mono ? QT_XFORM_TYPE_MSBFIRST : QT_XFORM_TYPE_LSBFIRST;
+        int dbpl = dImage.bytesPerLine();
+        qt_xForm_helper(mat, 0, type, bpp, dImage.bits(), dbpl, 0, hd, sptr, sbpl, ws, hs);
+    }
+    return dImage;
+}
+
+/*!
+    \fn QTransform QImage::trueMatrix(const QTransform &matrix, int width, int height)
+
+    Returns the actual matrix used for transforming an image with the
+    given \a width, \a height and \a matrix.
+
+    When transforming an image using the transformed() function, the
+    transformation matrix is internally adjusted to compensate for
+    unwanted translation, i.e. transformed() returns the smallest
+    image containing all transformed points of the original image.
+    This function returns the modified matrix, which maps points
+    correctly from the original image into the new image.
+
+    Unlike the other overload, this function creates transformation
+    matrices that can be used to perform perspective
+    transformations on images.
+
+    \sa transformed(), {QImage#Image Transformations}{Image
+    Transformations}
+*/
+
+QTransform QImage::trueMatrix(const QTransform &matrix, int w, int h)
+{
+    const QRectF rect(0, 0, w, h);
+    const QRect mapped = matrix.mapRect(rect).toAlignedRect();
+    const QPoint delta = mapped.topLeft();
+    return matrix * QTransform().translate(-delta.x(), -delta.y());
+}
+
+
+/*!
+    \typedef QImage::DataPtr
+    \internal
+*/
+
+/*!
+    \fn DataPtr & QImage::data_ptr()
+    \internal
+*/
+
+QT_END_NAMESPACE
diff --git a/src/gui/image/qimage.h b/src/gui/image/qimage.h
new file mode 100644
index 0000000..08c8d7c
--- /dev/null
+++ b/src/gui/image/qimage.h
@@ -0,0 +1,352 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QIMAGE_H
+#define QIMAGE_H
+
+#include <QtGui/qtransform.h>
+#include <QtGui/qpaintdevice.h>
+#include <QtGui/qrgb.h>
+#include <QtCore/qbytearray.h>
+#include <QtCore/qrect.h>
+#include <QtCore/qstring.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+class QIODevice;
+class QStringList;
+class QMatrix;
+class QTransform;
+class QVariant;
+template <class T> class QList;
+template <class T> class QVector;
+
+struct QImageData;
+class QImageDataMisc; // internal
+#ifndef QT_NO_IMAGE_TEXT
+class Q_GUI_EXPORT QImageTextKeyLang {
+public:
+    QImageTextKeyLang(const char* k, const char* l) : key(k), lang(l) { }
+    QImageTextKeyLang() { }
+
+    QByteArray key;
+    QByteArray lang;
+
+    bool operator< (const QImageTextKeyLang& other) const
+        { return key < other.key || (key==other.key && lang < other.lang); }
+    bool operator== (const QImageTextKeyLang& other) const
+        { return key==other.key && lang==other.lang; }
+    inline bool operator!= (const QImageTextKeyLang &other) const
+        { return !operator==(other); }
+};
+#endif //QT_NO_IMAGE_TEXT
+
+
+class Q_GUI_EXPORT QImage : public QPaintDevice
+{
+public:
+    enum InvertMode { InvertRgb, InvertRgba };
+    enum Format {
+        Format_Invalid,
+        Format_Mono,
+        Format_MonoLSB,
+        Format_Indexed8,
+        Format_RGB32,
+        Format_ARGB32,
+        Format_ARGB32_Premultiplied,
+        Format_RGB16,
+        Format_ARGB8565_Premultiplied,
+        Format_RGB666,
+        Format_ARGB6666_Premultiplied,
+        Format_RGB555,
+        Format_ARGB8555_Premultiplied,
+        Format_RGB888,
+        Format_RGB444,
+        Format_ARGB4444_Premultiplied,
+#if 0
+        // reserved for future use
+        Format_RGB15,
+        Format_Grayscale16,
+        Format_Grayscale8,
+        Format_Grayscale4,
+        Format_Grayscale4LSB,
+        Format_Grayscale2,
+        Format_Grayscale2LSB
+#endif
+#ifndef qdoc
+        NImageFormats
+#endif
+    };
+
+    QImage();
+    QImage(const QSize &size, Format format);
+    QImage(int width, int height, Format format);
+    QImage(uchar *data, int width, int height, Format format);
+    QImage(const uchar *data, int width, int height, Format format);
+    QImage(uchar *data, int width, int height, int bytesPerLine, Format format);
+    QImage(const uchar *data, int width, int height, int bytesPerLine, Format format);
+
+#ifndef QT_NO_IMAGEFORMAT_XPM
+    explicit QImage(const char * const xpm[]);
+#endif
+    explicit QImage(const QString &fileName, const char *format = 0);
+#ifndef QT_NO_CAST_FROM_ASCII
+    explicit QImage(const char *fileName, const char *format = 0);
+#endif
+
+    QImage(const QImage &);
+    ~QImage();
+
+    QImage &operator=(const QImage &);
+    bool isNull() const;
+
+    int devType() const;
+
+    bool operator==(const QImage &) const;
+    bool operator!=(const QImage &) const;
+    operator QVariant() const;
+    void detach();
+    bool isDetached() const;
+
+    QImage copy(const QRect &rect = QRect()) const;
+    inline QImage copy(int x, int y, int w, int h) const
+        { return copy(QRect(x, y, w, h)); }
+
+    Format format() const;
+
+    QImage convertToFormat(Format f, Qt::ImageConversionFlags flags = Qt::AutoColor) const Q_REQUIRED_RESULT;
+    QImage convertToFormat(Format f, const QVector<QRgb> &colorTable, Qt::ImageConversionFlags flags = Qt::AutoColor) const Q_REQUIRED_RESULT;
+
+    int width() const;
+    int height() const;
+    QSize size() const;
+    QRect rect() const;
+
+    int depth() const;
+    int numColors() const;
+
+    QRgb color(int i) const;
+    void setColor(int i, QRgb c);
+    void setNumColors(int);
+
+    bool allGray() const;
+    bool isGrayscale() const;
+
+    uchar *bits();
+    const uchar *bits() const;
+    int numBytes() const;
+
+    uchar *scanLine(int);
+    const uchar *scanLine(int) const;
+    int bytesPerLine() const;
+
+    bool valid(int x, int y) const;
+    bool valid(const QPoint &pt) const;
+
+    int pixelIndex(int x, int y) const;
+    int pixelIndex(const QPoint &pt) const;
+
+    QRgb pixel(int x, int y) const;
+    QRgb pixel(const QPoint &pt) const;
+
+    void setPixel(int x, int y, uint index_or_rgb);
+    void setPixel(const QPoint &pt, uint index_or_rgb);
+
+    QVector<QRgb> colorTable() const;
+    void setColorTable(const QVector<QRgb> colors);
+
+    void fill(uint pixel);
+
+    bool hasAlphaChannel() const;
+    void setAlphaChannel(const QImage &alphaChannel);
+    QImage alphaChannel() const;
+    QImage createAlphaMask(Qt::ImageConversionFlags flags = Qt::AutoColor) const;
+#ifndef QT_NO_IMAGE_HEURISTIC_MASK
+    QImage createHeuristicMask(bool clipTight = true) const;
+#endif
+    QImage createMaskFromColor(QRgb color, Qt::MaskMode mode = Qt::MaskInColor) const;
+
+    inline QImage scaled(int w, int h, Qt::AspectRatioMode aspectMode = Qt::IgnoreAspectRatio,
+                        Qt::TransformationMode mode = Qt::FastTransformation) const
+        { return scaled(QSize(w, h), aspectMode, mode); }
+    QImage scaled(const QSize &s, Qt::AspectRatioMode aspectMode = Qt::IgnoreAspectRatio,
+                 Qt::TransformationMode mode = Qt::FastTransformation) const;
+    QImage scaledToWidth(int w, Qt::TransformationMode mode = Qt::FastTransformation) const;
+    QImage scaledToHeight(int h, Qt::TransformationMode mode = Qt::FastTransformation) const;
+    QImage transformed(const QMatrix &matrix, Qt::TransformationMode mode = Qt::FastTransformation) const;
+    static QMatrix trueMatrix(const QMatrix &, int w, int h);
+    QImage transformed(const QTransform &matrix, Qt::TransformationMode mode = Qt::FastTransformation) const;
+    static QTransform trueMatrix(const QTransform &, int w, int h);
+    QImage mirrored(bool horizontally = false, bool vertically = true) const;
+    QImage rgbSwapped() const;
+    void invertPixels(InvertMode = InvertRgb);
+
+
+    bool load(QIODevice *device, const char* format);
+    bool load(const QString &fileName, const char* format=0);
+    bool loadFromData(const uchar *buf, int len, const char *format = 0);
+    inline bool loadFromData(const QByteArray &data, const char* aformat=0)
+        { return loadFromData(reinterpret_cast<const uchar *>(data.constData()), data.size(), aformat); }
+
+    bool save(const QString &fileName, const char* format=0, int quality=-1) const;
+    bool save(QIODevice *device, const char* format=0, int quality=-1) const;
+
+    static QImage fromData(const uchar *data, int size, const char *format = 0);
+    inline static QImage fromData(const QByteArray &data, const char *format = 0)
+        { return fromData(reinterpret_cast<const uchar *>(data.constData()), data.size(), format); }
+
+    int serialNumber() const;
+    qint64 cacheKey() const;
+
+    QPaintEngine *paintEngine() const;
+
+    // Auxiliary data
+    int dotsPerMeterX() const;
+    int dotsPerMeterY() const;
+    void setDotsPerMeterX(int);
+    void setDotsPerMeterY(int);
+    QPoint offset() const;
+    void setOffset(const QPoint&);
+#ifndef QT_NO_IMAGE_TEXT
+    QStringList textKeys() const;
+    QString text(const QString &key = QString()) const;
+    void setText(const QString &key, const QString &value);
+
+    // The following functions are obsolete as of 4.1
+    QString text(const char* key, const char* lang=0) const;
+    QList<QImageTextKeyLang> textList() const;
+    QStringList textLanguages() const;
+    QString text(const QImageTextKeyLang&) const;
+    void setText(const char* key, const char* lang, const QString&);
+#endif
+
+#ifdef QT3_SUPPORT
+    enum Endian { BigEndian, LittleEndian, IgnoreEndian };
+    QT3_SUPPORT_CONSTRUCTOR QImage(int width, int height, int depth, int numColors=0, Endian bitOrder=IgnoreEndian);
+    QT3_SUPPORT_CONSTRUCTOR QImage(const QSize&, int depth, int numColors=0, Endian bitOrder=IgnoreEndian);
+    QT3_SUPPORT_CONSTRUCTOR QImage(uchar *data, int w, int h, int depth, const QRgb *colortable, int numColors, Endian bitOrder);
+#ifdef Q_WS_QWS
+    QT3_SUPPORT_CONSTRUCTOR QImage(uchar *data, int w, int h, int depth, int pbl, const QRgb *colortable, int numColors, Endian bitOrder);
+#endif
+    inline QT3_SUPPORT Endian bitOrder() const {
+        Format f = format();
+        return f == Format_Mono ? BigEndian : (f == Format_MonoLSB ? LittleEndian : IgnoreEndian);
+    }
+    QT3_SUPPORT QImage convertDepth(int, Qt::ImageConversionFlags flags = Qt::AutoColor) const;
+    QT3_SUPPORT QImage convertDepthWithPalette(int, QRgb* p, int pc, Qt::ImageConversionFlags flags = Qt::AutoColor) const;
+    QT3_SUPPORT QImage convertBitOrder(Endian) const;
+    QT3_SUPPORT bool hasAlphaBuffer() const;
+    QT3_SUPPORT void setAlphaBuffer(bool);
+    QT3_SUPPORT uchar **jumpTable();
+    QT3_SUPPORT const uchar * const *jumpTable() const;
+    inline QT3_SUPPORT void reset() { *this = QImage(); }
+    static inline QT3_SUPPORT Endian systemByteOrder()
+        { return QSysInfo::ByteOrder == QSysInfo::BigEndian ? BigEndian : LittleEndian; }
+    inline QT3_SUPPORT QImage swapRGB() const { return rgbSwapped(); }
+    inline QT3_SUPPORT QImage mirror(bool horizontally = false, bool vertically = true) const
+        { return mirrored(horizontally, vertically); }
+    QT3_SUPPORT bool create(const QSize&, int depth, int numColors=0, Endian bitOrder=IgnoreEndian);
+    QT3_SUPPORT bool create(int width, int height, int depth, int numColors=0, Endian bitOrder=IgnoreEndian);
+    inline QT3_SUPPORT QImage xForm(const QMatrix &matrix) const { return transformed(QTransform(matrix)); }
+    inline QT3_SUPPORT QImage smoothScale(int w, int h, Qt::AspectRatioMode mode = Qt::IgnoreAspectRatio) const
+        { return scaled(QSize(w, h), mode, Qt::SmoothTransformation); }
+    inline QImage QT3_SUPPORT smoothScale(const QSize &s, Qt::AspectRatioMode mode = Qt::IgnoreAspectRatio) const
+        { return scaled(s, mode, Qt::SmoothTransformation); }
+    inline QT3_SUPPORT QImage scaleWidth(int w) const { return scaledToWidth(w); }
+    inline QT3_SUPPORT QImage scaleHeight(int h) const { return scaledToHeight(h); }
+    inline QT3_SUPPORT void invertPixels(bool invertAlpha) { invertAlpha ? invertPixels(InvertRgba) : invertPixels(InvertRgb); }
+    inline QT3_SUPPORT QImage copy(int x, int y, int w, int h, Qt::ImageConversionFlags) const
+        { return copy(QRect(x, y, w, h)); }
+    inline QT3_SUPPORT QImage copy(const QRect &rect, Qt::ImageConversionFlags) const
+        { return copy(rect); }
+    static QT3_SUPPORT Endian systemBitOrder();
+    inline QT3_SUPPORT_CONSTRUCTOR QImage(const QByteArray &data)
+        { d = 0; *this = QImage::fromData(data); }
+#endif
+
+protected:
+    virtual int metric(PaintDeviceMetric metric) const;
+
+private:
+    friend class QWSOnScreenSurface;
+    QImageData *d;
+
+    friend class QRasterPixmapData;
+    friend class QDetachedPixmap;
+    friend Q_GUI_EXPORT qint64 qt_image_id(const QImage &image);
+    friend const QVector<QRgb> *qt_image_colortable(const QImage &image);
+
+public:
+    typedef QImageData * DataPtr;
+    inline DataPtr &data_ptr() { return d; }
+};
+
+Q_DECLARE_SHARED(QImage)
+Q_DECLARE_TYPEINFO(QImage, Q_MOVABLE_TYPE);
+
+// Inline functions...
+
+Q_GUI_EXPORT_INLINE bool QImage::valid(const QPoint &pt) const { return valid(pt.x(), pt.y()); }
+Q_GUI_EXPORT_INLINE int QImage::pixelIndex(const QPoint &pt) const { return pixelIndex(pt.x(), pt.y());}
+Q_GUI_EXPORT_INLINE QRgb QImage::pixel(const QPoint &pt) const { return pixel(pt.x(), pt.y()); }
+Q_GUI_EXPORT_INLINE void QImage::setPixel(const QPoint &pt, uint index_or_rgb) { setPixel(pt.x(), pt.y(), index_or_rgb); }
+
+// QImage stream functions
+
+#if !defined(QT_NO_DATASTREAM)
+Q_GUI_EXPORT QDataStream &operator<<(QDataStream &, const QImage &);
+Q_GUI_EXPORT QDataStream &operator>>(QDataStream &, QImage &);
+#endif
+
+#ifdef QT3_SUPPORT
+Q_GUI_EXPORT QT3_SUPPORT void bitBlt(QImage* dst, int dx, int dy, const QImage* src,
+                                     int sx=0, int sy=0, int sw=-1, int sh=-1, Qt::ImageConversionFlags flags = Qt::AutoColor);
+#endif
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QIMAGE_H
diff --git a/src/gui/image/qimage_p.h b/src/gui/image/qimage_p.h
new file mode 100644
index 0000000..9b47c5c
--- /dev/null
+++ b/src/gui/image/qimage_p.h
@@ -0,0 +1,110 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QIMAGE_P_H
+#define QIMAGE_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 <QtCore/qglobal.h>
+
+#include <QVector>
+
+#ifndef QT_NO_IMAGE_TEXT
+#include <QMap>
+#endif
+
+QT_BEGIN_NAMESPACE
+
+struct QImageData {        // internal image data
+    QImageData();
+    ~QImageData();
+    static QImageData *create(const QSize &size, QImage::Format format, int numColors = 0);
+    static QImageData *create(uchar *data, int w, int h,  int bpl, QImage::Format format, bool readOnly);
+
+    QAtomicInt ref;
+
+    int width;
+    int height;
+    int depth;
+    int nbytes;               // number of bytes data
+    QVector<QRgb> colortable;
+    uchar *data;
+#ifdef QT3_SUPPORT
+    uchar **jumptable;
+#endif
+    QImage::Format format;
+    int bytes_per_line;
+    int ser_no;               // serial number
+    int detach_no;
+
+    qreal  dpmx;                // dots per meter X (or 0)
+    qreal  dpmy;                // dots per meter Y (or 0)
+    QPoint  offset;           // offset in pixels
+
+    uint own_data : 1;
+    uint ro_data : 1;
+    uint has_alpha_clut : 1;
+    uint is_cached : 1;
+
+    bool checkForAlphaPixels() const;
+
+
+#ifndef QT_NO_IMAGE_TEXT
+    QMap<QString, QString> text;
+#endif
+    bool doImageIO(const QImage *image, QImageWriter* io, int quality) const;
+
+    QPaintEngine *paintEngine;
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/gui/image/qimageiohandler.cpp b/src/gui/image/qimageiohandler.cpp
new file mode 100644
index 0000000..a47c69e
--- /dev/null
+++ b/src/gui/image/qimageiohandler.cpp
@@ -0,0 +1,571 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \class QImageIOHandler
+    \brief The QImageIOHandler class defines the common image I/O
+    interface for all image formats in Qt.
+    \reentrant
+
+    Qt uses QImageIOHandler for reading and writing images through
+    QImageReader and QImageWriter. You can also derive from this class
+    to write your own image format handler using Qt's plugin mechanism.
+
+    Call setDevice() to assign a device to the handler, and
+    setFormat() to assign a format to it. One QImageIOHandler may
+    support more than one image format. canRead() returns true if an
+    image can be read from the device, and read() and write() return
+    true if reading or writing an image was completed successfully.
+
+    QImageIOHandler also has support for animations formats, through
+    the functions loopCount(), imageCount(), nextImageDelay() and
+    currentImageNumber().
+
+    In order to determine what options an image handler supports, Qt
+    will call supportsOption() and setOption(). Make sure to
+    reimplement these functions if you can provide support for any of
+    the options in the ImageOption enum.
+
+    To write your own image handler, you must at least reimplement
+    canRead() and read(). Then create a QImageIOPlugin that
+    can create the handler. Finally, install your plugin, and
+    QImageReader and QImageWriter will then automatically load the
+    plugin, and start using it.
+
+    \sa QImageIOPlugin, QImageReader, QImageWriter
+*/
+
+/*! \enum QImageIOHandler::ImageOption
+
+    This enum describes the different options supported by
+    QImageIOHandler.  Some options are used to query an image for
+    properties, and others are used to toggle the way in which an
+    image should be written.
+
+    \value Size The original size of an image. A handler that supports
+    this option is expected to read the size of the image from the
+    image metadata, and return this size from option() as a QSize.
+
+    \value ClipRect The clip rect, or ROI (Region Of Interest). A
+    handler that supports this option is expected to only read the
+    provided QRect area from the original image in read(), before any
+    other transformation is applied.
+
+    \value ScaledSize The scaled size of the image. A handler that
+    supports this option is expected to scale the image to the
+    provided size (a QSize), after applying any clip rect
+    transformation (ClipRect). If the handler does not support this
+    option, QImageReader will perform the scaling after the image has
+    been read.
+
+    \value ScaledClipRect The scaled clip rect (or ROI, Region Of
+    Interest) of the image. A handler that supports this option is
+    expected to apply the provided clip rect (a QRect), after applying
+    any scaling (ScaleSize) or regular clipping (ClipRect). If the
+    handler does not support this option, QImageReader will apply the
+    scaled clip rect after the image has been read.
+
+    \value Description The image description. Some image formats,
+    such as GIF and PNG, allow embedding of text
+    or comments into the image data (e.g., for storing copyright
+    information). It's common that the text is stored in key-value
+    pairs, but some formats store all text in one continuous block.
+    QImageIOHandler returns the text as one
+    QString, where keys and values are separated by a ':', and
+    keys-value pairs are separated by two newlines (\\n\\n). For example,
+    "Title: Sunset\\n\\nAuthor: Jim Smith\\nSarah Jones\\n\\n". Formats that
+    store text in a single block can use "Description" as the key.
+
+    \value CompressionRatio The compression ratio of the image data. A
+    handler that supports this option is expected to set its
+    compression rate depending on the value of this option (an int)
+    when writing.
+
+    \value Gamma The gamma level of the image. A handler that supports
+    this option is expected to set the image gamma level depending on
+    the value of this option (a float) when writing.
+
+    \value Quality The quality level of the image. A handler that
+    supports this option is expected to set the image quality level
+    depending on the value of this option (an int) when writing.
+
+    \value Name The name of the image. A handler that supports this
+    option is expected to read the name from the image metadata and
+    return this as a QString, or when writing an image it is expected
+    to store the name in the image metadata.
+
+    \value SubType The subtype of the image. A handler that supports
+    this option can use the subtype value to help when reading and
+    writing images. For example, a PPM handler may have a subtype
+    value of "ppm" or "ppmraw".
+
+    \value IncrementalReading A handler that supports this option is
+    expected to read the image in several passes, as if it was an
+    animation. QImageReader will treat the image as an animation.
+
+    \value Endianness The endianness of the image. Certain image
+    formats can be stored as BigEndian or LittleEndian. A handler that
+    supports Endianness uses the value of this option to determine how
+    the image should be stored.
+
+    \value Animation Image formats that support animation return
+    true for this value in supportsOption(); otherwise, false is returned.
+
+    \value BackgroundColor Certain image formats allow the
+    background color to be specified. A handler that supports
+    BackgroundColor initializes the background color to this option
+    (a QColor) when reading an image.
+
+    \value ImageFormat The image's data format returned by the handler.
+    This can be any of the formats listed in QImage::Format.
+*/
+
+/*!
+    \class QImageIOPlugin
+    \brief The QImageIOPlugin class defines an interface for writing
+    an image format plugin.
+    \reentrant
+
+    \ingroup plugins
+
+    QImageIOPlugin is a factory for creating QImageIOHandler objects,
+    which are used internally by QImageReader and QImageWriter to add
+    support for different image formats to Qt.
+
+    Writing an image I/O plugin is achieved by subclassing this
+    base class, reimplementing the pure virtual functions capabilities(),
+    create(), and keys(), and exporting the class with the
+    Q_EXPORT_PLUGIN2() macro. See \l{How to Create Qt Plugins} for details.
+
+    An image format plugin can support three capabilities: reading (\l
+    CanRead), writing (\l CanWrite) and \e incremental reading (\l
+    CanReadIncremental). Reimplement capabilities() in you subclass to
+    expose the capabilities of your image format.
+
+    create() should create an instance of your QImageIOHandler
+    subclass, with the provided device and format properly set, and
+    return this handler. You must also reimplement keys() so that Qt
+    knows which image formats your plugin supports.
+
+    Different plugins can support different capabilities. For example,
+    you may have one plugin that supports reading the GIF format, and
+    another that supports writing. Qt will select the correct plugin
+    for the job, depending on the return value of capabilities(). If
+    several plugins support the same capability, Qt will select one
+    arbitrarily.
+
+    \sa QImageIOHandler, {How to Create Qt Plugins}
+*/
+
+/*!
+    \enum QImageIOPlugin::Capability
+
+    This enum describes the capabilities of a QImageIOPlugin.
+
+    \value CanRead The plugin can read images.
+    \value CanWrite The plugin can write images.
+    \value CanReadIncremental The plugin can read images incrementally.
+*/
+
+/*!
+    \class QImageIOHandlerFactoryInterface
+    \brief The QImageIOHandlerFactoryInterface class provides the factory
+    interface for QImageIOPlugin.
+    \reentrant
+
+    \internal
+
+    \sa QImageIOPlugin
+*/
+
+#include "qimageiohandler.h"
+
+#include <qbytearray.h>
+#include <qimage.h>
+#include <qvariant.h>
+
+QT_BEGIN_NAMESPACE
+
+class QIODevice;
+
+class QImageIOHandlerPrivate
+{
+    Q_DECLARE_PUBLIC(QImageIOHandler)
+public:
+    QImageIOHandlerPrivate(QImageIOHandler *q);
+    virtual ~QImageIOHandlerPrivate();
+
+    QIODevice *device;
+    mutable QByteArray format;
+
+    QImageIOHandler *q_ptr;
+};
+
+QImageIOHandlerPrivate::QImageIOHandlerPrivate(QImageIOHandler *q)
+{
+    device = 0;
+    q_ptr = q;
+}
+
+QImageIOHandlerPrivate::~QImageIOHandlerPrivate()
+{
+}
+
+/*!
+    Constructs a QImageIOHandler object.
+*/
+QImageIOHandler::QImageIOHandler()
+    : d_ptr(new QImageIOHandlerPrivate(this))
+{
+}
+
+/*! \internal
+
+    Constructs a QImageIOHandler object, using the private member \a
+    dd.
+*/
+QImageIOHandler::QImageIOHandler(QImageIOHandlerPrivate &dd)
+    : d_ptr(&dd)
+{
+}
+
+/*!
+    Destructs the QImageIOHandler object.
+*/
+QImageIOHandler::~QImageIOHandler()
+{
+    delete d_ptr;
+}
+
+/*!
+    Sets the device of the QImageIOHandler to \a device. The image
+    handler will use this device when reading and writing images.
+
+    The device can only be set once and must be set before calling
+    canRead(), read(), write(), etc. If you need to read multiple
+    files, construct multiple instances of the appropriate
+    QImageIOHandler subclass.
+
+    \sa device()
+*/
+void QImageIOHandler::setDevice(QIODevice *device)
+{
+    Q_D(QImageIOHandler);
+    d->device = device;
+}
+
+/*!
+    Returns the device currently assigned to the QImageIOHandler. If
+    not device has been assigned, 0 is returned.
+*/
+QIODevice *QImageIOHandler::device() const
+{
+    Q_D(const QImageIOHandler);
+    return d->device;
+}
+
+/*!
+    Sets the format of the QImageIOHandler to \a format. The format is
+    most useful for handlers that support multiple image formats.
+
+    \sa format()
+*/
+void QImageIOHandler::setFormat(const QByteArray &format)
+{
+    Q_D(QImageIOHandler);
+    d->format = format;
+}
+
+/*!
+    Sets the format of the QImageIOHandler to \a format. The format is
+    most useful for handlers that support multiple image formats.
+
+    This function is declared const so that it can be called from canRead().
+
+    \sa format()
+*/
+void QImageIOHandler::setFormat(const QByteArray &format) const
+{
+    Q_D(const QImageIOHandler);
+    d->format = format;
+}
+
+/*!
+    Returns the format that is currently assigned to
+    QImageIOHandler. If no format has been assigned, an empty string
+    is returned.
+
+    \sa setFormat()
+*/
+QByteArray QImageIOHandler::format() const
+{
+    Q_D(const QImageIOHandler);
+    return d->format;
+}
+
+/*!
+    \fn bool QImageIOHandler::read(QImage *image)
+
+    Read an image from the device, and stores it in \a image.
+    Returns true if the image is successfully read; otherwise returns
+    false.
+
+    For image formats that support incremental loading, and for animation
+    formats, the image handler can assume that \a image points to the
+    previous frame.
+
+    \sa canRead()
+*/
+
+/*!
+    \fn bool QImageIOHandler::canRead() const
+
+    Returns true if an image can be read from the device (i.e., the
+    image format is supported, the device can be read from and the
+    initial header information suggests that the image can be read);
+    otherwise returns false.
+
+    When reimplementing canRead(), make sure that the I/O device
+    (device()) is left in its original state (e.g., by using peek()
+    rather than read()).
+
+    \sa read(), QIODevice::peek()
+*/
+
+/*!
+    \obsolete
+
+    Use format() instead.
+*/
+
+QByteArray QImageIOHandler::name() const
+{
+    return format();
+}
+
+/*!
+    Writes the image \a image to the assigned device. Returns true on
+    success; otherwise returns false.
+
+    The default implementation does nothing, and simply returns false.
+*/
+bool QImageIOHandler::write(const QImage &image)
+{
+    Q_UNUSED(image);
+    return false;
+}
+
+/*!
+    Sets the option \a option with the value \a value.
+
+    \sa option(), ImageOption
+*/
+void QImageIOHandler::setOption(ImageOption option, const QVariant &value)
+{
+    Q_UNUSED(option);
+    Q_UNUSED(value);
+}
+
+/*!
+    Returns the value assigned to \a option as a QVariant. The type of
+    the value depends on the option. For example, option(Size) returns
+    a QSize variant.
+
+    \sa setOption(), supportsOption()
+*/
+QVariant QImageIOHandler::option(ImageOption option) const
+{
+    Q_UNUSED(option);
+    return QVariant();
+}
+
+/*!
+    Returns true if the QImageIOHandler supports the option \a option;
+    otherwise returns false. For example, if the QImageIOHandler
+    supports the \l Size option, supportsOption(Size) must return
+    true.
+
+    \sa setOption(), option()
+*/
+bool QImageIOHandler::supportsOption(ImageOption option) const
+{
+    Q_UNUSED(option);
+    return false;
+}
+
+/*!
+    For image formats that support animation, this function returns
+    the sequence number of the current image in the animation. If
+    this function is called before any image is read(), -1 is
+    returned. The number of the first image in the sequence is 0.
+    
+    If the image format does not support animation, 0 is returned.
+
+    \sa read()
+*/
+int QImageIOHandler::currentImageNumber() const
+{
+    return 0;
+}
+
+/*!
+    Returns the rect of the current image. If no rect is defined for the
+    image, and empty QRect() is returned.
+
+    This function is useful for animations, where only parts of the frame
+    may be updated at a time.
+*/
+QRect QImageIOHandler::currentImageRect() const
+{
+    return QRect();
+}
+
+/*!
+    For image formats that support animation, this function returns
+    the number of images in the animation. If the image format does
+    not support animation, or if it is unable to determine the number
+    of images, 0 is returned.
+
+    The default implementation returns 1 if canRead() returns true;
+    otherwise 0 is returned.
+*/
+int QImageIOHandler::imageCount() const
+{
+    return canRead() ? 1 : 0;
+}
+
+/*!
+   For image formats that support animation, this function jumps to the
+   next image.
+
+   The default implementation does nothing, and returns false.
+*/
+bool QImageIOHandler::jumpToNextImage()
+{
+    return false;
+}
+
+/*!
+   For image formats that support animation, this function jumps to the image
+   whose sequence number is \a imageNumber. The next call to read() will
+   attempt to read this image.
+
+   The default implementation does nothing, and returns false.
+*/
+bool QImageIOHandler::jumpToImage(int imageNumber)
+{
+    Q_UNUSED(imageNumber);
+    return false;
+}
+
+/*!
+    For image formats that support animation, this function returns
+    the number of times the animation should loop. If the image format
+    does not support animation, 0 is returned.
+*/
+int QImageIOHandler::loopCount() const
+{
+    return 0;
+}
+
+/*!
+    For image formats that support animation, this function returns
+    the number of milliseconds to wait until reading the next
+    image. If the image format does not support animation, 0 is
+    returned.
+*/
+int QImageIOHandler::nextImageDelay() const
+{
+    return 0;
+}
+
+/*!
+    Constructs an image plugin with the given \a parent. This is
+    invoked automatically by the Q_EXPORT_PLUGIN2() macro.
+*/
+QImageIOPlugin::QImageIOPlugin(QObject *parent)
+    : QObject(parent)
+{
+}
+
+/*!
+    Destroys the picture format plugin.
+
+    You never have to call this explicitly. Qt destroys a plugin
+    automatically when it is no longer used.
+*/
+QImageIOPlugin::~QImageIOPlugin()
+{
+}
+
+/*! \fn QImageIOPlugin::capabilities(QIODevice *device, const QByteArray &format) const
+
+    Returns the capabilities on the plugin, based on the data in \a
+    device and the format \a format. For example, if the
+    QImageIOHandler supports the BMP format, and the data in the
+    device starts with the characters "BM", this function should
+    return \l CanRead. If \a format is "bmp" and the handler supports
+    both reading and writing, this function should return \l CanRead |
+    \l CanWrite.
+*/
+
+/*!
+    \fn QImageIOPlugin::keys() const
+
+    Returns the list of image keys this plugin supports.
+
+    These keys are usually the names of the image formats that are implemented
+    in the plugin (e.g., "jpg" or "gif").
+
+    \sa capabilities()
+*/
+
+/*!
+    \fn QImageIOHandler *QImageIOPlugin::create(QIODevice *device, const QByteArray &format) const
+
+    Creates and returns a QImageIOHandler subclass, with \a device
+    and \a format set. The \a format must come from the list returned by keys().
+    Format names are case sensitive.
+
+    \sa keys()
+*/
+
+QT_END_NAMESPACE
diff --git a/src/gui/image/qimageiohandler.h b/src/gui/image/qimageiohandler.h
new file mode 100644
index 0000000..3b654f3
--- /dev/null
+++ b/src/gui/image/qimageiohandler.h
@@ -0,0 +1,151 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QIMAGEIOHANDLER_H
+#define QIMAGEIOHANDLER_H
+
+#include <QtCore/qplugin.h>
+#include <QtCore/qfactoryinterface.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+class QImage;
+class QRect;
+class QSize;
+class QVariant;
+
+class QImageIOHandlerPrivate;
+class Q_GUI_EXPORT QImageIOHandler
+{
+    Q_DECLARE_PRIVATE(QImageIOHandler)
+public:
+    QImageIOHandler();
+    virtual ~QImageIOHandler();
+
+    void setDevice(QIODevice *device);
+    QIODevice *device() const;
+
+    void setFormat(const QByteArray &format);
+    void setFormat(const QByteArray &format) const;
+    QByteArray format() const;
+
+    virtual QByteArray name() const;
+
+    virtual bool canRead() const = 0;
+    virtual bool read(QImage *image) = 0;
+    virtual bool write(const QImage &image);
+
+    enum ImageOption {
+        Size,
+        ClipRect,
+        Description,
+        ScaledClipRect,
+        ScaledSize,
+        CompressionRatio,
+        Gamma,
+        Quality,
+        Name,
+        SubType,
+        IncrementalReading,
+        Endianness,
+        Animation,
+        BackgroundColor,
+        ImageFormat
+    };
+    virtual QVariant option(ImageOption option) const;
+    virtual void setOption(ImageOption option, const QVariant &value);
+    virtual bool supportsOption(ImageOption option) const;
+
+    // incremental loading
+    virtual bool jumpToNextImage();
+    virtual bool jumpToImage(int imageNumber);
+    virtual int loopCount() const;
+    virtual int imageCount() const;
+    virtual int nextImageDelay() const;
+    virtual int currentImageNumber() const;
+    virtual QRect currentImageRect() const;
+
+protected:
+    QImageIOHandler(QImageIOHandlerPrivate &dd);
+    QImageIOHandlerPrivate *d_ptr;
+private:
+    Q_DISABLE_COPY(QImageIOHandler)
+};
+
+struct Q_GUI_EXPORT QImageIOHandlerFactoryInterface : public QFactoryInterface
+{
+    virtual QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const = 0;
+};
+
+#define QImageIOHandlerFactoryInterface_iid "com.trolltech.Qt.QImageIOHandlerFactoryInterface"
+Q_DECLARE_INTERFACE(QImageIOHandlerFactoryInterface, QImageIOHandlerFactoryInterface_iid)
+
+class Q_GUI_EXPORT QImageIOPlugin : public QObject, public QImageIOHandlerFactoryInterface
+{
+    Q_OBJECT
+    Q_INTERFACES(QImageIOHandlerFactoryInterface:QFactoryInterface)
+public:
+    explicit QImageIOPlugin(QObject *parent = 0);
+    virtual ~QImageIOPlugin();
+
+    enum Capability {
+        CanRead = 0x1,
+        CanWrite = 0x2,
+        CanReadIncremental = 0x4
+    };
+    Q_DECLARE_FLAGS(Capabilities, Capability)
+
+    virtual Capabilities capabilities(QIODevice *device, const QByteArray &format) const = 0;
+    virtual QStringList keys() const = 0;
+    virtual QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const = 0;
+};
+
+Q_DECLARE_OPERATORS_FOR_FLAGS(QImageIOPlugin::Capabilities)
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QIMAGEIOHANDLER_H
diff --git a/src/gui/image/qimagereader.cpp b/src/gui/image/qimagereader.cpp
new file mode 100644
index 0000000..5de39d9
--- /dev/null
+++ b/src/gui/image/qimagereader.cpp
@@ -0,0 +1,1376 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+//#define QIMAGEREADER_DEBUG
+
+/*!
+    \class QImageReader
+    \brief The QImageReader class provides a format independent interface
+    for reading images from files or other devices.
+
+    \reentrant
+    \ingroup multimedia
+    \ingroup io
+
+    The most common way to read images is through QImage and QPixmap's
+    constructors, or by calling QImage::load() and
+    QPixmap::load(). QImageReader is a specialized class which gives
+    you more control when reading images. For example, you can read an
+    image into a specific size by calling setScaledSize(), and you can
+    select a clip rect, effectively loading only parts of an image, by
+    calling setClipRect(). Depending on the underlying support in the
+    image format, this can save memory and speed up loading of images.
+
+    To read an image, you start by constructing a QImageReader object.
+    Pass either a file name or a device pointer, and the image format
+    to QImageReader's constructor. You can then set several options,
+    such as the clip rect (by calling setClipRect()) and scaled size
+    (by calling setScaledSize()). canRead() returns the image if the
+    QImageReader can read the image (i.e., the image format is
+    supported and the device is open for reading). Call read() to read
+    the image.
+
+    If any error occurs when reading the image, read() will return a
+    null QImage. You can then call error() to find the type of error
+    that occurred, or errorString() to get a human readable
+    description of what went wrong.
+
+    Call supportedImageFormats() for a list of formats that
+    QImageReader can read. QImageReader supports all built-in image
+    formats, in addition to any image format plugins that support
+    reading.
+
+    QImageReader autodetects the image format by default, by looking at the
+    provided (optional) format string, the file name suffix, and the data
+    stream contents. You can enable or disable this feature, by calling
+    setAutoDetectImageFormat().
+
+    \sa QImageWriter, QImageIOHandler, QImageIOPlugin
+*/
+
+/*!
+    \enum QImageReader::ImageReaderError
+
+    This enum describes the different types of errors that can occur
+    when reading images with QImageReader.
+
+    \value FileNotFoundError QImageReader was used with a file name,
+    but not file was found with that name. This can also happen if the
+    file name contained no extension, and the file with the correct
+    extension is not supported by Qt.
+
+    \value DeviceError QImageReader encountered a device error when
+    reading the image. You can consult your particular device for more
+    details on what went wrong.
+
+    \value UnsupportedFormatError Qt does not support the requested
+    image format.
+
+    \value InvalidDataError The image data was invalid, and
+    QImageReader was unable to read an image from it. The can happen
+    if the image file is damaged.
+
+    \value UnknownError An unknown error occurred. If you get this
+    value after calling read(), it is most likely caused by a bug in
+    QImageReader.
+*/
+#include "qimagereader.h"
+
+#include <qbytearray.h>
+#ifdef QIMAGEREADER_DEBUG
+#include <qdebug.h>
+#endif
+#include <qfile.h>
+#include <qfileinfo.h>
+#include <qimage.h>
+#include <qimageiohandler.h>
+#include <qlist.h>
+#include <qrect.h>
+#include <qset.h>
+#include <qsize.h>
+#include <qcolor.h>
+#include <qvariant.h>
+
+// factory loader
+#include <qcoreapplication.h>
+#include <private/qfactoryloader_p.h>
+
+// image handlers
+#include <private/qbmphandler_p.h>
+#include <private/qppmhandler_p.h>
+#include <private/qxbmhandler_p.h>
+#include <private/qxpmhandler_p.h>
+#ifndef QT_NO_IMAGEFORMAT_PNG
+#include <private/qpnghandler_p.h>
+#endif
+
+QT_BEGIN_NAMESPACE
+
+#if !defined (QT_NO_LIBRARY) && !defined(QT_NO_SETTINGS)
+Q_GLOBAL_STATIC_WITH_ARGS(QFactoryLoader, loader,
+                          (QImageIOHandlerFactoryInterface_iid, QLatin1String("/imageformats")))
+#endif
+
+enum _qt_BuiltInFormatType {
+#ifndef QT_NO_IMAGEFORMAT_PNG
+    _qt_PngFormat,
+#endif
+    _qt_BmpFormat,
+#ifndef QT_NO_IMAGEFORMAT_PPM
+    _qt_PpmFormat,
+    _qt_PgmFormat,
+    _qt_PbmFormat,
+#endif
+#ifndef QT_NO_IMAGEFORMAT_XBM
+    _qt_XbmFormat,
+#endif
+#ifndef QT_NO_IMAGEFORMAT_XPM
+    _qt_XpmFormat,
+#endif
+    _qt_NumFormats,
+    _qt_NoFormat = -1
+};
+
+struct _qt_BuiltInFormatStruct
+{
+    _qt_BuiltInFormatType type;
+    const char *extension;
+};
+
+static const _qt_BuiltInFormatStruct _qt_BuiltInFormats[] = {
+#ifndef QT_NO_IMAGEFORMAT_PNG
+    {_qt_PngFormat, "png"},
+#endif
+    {_qt_BmpFormat, "bmp"},
+#ifndef QT_NO_IMAGEFORMAT_PPM
+    {_qt_PpmFormat, "ppm"},
+    {_qt_PgmFormat, "pgm"},
+    {_qt_PbmFormat, "pbm"},
+#endif
+#ifndef QT_NO_IMAGEFORMAT_XBM
+    {_qt_XbmFormat, "xbm"},
+#endif
+#ifndef QT_NO_IMAGEFORMAT_XPM
+    {_qt_XpmFormat, "xpm"},
+#endif
+    {_qt_NoFormat, ""}
+};
+
+static QImageIOHandler *createReadHandlerHelper(QIODevice *device,
+                                                const QByteArray &format, bool autoDetectImageFormat)
+{
+    if (!autoDetectImageFormat && format.isEmpty())
+        return 0;
+
+    QByteArray form = format.toLower();
+    QImageIOHandler *handler = 0;
+
+#if !defined (QT_NO_LIBRARY) && !defined(QT_NO_SETTINGS)
+    // check if we have plugins that support the image format
+    QFactoryLoader *l = loader();
+    QStringList keys = l->keys();
+#endif
+    QByteArray suffix;
+
+#ifdef QIMAGEREADER_DEBUG
+    qDebug() << "QImageReader::createReadHandler( device =" << (void *)device << ", format =" << format << "),"
+             << keys.size() << "plugins available: " << keys;
+#endif
+
+#if !defined (QT_NO_LIBRARY) && !defined(QT_NO_SETTINGS)
+    int suffixPluginIndex = -1;
+    if (device && format.isEmpty() && autoDetectImageFormat) {
+        // if there's no format, see if \a device is a file, and if so, find
+        // the file suffix and find support for that format among our plugins.
+        // this allows plugins to override our built-in handlers.
+        if (QFile *file = qobject_cast<QFile *>(device)) {
+#ifdef QIMAGEREADER_DEBUG
+            qDebug() << "QImageReader::createReadHandler: device is a file:" << file->fileName();
+#endif
+            if (!(suffix = QFileInfo(file->fileName()).suffix().toLower().toLatin1()).isEmpty()) {
+                int index = keys.indexOf(QString::fromLatin1(suffix));
+                if (index != -1) {
+#ifdef QIMAGEREADER_DEBUG
+                    qDebug() << "QImageReader::createReadHandler: suffix recognized; the"
+                             << suffix << "plugin might be able to read this";
+#endif
+                    suffixPluginIndex = index;
+                }
+            }
+        }
+    }
+#endif // QT_NO_LIBRARY
+
+    QByteArray testFormat = !form.isEmpty() ? form : suffix;
+
+#if !defined (QT_NO_LIBRARY) && !defined(QT_NO_SETTINGS)
+    if (suffixPluginIndex != -1) {
+        // check if the plugin that claims support for this format can load
+        // from this device with this format.
+        const qint64 pos = device ? device->pos() : 0;
+        QImageIOPlugin *plugin = qobject_cast<QImageIOPlugin *>(l->instance(QString::fromLatin1(suffix)));
+        if (plugin && plugin->capabilities(device, testFormat) & QImageIOPlugin::CanRead) {
+            handler = plugin->create(device, testFormat);
+#ifdef QIMAGEREADER_DEBUG
+            qDebug() << "QImageReader::createReadHandler: using the" << suffix
+                     << "plugin";
+#endif
+        }
+        if (device && !device->isSequential())
+            device->seek(pos);
+    }
+
+    if (!handler && !testFormat.isEmpty() && autoDetectImageFormat) {
+        // check if any plugin supports the format (they are not allowed to
+        // read from the device yet).
+        const qint64 pos = device ? device->pos() : 0;
+        for (int i = 0; i < keys.size(); ++i) {
+            if (i != suffixPluginIndex) {
+                QImageIOPlugin *plugin = qobject_cast<QImageIOPlugin *>(l->instance(keys.at(i)));
+                if (plugin && plugin->capabilities(device, testFormat) & QImageIOPlugin::CanRead) {
+#ifdef QIMAGEREADER_DEBUG
+                    qDebug() << "QImageReader::createReadHandler: the" << keys.at(i) << "plugin can read this format";
+#endif
+                    handler = plugin->create(device, testFormat);
+                    break;
+                }
+            }
+        }
+        if (device && !device->isSequential())
+            device->seek(pos);
+    }
+#endif // QT_NO_LIBRARY
+
+    // if we don't have a handler yet, check if we have built-in support for
+    // the format
+    if (!handler && !testFormat.isEmpty()) {
+        if (false) {
+#ifndef QT_NO_IMAGEFORMAT_PNG
+	} else if (testFormat == "png") {
+            handler = new QPngHandler;
+#endif
+#ifndef QT_NO_IMAGEFORMAT_BMP
+        } else if (testFormat == "bmp") {
+            handler = new QBmpHandler;
+#endif
+#ifndef QT_NO_IMAGEFORMAT_XPM
+        } else if (testFormat == "xpm") {
+            handler = new QXpmHandler;
+#endif
+#ifndef QT_NO_IMAGEFORMAT_XBM
+        } else if (testFormat == "xbm") {
+            handler = new QXbmHandler;
+            handler->setOption(QImageIOHandler::SubType, testFormat);
+#endif
+#ifndef QT_NO_IMAGEFORMAT_PPM
+        } else if (testFormat == "pbm" || testFormat == "pbmraw" || testFormat == "pgm"
+                   || testFormat == "pgmraw" || testFormat == "ppm" || testFormat == "ppmraw") {
+            handler = new QPpmHandler;
+            handler->setOption(QImageIOHandler::SubType, testFormat);
+#endif
+        }
+
+#ifdef QIMAGEREADER_DEBUG
+        if (handler)
+            qDebug() << "QImageReader::createReadHandler: using the built-in handler for" << testFormat;
+#endif
+    }
+
+#if !defined (QT_NO_LIBRARY) && !defined(QT_NO_SETTINGS)
+    if (!handler && autoDetectImageFormat) {
+        // check if any of our plugins recognize the file from its contents.
+        const qint64 pos = device ? device->pos() : 0;
+        for (int i = 0; i < keys.size(); ++i) {
+            if (i != suffixPluginIndex) {
+                QImageIOPlugin *plugin = qobject_cast<QImageIOPlugin *>(l->instance(keys.at(i)));
+                if (plugin && plugin->capabilities(device, QByteArray()) & QImageIOPlugin::CanRead) {
+                    handler = plugin->create(device, testFormat);
+#ifdef QIMAGEREADER_DEBUG
+                    qDebug() << "QImageReader::createReadHandler: the" << keys.at(i) << "plugin can read this data";
+#endif
+                    break;
+                }
+            }
+        }
+        if (device && !device->isSequential())
+            device->seek(pos);
+    }
+#endif
+
+    if (!handler && autoDetectImageFormat) {
+        // check if any of our built-in handlers recognize the file from its
+        // contents.
+        int currentFormat = 0;
+        if (!suffix.isEmpty()) {
+            // If reading from a file with a suffix, start testing our
+            // built-in handler for that suffix first.
+            for (int i = 0; i < _qt_NumFormats; ++i) {
+                if (_qt_BuiltInFormats[i].extension == suffix) {
+                    currentFormat = i;
+                    break;
+                }
+            }
+        }
+
+        QByteArray subType;
+        int numFormats = _qt_NumFormats;
+        while (device && numFormats >= 0) {
+            const _qt_BuiltInFormatStruct *formatStruct = &_qt_BuiltInFormats[currentFormat];
+
+            const qint64 pos = device->pos();
+            switch (formatStruct->type) {
+#ifndef QT_NO_IMAGEFORMAT_PNG
+            case _qt_PngFormat:
+                if (QPngHandler::canRead(device))
+                    handler = new QPngHandler;
+                break;
+#endif
+#ifndef QT_NO_IMAGEFORMAT_BMP
+            case _qt_BmpFormat:
+                if (QBmpHandler::canRead(device))
+                    handler = new QBmpHandler;
+                break;
+#endif
+#ifndef QT_NO_IMAGEFORMAT_XPM
+            case _qt_XpmFormat:
+                if (QXpmHandler::canRead(device))
+                    handler = new QXpmHandler;
+                break;
+#endif
+#ifndef QT_NO_IMAGEFORMAT_PPM
+            case _qt_PbmFormat:
+            case _qt_PgmFormat:
+            case _qt_PpmFormat:
+                if (QPpmHandler::canRead(device, &subType)) {
+                    handler = new QPpmHandler;
+                    handler->setOption(QImageIOHandler::SubType, subType);
+                }
+                break;
+#endif
+#ifndef QT_NO_IMAGEFORMAT_XBM
+            case _qt_XbmFormat:
+                if (QXbmHandler::canRead(device))
+                    handler = new QXbmHandler;
+                break;
+#endif
+            default:
+                break;
+            }
+            if (!device->isSequential())
+                device->seek(pos);
+
+            if (handler) {
+#ifdef QIMAGEREADER_DEBUG
+                qDebug() << "QImageReader::createReadHandler: the" << formatStruct->extension
+                         << "built-in handler can read this data";
+#endif
+                break;
+            }
+
+            --numFormats;
+            ++currentFormat;
+            currentFormat %= _qt_NumFormats;
+        }
+    }
+
+    if (!handler) {
+#ifdef QIMAGEREADER_DEBUG
+        qDebug() << "QImageReader::createReadHandler: no handlers found. giving up.";
+#endif
+        // no handler: give up.
+        return 0;
+    }
+
+    handler->setDevice(device);
+    if (!form.isEmpty())
+        handler->setFormat(form);
+    return handler;
+}
+
+class QImageReaderPrivate
+{
+public:
+    QImageReaderPrivate(QImageReader *qq);
+    ~QImageReaderPrivate();
+
+    // device
+    QByteArray format;
+    bool autoDetectImageFormat;
+    QIODevice *device;
+    bool deleteDevice;
+    QImageIOHandler *handler;
+    bool initHandler();
+
+    // image options
+    QRect clipRect;
+    QSize scaledSize;
+    QRect scaledClipRect;
+    int quality;
+    QMap<QString, QString> text;
+    void getText();
+
+    // error
+    QImageReader::ImageReaderError imageReaderError;
+    QString errorString;
+
+    QImageReader *q;
+};
+
+/*!
+    \internal
+*/
+QImageReaderPrivate::QImageReaderPrivate(QImageReader *qq)
+    : autoDetectImageFormat(true)
+{
+    device = 0;
+    deleteDevice = false;
+    handler = 0;
+    quality = -1;
+    imageReaderError = QImageReader::UnknownError;
+    errorString = QLatin1String(QT_TRANSLATE_NOOP(QImageReader, "Unknown error"));
+
+    q = qq;
+}
+
+/*!
+    \internal
+*/
+QImageReaderPrivate::~QImageReaderPrivate()
+{
+    if (deleteDevice)
+        delete device;
+    delete handler;
+}
+
+/*!
+    \internal
+*/
+bool QImageReaderPrivate::initHandler()
+{
+    // check some preconditions
+    if (!device || (!deleteDevice && !device->isOpen())) {
+        imageReaderError = QImageReader::DeviceError;
+        errorString = QLatin1String(QT_TRANSLATE_NOOP(QImageReader, "Invalid device"));
+        return false;
+    }
+
+    // probe the file extension
+    if (deleteDevice && !device->isOpen() && !device->open(QIODevice::ReadOnly) && autoDetectImageFormat) {
+        QList<QByteArray> extensions = QImageReader::supportedImageFormats();
+        if (!format.isEmpty()) {
+            // Try the most probable extension first
+            int currentFormatIndex = extensions.indexOf(format.toLower());
+            if (currentFormatIndex > 0)
+                extensions.swap(0, currentFormatIndex);
+        }
+
+        int currentExtension = 0;
+
+        QFile *file = static_cast<QFile *>(device);
+        QString fileName = file->fileName();
+
+        do {
+            file->setFileName(fileName + QLatin1Char('.')
+                    + QString::fromLatin1(extensions.at(currentExtension++).constData()));
+            file->open(QIODevice::ReadOnly);
+        } while (!file->isOpen() && currentExtension < extensions.size());
+
+        if (!device->isOpen()) {
+            imageReaderError = QImageReader::FileNotFoundError;
+            errorString = QLatin1String(QT_TRANSLATE_NOOP(QImageReader, "File not found"));
+            file->setFileName(fileName); // restore the old file name
+            return false;
+        }
+    }
+
+    // assign a handler
+    if (!handler && (handler = createReadHandlerHelper(device, format, autoDetectImageFormat)) == 0) {
+        imageReaderError = QImageReader::UnsupportedFormatError;
+        errorString = QLatin1String(QT_TRANSLATE_NOOP(QImageReader, "Unsupported image format"));
+        return false;
+    }
+    return true;
+}
+
+/*!
+    \internal
+*/
+void QImageReaderPrivate::getText()
+{
+    if (!text.isEmpty() || (!handler && !initHandler()) || !handler->supportsOption(QImageIOHandler::Description))
+        return;
+    foreach (QString pair, handler->option(QImageIOHandler::Description).toString().split(
+                QLatin1String("\n\n"))) {
+        int index = pair.indexOf(QLatin1Char(':'));
+        if (index >= 0 && pair.indexOf(QLatin1Char(' ')) < index) {
+            text.insert(QLatin1String("Description"), pair.simplified());
+        } else {
+            QString key = pair.left(index);
+            text.insert(key, pair.mid(index + 2).simplified());
+        }
+    }
+}
+
+/*!
+    Constructs an empty QImageReader object. Before reading an image,
+    call setDevice() or setFileName().
+*/
+QImageReader::QImageReader()
+    : d(new QImageReaderPrivate(this))
+{
+}
+
+/*!
+    Constructs a QImageReader object with the device \a device and the
+    image format \a format.
+*/
+QImageReader::QImageReader(QIODevice *device, const QByteArray &format)
+    : d(new QImageReaderPrivate(this))
+{
+    d->device = device;
+    d->format = format;
+}
+
+/*!
+    Constructs a QImageReader object with the file name \a fileName
+    and the image format \a format.
+
+    \sa setFileName()
+*/
+QImageReader::QImageReader(const QString &fileName, const QByteArray &format)
+    : d(new QImageReaderPrivate(this))
+{
+    QFile *file = new QFile(fileName);
+    d->device = file;
+    d->deleteDevice = true;
+    d->format = format;
+}
+
+/*!
+    Destructs the QImageReader object.
+*/
+QImageReader::~QImageReader()
+{
+    delete d;
+}
+
+/*!
+    Sets the format QImageReader will use when reading images, to \a
+    format. \a format is a case insensitive text string. Example:
+
+    \snippet doc/src/snippets/code/src_gui_image_qimagereader.cpp 0
+
+    You can call supportedImageFormats() for the full list of formats
+    QImageReader supports.
+
+    \sa format()
+*/
+void QImageReader::setFormat(const QByteArray &format)
+{
+    d->format = format;
+}
+
+/*!
+    Returns the format QImageReader uses for reading images.
+
+    You can call this function after assigning a device to the
+    reader to determine the format of the device. For example:
+
+    \snippet doc/src/snippets/code/src_gui_image_qimagereader.cpp 1
+
+    If the reader cannot read any image from the device (e.g., there is no
+    image there, or the image has already been read), or if the format is
+    unsupported, this function returns an empty QByteArray().
+
+    \sa setFormat(), supportedImageFormats()
+*/
+QByteArray QImageReader::format() const
+{
+    if (d->format.isEmpty()) {
+        if (!d->initHandler())
+            return QByteArray();
+        return d->handler->canRead() ? d->handler->format() : QByteArray();
+    }
+
+    return d->format;
+}
+
+/*!
+    If \a enabled is true, image format autodetection is enabled; otherwise,
+    it is disabled. By default, autodetection is enabled.
+
+    QImageReader uses an extensive approach to detecting the image format;
+    firstly, if you pass a file name to QImageReader, it will attempt to
+    detect the file extension if the given file name does not point to an
+    existing file, by appending supported default extensions to the given file
+    name, one at a time. It then uses the following approach to detect the
+    image format:
+
+    \list
+
+    \o Image plugins are queried first, based on either the optional format
+    string, or the file name suffix (if the source device is a file). No
+    content detection is done at this stage. QImageReader will choose the
+    first plugin that supports reading for this format.
+
+    \o If no plugin supports the image format, Qt's built-in handlers are
+    checked based on either the optional format string, or the file name
+    suffix.
+
+    \o If no capable plugins or built-in handlers are found, each plugin is
+    tested by inspecting the content of the data stream.
+
+    \o If no plugins could detect the image format based on data contents,
+    each built-in image handler is tested by inspecting the contents.
+
+    \o Finally, if all above approaches fail, QImageReader will report failure
+    when trying to read the image.
+
+    \endlist    
+
+    By disabling image format autodetection, QImageReader will only query the
+    plugins and built-in handlers based on the format string (i.e., no file
+    name extensions are tested).
+
+    \sa QImageIOHandler::canRead(), QImageIOPlugin::capabilities()
+*/
+void QImageReader::setAutoDetectImageFormat(bool enabled)
+{
+    d->autoDetectImageFormat = enabled;
+}
+
+/*!
+    Returns true if image format autodetection is enabled on this image
+    reader; otherwise returns false. By default, autodetection is enabled.
+
+    \sa setAutoDetectImageFormat()    
+*/
+bool QImageReader::autoDetectImageFormat() const
+{
+    return d->autoDetectImageFormat;
+}
+
+/*!
+    Sets QImageReader's device to \a device. If a device has already
+    been set, the old device is removed from QImageReader and is
+    otherwise left unchanged.
+
+    If the device is not already open, QImageReader will attempt to
+    open the device in \l QIODevice::ReadOnly mode by calling
+    open(). Note that this does not work for certain devices, such as
+    QProcess, QTcpSocket and QUdpSocket, where more logic is required
+    to open the device.
+
+    \sa device(), setFileName()
+*/
+void QImageReader::setDevice(QIODevice *device)
+{
+    if (d->device && d->deleteDevice)
+        delete d->device;
+    d->device = device;
+    d->deleteDevice = false;
+    delete d->handler;
+    d->handler = 0;
+    d->text.clear();
+}
+
+/*!
+    Returns the device currently assigned to QImageReader, or 0 if no
+    device has been assigned.
+*/
+QIODevice *QImageReader::device() const
+{
+    return d->device;
+}
+
+/*!
+    Sets the file name of QImageReader to \a fileName. Internally,
+    QImageReader will create a QFile object and open it in \l
+    QIODevice::ReadOnly mode, and use this when reading images.
+
+    If \a fileName does not include a file extension (e.g., .png or .bmp),
+    QImageReader will cycle through all supported extensions until it finds
+    a matching file.
+
+    \sa fileName(), setDevice(), supportedImageFormats()
+*/
+void QImageReader::setFileName(const QString &fileName)
+{
+    setDevice(new QFile(fileName));
+    d->deleteDevice = true;
+}
+
+/*!
+    If the currently assigned device is a QFile, or if setFileName()
+    has been called, this function returns the name of the file
+    QImageReader reads from. Otherwise (i.e., if no device has been
+    assigned or the device is not a QFile), an empty QString is
+    returned.
+
+    \sa setFileName(), setDevice()
+*/
+QString QImageReader::fileName() const
+{
+    QFile *file = qobject_cast<QFile *>(d->device);
+    return file ? file->fileName() : QString();
+}
+
+/*!
+    \since 4.2
+
+    This is an image format specific function that sets the quality
+    level of the image to \a quality. For image formats that do not
+    support setting the quality, this value is ignored.
+
+    The value range of \a quality depends on the image format. For
+    example, the "jpeg" format supports a quality range from 0 (low
+    quality, high compression) to 100 (high quality, low compression).
+
+    \sa quality()
+*/
+void QImageReader::setQuality(int quality)
+{
+    d->quality = quality;
+}
+
+/*!
+    \since 4.2
+
+    Returns the quality level of the image.
+
+    \sa setQuality()
+*/
+int QImageReader::quality() const
+{
+    return d->quality;
+}
+
+
+/*!
+    Returns the size of the image, without actually reading the image
+    contents.
+
+    If the image format does not support this feature, this function returns
+    an invalid size. Qt's built-in image handlers all support this feature,
+    but custom image format plugins are not required to do so.
+
+    \sa QImageIOHandler::ImageOption, QImageIOHandler::option(), QImageIOHandler::supportsOption()
+*/
+QSize QImageReader::size() const
+{
+    if (!d->initHandler())
+        return QSize();
+
+    if (d->handler->supportsOption(QImageIOHandler::Size))
+        return d->handler->option(QImageIOHandler::Size).toSize();
+
+    return QSize();
+}
+
+/*!
+    \since 4.5
+
+    Returns the format of the image, without actually reading the image
+    contents. The format describes the image format \l QImageReader::read()
+    returns, not the format of the actual image.
+
+    If the image format does not support this feature, this function returns
+    an invalid format.
+
+    \sa QImageIOHandler::ImageOption, QImageIOHandler::option(), QImageIOHandler::supportsOption()
+*/
+QImage::Format QImageReader::imageFormat() const
+{
+    if (!d->initHandler())
+        return QImage::Format_Invalid;
+
+    if (d->handler->supportsOption(QImageIOHandler::ImageFormat))
+        return (QImage::Format)d->handler->option(QImageIOHandler::ImageFormat).toInt();
+
+    return QImage::Format_Invalid;
+}
+
+/*!
+    \since 4.1
+
+    Returns the text keys for this image. You can use
+    these keys with text() to list the image text for
+    a certain key.
+
+    Support for this option is implemented through
+    QImageIOHandler::Description.
+
+    \sa text(), QImageWriter::setText(), QImage::textKeys()
+*/
+QStringList QImageReader::textKeys() const
+{
+    d->getText();
+    return d->text.keys();
+}
+
+/*!
+    \since 4.1
+
+    Returns the image text associated with \a key.
+
+    Support for this option is implemented through
+    QImageIOHandler::Description.
+
+    \sa textKeys(), QImageWriter::setText()
+*/
+QString QImageReader::text(const QString &key) const
+{
+    d->getText();
+    return d->text.value(key);
+}
+
+/*!
+    Sets the image clip rect (also known as the ROI, or Region Of
+    Interest) to \a rect. The coordinates of \a rect are relative to
+    the untransformed image size, as returned by size().
+
+    \sa clipRect(), setScaledSize(), setScaledClipRect()
+*/
+void QImageReader::setClipRect(const QRect &rect)
+{
+    d->clipRect = rect;
+}
+
+/*!
+    Returns the clip rect (also known as the ROI, or Region Of
+    Interest) of the image. If no clip rect has been set, an invalid
+    QRect is returned.
+
+    \sa setClipRect()
+*/
+QRect QImageReader::clipRect() const
+{
+    return d->clipRect;
+}
+
+/*!
+    Sets the scaled size of the image to \a size. The scaling is
+    performed after the initial clip rect, but before the scaled clip
+    rect is applied. The algorithm used for scaling depends on the
+    image format. By default (i.e., if the image format does not
+    support scaling), QImageReader will use QImage::scale() with
+    Qt::SmoothScaling.
+
+    \sa scaledSize(), setClipRect(), setScaledClipRect()
+*/
+void QImageReader::setScaledSize(const QSize &size)
+{
+    d->scaledSize = size;
+}
+
+/*!
+    Returns the scaled size of the image.
+
+    \sa setScaledSize()
+*/
+QSize QImageReader::scaledSize() const
+{
+    return d->scaledSize;
+}
+
+/*!
+    Sets the scaled clip rect to \a rect. The scaled clip rect is the
+    clip rect (also known as ROI, or Region Of Interest) that is
+    applied after the image has been scaled.
+
+    \sa scaledClipRect(), setScaledSize()
+*/
+void QImageReader::setScaledClipRect(const QRect &rect)
+{
+    d->scaledClipRect = rect;
+}
+
+/*!
+    Returns the scaled clip rect of the image.
+
+    \sa setScaledClipRect()
+*/
+QRect QImageReader::scaledClipRect() const
+{
+    return d->scaledClipRect;
+}
+
+/*!
+    \since 4.1
+
+    Sets the background color to \a color.
+    Image formats that support this operation are expected to
+    initialize the background to \a color before reading an image.
+
+    \sa backgroundColor(), read()
+*/
+void QImageReader::setBackgroundColor(const QColor &color)
+{
+    if (!d->initHandler())
+        return;
+    if (d->handler->supportsOption(QImageIOHandler::BackgroundColor))
+        d->handler->setOption(QImageIOHandler::BackgroundColor, color);
+}
+
+/*!
+    \since 4.1
+
+    Returns the background color that's used when reading an image.
+    If the image format does not support setting the background color
+    an invalid color is returned.
+
+    \sa setBackgroundColor(), read()
+*/
+QColor QImageReader::backgroundColor() const
+{
+    if (!d->initHandler())
+        return QColor();
+    if (d->handler->supportsOption(QImageIOHandler::BackgroundColor))
+        return qVariantValue<QColor>(d->handler->option(QImageIOHandler::BackgroundColor));
+    return QColor();
+}
+
+/*!
+    \since 4.1
+
+    Returns true if the image format supports animation;
+    otherwise, false is returned.
+
+    \sa QMovie::supportedFormats()
+*/
+bool QImageReader::supportsAnimation() const
+{
+    if (!d->initHandler())
+        return false;
+    if (d->handler->supportsOption(QImageIOHandler::Animation))
+        return d->handler->option(QImageIOHandler::Animation).toBool();
+    return false;
+}
+
+/*!
+    Returns true if an image can be read for the device (i.e., the
+    image format is supported, and the device seems to contain valid
+    data); otherwise returns false.
+
+    canRead() is a lightweight function that only does a quick test to
+    see if the image data is valid. read() may still return false
+    after canRead() returns true, if the image data is corrupt.
+
+    For images that support animation, canRead() returns false when
+    all frames have been read.
+
+    \sa read(), supportedImageFormats()
+*/
+bool QImageReader::canRead() const
+{
+    if (!d->initHandler())
+        return false;
+
+    return d->handler->canRead();
+}
+
+/*!
+    Reads an image from the device. On success, the image that was
+    read is returned; otherwise, a null QImage is returned. You can
+    then call error() to find the type of error that occurred, or
+    errorString() to get a human readable description of the error.
+
+    For image formats that support animation, calling read()
+    repeatedly will return the next frame. When all frames have been
+    read, a null image will be returned.
+
+    \sa canRead(), supportedImageFormats(), supportsAnimation(), QMovie
+*/
+QImage QImageReader::read()
+{
+    // Because failed image reading might have side effects, we explicitly
+    // return a null image instead of the image we've just created.
+    QImage image;
+    return read(&image) ? image : QImage();
+}
+
+/*!
+    \overload
+
+    Reads an image from the device into \a image, which must point to a
+    QImage. Returns true on success; otherwise, returns false.
+
+    If \a image has same format and size as the image data that is about to be
+    read, this function may not need to allocate a new image before
+    reading. Because of this, it can be faster than the other read() overload,
+    which always constructs a new image; especially when reading several
+    images with the same format and size.
+
+    \snippet doc/src/snippets/code/src_gui_image_qimagereader.cpp 2
+
+    For image formats that support animation, calling read() repeatedly will
+    return the next frame. When all frames have been read, a null image will
+    be returned.
+
+    \sa canRead(), supportedImageFormats(), supportsAnimation(), QMovie
+*/
+bool QImageReader::read(QImage *image)
+{
+    if (!image) {
+        qWarning("QImageReader::read: cannot read into null pointer");
+        return false;
+    }
+
+    if (!d->handler && !d->initHandler())
+        return false;
+
+    // set the handler specific options.
+    if (d->handler->supportsOption(QImageIOHandler::ScaledSize) && d->scaledSize.isValid()) {
+        if ((d->handler->supportsOption(QImageIOHandler::ClipRect) && !d->clipRect.isNull())
+            || d->clipRect.isNull()) {
+            // Only enable the ScaledSize option if there is no clip rect, or
+            // if the handler also supports ClipRect.
+            d->handler->setOption(QImageIOHandler::ScaledSize, d->scaledSize);
+        }
+    }
+    if (d->handler->supportsOption(QImageIOHandler::ClipRect) && !d->clipRect.isNull())
+        d->handler->setOption(QImageIOHandler::ClipRect, d->clipRect);
+    if (d->handler->supportsOption(QImageIOHandler::ScaledClipRect) && !d->scaledClipRect.isNull())
+        d->handler->setOption(QImageIOHandler::ScaledClipRect, d->scaledClipRect);
+    if (d->handler->supportsOption(QImageIOHandler::Quality))
+        d->handler->setOption(QImageIOHandler::Quality, d->quality);
+
+    // read the image
+    if (!d->handler->read(image)) {
+        d->imageReaderError = InvalidDataError;
+        d->errorString = QLatin1String(QT_TRANSLATE_NOOP(QImageReader, "Unable to read image data"));
+        return false;
+    }
+
+    // provide default implementations for any unsupported image
+    // options
+    if (d->handler->supportsOption(QImageIOHandler::ClipRect) && !d->clipRect.isNull()) {
+        if (d->handler->supportsOption(QImageIOHandler::ScaledSize) && d->scaledSize.isValid()) {
+            if (d->handler->supportsOption(QImageIOHandler::ScaledClipRect) && !d->scaledClipRect.isNull()) {
+                // all features are supported by the handler; nothing to do.
+            } else {
+                // the image is already scaled, so apply scaled clipping.
+                if (!d->scaledClipRect.isNull())
+                    *image = image->copy(d->scaledClipRect);
+            }
+        } else {
+            if (d->handler->supportsOption(QImageIOHandler::ScaledClipRect) && !d->scaledClipRect.isNull()) {
+                // supports scaled clipping but not scaling, most
+                // likely a broken handler.
+            } else {
+                if (d->scaledSize.isValid()) {
+                    *image = image->scaled(d->scaledSize, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
+                }
+                if (d->scaledClipRect.isValid()) {
+                    *image = image->copy(d->scaledClipRect);
+                }
+            }
+        }
+    } else {
+        if (d->handler->supportsOption(QImageIOHandler::ScaledSize) && d->scaledSize.isValid()) {
+            // in this case, there's nothing we can do. if the
+            // plugin supports scaled size but not ClipRect, then
+            // we have to ignore ClipRect."
+
+            if (d->handler->supportsOption(QImageIOHandler::ScaledClipRect) && !d->scaledClipRect.isNull()) {
+                // nothing to do (ClipRect is ignored!)
+            } else {
+                // provide all workarounds.
+                if (d->scaledClipRect.isValid()) {
+                    *image = image->copy(d->scaledClipRect);
+                }
+            }
+        } else {
+            if (d->handler->supportsOption(QImageIOHandler::ScaledClipRect) && !d->scaledClipRect.isNull()) {
+                // this makes no sense; a handler that supports
+                // ScaledClipRect but not ScaledSize is broken, and we
+                // can't work around it.
+            } else {
+                // provide all workarounds.
+                if (d->clipRect.isValid())
+                    *image = image->copy(d->clipRect);
+                if (d->scaledSize.isValid())
+                    *image = image->scaled(d->scaledSize, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
+                if (d->scaledClipRect.isValid())
+                    *image = image->copy(d->scaledClipRect);
+            }
+        }
+    }
+
+    return true;
+}
+
+/*!
+   For image formats that support animation, this function steps over the
+   current image, returning true if successful or false if there is no
+   following image in the animation.
+
+   The default implementation calls read(), then discards the resulting
+   image, but the image handler may have a more efficient way of implementing
+   this operation.
+
+   \sa jumpToImage(), QImageIOHandler::jumpToNextImage()
+*/
+bool QImageReader::jumpToNextImage()
+{
+    if (!d->initHandler())
+        return false;
+    return d->handler->jumpToNextImage();
+}
+
+/*!
+   For image formats that support animation, this function skips to the image
+   whose sequence number is \a imageNumber, returning true if successful
+   or false if the corresponding image cannot be found.
+
+   The next call to read() will attempt to read this image.
+
+   \sa jumpToNextImage(), QImageIOHandler::jumpToImage()
+*/
+bool QImageReader::jumpToImage(int imageNumber)
+{
+    if (!d->initHandler())
+        return false;
+    return d->handler->jumpToImage(imageNumber);
+}
+
+/*!
+    For image formats that support animation, this function returns
+    the number of times the animation should loop. Otherwise, it
+    returns -1.
+
+    \sa supportsAnimation(), QImageIOHandler::loopCount()
+*/
+int QImageReader::loopCount() const
+{
+    if (!d->initHandler())
+        return -1;
+    return d->handler->loopCount();
+}
+
+/*!
+    For image formats that support animation, this function returns
+    the total number of images in the animation.
+
+    Certain animation formats do not support this feature, in which
+    case 0 is returned.
+
+    \sa supportsAnimation(), QImageIOHandler::imageCount()
+*/
+int QImageReader::imageCount() const
+{
+    if (!d->initHandler())
+        return -1;
+    return d->handler->imageCount();
+}
+
+/*!
+    For image formats that support animation, this function returns
+    the number of milliseconds to wait until displaying the next frame
+    in the animation. Otherwise, 0 is returned.
+
+    \sa supportsAnimation(), QImageIOHandler::nextImageDelay()
+*/
+int QImageReader::nextImageDelay() const
+{
+    if (!d->initHandler())
+        return -1;
+    return d->handler->nextImageDelay();
+}
+
+/*!
+    For image formats that support animation, this function returns
+    the sequence number of the current frame. Otherwise, -1 is
+    returned.
+
+    \sa supportsAnimation(), QImageIOHandler::currentImageNumber()
+*/
+int QImageReader::currentImageNumber() const
+{
+    if (!d->initHandler())
+        return -1;
+    return d->handler->currentImageNumber();
+}
+
+/*!
+    For image formats that support animation, this function returns
+    the rect for the current frame. Otherwise, a null rect is returned.
+
+    \sa supportsAnimation(), QImageIOHandler::currentImageRect()
+*/
+QRect QImageReader::currentImageRect() const
+{
+    if (!d->initHandler())
+        return QRect();
+    return d->handler->currentImageRect();
+}
+
+/*!
+    Returns the type of error that occurred last.
+
+    \sa ImageReaderError, errorString()
+*/
+QImageReader::ImageReaderError QImageReader::error() const
+{
+    return d->imageReaderError;
+}
+
+/*!
+    Returns a human readable description of the last error that
+    occurred.
+
+    \sa error()
+*/
+QString QImageReader::errorString() const
+{
+    return d->errorString;
+}
+
+/*!
+    \since 4.2
+
+    Returns true if the reader supports \a option; otherwise returns
+    false.
+
+    Different image formats support different options. Call this function to
+    determine whether a certain option is supported by the current format. For
+    example, the PNG format allows you to embed text into the image's metadata
+    (see text()), and the BMP format allows you to determine the image's size
+    without loading the whole image into memory (see size()).
+
+    \snippet doc/src/snippets/code/src_gui_image_qimagereader.cpp 3
+
+    \sa QImageWriter::supportsOption()
+*/
+bool QImageReader::supportsOption(QImageIOHandler::ImageOption option) const
+{
+    if (!d->initHandler())
+        return false;
+    return d->handler->supportsOption(option);
+}
+
+/*!
+    If supported, this function returns the image format of the file
+    \a fileName. Otherwise, an empty string is returned.
+*/
+QByteArray QImageReader::imageFormat(const QString &fileName)
+{
+    QFile file(fileName);
+    if (!file.open(QFile::ReadOnly))
+        return QByteArray();
+
+    return imageFormat(&file);
+}
+
+/*!
+    If supported, this function returns the image format of the device
+    \a device. Otherwise, an empty string is returned.
+
+    \sa QImageReader::autoDetectImageFormat()
+*/
+QByteArray QImageReader::imageFormat(QIODevice *device)
+{
+    QByteArray format;
+    QImageIOHandler *handler = createReadHandlerHelper(device, format, /* autoDetectImageFormat = */ true);
+    if (handler) {
+        if (handler->canRead())
+            format = handler->format();
+        delete handler;
+    }
+    return format;
+}
+
+/*!
+    Returns the list of image formats supported by QImageReader.
+
+    By default, Qt can read the following formats:
+
+    \table
+    \header \o Format \o Description
+    \row    \o BMP    \o Windows Bitmap
+    \row    \o GIF    \o Graphic Interchange Format (optional)
+    \row    \o JPG    \o Joint Photographic Experts Group
+    \row    \o JPEG   \o Joint Photographic Experts Group
+    \row    \o MNG    \o Multiple-image Network Graphics
+    \row    \o PNG    \o Portable Network Graphics
+    \row    \o PBM    \o Portable Bitmap
+    \row    \o PGM    \o Portable Graymap
+    \row    \o PPM    \o Portable Pixmap
+    \row    \o TIFF   \o Tagged Image File Format
+    \row    \o XBM    \o X11 Bitmap
+    \row    \o XPM    \o X11 Pixmap
+    \endtable
+
+    Reading and writing SVG files is supported through Qt's
+    \l{QtSvg Module}{SVG Module}.
+
+    To configure Qt with GIF support, pass \c -qt-gif to the \c
+    configure script or check the appropriate option in the graphical
+    installer.
+
+    \sa setFormat(), QImageWriter::supportedImageFormats(), QImageIOPlugin
+*/
+QList<QByteArray> QImageReader::supportedImageFormats()
+{
+    QSet<QByteArray> formats;
+    for (int i = 0; i < _qt_NumFormats; ++i)
+        formats << _qt_BuiltInFormats[i].extension;
+
+#if !defined (QT_NO_LIBRARY) && !defined(QT_NO_SETTINGS)
+    QFactoryLoader *l = loader();
+    QStringList keys = l->keys();
+
+    for (int i = 0; i < keys.count(); ++i) {
+        QImageIOPlugin *plugin = qobject_cast<QImageIOPlugin *>(l->instance(keys.at(i)));
+        if (plugin && plugin->capabilities(0, keys.at(i).toLatin1()) & QImageIOPlugin::CanRead)
+            formats << keys.at(i).toLatin1();
+    }
+#endif // QT_NO_LIBRARY
+
+    QList<QByteArray> sortedFormats;
+    for (QSet<QByteArray>::ConstIterator it = formats.constBegin(); it != formats.constEnd(); ++it)
+        sortedFormats << *it;
+
+    qSort(sortedFormats);
+    return sortedFormats;
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/image/qimagereader.h b/src/gui/image/qimagereader.h
new file mode 100644
index 0000000..95d4b9a
--- /dev/null
+++ b/src/gui/image/qimagereader.h
@@ -0,0 +1,144 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QIMAGEREADER_H
+#define QIMAGEREADER_H
+
+#include <QtCore/qbytearray.h>
+#include <QtGui/qimage.h>
+#include <QtGui/qimageiohandler.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+class QColor;
+class QIODevice;
+class QRect;
+class QSize;
+class QStringList;
+
+class QImageReaderPrivate;
+class Q_GUI_EXPORT QImageReader
+{
+public:
+    enum ImageReaderError {
+        UnknownError,
+        FileNotFoundError,
+        DeviceError,
+        UnsupportedFormatError,
+        InvalidDataError
+    };
+
+    QImageReader();
+    explicit QImageReader(QIODevice *device, const QByteArray &format = QByteArray());
+    explicit QImageReader(const QString &fileName, const QByteArray &format = QByteArray());
+    ~QImageReader();
+
+    void setFormat(const QByteArray &format);
+    QByteArray format() const;
+
+    void setAutoDetectImageFormat(bool enabled);
+    bool autoDetectImageFormat() const;
+
+    void setDevice(QIODevice *device);
+    QIODevice *device() const;
+
+    void setFileName(const QString &fileName);
+    QString fileName() const;
+
+    QSize size() const;
+
+    QImage::Format imageFormat() const;
+
+    QStringList textKeys() const;
+    QString text(const QString &key) const;
+
+    void setClipRect(const QRect &rect);
+    QRect clipRect() const;
+
+    void setScaledSize(const QSize &size);
+    QSize scaledSize() const;
+
+    void setQuality(int quality);
+    int quality() const;
+
+    void setScaledClipRect(const QRect &rect);
+    QRect scaledClipRect() const;
+
+    void setBackgroundColor(const QColor &color);
+    QColor backgroundColor() const;
+
+    bool supportsAnimation() const;
+
+    bool canRead() const;
+    QImage read();
+    bool read(QImage *image);
+
+    bool jumpToNextImage();
+    bool jumpToImage(int imageNumber);
+    int loopCount() const;
+    int imageCount() const;
+    int nextImageDelay() const;
+    int currentImageNumber() const;
+    QRect currentImageRect() const;
+
+    ImageReaderError error() const;
+    QString errorString() const;
+
+    bool supportsOption(QImageIOHandler::ImageOption option) const;
+
+    static QByteArray imageFormat(const QString &fileName);
+    static QByteArray imageFormat(QIODevice *device);
+    static QList<QByteArray> supportedImageFormats();
+
+private:
+    Q_DISABLE_COPY(QImageReader)
+    QImageReaderPrivate *d;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QIMAGEREADER_H
diff --git a/src/gui/image/qimagewriter.cpp b/src/gui/image/qimagewriter.cpp
new file mode 100644
index 0000000..c24bbda
--- /dev/null
+++ b/src/gui/image/qimagewriter.cpp
@@ -0,0 +1,690 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \class QImageWriter
+    \brief The QImageWriter class provides a format independent interface
+    for writing images to files or other devices.
+
+    \reentrant
+    \ingroup multimedia
+    \ingroup io
+
+    QImageWriter supports setting format specific options, such as the
+    gamma level, compression level and quality, prior to storing the
+    image. If you do not need such options, you can use QImage::save()
+    or QPixmap::save() instead.
+
+    To store an image, you start by constructing a QImageWriter
+    object.  Pass either a file name or a device pointer, and the
+    image format to QImageWriter's constructor. You can then set
+    several options, such as the gamma level (by calling setGamma())
+    and quality (by calling setQuality()). canWrite() returns true if
+    QImageWriter can write the image (i.e., the image format is
+    supported and the device is open for writing). Call write() to
+    write the image to the device.
+
+    If any error occurs when writing the image, write() will return
+    false. You can then call error() to find the type of error that
+    occurred, or errorString() to get a human readable description of
+    what went wrong.
+
+    Call supportedImageFormats() for a list of formats that
+    QImageWriter can write. QImageWriter supports all built-in image
+    formats, in addition to any image format plugins that support
+    writing.
+
+    \sa QImageReader, QImageIOHandler, QImageIOPlugin
+*/
+
+/*!
+    \enum QImageWriter::ImageWriterError
+
+    This enum describes errors that can occur when writing images with
+    QImageWriter.
+
+    \value DeviceError QImageWriter encountered a device error when
+    writing the image data. Consult your device for more details on
+    what went wrong.
+
+    \value UnsupportedFormatError Qt does not support the requested
+    image format.
+
+    \value UnknownError An unknown error occurred. If you get this
+    value after calling write(), it is most likely caused by a bug in
+    QImageWriter.
+*/
+
+#include "qimagewriter.h"
+
+#include <qbytearray.h>
+#include <qfile.h>
+#include <qfileinfo.h>
+#include <qimageiohandler.h>
+#include <qset.h>
+#include <qvariant.h>
+
+// factory loader
+#include <qcoreapplication.h>
+#include <private/qfactoryloader_p.h>
+
+// image handlers
+#include <private/qbmphandler_p.h>
+#include <private/qppmhandler_p.h>
+#include <private/qxbmhandler_p.h>
+#include <private/qxpmhandler_p.h>
+#ifndef QT_NO_IMAGEFORMAT_PNG
+#include <private/qpnghandler_p.h>
+#endif
+
+QT_BEGIN_NAMESPACE
+
+#if !defined (QT_NO_LIBRARY) && !defined(QT_NO_SETTINGS)
+Q_GLOBAL_STATIC_WITH_ARGS(QFactoryLoader, loader,
+                          (QImageIOHandlerFactoryInterface_iid, QLatin1String("/imageformats")))
+#endif
+
+static QImageIOHandler *createWriteHandlerHelper(QIODevice *device,
+    const QByteArray &format)
+{
+    QByteArray form = format.toLower();
+    QByteArray suffix;
+    QImageIOHandler *handler = 0;
+
+#if !defined (QT_NO_LIBRARY) && !defined(QT_NO_SETTINGS)
+    // check if any plugins can write the image
+    QFactoryLoader *l = loader();
+    QStringList keys = l->keys();
+    int suffixPluginIndex = -1;
+#endif
+
+    if (device && format.isEmpty()) {
+        // if there's no format, see if \a device is a file, and if so, find
+        // the file suffix and find support for that format among our plugins.
+        // this allows plugins to override our built-in handlers.
+        if (QFile *file = qobject_cast<QFile *>(device)) {
+            if (!(suffix = QFileInfo(file->fileName()).suffix().toLower().toLatin1()).isEmpty()) {
+#if !defined (QT_NO_LIBRARY) && !defined(QT_NO_SETTINGS)
+                int index = keys.indexOf(QString::fromLatin1(suffix));
+                if (index != -1)
+                    suffixPluginIndex = index;
+#endif
+            }
+        }
+    }
+
+    QByteArray testFormat = !form.isEmpty() ? form : suffix;
+
+#if !defined (QT_NO_LIBRARY) && !defined(QT_NO_SETTINGS)
+    if (suffixPluginIndex != -1) {
+        // when format is missing, check if we can find a plugin for the
+        // suffix.
+        QImageIOPlugin *plugin = qobject_cast<QImageIOPlugin *>(l->instance(QString::fromLatin1(suffix)));
+        if (plugin && (plugin->capabilities(device, suffix) & QImageIOPlugin::CanWrite))
+            handler = plugin->create(device, suffix);
+    }
+#endif // Q_NO_LIBRARY
+
+    // check if any built-in handlers can write the image
+    if (!handler && !testFormat.isEmpty()) {
+        if (false) {
+#ifndef QT_NO_IMAGEFORMAT_PNG
+        } else if (testFormat == "png") {
+            handler = new QPngHandler;
+#endif
+#ifndef QT_NO_IMAGEFORMAT_BMP
+        } else if (testFormat == "bmp") {
+            handler = new QBmpHandler;
+#endif
+#ifndef QT_NO_IMAGEFORMAT_XPM
+        } else if (testFormat == "xpm") {
+            handler = new QXpmHandler;
+#endif
+#ifndef QT_NO_IMAGEFORMAT_XBM
+        } else if (testFormat == "xbm") {
+            handler = new QXbmHandler;
+            handler->setOption(QImageIOHandler::SubType, testFormat);
+#endif
+#ifndef QT_NO_IMAGEFORMAT_PPM
+        } else if (testFormat == "pbm" || testFormat == "pbmraw" || testFormat == "pgm"
+                 || testFormat == "pgmraw" || testFormat == "ppm" || testFormat == "ppmraw") {
+            handler = new QPpmHandler;
+            handler->setOption(QImageIOHandler::SubType, testFormat);
+#endif
+        }
+    }
+
+#if !defined (QT_NO_LIBRARY) && !defined(QT_NO_SETTINGS)
+    if (!testFormat.isEmpty()) {
+        for (int i = 0; i < keys.size(); ++i) {
+            QImageIOPlugin *plugin = qobject_cast<QImageIOPlugin *>(l->instance(keys.at(i)));
+            if (plugin && (plugin->capabilities(device, testFormat) & QImageIOPlugin::CanWrite)) {
+                handler = plugin->create(device, testFormat);
+                break;
+            }
+        }
+    }
+#endif
+
+    if (!handler)
+        return 0;
+
+    handler->setDevice(device);
+    if (!testFormat.isEmpty())
+        handler->setFormat(testFormat);
+    return handler;
+}
+
+class QImageWriterPrivate
+{
+public:
+    QImageWriterPrivate(QImageWriter *qq);
+
+    // device
+    QByteArray format;
+    QIODevice *device;
+    bool deleteDevice;
+    QImageIOHandler *handler;
+
+    // image options
+    int quality;
+    int compression;
+    float gamma;
+    QString description;
+    QString text;
+
+    // error
+    QImageWriter::ImageWriterError imageWriterError;
+    QString errorString;
+
+    QImageWriter *q;
+};
+
+/*!
+    \internal
+*/
+QImageWriterPrivate::QImageWriterPrivate(QImageWriter *qq)
+{
+    device = 0;
+    deleteDevice = false;
+    handler = 0;
+    quality = -1;
+    compression = 0;
+    gamma = 0.0;
+    imageWriterError = QImageWriter::UnknownError;
+    errorString = QT_TRANSLATE_NOOP(QImageWriter, QLatin1String("Unknown error"));
+
+    q = qq;
+}
+
+/*!
+    Constructs an empty QImageWriter object. Before writing, you must
+    call setFormat() to set an image format, then setDevice() or
+    setFileName().
+*/
+QImageWriter::QImageWriter()
+    : d(new QImageWriterPrivate(this))
+{
+}
+
+/*!
+    Constructs a QImageWriter object using the device \a device and
+    image format \a format.
+*/
+QImageWriter::QImageWriter(QIODevice *device, const QByteArray &format)
+    : d(new QImageWriterPrivate(this))
+{
+    d->device = device;
+    d->format = format;
+}
+
+/*!
+    Constructs a QImageWriter objects that will write to a file with
+    the name \a fileName, using the image format \a format. If \a
+    format is not provided, QImageWriter will detect the image format
+    by inspecting the extension of \a fileName.
+*/
+QImageWriter::QImageWriter(const QString &fileName, const QByteArray &format)
+    : d(new QImageWriterPrivate(this))
+{
+    QFile *file = new QFile(fileName);
+    d->device = file;
+    d->deleteDevice = true;
+    d->format = format;
+}
+
+/*!
+    Destructs the QImageWriter object.
+*/
+QImageWriter::~QImageWriter()
+{
+    if (d->deleteDevice)
+        delete d->device;
+    delete d->handler;
+    delete d;
+}
+
+/*!
+    Sets the format QImageWriter will use when writing images, to \a
+    format. \a format is a case insensitive text string. Example:
+
+    \snippet doc/src/snippets/code/src_gui_image_qimagewriter.cpp 0
+
+    You can call supportedImageFormats() for the full list of formats
+    QImageWriter supports.
+
+    \sa format()
+*/
+void QImageWriter::setFormat(const QByteArray &format)
+{
+    d->format = format;
+}
+
+/*!
+    Returns the format QImageWriter uses for writing images.
+
+    \sa setFormat()
+*/
+QByteArray QImageWriter::format() const
+{
+    return d->format;
+}
+
+/*!
+    Sets QImageWriter's device to \a device. If a device has already
+    been set, the old device is removed from QImageWriter and is
+    otherwise left unchanged.
+
+    If the device is not already open, QImageWriter will attempt to
+    open the device in \l QIODevice::WriteOnly mode by calling
+    open(). Note that this does not work for certain devices, such as
+    QProcess, QTcpSocket and QUdpSocket, where more logic is required
+    to open the device.
+
+    \sa device(), setFileName()
+*/
+void QImageWriter::setDevice(QIODevice *device)
+{
+    if (d->device && d->deleteDevice)
+        delete d->device;
+
+    d->device = device;
+    d->deleteDevice = false;
+    delete d->handler;
+    d->handler = 0;
+}
+
+/*!
+    Returns the device currently assigned to QImageWriter, or 0 if no
+    device has been assigned.
+*/
+QIODevice *QImageWriter::device() const
+{
+    return d->device;
+}
+
+/*!
+    Sets the file name of QImageWriter to \a fileName. Internally,
+    QImageWriter will create a QFile and open it in \l
+    QIODevice::WriteOnly mode, and use this file when writing images.
+
+    \sa fileName(), setDevice()
+*/
+void QImageWriter::setFileName(const QString &fileName)
+{
+    setDevice(new QFile(fileName));
+    d->deleteDevice = true;
+}
+
+/*!
+    If the currently assigned device is a QFile, or if setFileName()
+    has been called, this function returns the name of the file
+    QImageWriter writes to. Otherwise (i.e., if no device has been
+    assigned or the device is not a QFile), an empty QString is
+    returned.
+
+    \sa setFileName(), setDevice()
+*/
+QString QImageWriter::fileName() const
+{
+    QFile *file = qobject_cast<QFile *>(d->device);
+    return file ? file->fileName() : QString();
+}
+
+/*!
+    This is an image format specific function that sets the quality
+    level of the image to \a quality. For image formats that do not
+    support setting the quality, this value is ignored.
+
+    The value range of \a quality depends on the image format. For
+    example, the "jpeg" format supports a quality range from 0 (low
+    quality, high compression) to 100 (high quality, low compression).
+
+    \sa quality()
+*/
+void QImageWriter::setQuality(int quality)
+{
+    d->quality = quality;
+}
+
+/*!
+    Returns the quality level of the image.
+
+    \sa setQuality()
+*/
+int QImageWriter::quality() const
+{
+    return d->quality;
+}
+
+/*!
+    This is an image format specific function that set the compression
+    of an image. For image formats that do not support setting the
+    compression, this value is ignored.
+
+    The value range of \a compression depends on the image format. For
+    example, the "tiff" format supports two values, 0(no compression) and
+    1(LZW-compression).
+
+    \sa compression()
+*/
+void QImageWriter::setCompression(int compression)
+{
+    d->compression = compression;
+}
+
+/*!
+    Returns the compression of the image.
+
+    \sa setCompression()
+*/
+int QImageWriter::compression() const
+{
+    return d->compression;
+}
+
+/*!
+    This is an image format specific function that sets the gamma
+    level of the image to \a gamma. For image formats that do not
+    support setting the gamma level, this value is ignored.
+
+    The value range of \a gamma depends on the image format. For
+    example, the "png" format supports a gamma range from 0.0 to 1.0.
+
+    \sa quality()
+*/
+void QImageWriter::setGamma(float gamma)
+{
+    d->gamma = gamma;
+}
+
+/*!
+    Returns the gamma level of the image.
+
+    \sa setGamma()
+*/
+float QImageWriter::gamma() const
+{
+    return d->gamma;
+}
+
+/*!
+    \obsolete
+
+    Use setText() instead.
+
+    This is an image format specific function that sets the
+    description of the image to \a description. For image formats that
+    do not support setting the description, this value is ignored.
+
+    The contents of \a description depends on the image format.
+
+    \sa description()
+*/
+void QImageWriter::setDescription(const QString &description)
+{
+    d->description = description;
+}
+
+/*!
+    \obsolete
+
+    Use QImageReader::text() instead.
+
+    Returns the description of the image.
+
+    \sa setDescription()
+*/
+QString QImageWriter::description() const
+{
+    return d->description;
+}
+
+/*!
+    \since 4.1
+
+    Sets the image text associated with the key \a key to
+    \a text. This is useful for storing copyright information
+    or other information about the image. Example:
+
+    \snippet doc/src/snippets/code/src_gui_image_qimagewriter.cpp 1
+
+    If you want to store a single block of data
+    (e.g., a comment), you can pass an empty key, or use
+    a generic key like "Description".
+
+    The key and text will be embedded into the
+    image data after calling write().
+
+    Support for this option is implemented through
+    QImageIOHandler::Description.
+
+    \sa QImage::setText(), QImageReader::text()
+*/
+void QImageWriter::setText(const QString &key, const QString &text)
+{
+    if (!d->description.isEmpty())
+        d->description += QLatin1String("\n\n");
+    d->description += key.simplified() + QLatin1String(": ") + text.simplified();
+}
+
+/*!
+    Returns true if QImageWriter can write the image; i.e., the image
+    format is supported and the assigned device is open for reading.
+
+    \sa write(), setDevice(), setFormat()
+*/
+bool QImageWriter::canWrite() const
+{
+    if (d->device && !d->handler && (d->handler = createWriteHandlerHelper(d->device, d->format)) == 0) {
+        d->imageWriterError = QImageWriter::UnsupportedFormatError;
+        d->errorString = QT_TRANSLATE_NOOP(QImageWriter,
+                                           QLatin1String("Unsupported image format"));
+        return false;
+    }
+    if (d->device && !d->device->isOpen())
+        d->device->open(QIODevice::WriteOnly);
+    if (!d->device || !d->device->isWritable()) {
+        d->imageWriterError = QImageWriter::DeviceError;
+        d->errorString = QT_TRANSLATE_NOOP(QImageWriter,
+                                           QLatin1String("Device not writable"));
+        return false;
+    }
+    return true;
+}
+
+/*!
+    Writes the image \a image to the assigned device or file
+    name. Returns true on success; otherwise returns false. If the
+    operation fails, you can call error() to find the type of error
+    that occurred, or errorString() to get a human readable
+    description of the error.
+
+    \sa canWrite(), error(), errorString()
+*/
+bool QImageWriter::write(const QImage &image)
+{
+    if (!canWrite())
+        return false;
+
+    if (d->handler->supportsOption(QImageIOHandler::Quality))
+        d->handler->setOption(QImageIOHandler::Quality, d->quality);
+    if (d->handler->supportsOption(QImageIOHandler::CompressionRatio))
+        d->handler->setOption(QImageIOHandler::CompressionRatio, d->compression);
+    if (d->handler->supportsOption(QImageIOHandler::Gamma))
+        d->handler->setOption(QImageIOHandler::Gamma, d->gamma);
+    if (!d->description.isEmpty() && d->handler->supportsOption(QImageIOHandler::Description))
+        d->handler->setOption(QImageIOHandler::Description, d->description);
+
+    if (!d->handler->write(image))
+        return false;
+    if (QFile *file = qobject_cast<QFile *>(d->device))
+        file->flush();
+    return true;
+}
+
+/*!
+    Returns the type of error that last occurred.
+
+    \sa ImageWriterError, errorString()
+*/
+QImageWriter::ImageWriterError QImageWriter::error() const
+{
+    return d->imageWriterError;
+}
+
+/*!
+    Returns a human readable description of the last error that occurred.
+
+    \sa error()
+*/
+QString QImageWriter::errorString() const
+{
+    return d->errorString;
+}
+
+/*!
+    \since 4.2
+
+    Returns true if the writer supports \a option; otherwise returns
+    false.
+
+    Different image formats support different options. Call this function to
+    determine whether a certain option is supported by the current format. For
+    example, the PNG format allows you to embed text into the image's metadata
+    (see text()).
+
+    \snippet doc/src/snippets/code/src_gui_image_qimagewriter.cpp 2
+
+    Options can be tested after the writer has been associated with a format.
+
+    \sa QImageReader::supportsOption(), setFormat()
+*/
+bool QImageWriter::supportsOption(QImageIOHandler::ImageOption option) const
+{
+    if (!d->handler && (d->handler = createWriteHandlerHelper(d->device, d->format)) == 0) {
+        d->imageWriterError = QImageWriter::UnsupportedFormatError;
+        d->errorString = QT_TRANSLATE_NOOP(QImageWriter,
+                                           QLatin1String("Unsupported image format"));
+        return false;
+    }
+
+    return d->handler->supportsOption(option);
+}
+
+/*!
+    Returns the list of image formats supported by QImageWriter.
+
+    By default, Qt can write the following formats:
+
+    \table
+    \header \o Format \o Description
+    \row    \o BMP    \o Windows Bitmap
+    \row    \o JPG    \o Joint Photographic Experts Group
+    \row    \o JPEG   \o Joint Photographic Experts Group
+    \row    \o PNG    \o Portable Network Graphics
+    \row    \o PPM    \o Portable Pixmap
+    \row    \o TIFF   \o Tagged Image File Format
+    \row    \o XBM    \o X11 Bitmap
+    \row    \o XPM    \o X11 Pixmap
+    \endtable
+
+    Reading and writing SVG files is supported through Qt's
+    \l{QtSvg Module}{SVG Module}.
+
+    \sa setFormat(), QImageReader::supportedImageFormats(), QImageIOPlugin
+*/
+QList<QByteArray> QImageWriter::supportedImageFormats()
+{
+    QSet<QByteArray> formats;
+    formats << "bmp";
+#ifndef QT_NO_IMAGEFORMAT_PPM
+    formats << "ppm";
+#endif
+#ifndef QT_NO_IMAGEFORMAT_XBM
+    formats << "xbm";
+#endif
+#ifndef QT_NO_IMAGEFORMAT_XPM
+    formats << "xpm";
+#endif
+#ifndef QT_NO_IMAGEFORMAT_PNG
+    formats << "png";
+#endif
+
+#if !defined (QT_NO_LIBRARY) && !defined(QT_NO_SETTINGS)
+    QFactoryLoader *l = loader();
+    QStringList keys = l->keys();
+    for (int i = 0; i < keys.count(); ++i) {
+        QImageIOPlugin *plugin = qobject_cast<QImageIOPlugin *>(l->instance(keys.at(i)));
+        if (plugin && (plugin->capabilities(0, keys.at(i).toLatin1()) & QImageIOPlugin::CanWrite) != 0)
+            formats << keys.at(i).toLatin1();
+    }
+#endif // QT_NO_LIBRARY
+
+    QList<QByteArray> sortedFormats;
+    for (QSet<QByteArray>::ConstIterator it = formats.constBegin(); it != formats.constEnd(); ++it)
+        sortedFormats << *it;
+
+    qSort(sortedFormats);
+    return sortedFormats;
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/image/qimagewriter.h b/src/gui/image/qimagewriter.h
new file mode 100644
index 0000000..5756618
--- /dev/null
+++ b/src/gui/image/qimagewriter.h
@@ -0,0 +1,116 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QIMAGEWRITER_H
+#define QIMAGEWRITER_H
+
+#include <QtCore/qbytearray.h>
+#include <QtCore/qlist.h>
+#include <QtGui/qimageiohandler.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+class QIODevice;
+class QImage;
+
+class QImageWriterPrivate;
+class Q_GUI_EXPORT QImageWriter
+{
+public:
+    enum ImageWriterError {
+        UnknownError,
+        DeviceError,
+        UnsupportedFormatError
+    };
+
+    QImageWriter();
+    explicit QImageWriter(QIODevice *device, const QByteArray &format);
+    explicit QImageWriter(const QString &fileName, const QByteArray &format = QByteArray());
+    ~QImageWriter();
+
+    void setFormat(const QByteArray &format);
+    QByteArray format() const;
+
+    void setDevice(QIODevice *device);
+    QIODevice *device() const;
+
+    void setFileName(const QString &fileName);
+    QString fileName() const;
+
+    void setQuality(int quality);
+    int quality() const;
+
+    void setCompression(int compression);
+    int compression() const;
+
+    void setGamma(float gamma);
+    float gamma() const;
+
+    // Obsolete as of 4.1
+    void setDescription(const QString &description);
+    QString description() const;
+
+    void setText(const QString &key, const QString &text);
+
+    bool canWrite() const;
+    bool write(const QImage &image);
+
+    ImageWriterError error() const;
+    QString errorString() const;
+
+    bool supportsOption(QImageIOHandler::ImageOption option) const;
+
+    static QList<QByteArray> supportedImageFormats();
+
+private:
+    Q_DISABLE_COPY(QImageWriter)
+    QImageWriterPrivate *d;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QIMAGEWRITER_H
diff --git a/src/gui/image/qmovie.cpp b/src/gui/image/qmovie.cpp
new file mode 100644
index 0000000..ca69cab
--- /dev/null
+++ b/src/gui/image/qmovie.cpp
@@ -0,0 +1,1081 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*! 
+    \class QMovie
+
+    \brief The QMovie class is a convenience class for playing movies
+    with QImageReader.
+
+    \ingroup multimedia
+
+    First, create a QMovie object by passing either the name of a file or a
+    pointer to a QIODevice containing an animated image format to QMovie's
+    constructor. You can call isValid() to check if the image data is valid,
+    before starting the movie. To start the movie, call start(). QMovie will
+    enter \l Running state, and emit started() and stateChanged(). To get the
+    current state of the movie, call state().
+
+    To display the movie in your application, you can pass your QMovie object
+    to QLabel::setMovie(). Example:
+
+    \snippet doc/src/snippets/code/src_gui_image_qmovie.cpp 0
+
+    Whenever a new frame is available in the movie, QMovie will emit
+    updated(). If the size of the frame changes, resized() is emitted. You can
+    call currentImage() or currentPixmap() to get a copy of the current
+    frame. When the movie is done, QMovie emits finished(). If any error
+    occurs during playback (i.e, the image file is corrupt), QMovie will emit
+    error().
+
+    You can control the speed of the movie playback by calling setSpeed(),
+    which takes the percentage of the original speed as an argument. Pause the
+    movie by calling setPaused(true). QMovie will then enter \l Paused state
+    and emit stateChanged(). If you call setPaused(false), QMovie will reenter
+    \l Running state and start the movie again. To stop the movie, call
+    stop().
+
+    Certain animation formats allow you to set the background color. You can
+    call setBackgroundColor() to set the color, or backgroundColor() to
+    retrieve the current background color.
+
+    currentFrameNumber() returns the sequence number of the current frame. The
+    first frame in the animation has the sequence number 0. frameCount()
+    returns the total number of frames in the animation, if the image format
+    supports this. You can call loopCount() to get the number of times the
+    movie should loop before finishing. nextFrameDelay() returns the number of
+    milliseconds the current frame should be displayed.
+
+    QMovie can be instructed to cache frames of an animation by calling
+    setCacheMode().
+
+    Call supportedFormats() for a list of formats that QMovie supports.
+
+    \sa QLabel, QImageReader, {Movie Example}
+*/
+
+/*! \enum QMovie::MovieState
+
+    This enum describes the different states of QMovie.
+
+    \value NotRunning The movie is not running. This is QMovie's initial
+    state, and the state it enters after stop() has been called or the movie
+    is finished.
+
+    \value Paused The movie is paused, and QMovie stops emitting updated() or
+    resized(). This state is entered after calling pause() or
+    setPaused(true). The current frame number it kept, and the movie will
+    continue with the next frame when unpause() or setPaused(false) is called.
+
+    \value Running The movie is running.
+*/
+
+/*! \enum QMovie::CacheMode
+
+    This enum describes the different cache modes of QMovie.
+
+    \value CacheNone No frames are cached (the default).
+
+    \value CacheAll All frames are cached.
+*/
+
+/*! \fn void QMovie::started()
+
+    This signal is emitted after QMovie::start() has been called, and QMovie
+    has entered QMovie::Running state.
+*/
+
+/*! \fn void QMovie::resized(const QSize &size)
+
+    This signal is emitted when the current frame has been resized to \a
+    size. This effect is sometimes used in animations as an alternative to
+    replacing the frame. You can call currentImage() or currentPixmap() to get a
+    copy of the updated frame.
+*/
+
+/*! \fn void QMovie::updated(const QRect &rect)
+
+    This signal is emitted when the rect \a rect in the current frame has been
+    updated. You can call currentImage() or currentPixmap() to get a copy of the
+    updated frame.
+*/
+
+/*! \fn void QMovie::frameChanged(int frameNumber)
+    \since 4.1
+
+    This signal is emitted when the frame number has changed to
+    \a frameNumber.  You can call currentImage() or currentPixmap() to get a
+    copy of the frame.
+*/
+
+/*! 
+    \fn void QMovie::stateChanged(QMovie::MovieState state)
+
+    This signal is emitted every time the state of the movie changes. The new
+    state is specified by \a state.
+
+    \sa QMovie::state()
+*/
+
+/*! \fn void QMovie::error(QImageReader::ImageReaderError error)
+
+    This signal is emitted by QMovie when the error \a error occurred during
+    playback.  QMovie will stop the movie, and enter QMovie::NotRunning state.
+*/
+
+/*! \fn void QMovie::finished()
+
+    This signal is emitted when the movie has finished.
+
+    \sa QMovie::stop()
+*/
+
+#include "qglobal.h"
+
+#ifndef QT_NO_MOVIE
+
+#include "qmovie.h"
+#include "qimage.h"
+#include "qimagereader.h"
+#include "qpixmap.h"
+#include "qrect.h"
+#include "qdatetime.h"
+#include "qtimer.h"
+#include "qpair.h"
+#include "qmap.h"
+#include "qlist.h"
+#include "qbuffer.h"
+#include "qdir.h"
+#include "private/qobject_p.h"
+
+#define QMOVIE_INVALID_DELAY -1
+
+QT_BEGIN_NAMESPACE
+
+class QFrameInfo
+{
+public:
+    QPixmap pixmap;
+    int delay;
+    bool endMark;
+    inline QFrameInfo(bool endMark)
+        : pixmap(QPixmap()), delay(QMOVIE_INVALID_DELAY), endMark(endMark)
+    { }
+    
+    inline QFrameInfo()
+        : pixmap(QPixmap()), delay(QMOVIE_INVALID_DELAY), endMark(false)
+    { }
+    
+    inline QFrameInfo(const QPixmap &pixmap, int delay)
+        : pixmap(pixmap), delay(delay), endMark(false)
+    { }
+    
+    inline bool isValid()
+    {
+        return endMark || !(pixmap.isNull() && (delay == QMOVIE_INVALID_DELAY));
+    }
+    
+    inline bool isEndMarker()
+    { return endMark; }
+    
+    static inline QFrameInfo endMarker()
+    { return QFrameInfo(true); }
+};
+
+class QMoviePrivate : public QObjectPrivate
+{
+    Q_DECLARE_PUBLIC(QMovie)
+
+public:
+    QMoviePrivate(QMovie *qq);
+    bool isDone();
+    bool next();
+    int speedAdjustedDelay(int delay) const;
+    bool isValid() const;
+    bool jumpToFrame(int frameNumber);
+    int frameCount() const;
+    bool jumpToNextFrame();
+    QFrameInfo infoForFrame(int frameNumber);
+    void reset();
+
+    inline void enterState(QMovie::MovieState newState) {
+        movieState = newState;
+        emit q_func()->stateChanged(newState);
+    }
+
+    // private slots
+    void _q_loadNextFrame();
+    void _q_loadNextFrame(bool starting);
+
+    QImageReader *reader;
+    int speed;
+    QMovie::MovieState movieState;
+    QRect frameRect;
+    QPixmap currentPixmap;
+    int currentFrameNumber;
+    int nextFrameNumber;
+    int greatestFrameNumber;
+    int nextDelay;
+    int playCounter;
+    qint64 initialDevicePos;
+    QMovie::CacheMode cacheMode;
+    bool haveReadAll;
+    bool isFirstIteration;
+    QMap<int, QFrameInfo> frameMap;
+    QString absoluteFilePath;
+
+    QTimer nextImageTimer;
+};
+
+/*! \internal
+ */
+QMoviePrivate::QMoviePrivate(QMovie *qq)
+    : reader(0), speed(100), movieState(QMovie::NotRunning),
+      currentFrameNumber(-1), nextFrameNumber(0), greatestFrameNumber(-1),
+      nextDelay(0), playCounter(-1),
+      cacheMode(QMovie::CacheNone), haveReadAll(false), isFirstIteration(true)
+{
+    q_ptr = qq;
+    nextImageTimer.setSingleShot(true);
+}
+
+/*! \internal
+ */
+void QMoviePrivate::reset()
+{
+    nextImageTimer.stop();
+    if (reader->device())
+        initialDevicePos = reader->device()->pos();
+    currentFrameNumber = -1;
+    nextFrameNumber = 0;
+    greatestFrameNumber = -1;
+    nextDelay = 0;
+    playCounter = -1;
+    haveReadAll = false;
+    isFirstIteration = true;
+    frameMap.clear();
+}
+
+/*! \internal
+ */
+bool QMoviePrivate::isDone()
+{
+    return (playCounter == 0);
+}
+
+/*!
+    \internal
+
+    Given the original \a delay, this function returns the
+    actual number of milliseconds to delay according to
+    the current speed. E.g. if the speed is 200%, the
+    result will be half of the original delay.
+*/
+int QMoviePrivate::speedAdjustedDelay(int delay) const
+{
+    return int( (qint64(delay) * qint64(100) ) / qint64(speed) );
+}
+
+/*!
+    \internal
+
+    Returns the QFrameInfo for the given \a frameNumber.
+
+    If the frame number is invalid, an invalid QFrameInfo is
+    returned.
+
+    If the end of the animation has been reached, a
+    special end marker QFrameInfo is returned.
+
+*/
+QFrameInfo QMoviePrivate::infoForFrame(int frameNumber)
+{
+    if (frameNumber < 0)
+        return QFrameInfo(); // Invalid
+
+    if (haveReadAll && (frameNumber > greatestFrameNumber)) {
+        if (frameNumber == greatestFrameNumber+1)
+            return QFrameInfo::endMarker();
+        return QFrameInfo(); // Invalid
+    }
+
+    if (cacheMode == QMovie::CacheNone) {
+        if (frameNumber != currentFrameNumber+1) {
+            // Non-sequential frame access
+            if (!reader->jumpToImage(frameNumber)) {
+                if (frameNumber == 0) {
+                    // Special case: Attempt to "rewind" so we can loop
+                    // ### This could be implemented as QImageReader::rewind()
+                    if (reader->device()->isSequential())
+                        return QFrameInfo(); // Invalid
+                    QString fileName = reader->fileName();
+                    QByteArray format = reader->format();
+                    QIODevice *device = reader->device();
+                    QColor bgColor = reader->backgroundColor();
+                    QSize scaledSize = reader->scaledSize();
+                    delete reader;
+                    if (fileName.isEmpty())
+                        reader = new QImageReader(device, format);
+                    else
+                        reader = new QImageReader(absoluteFilePath, format);
+                    reader->canRead(); // Provoke a device->open() call
+                    reader->device()->seek(initialDevicePos);
+                    reader->setBackgroundColor(bgColor);
+                    reader->setScaledSize(scaledSize);
+                } else {
+                    return QFrameInfo(); // Invalid
+                }
+            }
+        }
+        if (reader->canRead()) {
+            // reader says we can read. Attempt to actually read image
+            QImage anImage = reader->read();
+            if (anImage.isNull()) {
+                // Reading image failed.
+                return QFrameInfo(); // Invalid
+            }
+            if (frameNumber > greatestFrameNumber)
+                greatestFrameNumber = frameNumber;
+            QPixmap aPixmap = QPixmap::fromImage(anImage);
+            int aDelay = reader->nextImageDelay();
+            return QFrameInfo(aPixmap, aDelay);
+        } else {
+            // We've read all frames now. Return an end marker
+            haveReadAll = true;
+            return QFrameInfo::endMarker();
+        }
+    }
+
+    // CacheMode == CacheAll
+    if (frameNumber > greatestFrameNumber) {
+        // Frame hasn't been read from file yet. Try to do it
+        for (int i = greatestFrameNumber + 1; i <= frameNumber; ++i) {
+            if (reader->canRead()) {
+                // reader says we can read. Attempt to actually read image
+                QImage anImage = reader->read();
+                if (anImage.isNull()) {
+                    // Reading image failed.
+                    return QFrameInfo(); // Invalid
+                }
+                greatestFrameNumber = i;
+                QPixmap aPixmap = QPixmap::fromImage(anImage);
+                int aDelay = reader->nextImageDelay();
+                QFrameInfo info(aPixmap, aDelay);
+                // Cache it!
+                frameMap.insert(i, info);
+                if (i == frameNumber) {
+                    return info;
+                }
+            } else {
+                // We've read all frames now. Return an end marker
+                haveReadAll = true;
+                return QFrameInfo::endMarker();
+            }
+        }
+    }
+    // Return info for requested (cached) frame
+    return frameMap.value(frameNumber);
+}
+
+/*!
+    \internal
+
+    Attempts to advance the animation to the next frame.
+    If successful, currentFrameNumber, currentPixmap and
+    nextDelay are updated accordingly, and true is returned.
+    Otherwise, false is returned.
+    When false is returned, isDone() can be called to
+    determine whether the animation ended gracefully or
+    an error occurred when reading the frame.
+*/
+bool QMoviePrivate::next()
+{
+    QTime time;
+    time.start();
+    QFrameInfo info = infoForFrame(nextFrameNumber);
+    if (!info.isValid())
+        return false;
+    if (info.isEndMarker()) {
+        // We reached the end of the animation.
+        if (isFirstIteration) {
+            if (nextFrameNumber == 0) {
+                // No frames could be read at all (error).
+                return false;
+            }
+            // End of first iteration. Initialize play counter
+            playCounter = reader->loopCount();
+            isFirstIteration = false;
+        }
+        // Loop as appropriate
+        if (playCounter != 0) {
+            if (playCounter != -1) // Infinite?
+                playCounter--;     // Nope
+            nextFrameNumber = 0;
+            return next();
+        }
+        // Loop no more. Done
+        return false;
+    }
+    // Image and delay OK, update internal state
+    currentFrameNumber = nextFrameNumber++;
+    QSize scaledSize = reader->scaledSize();
+    if (scaledSize.isValid() && (scaledSize != info.pixmap.size()))
+        currentPixmap = QPixmap::fromImage( info.pixmap.toImage().scaled(scaledSize) );
+    else
+        currentPixmap = info.pixmap;
+    nextDelay = speedAdjustedDelay(info.delay);
+    // Adjust delay according to the time it took to read the frame
+    int processingTime = time.elapsed();
+    if (processingTime > nextDelay)
+        nextDelay = 0;
+    else
+        nextDelay = nextDelay - processingTime;
+    return true;
+}
+
+/*! \internal
+ */
+void QMoviePrivate::_q_loadNextFrame()
+{
+    _q_loadNextFrame(false);
+}
+
+void QMoviePrivate::_q_loadNextFrame(bool starting)
+{
+    Q_Q(QMovie);
+    if (next()) {
+        if (starting && movieState == QMovie::NotRunning) {
+            enterState(QMovie::Running);
+            emit q->started();
+        }
+
+        if (frameRect.size() != currentPixmap.rect().size()) {
+            frameRect = currentPixmap.rect();
+            emit q->resized(frameRect.size());
+        }
+
+        emit q->updated(frameRect);
+        emit q->frameChanged(currentFrameNumber);
+
+        if (movieState == QMovie::Running)
+            nextImageTimer.start(nextDelay);
+    } else {
+        // Could not read another frame
+        if (!isDone()) {
+            emit q->error(reader->error());
+        }
+
+        // Graceful finish
+        if (movieState != QMovie::Paused) {
+            nextFrameNumber = 0;
+            isFirstIteration = true;
+            playCounter = -1;
+            enterState(QMovie::NotRunning);
+            emit q->finished();
+        }
+    }
+}
+
+/*!
+    \internal
+*/
+bool QMoviePrivate::isValid() const
+{
+    return (greatestFrameNumber >= 0) // have we seen valid data
+        || reader->canRead(); // or does the reader see valid data
+}
+
+/*!
+    \internal
+*/
+bool QMoviePrivate::jumpToFrame(int frameNumber)
+{
+    if (frameNumber < 0)
+        return false;
+    if (currentFrameNumber == frameNumber)
+        return true;
+    nextFrameNumber = frameNumber;
+    if (movieState == QMovie::Running)
+        nextImageTimer.stop();
+    _q_loadNextFrame();
+    return (nextFrameNumber == currentFrameNumber+1);
+}
+
+/*!
+    \internal
+*/
+int QMoviePrivate::frameCount() const
+{
+    int result;
+    if ((result = reader->imageCount()) != 0)
+        return result;
+    if (haveReadAll)
+        return greatestFrameNumber+1;
+    return 0; // Don't know
+}
+
+/*!
+    \internal
+*/
+bool QMoviePrivate::jumpToNextFrame()
+{
+    return jumpToFrame(currentFrameNumber+1);
+}
+
+/*!
+    Constructs a QMovie object, passing the \a parent object to QObject's
+    constructor.
+
+    \sa setFileName(), setDevice(), setFormat()
+ */
+QMovie::QMovie(QObject *parent)
+    : QObject(*new QMoviePrivate(this), parent)
+{
+    Q_D(QMovie);
+    d->reader = new QImageReader;
+    connect(&d->nextImageTimer, SIGNAL(timeout()), this, SLOT(_q_loadNextFrame()));
+}
+
+/*!
+    Constructs a QMovie object. QMovie will use read image data from \a
+    device, which it assumes is open and readable. If \a format is not empty,
+    QMovie will use the image format \a format for decoding the image
+    data. Otherwise, QMovie will attempt to guess the format.
+
+    The \a parent object is passed to QObject's constructor.
+ */
+QMovie::QMovie(QIODevice *device, const QByteArray &format, QObject *parent)
+    : QObject(*new QMoviePrivate(this), parent)
+{
+    Q_D(QMovie);
+    d->reader = new QImageReader(device, format);
+    d->initialDevicePos = device->pos();
+    connect(&d->nextImageTimer, SIGNAL(timeout()), this, SLOT(_q_loadNextFrame()));
+}
+
+/*!
+    Constructs a QMovie object. QMovie will use read image data from \a
+    fileName. If \a format is not empty, QMovie will use the image format \a
+    format for decoding the image data. Otherwise, QMovie will attempt to
+    guess the format.
+
+    The \a parent object is passed to QObject's constructor.
+ */
+QMovie::QMovie(const QString &fileName, const QByteArray &format, QObject *parent)
+    : QObject(*new QMoviePrivate(this), parent)
+{
+    Q_D(QMovie);
+    d->absoluteFilePath = QDir(fileName).absolutePath();
+    d->reader = new QImageReader(fileName, format);
+    if (d->reader->device())
+        d->initialDevicePos = d->reader->device()->pos();
+    connect(&d->nextImageTimer, SIGNAL(timeout()), this, SLOT(_q_loadNextFrame()));
+}
+
+/*!
+    Destructs the QMovie object.
+*/
+QMovie::~QMovie()
+{
+    Q_D(QMovie);
+    delete d->reader;
+}
+
+/*!
+    Sets the current device to \a device. QMovie will read image data from
+    this device when the movie is running.
+
+    \sa device(), setFormat()
+*/
+void QMovie::setDevice(QIODevice *device)
+{
+    Q_D(QMovie);
+    d->reader->setDevice(device);
+    d->reset();
+}
+
+/*!
+    Returns the device QMovie reads image data from. If no device has
+    currently been assigned, 0 is returned.
+
+    \sa setDevice(), fileName()
+*/
+QIODevice *QMovie::device() const
+{
+    Q_D(const QMovie);
+    return d->reader->device();
+}
+
+/*!
+    Sets the name of the file that QMovie reads image data from, to \a
+    fileName.
+
+    \sa fileName(), setDevice(), setFormat()
+*/
+void QMovie::setFileName(const QString &fileName)
+{
+    Q_D(QMovie);
+    d->absoluteFilePath = QDir(fileName).absolutePath();
+    d->reader->setFileName(fileName);
+    d->reset();
+}
+
+/*!
+    Returns the name of the file that QMovie reads image data from. If no file
+    name has been assigned, or if the assigned device is not a file, an empty
+    QString is returned.
+
+    \sa setFileName(), device()
+*/
+QString QMovie::fileName() const
+{
+    Q_D(const QMovie);
+    return d->reader->fileName();
+}
+
+/*!
+    Sets the format that QMovie will use when decoding image data, to \a
+    format. By default, QMovie will attempt to guess the format of the image
+    data.
+
+    You can call supportedFormats() for the full list of formats
+    QMovie supports.
+
+    \sa QImageReader::supportedImageFormats()
+*/
+void QMovie::setFormat(const QByteArray &format)
+{
+    Q_D(QMovie);
+    d->reader->setFormat(format);
+}
+
+/*!
+    Returns the format that QMovie uses when decoding image data. If no format
+    has been assigned, an empty QByteArray() is returned.
+
+    \sa setFormat()
+*/
+QByteArray QMovie::format() const
+{
+    Q_D(const QMovie);
+    return d->reader->format();
+}
+
+/*!
+    For image formats that support it, this function sets the background color
+    to \a color.
+
+    \sa backgroundColor()
+*/
+void QMovie::setBackgroundColor(const QColor &color)
+{
+    Q_D(QMovie);
+    d->reader->setBackgroundColor(color);
+}
+
+/*!
+    Returns the background color of the movie. If no background color has been
+    assigned, an invalid QColor is returned.
+
+    \sa setBackgroundColor()
+*/
+QColor QMovie::backgroundColor() const
+{
+    Q_D(const QMovie);
+    return d->reader->backgroundColor();
+}
+
+/*!
+    Returns the current state of QMovie.
+
+    \sa MovieState, stateChanged()
+*/
+QMovie::MovieState QMovie::state() const
+{
+    Q_D(const QMovie);
+    return d->movieState;
+}
+
+/*!
+    Returns the rect of the last frame. If no frame has yet been updated, an
+    invalid QRect is returned.
+
+    \sa currentImage(), currentPixmap()
+*/
+QRect QMovie::frameRect() const
+{
+    Q_D(const QMovie);
+    return d->frameRect;
+}
+
+/*! \fn QImage QMovie::framePixmap() const
+
+    Use currentPixmap() instead.
+*/
+
+/*! \fn void QMovie::pause()
+
+    Use setPaused(true) instead.
+*/
+
+/*! \fn void QMovie::unpause()
+
+    Use setPaused(false) instead.
+*/
+
+/*!
+    Returns the current frame as a QPixmap.
+
+    \sa currentImage(), updated()
+*/
+QPixmap QMovie::currentPixmap() const
+{
+    Q_D(const QMovie);
+    return d->currentPixmap;
+}
+
+/*! \fn QImage QMovie::frameImage() const
+
+    Use currentImage() instead.
+*/
+
+/*!
+    Returns the current frame as a QImage.
+
+    \sa currentPixmap(), updated()
+*/
+QImage QMovie::currentImage() const
+{
+    Q_D(const QMovie);
+    return d->currentPixmap.toImage();
+}
+
+/*!
+    Returns true if the movie is valid (e.g., the image data is readable and
+    the image format is supported); otherwise returns false.
+*/
+bool QMovie::isValid() const
+{
+    Q_D(const QMovie);
+    return d->isValid();
+}
+
+/*! \fn bool QMovie::running() const
+
+    Use state() instead.
+*/
+
+/*! \fn bool QMovie::isNull() const
+
+    Use isValid() instead.
+*/
+
+/*! \fn int QMovie::frameNumber() const
+
+    Use currentFrameNumber() instead.
+*/
+
+/*! \fn bool QMovie::paused() const
+
+    Use state() instead.
+*/
+
+/*! \fn bool QMovie::finished() const
+
+    Use state() instead.
+*/
+
+/*! \fn void QMovie::restart()
+
+    Use stop() and start() instead.
+*/
+
+/*!
+    \fn void QMovie::step()
+
+    Use jumpToNextFrame() instead.
+*/
+
+/*!
+    Returns the number of frames in the movie.
+
+    Certain animation formats do not support this feature, in which
+    case 0 is returned.
+*/
+int QMovie::frameCount() const
+{
+    Q_D(const QMovie);
+    return d->frameCount();
+}
+
+/*!
+    Returns the number of milliseconds QMovie will wait before updating the
+    next frame in the animation.
+*/
+int QMovie::nextFrameDelay() const
+{
+    Q_D(const QMovie);
+    return d->nextDelay;
+}
+
+/*!
+    Returns the sequence number of the current frame. The number of the first
+    frame in the movie is 0.
+*/
+int QMovie::currentFrameNumber() const
+{
+    Q_D(const QMovie);
+    return d->currentFrameNumber;
+}
+
+/*!
+    Jumps to the next frame. Returns true on success; otherwise returns false.
+*/
+bool QMovie::jumpToNextFrame()
+{
+    Q_D(QMovie);
+    return d->jumpToNextFrame();
+}
+
+/*!
+    Jumps to frame number \a frameNumber. Returns true on success; otherwise
+    returns false.
+*/
+bool QMovie::jumpToFrame(int frameNumber)
+{
+    Q_D(QMovie);
+    return d->jumpToFrame(frameNumber);
+}
+
+/*!
+    Returns the number of times the movie will loop before it finishes.
+    If the movie will only play once (no looping), loopCount returns 0.
+    If the movie loops forever, loopCount returns -1.
+
+    Note that, if the image data comes from a sequential device (e.g. a
+    socket), QMovie can only loop the movie if the cacheMode is set to
+    QMovie::CacheAll.
+*/
+int QMovie::loopCount() const
+{
+    Q_D(const QMovie);
+    return d->reader->loopCount();
+}
+
+/*!
+    If \a paused is true, QMovie will enter \l Paused state and emit
+    stateChanged(Paused); otherwise it will enter \l Running state and emit
+    stateChanged(Running).
+
+    \sa state()
+*/
+void QMovie::setPaused(bool paused)
+{
+    Q_D(QMovie);
+    if (paused) {
+        if (d->movieState == NotRunning)
+            return;
+        d->enterState(Paused);
+        d->nextImageTimer.stop();
+    } else {
+        if (d->movieState == Running)
+            return;
+        d->enterState(Running);
+        d->nextImageTimer.start(nextFrameDelay());
+    }
+}
+
+/*!
+    \property QMovie::speed
+    \brief the movie's speed
+
+    The speed is measured in percentage of the original movie speed.
+    The default speed is 100%.
+    Example:
+
+    \snippet doc/src/snippets/code/src_gui_image_qmovie.cpp 1
+*/
+void QMovie::setSpeed(int percentSpeed)
+{
+    Q_D(QMovie);
+    d->speed = percentSpeed;
+}
+
+int QMovie::speed() const
+{
+    Q_D(const QMovie);
+    return d->speed;
+}
+
+/*!
+    Starts the movie. QMovie will enter \l Running state, and start emitting
+    updated() and resized() as the movie progresses.
+
+    If QMovie is in the \l Paused state, this function is equivalent
+    to calling setPaused(false). If QMovie is already in the \l
+    Running state, this function does nothing.
+
+    \sa stop(), setPaused()
+*/
+void QMovie::start()
+{
+    Q_D(QMovie);
+    if (d->movieState == NotRunning) {
+        d->_q_loadNextFrame(true);
+    } else if (d->movieState == Paused) {
+        setPaused(false);
+    }
+}
+
+/*!
+    Stops the movie. QMovie enters \l NotRunning state, and stops emitting
+    updated() and resized(). If start() is called again, the movie will
+    restart from the beginning.
+
+    If QMovie is already in the \l NotRunning state, this function
+    does nothing.
+
+    \sa start(), setPaused()
+*/
+void QMovie::stop()
+{
+    Q_D(QMovie);
+    if (d->movieState == NotRunning)
+        return;
+    d->enterState(NotRunning);
+    d->nextImageTimer.stop();
+    d->nextFrameNumber = 0;
+}
+
+/*!
+    \since 4.1
+
+    Returns the scaled size of frames.
+
+    \sa QImageReader::scaledSize()
+*/
+QSize QMovie::scaledSize()
+{
+    Q_D(QMovie);
+    return d->reader->scaledSize();
+}
+
+/*!
+    \since 4.1
+
+    Sets the scaled frame size to \a size.
+
+    \sa QImageReader::setScaledSize()
+*/
+void QMovie::setScaledSize(const QSize &size)
+{
+    Q_D(QMovie);
+    d->reader->setScaledSize(size);
+}
+
+/*!
+    \since 4.1
+
+    Returns the list of image formats supported by QMovie.
+
+    \sa QImageReader::supportedImageFormats()
+*/
+QList<QByteArray> QMovie::supportedFormats()
+{
+    QList<QByteArray> list = QImageReader::supportedImageFormats();
+    QMutableListIterator<QByteArray> it(list);
+    QBuffer buffer;
+    buffer.open(QIODevice::ReadOnly);
+    while (it.hasNext()) {
+        QImageReader reader(&buffer, it.next());
+        if (!reader.supportsAnimation())
+            it.remove();
+    }
+    return list;
+}
+
+/*!
+    \property QMovie::cacheMode
+    \brief the movie's cache mode
+
+    Caching frames can be useful when the underlying animation format handler
+    that QMovie relies on to decode the animation data does not support
+    jumping to particular frames in the animation, or even "rewinding" the
+    animation to the beginning (for looping). Furthermore, if the image data
+    comes from a sequential device, it is not possible for the underlying
+    animation handler to seek back to frames whose data has already been read
+    (making looping altogether impossible).
+
+    To aid in such situations, a QMovie object can be instructed to cache the
+    frames, at the added memory cost of keeping the frames in memory for the
+    lifetime of the object.
+
+    By default, this property is set to \l CacheNone.
+
+    \sa QMovie::CacheMode
+*/
+
+QMovie::CacheMode QMovie::cacheMode() const
+{
+    Q_D(const QMovie);
+    return d->cacheMode;
+}
+
+void QMovie::setCacheMode(CacheMode cacheMode)
+{
+    Q_D(QMovie);
+    d->cacheMode = cacheMode;
+}
+
+/*!
+  \internal
+*/
+QMovie::CacheMode QMovie::cacheMode()
+{
+    Q_D(QMovie);
+    return d->cacheMode;
+}
+
+QT_END_NAMESPACE
+
+#include "moc_qmovie.cpp"
+
+#endif // QT_NO_MOVIE
diff --git a/src/gui/image/qmovie.h b/src/gui/image/qmovie.h
new file mode 100644
index 0000000..c2c3abb
--- /dev/null
+++ b/src/gui/image/qmovie.h
@@ -0,0 +1,177 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QMOVIE_H
+#define QMOVIE_H
+
+#include <QtCore/qobject.h>
+
+#ifndef QT_NO_MOVIE
+
+#include <QtCore/qbytearray.h>
+#include <QtCore/qlist.h>
+#include <QtCore/qobject.h>
+#include <QtGui/qimagereader.h>
+
+#ifdef QT3_SUPPORT
+#include <QtGui/qimage.h>
+#include <QtGui/qpixmap.h>
+#endif
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+class QByteArray;
+class QColor;
+class QIODevice;
+class QImage;
+class QPixmap;
+class QRect;
+class QSize;
+
+class QMoviePrivate;
+class Q_GUI_EXPORT QMovie : public QObject
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(QMovie)
+    Q_ENUMS(MovieState CacheMode)
+    Q_PROPERTY(int speed READ speed WRITE setSpeed)
+    Q_PROPERTY(CacheMode cacheMode READ cacheMode WRITE setCacheMode)
+public:
+    enum MovieState {
+        NotRunning,
+        Paused,
+        Running
+    };
+    enum CacheMode {
+        CacheNone,
+        CacheAll
+    };
+
+    QMovie(QObject *parent = 0);
+    explicit QMovie(QIODevice *device, const QByteArray &format = QByteArray(), QObject *parent = 0);
+    explicit QMovie(const QString &fileName, const QByteArray &format = QByteArray(), QObject *parent = 0);
+    ~QMovie();
+
+    static QList<QByteArray> supportedFormats();
+
+    void setDevice(QIODevice *device);
+    QIODevice *device() const;
+
+    void setFileName(const QString &fileName);
+    QString fileName() const;
+
+    void setFormat(const QByteArray &format);
+    QByteArray format() const;
+
+    void setBackgroundColor(const QColor &color);
+    QColor backgroundColor() const;
+
+    MovieState state() const;
+
+    QRect frameRect() const;
+    QImage currentImage() const;
+    QPixmap currentPixmap() const;
+
+    bool isValid() const;
+
+    bool jumpToFrame(int frameNumber);
+    int loopCount() const;
+    int frameCount() const;
+    int nextFrameDelay() const;
+    int currentFrameNumber() const;
+
+    int speed() const;
+
+    QSize scaledSize();
+    void setScaledSize(const QSize &size);
+
+    CacheMode cacheMode() const;
+    void setCacheMode(CacheMode mode);
+
+    CacheMode cacheMode(); // ### Qt 5: remove me
+
+Q_SIGNALS:
+    void started();
+    void resized(const QSize &size);
+    void updated(const QRect &rect);
+    void stateChanged(QMovie::MovieState state);
+    void error(QImageReader::ImageReaderError error);
+    void finished();
+    void frameChanged(int frameNumber);
+
+public Q_SLOTS:
+    void start();
+    bool jumpToNextFrame();
+    void setPaused(bool paused);
+    void stop();
+    void setSpeed(int percentSpeed);
+
+private:
+    Q_DISABLE_COPY(QMovie)
+    Q_PRIVATE_SLOT(d_func(), void _q_loadNextFrame())
+
+#ifdef QT3_SUPPORT
+public:
+    inline QT3_SUPPORT bool isNull() const { return isValid(); }
+    inline QT3_SUPPORT int frameNumber() const { return currentFrameNumber(); }
+    inline QT3_SUPPORT bool running() const { return state() == Running; }
+    inline QT3_SUPPORT bool paused() const { return state() == Paused; }
+    inline QT3_SUPPORT bool finished() const { return state() == NotRunning; }
+    inline QT3_SUPPORT void restart() { stop(); start(); }
+    inline QT3_SUPPORT QImage frameImage() const { return currentImage(); }
+    inline QT3_SUPPORT QPixmap framePixmap() const { return currentPixmap(); }
+    inline QT3_SUPPORT void step() { jumpToNextFrame(); }
+    inline QT3_SUPPORT void pause() { setPaused(true); }
+    inline QT3_SUPPORT void unpause() { setPaused(false); }
+#endif
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QT_NO_MOVIE
+
+#endif // QMOVIE_H
diff --git a/src/gui/image/qnativeimage.cpp b/src/gui/image/qnativeimage.cpp
new file mode 100644
index 0000000..6b74323
--- /dev/null
+++ b/src/gui/image/qnativeimage.cpp
@@ -0,0 +1,279 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <qdebug.h>
+#include "qnativeimage_p.h"
+#include "qcolormap.h"
+
+#include "private/qpaintengine_raster_p.h"
+
+#if defined(Q_WS_X11) && !defined(QT_NO_MITSHM)
+#include <qx11info_x11.h>
+#include <sys/ipc.h>
+#include <sys/shm.h>
+#include <qwidget.h>
+#endif
+
+QT_BEGIN_NAMESPACE
+
+#ifdef Q_WS_WIN
+typedef struct {
+    BITMAPINFOHEADER bmiHeader;
+    DWORD redMask;
+    DWORD greenMask;
+    DWORD blueMask;
+} BITMAPINFO_MASK;
+
+
+QNativeImage::QNativeImage(int width, int height, QImage::Format format, bool isTextBuffer, QWidget *)
+{
+#ifndef Q_OS_WINCE
+    Q_UNUSED(isTextBuffer);
+#endif
+    BITMAPINFO_MASK bmi;
+    memset(&bmi, 0, sizeof(bmi));
+    bmi.bmiHeader.biSize        = sizeof(BITMAPINFOHEADER);
+    bmi.bmiHeader.biWidth       = width;
+    bmi.bmiHeader.biHeight      = -height;
+    bmi.bmiHeader.biPlanes      = 1;
+    bmi.bmiHeader.biSizeImage   = 0;
+
+    if (format == QImage::Format_RGB16) {
+        bmi.bmiHeader.biBitCount = 16;
+#ifdef Q_OS_WINCE
+        if (isTextBuffer) {
+            bmi.bmiHeader.biCompression = BI_RGB;
+            bmi.redMask = 0;
+            bmi.greenMask = 0;
+            bmi.blueMask = 0;
+        } else
+#endif
+        {
+            bmi.bmiHeader.biCompression = BI_BITFIELDS;
+            bmi.redMask = 0xF800;
+            bmi.greenMask = 0x07E0;
+            bmi.blueMask = 0x001F;
+        }
+    } else {
+        bmi.bmiHeader.biBitCount    = 32;
+        bmi.bmiHeader.biCompression = BI_RGB;
+        bmi.redMask = 0;
+        bmi.greenMask = 0;
+        bmi.blueMask = 0;
+    }
+
+    hdc = CreateCompatibleDC(qt_win_display_dc());
+    Q_ASSERT(hdc);
+
+    uchar *bits = 0;
+    bitmap = CreateDIBSection(hdc, reinterpret_cast<BITMAPINFO *>(&bmi), DIB_RGB_COLORS, (void**) &bits, 0, 0);
+    Q_ASSERT(bitmap);
+    Q_ASSERT(bits);
+
+    null_bitmap = (HBITMAP)SelectObject(hdc, bitmap);
+    image = QImage(bits, width, height, format);
+
+    Q_ASSERT(image.paintEngine()->type() == QPaintEngine::Raster);
+    static_cast<QRasterPaintEngine *>(image.paintEngine())->setDC(hdc);
+
+#ifndef Q_OS_WINCE
+    GdiFlush();
+#endif
+}
+
+QNativeImage::~QNativeImage()
+{
+    if (bitmap || hdc) {
+        Q_ASSERT(hdc);
+        Q_ASSERT(bitmap);
+        if (null_bitmap)
+            SelectObject(hdc, null_bitmap);
+        DeleteDC(hdc);
+        DeleteObject(bitmap);
+    }
+}
+
+QImage::Format QNativeImage::systemFormat()
+{
+    if (QColormap::instance().depth() == 16)
+        return QImage::Format_RGB16;
+    return QImage::Format_RGB32;
+}
+
+
+#elif defined(Q_WS_X11) && !defined(QT_NO_MITSHM)
+
+QNativeImage::QNativeImage(int width, int height, QImage::Format format,bool /* isTextBuffer */, QWidget *widget)
+{
+    if (!X11->use_mitshm) {
+        xshmimg = 0;
+        xshmpm = 0;
+        image = QImage(width, height, format);
+        return;
+    }
+
+    QX11Info info = widget->x11Info();
+
+    int dd = info.depth();
+    Visual *vis = (Visual*) info.visual();
+
+    xshmimg = XShmCreateImage(X11->display, vis, dd, ZPixmap, 0, &xshminfo, width, height);
+    if (!xshmimg) {
+        qWarning("QNativeImage: Unable to create shared XImage.");
+        return;
+    }
+
+    bool ok;
+    xshminfo.shmid = shmget(IPC_PRIVATE, xshmimg->bytes_per_line * xshmimg->height,
+                            IPC_CREAT | 0777);
+    ok = xshminfo.shmid != -1;
+    if (ok) {
+        xshmimg->data = (char*)shmat(xshminfo.shmid, 0, 0);
+        xshminfo.shmaddr = xshmimg->data;
+        ok = (xshminfo.shmaddr != (char*)-1);
+        if (ok)
+            image = QImage((uchar *)xshmimg->data, width, height, systemFormat());
+    }
+    xshminfo.readOnly = false;
+    if (ok)
+        ok = XShmAttach(X11->display, &xshminfo);
+    if (!ok) {
+        qWarning() << "QNativeImage: Unable to attach to shared memory segment.";
+        if (xshmimg->data) {
+            free(xshmimg->data);
+            xshmimg->data = 0;
+        }
+        XDestroyImage(xshmimg);
+        xshmimg = 0;
+        if (xshminfo.shmaddr)
+            shmdt(xshminfo.shmaddr);
+        if (xshminfo.shmid != -1)
+            shmctl(xshminfo.shmid, IPC_RMID, 0);
+        return;
+    }
+    xshmpm = XShmCreatePixmap(X11->display, DefaultRootWindow(X11->display), xshmimg->data,
+                              &xshminfo, width, height, dd);
+    if (!xshmpm) {
+        qWarning() << "QNativeImage: Unable to create shared Pixmap.";
+    }
+}
+
+
+QNativeImage::~QNativeImage()
+{
+    if (!xshmimg)
+        return;
+
+    if (xshmpm) {
+        XFreePixmap(X11->display, xshmpm);
+        xshmpm = 0;
+    }
+    XShmDetach(X11->display, &xshminfo);
+    xshmimg->data = 0;
+    XDestroyImage(xshmimg);
+    xshmimg = 0;
+    shmdt(xshminfo.shmaddr);
+    shmctl(xshminfo.shmid, IPC_RMID, 0);
+}
+
+QImage::Format QNativeImage::systemFormat()
+{
+    if (QX11Info::appDepth() == 16)
+        return QImage::Format_RGB16;
+    return QImage::Format_RGB32;
+}
+
+#elif defined(Q_WS_MAC)
+
+QNativeImage::QNativeImage(int width, int height, QImage::Format format, bool /* isTextBuffer */, QWidget *)
+    : image(width, height, format)
+{
+    cgColorSpace = CGColorSpaceCreateDeviceRGB();
+    uint cgflags = kCGImageAlphaNoneSkipFirst;
+
+#ifdef kCGBitmapByteOrder32Host //only needed because CGImage.h added symbols in the minor version
+    if(QSysInfo::MacintoshVersion >= QSysInfo::MV_10_4)
+        cgflags |= kCGBitmapByteOrder32Host;
+#endif
+
+    cg = CGBitmapContextCreate(image.bits(), width, height, 8, image.bytesPerLine(), cgColorSpace, cgflags);
+    CGContextTranslateCTM(cg, 0, height);
+    CGContextScaleCTM(cg, 1, -1);
+
+    Q_ASSERT(image.paintEngine()->type() == QPaintEngine::Raster);
+    static_cast<QRasterPaintEngine *>(image.paintEngine())->setCGContext(cg);
+}
+
+
+QNativeImage::~QNativeImage()
+{
+    CGContextRelease(cg);
+    CGColorSpaceRelease(cgColorSpace);
+}
+
+QImage::Format QNativeImage::systemFormat()
+{
+    return QImage::Format_RGB32;
+}
+
+
+#else // other platforms...
+
+QNativeImage::QNativeImage(int width, int height, QImage::Format format,  bool /* isTextBuffer */, QWidget *)
+    : image(width, height, format)
+{
+
+}
+
+
+QNativeImage::~QNativeImage()
+{
+}
+
+QImage::Format QNativeImage::systemFormat()
+{
+    return QImage::Format_RGB32;
+}
+
+#endif // platforms
+
+QT_END_NAMESPACE
+
diff --git a/src/gui/image/qnativeimage_p.h b/src/gui/image/qnativeimage_p.h
new file mode 100644
index 0000000..860485a
--- /dev/null
+++ b/src/gui/image/qnativeimage_p.h
@@ -0,0 +1,110 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QNATIVEIMAGE_P_H
+#define QNATIVEIMAGE_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 "qimage.h"
+
+#ifdef Q_WS_WIN
+#include "qt_windows.h"
+
+#elif defined(Q_WS_X11)
+#include <private/qt_x11_p.h>
+
+#elif defined(Q_WS_MAC)
+#include <private/qt_mac_p.h>
+
+#endif
+
+QT_BEGIN_NAMESPACE
+
+class QWidget;
+
+class Q_GUI_EXPORT QNativeImage
+{
+public:
+    QNativeImage(int width, int height, QImage::Format format, bool isTextBuffer = false, QWidget *widget = 0);
+    ~QNativeImage();
+
+    inline int width() const;
+    inline int height() const;
+
+    QImage image;
+
+    static QImage::Format systemFormat();
+
+#ifdef Q_WS_WIN
+    HDC hdc;
+    HBITMAP bitmap;
+    HBITMAP null_bitmap;
+
+#elif defined(Q_WS_X11) && !defined(QT_NO_MITSHM)
+    XImage *xshmimg;
+    Pixmap xshmpm;
+    XShmSegmentInfo xshminfo;
+
+#elif defined(Q_WS_MAC)
+    CGContextRef cg;
+    CGColorSpaceRef cgColorSpace;
+#endif
+
+private:
+    Q_DISABLE_COPY(QNativeImage)
+};
+
+inline int QNativeImage::width() const { return image.width(); }
+inline int QNativeImage::height() const { return image.height(); }
+
+QT_END_NAMESPACE
+
+#endif // QNATIVEIMAGE_P_H
diff --git a/src/gui/image/qpaintengine_pic.cpp b/src/gui/image/qpaintengine_pic.cpp
new file mode 100644
index 0000000..cba9827
--- /dev/null
+++ b/src/gui/image/qpaintengine_pic.cpp
@@ -0,0 +1,519 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "private/qpaintengine_p.h"
+#include "private/qpainter_p.h"
+#include "private/qpicture_p.h"
+#include "private/qfont_p.h"
+
+#ifndef QT_NO_PICTURE
+
+#include "qbuffer.h"
+#include "qbytearray.h"
+#include "qdatastream.h"
+#include "qmath.h"
+#include "qpaintengine_pic_p.h"
+#include "qpicture.h"
+#include "qpolygon.h"
+#include "qrect.h"
+#include <private/qtextengine_p.h>
+
+//#define QT_PICTURE_DEBUG
+#include <qdebug.h>
+
+
+QT_BEGIN_NAMESPACE
+
+class QPicturePaintEnginePrivate : public QPaintEnginePrivate
+{
+    Q_DECLARE_PUBLIC(QPicturePaintEngine)
+public:
+    QDataStream s;
+    QPainter *pt;
+    QPicturePrivate *pic_d;
+};
+
+QPicturePaintEngine::QPicturePaintEngine()
+    : QPaintEngine(*(new QPicturePaintEnginePrivate), AllFeatures)
+{
+    Q_D(QPicturePaintEngine);
+    d->pt = 0;
+}
+
+QPicturePaintEngine::QPicturePaintEngine(QPaintEnginePrivate &dptr)
+    : QPaintEngine(dptr, AllFeatures)
+{
+    Q_D(QPicturePaintEngine);
+    d->pt = 0;
+}
+
+QPicturePaintEngine::~QPicturePaintEngine()
+{
+}
+
+bool QPicturePaintEngine::begin(QPaintDevice *pd)
+{
+    Q_D(QPicturePaintEngine);
+#ifdef QT_PICTURE_DEBUG
+    qDebug() << "QPicturePaintEngine::begin()";
+#endif
+    Q_ASSERT(pd);
+    QPicture *pic = static_cast<QPicture *>(pd);
+
+    d->pdev = pd;
+    d->pic_d = pic->d_func();
+    Q_ASSERT(d->pic_d);
+
+    d->s.setDevice(&d->pic_d->pictb);
+    d->s.setVersion(d->pic_d->formatMajor);
+
+    d->pic_d->pictb.open(QIODevice::WriteOnly | QIODevice::Truncate);
+    d->s.writeRawData(qt_mfhdr_tag, 4);
+    d->s << (quint16) 0 << (quint16) d->pic_d->formatMajor << (quint16) d->pic_d->formatMinor;
+    d->s << (quint8) QPicturePrivate::PdcBegin << (quint8) sizeof(qint32);
+    d->pic_d->brect = QRect();
+    if (d->pic_d->formatMajor >= 4) {
+        QRect r = pic->boundingRect();
+        d->s << (qint32) r.left() << (qint32) r.top() << (qint32) r.width()
+             << (qint32) r.height();
+    }
+    d->pic_d->trecs = 0;
+    d->s << (quint32)d->pic_d->trecs; // total number of records
+    d->pic_d->formatOk = false;
+    setActive(true);
+    return true;
+}
+
+bool QPicturePaintEngine::end()
+{
+    Q_D(QPicturePaintEngine);
+#ifdef QT_PICTURE_DEBUG
+    qDebug() << "QPicturePaintEngine::end()";
+#endif
+    d->pic_d->trecs++;
+    d->s << (quint8) QPicturePrivate::PdcEnd << (quint8) 0;
+    int cs_start = sizeof(quint32);                // pos of checksum word
+    int data_start = cs_start + sizeof(quint16);
+    int brect_start = data_start + 2*sizeof(qint16) + 2*sizeof(quint8);
+    int pos = d->pic_d->pictb.pos();
+    d->pic_d->pictb.seek(brect_start);
+    if (d->pic_d->formatMajor >= 4) { // bounding rectangle
+        QRect r = static_cast<QPicture *>(d->pdev)->boundingRect();
+        d->s << (qint32) r.left() << (qint32) r.top() << (qint32) r.width()
+             << (qint32) r.height();
+    }
+    d->s << (quint32) d->pic_d->trecs;                        // write number of records
+    d->pic_d->pictb.seek(cs_start);
+    QByteArray buf = d->pic_d->pictb.buffer();
+    quint16 cs = (quint16) qChecksum(buf.constData() + data_start, pos - data_start);
+    d->s << cs;                                // write checksum
+    d->pic_d->pictb.close();
+    setActive(false);
+    return true;
+}
+
+#define SERIALIZE_CMD(c) \
+    d->pic_d->trecs++; \
+    d->s << (quint8) c; \
+    d->s << (quint8) 0; \
+    pos = d->pic_d->pictb.pos()
+
+void QPicturePaintEngine::updatePen(const QPen &pen)
+{
+    Q_D(QPicturePaintEngine);
+#ifdef QT_PICTURE_DEBUG
+    qDebug() << " -> updatePen(): width:" << pen.width() << "style:"
+             << pen.style() << "color:" << pen.color();
+#endif
+    int pos;
+    SERIALIZE_CMD(QPicturePrivate::PdcSetPen);
+    if (d->pic_d->in_memory_only) {
+        int index = d->pic_d->pen_list.size();
+        d->pic_d->pen_list.append(pen);
+        d->s << index;
+    } else {
+        d->s << pen;
+    }
+    writeCmdLength(pos, QRect(), false);
+}
+
+void QPicturePaintEngine::updateCompositionMode(QPainter::CompositionMode cmode)
+{
+    Q_D(QPicturePaintEngine);
+#ifdef QT_PICTURE_DEBUG
+    qDebug() << " -> updateCompositionMode():" << cmode;
+#endif
+    int pos;
+    SERIALIZE_CMD(QPicturePrivate::PdcSetCompositionMode);
+    d->s << (qint32)cmode;
+    writeCmdLength(pos, QRectF(), false);
+}
+
+void QPicturePaintEngine::updateClipEnabled(bool enabled)
+{
+    Q_D(QPicturePaintEngine);
+#ifdef QT_PICTURE_DEBUG
+    qDebug() << " -> updateClipEnabled():" << enabled;
+#endif
+    int pos;
+    SERIALIZE_CMD(QPicturePrivate::PdcSetClipEnabled);
+    d->s << enabled;
+    writeCmdLength(pos, QRectF(), false);
+}
+
+void QPicturePaintEngine::updateOpacity(qreal opacity)
+{
+    Q_D(QPicturePaintEngine);
+#ifdef QT_PICTURE_DEBUG
+    qDebug() << " -> updateOpacity():" << opacity;
+#endif
+    int pos;
+    SERIALIZE_CMD(QPicturePrivate::PdcSetOpacity);
+    d->s << double(opacity);
+    writeCmdLength(pos, QRectF(), false);
+}
+
+void QPicturePaintEngine::updateBrush(const QBrush &brush)
+{
+    Q_D(QPicturePaintEngine);
+#ifdef QT_PICTURE_DEBUG
+    qDebug() << " -> updateBrush(): style:" << brush.style();
+#endif
+    int pos;
+    SERIALIZE_CMD(QPicturePrivate::PdcSetBrush);
+    if (d->pic_d->in_memory_only) {
+        int index = d->pic_d->brush_list.size();
+        d->pic_d->brush_list.append(brush);
+        d->s << index;
+    } else {
+        d->s << brush;
+    }
+    writeCmdLength(pos, QRect(), false);
+}
+
+void QPicturePaintEngine::updateBrushOrigin(const QPointF &p)
+{
+    Q_D(QPicturePaintEngine);
+#ifdef QT_PICTURE_DEBUG
+    qDebug() << " -> updateBrushOrigin(): " << p;
+#endif
+    int pos;
+    SERIALIZE_CMD(QPicturePrivate::PdcSetBrushOrigin);
+    d->s << p;
+    writeCmdLength(pos, QRect(), false);
+}
+
+void QPicturePaintEngine::updateFont(const QFont &font)
+{
+    Q_D(QPicturePaintEngine);
+#ifdef QT_PICTURE_DEBUG
+    qDebug() << " -> updateFont(): pt sz:" << font.pointSize();
+#endif
+    int pos;
+    SERIALIZE_CMD(QPicturePrivate::PdcSetFont);
+    QFont fnt = font;
+    d->s << fnt;
+    writeCmdLength(pos, QRectF(), false);
+}
+
+void QPicturePaintEngine::updateBackground(Qt::BGMode bgMode, const QBrush &bgBrush)
+{
+    Q_D(QPicturePaintEngine);
+#ifdef QT_PICTURE_DEBUG
+    qDebug() << " -> updateBackground(): mode:" << bgMode << "style:" << bgBrush.style();
+#endif
+    int pos;
+    SERIALIZE_CMD(QPicturePrivate::PdcSetBkColor);
+    d->s << bgBrush.color();
+    writeCmdLength(pos, QRect(), false);
+
+    SERIALIZE_CMD(QPicturePrivate::PdcSetBkMode);
+    d->s << (qint8) bgMode;
+    writeCmdLength(pos, QRectF(), false);
+}
+
+void QPicturePaintEngine::updateMatrix(const QTransform &matrix)
+{
+    Q_D(QPicturePaintEngine);
+#ifdef QT_PICTURE_DEBUG
+    qDebug() << " -> updateMatrix():" << matrix;
+#endif
+    int pos;
+    SERIALIZE_CMD(QPicturePrivate::PdcSetWMatrix);
+    d->s << matrix << (qint8) false;
+    writeCmdLength(pos, QRectF(), false);
+}
+
+void QPicturePaintEngine::updateClipRegion(const QRegion &region, Qt::ClipOperation op)
+{
+    Q_D(QPicturePaintEngine);
+#ifdef QT_PICTURE_DEBUG
+    qDebug() << " -> updateClipRegion(): op:" << op
+             << "bounding rect:" << region.boundingRect();
+#endif
+    int pos;
+    SERIALIZE_CMD(QPicturePrivate::PdcSetClipRegion);
+    d->s << region << qint8(op);
+    writeCmdLength(pos, QRectF(), false);
+}
+
+void QPicturePaintEngine::updateClipPath(const QPainterPath &path, Qt::ClipOperation op)
+{
+    Q_D(QPicturePaintEngine);
+#ifdef QT_PICTURE_DEBUG
+    qDebug() << " -> updateClipPath(): op:" << op
+             << "bounding rect:" << path.boundingRect();
+#endif
+    int pos;
+
+    SERIALIZE_CMD(QPicturePrivate::PdcSetClipPath);
+    d->s << path << qint8(op);
+    writeCmdLength(pos, QRectF(), false);
+}
+
+void QPicturePaintEngine::updateRenderHints(QPainter::RenderHints hints)
+{
+    Q_D(QPicturePaintEngine);
+#ifdef QT_PICTURE_DEBUG
+    qDebug() << " -> updateRenderHints(): " << hints;
+#endif
+    int pos;
+    SERIALIZE_CMD(QPicturePrivate::PdcSetRenderHint);
+    d->s << (quint32) hints;
+    writeCmdLength(pos, QRect(), false);
+}
+
+void QPicturePaintEngine::writeCmdLength(int pos, const QRectF &r, bool corr)
+{
+    Q_D(QPicturePaintEngine);
+    int newpos = d->pic_d->pictb.pos();            // new position
+    int length = newpos - pos;
+    QRectF br(r);
+
+    if (length < 255) {                         // write 8-bit length
+        d->pic_d->pictb.seek(pos - 1);             // position to right index
+        d->s << (quint8)length;
+    } else {                                    // write 32-bit length
+        d->s << (quint32)0;                    // extend the buffer
+        d->pic_d->pictb.seek(pos - 1);             // position to right index
+        d->s << (quint8)255;                   // indicate 32-bit length
+        char *p = d->pic_d->pictb.buffer().data();
+        memmove(p+pos+4, p+pos, length);        // make room for 4 byte
+        d->s << (quint32)length;
+        newpos += 4;
+    }
+    d->pic_d->pictb.seek(newpos);                  // set to new position
+
+    if (br.width() > 0.0 || br.height() > 0.0) {
+        if (corr) {                             // widen bounding rect
+            int w2 = painter()->pen().width() / 2;
+            br.setCoords(br.left() - w2, br.top() - w2,
+                        br.right() + w2, br.bottom() + w2);
+        }
+        br = painter()->transform().mapRect(br);
+        if (painter()->hasClipping()) {
+            QRect cr = painter()->clipRegion().boundingRect();
+            br &= cr;
+        }
+
+        if (br.width() > 0.0 || br.height() > 0.0) {
+            int minx = qFloor(br.left());
+            int miny = qFloor(br.top());
+            int maxx = qCeil(br.right());
+            int maxy = qCeil(br.bottom());
+
+            if (d->pic_d->brect.width() > 0 || d->pic_d->brect.height() > 0) {
+                minx = qMin(minx, d->pic_d->brect.left());
+                miny = qMin(miny, d->pic_d->brect.top());
+                maxx = qMax(maxx, d->pic_d->brect.x() + d->pic_d->brect.width());
+                maxy = qMax(maxy, d->pic_d->brect.y() + d->pic_d->brect.height());
+                d->pic_d->brect = QRect(minx, miny, maxx - minx, maxy - miny);
+            } else {
+                d->pic_d->brect = QRect(minx, miny, maxx - minx, maxy - miny);
+            }
+        }
+    }
+}
+
+void QPicturePaintEngine::drawEllipse(const QRectF &rect)
+{
+    Q_D(QPicturePaintEngine);
+#ifdef QT_PICTURE_DEBUG
+    qDebug() << " -> drawEllipse():" << rect;
+#endif
+    int pos;
+    SERIALIZE_CMD(QPicturePrivate::PdcDrawEllipse);
+    d->s << rect;
+    writeCmdLength(pos, rect, true);
+}
+
+void QPicturePaintEngine::drawPath(const QPainterPath &path)
+{
+    Q_D(QPicturePaintEngine);
+#ifdef QT_PICTURE_DEBUG
+    qDebug() << " -> drawPath():" << path.boundingRect();
+#endif
+    int pos;
+    SERIALIZE_CMD(QPicturePrivate::PdcDrawPath);
+    d->s << path;
+    writeCmdLength(pos, path.boundingRect(), true);
+}
+
+void QPicturePaintEngine::drawPolygon(const QPointF *points, int numPoints, PolygonDrawMode mode)
+{
+    Q_D(QPicturePaintEngine);
+#ifdef QT_PICTURE_DEBUG
+    qDebug() << " -> drawPolygon(): size=" << numPoints;
+#endif
+    int pos;
+
+    QPolygonF polygon;
+    for (int i=0; i<numPoints; ++i)
+        polygon << points[i];
+
+    if (mode == PolylineMode) {
+        SERIALIZE_CMD(QPicturePrivate::PdcDrawPolyline);
+        d->s << polygon;
+    } else {
+        SERIALIZE_CMD(QPicturePrivate::PdcDrawPolygon);
+        d->s << polygon;
+        d->s << (qint8)(mode == OddEvenMode ? 0 : 1);
+    }
+
+    writeCmdLength(pos, polygon.boundingRect(), true);
+}
+
+void QPicturePaintEngine::drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr)
+{
+    Q_D(QPicturePaintEngine);
+#ifdef QT_PICTURE_DEBUG
+    qDebug() << " -> drawPixmap():" << r;
+#endif
+    int pos;
+    SERIALIZE_CMD(QPicturePrivate::PdcDrawPixmap);
+
+    if (d->pic_d->in_memory_only) {
+        int index = d->pic_d->pixmap_list.size();
+        d->pic_d->pixmap_list.append(pm);
+        d->s << r << index << sr;
+    } else {
+        d->s << r << pm << sr;
+    }
+    writeCmdLength(pos, r, false);
+}
+
+void QPicturePaintEngine::drawTiledPixmap(const QRectF &r, const QPixmap &pixmap, const QPointF &s)
+{
+    Q_D(QPicturePaintEngine);
+#ifdef QT_PICTURE_DEBUG
+    qDebug() << " -> drawTiledPixmap():" << r << s;
+#endif
+    int pos;
+    SERIALIZE_CMD(QPicturePrivate::PdcDrawTiledPixmap);
+    if (d->pic_d->in_memory_only) {
+        int index = d->pic_d->pixmap_list.size();
+        d->pic_d->pixmap_list.append(pixmap);
+        d->s << r << index << s;
+    } else {
+        d->s << r << pixmap << s;
+    }
+    writeCmdLength(pos, r, false);
+}
+
+extern int qt_defaultDpi();
+
+void QPicturePaintEngine::drawTextItem(const QPointF &p , const QTextItem &ti)
+{
+    Q_D(QPicturePaintEngine);
+#ifdef QT_PICTURE_DEBUG
+    qDebug() << " -> drawTextItem():" << p << ti.text();
+#endif
+
+    if (d->pic_d->formatMajor >= 9) {
+        const QTextItemInt &si = static_cast<const QTextItemInt &>(ti);
+        int pos;
+        SERIALIZE_CMD(QPicturePrivate::PdcDrawTextItem);
+        QFont fnt = ti.font();
+        fnt.setUnderline(false);
+        fnt.setStrikeOut(false);
+        fnt.setOverline(false);
+
+        qreal justificationWidth = 0;
+        if (si.justified)
+            justificationWidth = si.width.toReal();
+
+        d->s << p << ti.text() << fnt << ti.renderFlags() << double(fnt.d->dpi)/qt_defaultDpi() << justificationWidth;
+        writeCmdLength(pos, /*brect=*/QRectF(), /*corr=*/false);
+    } else if (d->pic_d->formatMajor >= 8) {
+        // old old (buggy) format
+        int pos;
+        SERIALIZE_CMD(QPicturePrivate::PdcDrawTextItem);
+        d->s << QPointF(p.x(), p.y() - ti.ascent()) << ti.text() << ti.font() << ti.renderFlags();
+        writeCmdLength(pos, /*brect=*/QRectF(), /*corr=*/false);
+    } else {
+        // old (buggy) format
+        int pos;
+        SERIALIZE_CMD(QPicturePrivate::PdcDrawText2);
+        d->s << p << ti.text();
+        writeCmdLength(pos, QRectF(p, QSizeF(1,1)), true);
+    }
+}
+
+void QPicturePaintEngine::updateState(const QPaintEngineState &state)
+{
+    QPaintEngine::DirtyFlags flags = state.state();
+    if (flags & DirtyPen) updatePen(state.pen());
+    if (flags & DirtyBrush) updateBrush(state.brush());
+    if (flags & DirtyBrushOrigin) updateBrushOrigin(state.brushOrigin());
+    if (flags & DirtyFont) updateFont(state.font());
+    if (flags & DirtyBackground) updateBackground(state.backgroundMode(), state.backgroundBrush());
+    if (flags & DirtyTransform) updateMatrix(state.transform());
+    if (flags & DirtyClipEnabled) updateClipEnabled(state.isClipEnabled());
+    if (flags & DirtyClipRegion) updateClipRegion(state.clipRegion(), state.clipOperation());
+    if (flags & DirtyClipPath) updateClipPath(state.clipPath(), state.clipOperation());
+    if (flags & DirtyHints) updateRenderHints(state.renderHints());
+    if (flags & DirtyCompositionMode) updateCompositionMode(state.compositionMode());
+    if (flags & DirtyOpacity) updateOpacity(state.opacity());
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_PICTURE
diff --git a/src/gui/image/qpaintengine_pic_p.h b/src/gui/image/qpaintengine_pic_p.h
new file mode 100644
index 0000000..3ae0845
--- /dev/null
+++ b/src/gui/image/qpaintengine_pic_p.h
@@ -0,0 +1,120 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPAINTENGINE_PIC_P_H
+#define QPAINTENGINE_PIC_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of QAbstractItemModel*.  This header file may change from version
+// to version without notice, or even be removed.
+//
+// We mean it.
+//
+//
+
+#include "QtGui/qpaintengine.h"
+
+#ifndef QT_NO_PICTURE
+
+QT_BEGIN_NAMESPACE
+
+class QPicturePaintEnginePrivate;
+class QBuffer;
+
+class QPicturePaintEngine : public QPaintEngine
+{
+    Q_DECLARE_PRIVATE(QPicturePaintEngine)
+public:
+    QPicturePaintEngine();
+    ~QPicturePaintEngine();
+
+    bool begin(QPaintDevice *pdev);
+    bool end();
+
+    void updateState(const QPaintEngineState &state);
+
+    void updatePen(const QPen &pen);
+    void updateBrush(const QBrush &brush);
+    void updateBrushOrigin(const QPointF &origin);
+    void updateFont(const QFont &font);
+    void updateBackground(Qt::BGMode bgmode, const QBrush &bgBrush);
+    void updateMatrix(const QTransform &matrix);
+    void updateClipRegion(const QRegion &region, Qt::ClipOperation op);
+    void updateClipPath(const QPainterPath &path, Qt::ClipOperation op);
+    void updateRenderHints(QPainter::RenderHints hints);
+    void updateCompositionMode(QPainter::CompositionMode cmode);
+    void updateClipEnabled(bool enabled);
+    void updateOpacity(qreal opacity);
+
+    void drawEllipse(const QRectF &rect);
+    void drawPath(const QPainterPath &path);
+    void drawPolygon(const QPointF *points, int numPoints, PolygonDrawMode mode);
+#ifdef Q_NO_USING_KEYWORD
+    inline void drawPolygon(const QPoint *points, int pointCount, PolygonDrawMode mode)
+        { QPaintEngine::drawPolygon(points, pointCount, mode); }
+#else
+    using QPaintEngine::drawPolygon;
+#endif
+
+    void drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr);
+    void drawTiledPixmap(const QRectF &r, const QPixmap &pixmap, const QPointF &s);
+    void drawTextItem(const QPointF &p, const QTextItem &ti);
+
+    Type type() const { return Picture; }
+
+protected:
+    QPicturePaintEngine(QPaintEnginePrivate &dptr);
+
+private:
+    Q_DISABLE_COPY(QPicturePaintEngine)
+
+    void writeCmdLength(int pos, const QRectF &r, bool corr);
+};
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_PICTURE
+
+#endif // QPAINTENGINE_PIC_P_H
diff --git a/src/gui/image/qpicture.cpp b/src/gui/image/qpicture.cpp
new file mode 100644
index 0000000..d5d7cb0
--- /dev/null
+++ b/src/gui/image/qpicture.cpp
@@ -0,0 +1,1968 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@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 multimedia
+    \ingroup shared
+    \mainclass
+
+    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);
+    d_ptr->q_ptr = this;
+    d->paintEngine = 0;
+
+    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)
+{
+    d_func()->ref.ref();
+}
+
+/*! \internal */
+QPicture::QPicture(QPicturePrivate &dptr)
+    : QPaintDevice(),
+      d_ptr(&dptr)
+{
+    d_ptr->q_ptr = this;
+}
+
+/*!
+    Destroys the picture.
+*/
+QPicture::~QPicture()
+{
+    if (!d_func()->ref.deref()) {
+        delete d_func()->paintEngine;
+        delete d_func();
+    }
+}
+
+/*!
+  \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()
+{
+    if (d_func()->ref != 1)
+        detach_helper();
+}
+
+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->drawPixmap(p, QPixmap::fromImage(image));
+            } else if (d->formatMajor <= 5){
+                s >> ir >> image;
+                painter->drawPixmap(ir, QPixmap::fromImage(image), QRect(0, 0, ir.width(), ir.height()));
+            } else {
+                s >> r >> image;
+                painter->drawPixmap(r, QPixmap::fromImage(image), QRectF(0, 0, r.width(), r.height()));
+            }
+        }
+            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 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
+*/
+void QPicture::detach_helper()
+{
+    Q_D(QPicture);
+    QPicturePrivate *x = new QPicturePrivate;
+    int pictsize = size();
+    x->pictb.setData(data(), pictsize);
+    if (d->pictb.isOpen()) {
+        x->pictb.open(d->pictb.openMode());
+        x->pictb.seek(d->pictb.pos());
+    }
+    x->trecs = d->trecs;
+    x->formatOk = d->formatOk;
+    x->formatMinor = d->formatMinor;
+    x->brect = d->brect;
+    x->override_rect = d->override_rect;
+    if (!d->ref.deref())
+        delete d;
+    d_ptr = x;
+}
+
+/*!
+    Assigns picture \a p to this picture and returns a reference to
+    this picture.
+*/
+QPicture& QPicture::operator=(const QPicture &p)
+{
+    qAtomicAssign<QPicturePrivate>(d_ptr, p.d_ptr);
+    return *this;
+}
+
+/*!
+  \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 = new QPicturePaintEngine;
+    return d_func()->paintEngine;
+}
+
+/*****************************************************************************
+  QPicture stream functions
+ *****************************************************************************/
+
+/*!
+    \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;
+}
+
+
+#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 multimedia
+    \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
+*/
diff --git a/src/gui/image/qpicture.h b/src/gui/image/qpicture.h
new file mode 100644
index 0000000..fe86e8d
--- /dev/null
+++ b/src/gui/image/qpicture.h
@@ -0,0 +1,196 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPICTURE_H
+#define QPICTURE_H
+
+#include <QtGui/qpaintdevice.h>
+#include <QtCore/qstringlist.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+#ifndef QT_NO_PICTURE
+
+class QPicturePrivate;
+class Q_GUI_EXPORT QPicture : public QPaintDevice
+{
+    Q_DECLARE_PRIVATE(QPicture)
+public:
+    explicit QPicture(int formatVersion = -1);
+    QPicture(const QPicture &);
+    ~QPicture();
+
+    bool isNull() const;
+
+    int devType() const;
+    uint size() const;
+    const char* data() const;
+    virtual void setData(const char* data, uint size);
+
+    bool play(QPainter *p);
+
+    bool load(QIODevice *dev, const char *format = 0);
+    bool load(const QString &fileName, const char *format = 0);
+    bool save(QIODevice *dev, const char *format = 0);
+    bool save(const QString &fileName, const char *format = 0);
+
+    QRect boundingRect() const;
+    void setBoundingRect(const QRect &r);
+
+    QPicture& operator=(const QPicture &p);
+    void detach();
+    bool isDetached() const;
+
+    friend Q_GUI_EXPORT QDataStream &operator<<(QDataStream &in, const QPicture &p);
+    friend Q_GUI_EXPORT QDataStream &operator>>(QDataStream &in, QPicture &p);
+
+    static const char* pictureFormat(const QString &fileName);
+    static QList<QByteArray> inputFormats();
+    static QList<QByteArray> outputFormats();
+    static QStringList inputFormatList();
+    static QStringList outputFormatList();
+
+    QPaintEngine *paintEngine() const;
+
+protected:
+    QPicture(QPicturePrivate &data);
+
+    int metric(PaintDeviceMetric m) const;
+#ifdef QT3_SUPPORT
+    inline QT3_SUPPORT QPicture copy() const { QPicture p(*this); p.detach(); return p; }
+#endif
+
+private:
+    bool exec(QPainter *p, QDataStream &ds, int i);
+    void detach_helper();
+
+    QPicturePrivate *d_ptr;
+    friend class QPicturePaintEngine;
+    friend class Q3Picture;
+    friend class QAlphaPaintEngine;
+    friend class QPreviewPaintEngine;
+
+public:
+    typedef QPicturePrivate* DataPtr;
+    inline DataPtr &data_ptr() { return d_ptr; }
+};
+
+Q_DECLARE_SHARED(QPicture)
+
+
+#ifndef QT_NO_PICTUREIO
+class QIODevice;
+class QPictureIO;
+typedef void (*picture_io_handler)(QPictureIO *); // picture IO handler
+
+struct QPictureIOData;
+
+class Q_GUI_EXPORT QPictureIO
+{
+public:
+    QPictureIO();
+    QPictureIO(QIODevice *ioDevice, const char *format);
+    QPictureIO(const QString &fileName, const char *format);
+    ~QPictureIO();
+
+    const QPicture &picture() const;
+    int status() const;
+    const char *format() const;
+    QIODevice *ioDevice() const;
+    QString fileName() const;
+    int quality() const;
+    QString description() const;
+    const char *parameters() const;
+    float gamma() const;
+
+    void setPicture(const QPicture &);
+    void setStatus(int);
+    void setFormat(const char *);
+    void setIODevice(QIODevice *);
+    void setFileName(const QString &);
+    void setQuality(int);
+    void setDescription(const QString &);
+    void setParameters(const char *);
+    void setGamma(float);
+
+    bool read();
+    bool write();
+
+    static QByteArray pictureFormat(const QString &fileName);
+    static QByteArray pictureFormat(QIODevice *);
+    static QList<QByteArray> inputFormats();
+    static QList<QByteArray> outputFormats();
+
+    static void defineIOHandler(const char *format,
+                                const char *header,
+                                const char *flags,
+                                picture_io_handler read_picture,
+                                picture_io_handler write_picture);
+
+private:
+    Q_DISABLE_COPY(QPictureIO)
+
+    void init();
+
+    QPictureIOData *d;
+};
+
+#endif //QT_NO_PICTUREIO
+
+
+/*****************************************************************************
+  QPicture stream functions
+ *****************************************************************************/
+
+Q_GUI_EXPORT QDataStream &operator<<(QDataStream &, const QPicture &);
+Q_GUI_EXPORT QDataStream &operator>>(QDataStream &, QPicture &);
+
+#endif // QT_NO_PICTURE
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QPICTURE_H
diff --git a/src/gui/image/qpicture_p.h b/src/gui/image/qpicture_p.h
new file mode 100644
index 0000000..1da7f07
--- /dev/null
+++ b/src/gui/image/qpicture_p.h
@@ -0,0 +1,170 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPICTURE_P_H
+#define QPICTURE_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 "QtCore/qatomic.h"
+#include "QtCore/qbuffer.h"
+#include "QtCore/qobjectdefs.h"
+#include "QtGui/qpicture.h"
+#include "QtGui/qpixmap.h"
+#include "QtGui/qpen.h"
+#include "QtGui/qbrush.h"
+#include "QtCore/qrect.h"
+#include "private/qobject_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QPaintEngine;
+
+extern const char  *qt_mfhdr_tag;
+
+class Q_GUI_EXPORT QPicturePrivate
+{
+    Q_DECLARE_PUBLIC(QPicture)
+    friend class QPicturePaintEngine;
+    friend Q_GUI_EXPORT QDataStream &operator<<(QDataStream &s, const QPicture &r);
+    friend Q_GUI_EXPORT QDataStream &operator>>(QDataStream &s, QPicture &r);
+
+public:
+    enum PaintCommand {
+        PdcNOP = 0, //  <void>
+        PdcDrawPoint = 1, // point
+        PdcDrawFirst = PdcDrawPoint,
+        PdcMoveTo = 2, // point
+        PdcLineTo = 3, // point
+        PdcDrawLine = 4, // point,point
+        PdcDrawRect = 5, // rect
+        PdcDrawRoundRect = 6, // rect,ival,ival
+        PdcDrawEllipse = 7, // rect
+        PdcDrawArc = 8, // rect,ival,ival
+        PdcDrawPie = 9, // rect,ival,ival
+        PdcDrawChord = 10, // rect,ival,ival
+        PdcDrawLineSegments = 11, // ptarr
+        PdcDrawPolyline = 12, // ptarr
+        PdcDrawPolygon = 13, // ptarr,ival
+        PdcDrawCubicBezier = 14, // ptarr
+        PdcDrawText = 15, // point,str
+        PdcDrawTextFormatted = 16, // rect,ival,str
+        PdcDrawPixmap = 17, // rect,pixmap
+        PdcDrawImage = 18, // rect,image
+        PdcDrawText2 = 19, // point,str
+        PdcDrawText2Formatted = 20, // rect,ival,str
+        PdcDrawTextItem = 21, // pos,text,font,flags
+        PdcDrawLast = PdcDrawTextItem,
+        PdcDrawPoints = 22, // ptarr,ival,ival
+        PdcDrawWinFocusRect = 23, // rect,color
+        PdcDrawTiledPixmap = 24, // rect,pixmap,point
+        PdcDrawPath = 25, // path
+
+        // no painting commands below PdcDrawLast.
+
+        PdcBegin = 30, //  <void>
+        PdcEnd = 31, //  <void>
+        PdcSave = 32, //  <void>
+        PdcRestore = 33, //  <void>
+        PdcSetdev = 34, // device - PRIVATE
+        PdcSetBkColor = 40, // color
+        PdcSetBkMode = 41, // ival
+        PdcSetROP = 42, // ival
+        PdcSetBrushOrigin = 43, // point
+        PdcSetFont = 45, // font
+        PdcSetPen = 46, // pen
+        PdcSetBrush = 47, // brush
+        PdcSetTabStops = 48, // ival
+        PdcSetTabArray = 49, // ival,ivec
+        PdcSetUnit = 50, // ival
+        PdcSetVXform = 51, // ival
+        PdcSetWindow = 52, // rect
+        PdcSetViewport = 53, // rect
+        PdcSetWXform = 54, // ival
+        PdcSetWMatrix = 55, // matrix,ival
+        PdcSaveWMatrix = 56,
+        PdcRestoreWMatrix = 57,
+        PdcSetClip = 60, // ival
+        PdcSetClipRegion = 61, // rgn
+        PdcSetClipPath = 62, // path
+        PdcSetRenderHint = 63, // ival
+        PdcSetCompositionMode = 64, // ival
+        PdcSetClipEnabled = 65, // bool
+        PdcSetOpacity = 66, // qreal
+
+        PdcReservedStart = 0, // codes 0-199 are reserved
+        PdcReservedStop = 199 //   for Qt
+    };
+
+    inline QPicturePrivate() : in_memory_only(false), q_ptr(0) { ref = 1; }
+    QAtomicInt ref;
+
+    bool checkFormat();
+    void resetFormat();
+
+    QBuffer pictb;
+    int trecs;
+    bool formatOk;
+    int formatMajor;
+    int formatMinor;
+    QRect brect;
+    QRect override_rect;
+    QPaintEngine *paintEngine;
+    bool in_memory_only;
+    QList<QPixmap> pixmap_list;
+    QList<QBrush> brush_list;
+    QList<QPen> pen_list;
+
+    QPicture *q_ptr;
+};
+
+QT_END_NAMESPACE
+
+#endif // QPICTURE_P_H
diff --git a/src/gui/image/qpictureformatplugin.cpp b/src/gui/image/qpictureformatplugin.cpp
new file mode 100644
index 0000000..33d10a4
--- /dev/null
+++ b/src/gui/image/qpictureformatplugin.cpp
@@ -0,0 +1,139 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qpictureformatplugin.h"
+#if !defined(QT_NO_LIBRARY) && !defined(QT_NO_PICTURE)
+#include "qpicture.h"
+
+QT_BEGIN_NAMESPACE
+
+/*!
+    \obsolete
+
+    \class QPictureFormatPlugin
+    \brief The QPictureFormatPlugin class provides an abstract base
+    for custom picture format plugins.
+
+    \ingroup plugins
+
+    The picture format plugin is a simple plugin interface that makes
+    it easy to create custom picture formats that can be used
+    transparently by applications.
+
+    Writing an picture format plugin is achieved by subclassing this
+    base class, reimplementing the pure virtual functions keys(),
+    loadPicture(), savePicture(), and installIOHandler(), and
+    exporting the class with the Q_EXPORT_PLUGIN2() macro.
+
+    \sa {How to Create Qt Plugins}
+*/
+
+/*!
+    \fn QStringList QPictureFormatPlugin::keys() const
+
+    Returns the list of picture formats this plugin supports.
+
+    \sa installIOHandler()
+*/
+
+/*!
+    \fn bool QPictureFormatPlugin::installIOHandler(const QString &format)
+
+    Installs a QPictureIO picture I/O handler for the picture format \a
+    format.
+
+    \sa keys()
+*/
+
+
+/*!
+    Constructs an picture format plugin with the given \a parent.
+    This is invoked automatically by the Q_EXPORT_PLUGIN2() macro.
+*/
+QPictureFormatPlugin::QPictureFormatPlugin(QObject *parent)
+    : QObject(parent)
+{
+}
+
+/*!
+    Destroys the picture format plugin.
+
+    You never have to call this explicitly. Qt destroys a plugin
+    automatically when it is no longer used.
+*/
+QPictureFormatPlugin::~QPictureFormatPlugin()
+{
+}
+
+
+/*!
+    Loads the picture stored in the file called \a fileName, with the
+    given \a format, into *\a picture. Returns true on success;
+    otherwise returns false.
+
+    \sa savePicture()
+*/
+bool QPictureFormatPlugin::loadPicture(const QString &format, const QString &fileName, QPicture *picture)
+{
+    Q_UNUSED(format)
+    Q_UNUSED(fileName)
+    Q_UNUSED(picture)
+    return false;
+}
+
+/*!
+    Saves the given \a picture into the file called \a fileName,
+    using the specified \a format. Returns true on success; otherwise
+    returns false.
+
+    \sa loadPicture()
+*/
+bool QPictureFormatPlugin::savePicture(const QString &format, const QString &fileName, const QPicture &picture)
+{
+    Q_UNUSED(format)
+    Q_UNUSED(fileName)
+    Q_UNUSED(picture)
+    return false;
+}
+
+#endif // QT_NO_LIBRARY || QT_NO_PICTURE
+
+QT_END_NAMESPACE
diff --git a/src/gui/image/qpictureformatplugin.h b/src/gui/image/qpictureformatplugin.h
new file mode 100644
index 0000000..2eca024
--- /dev/null
+++ b/src/gui/image/qpictureformatplugin.h
@@ -0,0 +1,94 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPICTUREFORMATPLUGIN_H
+#define QPICTUREFORMATPLUGIN_H
+
+#include <QtCore/qplugin.h>
+#include <QtCore/qfactoryinterface.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+#if !defined(QT_NO_LIBRARY) && !defined(QT_NO_PICTURE)
+
+class QPicture;
+class QImage;
+class QString;
+class QStringList;
+
+struct Q_GUI_EXPORT QPictureFormatInterface : public QFactoryInterface
+{
+    virtual bool loadPicture(const QString &format, const QString &filename, QPicture *) = 0;
+    virtual bool savePicture(const QString &format, const QString &filename, const QPicture &) = 0;
+
+    virtual bool installIOHandler(const QString &) = 0;
+};
+
+#define QPictureFormatInterface_iid "com.trolltech.Qt.QPictureFormatInterface"
+Q_DECLARE_INTERFACE(QPictureFormatInterface, QPictureFormatInterface_iid)
+
+
+class Q_GUI_EXPORT QPictureFormatPlugin : public QObject, public QPictureFormatInterface
+{
+    Q_OBJECT
+    Q_INTERFACES(QPictureFormatInterface:QFactoryInterface)
+public:
+    explicit QPictureFormatPlugin(QObject *parent = 0);
+    ~QPictureFormatPlugin();
+
+    virtual QStringList keys() const = 0;
+    virtual bool loadPicture(const QString &format, const QString &filename, QPicture *pic);
+    virtual bool savePicture(const QString &format, const QString &filename, const QPicture &pic);
+    virtual bool installIOHandler(const QString &format) = 0;
+
+};
+
+#endif // QT_NO_LIBRARY || QT_NO_PICTURE
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QPICTUREFORMATPLUGIN_H
diff --git a/src/gui/image/qpixmap.cpp b/src/gui/image/qpixmap.cpp
new file mode 100644
index 0000000..e563fc9
--- /dev/null
+++ b/src/gui/image/qpixmap.cpp
@@ -0,0 +1,2053 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <qglobal.h>
+
+#include "qpixmap.h"
+#include "qpixmapdata_p.h"
+
+#include "qbitmap.h"
+#include "qcolormap.h"
+#include "qimage.h"
+#include "qwidget.h"
+#include "qpainter.h"
+#include "qdatastream.h"
+#include "qbuffer.h"
+#include "qapplication.h"
+#include <private/qapplication_p.h>
+#include <private/qgraphicssystem_p.h>
+#include <private/qwidget_p.h>
+#include "qevent.h"
+#include "qfile.h"
+#include "qfileinfo.h"
+#include "qpixmapcache.h"
+#include "qdatetime.h"
+#include "qimagereader.h"
+#include "qimagewriter.h"
+#include "qpaintengine.h"
+#include "qthread.h"
+
+#ifdef Q_WS_MAC
+# include "private/qt_mac_p.h"
+# include "private/qpixmap_mac_p.h"
+#endif
+
+#if defined(Q_WS_X11)
+# include "qx11info_x11.h"
+# include <private/qt_x11_p.h>
+# include <private/qpixmap_x11_p.h>
+#endif
+
+#include "qpixmap_raster_p.h"
+
+QT_BEGIN_NAMESPACE
+
+// ### Qt 5: remove
+typedef void (*_qt_pixmap_cleanup_hook)(int);
+Q_GUI_EXPORT _qt_pixmap_cleanup_hook qt_pixmap_cleanup_hook = 0;
+
+// ### Qt 5: rename
+typedef void (*_qt_pixmap_cleanup_hook_64)(qint64);
+Q_GUI_EXPORT _qt_pixmap_cleanup_hook_64 qt_pixmap_cleanup_hook_64 = 0;
+
+// ### Qt 5: remove
+Q_GUI_EXPORT qint64 qt_pixmap_id(const QPixmap &pixmap)
+{
+    return pixmap.cacheKey();
+}
+
+static bool qt_pixmap_thread_test()
+{
+    if (!qApp) {
+        qFatal("QPixmap: Must construct a QApplication before a QPaintDevice");
+        return false;
+    }
+#ifndef Q_WS_WIN
+    if (qApp->thread() != QThread::currentThread()) {
+        qWarning("QPixmap: It is not safe to use pixmaps outside the GUI thread");
+        return false;
+    }
+#endif
+    return true;
+}
+
+void QPixmap::init(int w, int h, Type type)
+{
+    init(w, h, int(type));
+}
+
+void QPixmap::init(int w, int h, int type)
+{
+    QGraphicsSystem* gs = QApplicationPrivate::graphicsSystem();
+    if (gs)
+        data = gs->createPixmapData(static_cast<QPixmapData::PixelType>(type));
+    else
+        data = QGraphicsSystem::createDefaultPixmapData(static_cast<QPixmapData::PixelType>(type));
+
+    data->resize(w, h);
+    data->ref.ref();
+}
+
+/*!
+    \enum QPixmap::ColorMode
+
+    \compat
+
+    This enum type defines the color modes that exist for converting
+    QImage objects to QPixmap.  It is provided here for compatibility
+    with earlier versions of Qt.
+
+    Use Qt::ImageConversionFlags instead.
+
+    \value Auto  Select \c Color or \c Mono on a case-by-case basis.
+    \value Color Always create colored pixmaps.
+    \value Mono  Always create bitmaps.
+*/
+
+/*!
+    Constructs a null pixmap.
+
+    \sa isNull()
+*/
+
+QPixmap::QPixmap()
+    : QPaintDevice()
+{
+    (void) qt_pixmap_thread_test();
+    init(0, 0, QPixmapData::PixmapType);
+}
+
+/*!
+    \fn QPixmap::QPixmap(int width, int height)
+
+    Constructs a pixmap with the given \a width and \a height. If
+    either \a width or \a height is zero, a null pixmap is
+    constructed.
+
+    \warning This will create a QPixmap with uninitialized data. Call
+    fill() to fill the pixmap with an appropriate color before drawing
+    onto it with QPainter.
+
+    \sa isNull()
+*/
+
+QPixmap::QPixmap(int w, int h)
+    : QPaintDevice()
+{
+    if (!qt_pixmap_thread_test())
+        init(0, 0, QPixmapData::PixmapType);
+    else
+        init(w, h, QPixmapData::PixmapType);
+}
+
+/*!
+    \overload
+
+    Constructs a pixmap of the given \a size.
+
+    \warning This will create a QPixmap with uninitialized data. Call
+    fill() to fill the pixmap with an appropriate color before drawing
+    onto it with QPainter.
+*/
+
+QPixmap::QPixmap(const QSize &size)
+    : QPaintDevice()
+{
+    if (!qt_pixmap_thread_test())
+        init(0, 0, QPixmapData::PixmapType);
+    else
+        init(size.width(), size.height(), QPixmapData::PixmapType);
+}
+
+/*!
+  \internal
+*/
+QPixmap::QPixmap(const QSize &s, Type type)
+{
+    if (!qt_pixmap_thread_test())
+        init(0, 0, type);
+    else
+        init(s.width(), s.height(), type);
+}
+
+/*!
+  \internal
+*/
+QPixmap::QPixmap(const QSize &s, int type)
+{
+    if (!qt_pixmap_thread_test())
+        init(0, 0, static_cast<QPixmapData::PixelType>(type));
+    else
+        init(s.width(), s.height(), static_cast<QPixmapData::PixelType>(type));
+}
+
+/*!
+    \internal
+*/
+QPixmap::QPixmap(QPixmapData *d)
+    : QPaintDevice(), data(d)
+{
+    data->ref.ref();
+}
+
+/*!
+    Constructs a pixmap from the file with the given \a fileName. If the
+    file does not exist or is of an unknown format, the pixmap becomes a
+    null pixmap.
+
+    The loader attempts to read the pixmap using the specified \a
+    format. If the \a format is not specified (which is the default),
+    the loader probes the file for a header to guess the file format.
+
+    The file name can either refer to an actual file on disk or to
+    one of the application's embedded resources. See the
+    \l{resources.html}{Resource System} overview for details on how
+    to embed images and other resource files in the application's
+    executable.
+
+    If the image needs to be modified to fit in a lower-resolution
+    result (e.g. converting from 32-bit to 8-bit), use the \a
+    flags to control the conversion.
+
+    The \a fileName, \a format and \a flags parameters are
+    passed on to load(). This means that the data in \a fileName is
+    not compiled into the binary. If \a fileName contains a relative
+    path (e.g. the filename only) the relevant file must be found
+    relative to the runtime working directory.
+
+    \sa {QPixmap#Reading and Writing Image Files}{Reading and Writing
+    Image Files}
+*/
+
+QPixmap::QPixmap(const QString& fileName, const char *format, Qt::ImageConversionFlags flags)
+    : QPaintDevice()
+{
+    init(0, 0, QPixmapData::PixmapType);
+    if (!qt_pixmap_thread_test())
+        return;
+
+    load(fileName, format, flags);
+}
+
+/*!
+    Constructs a pixmap that is a copy of the given \a pixmap.
+
+    \sa copy()
+*/
+
+QPixmap::QPixmap(const QPixmap &pixmap)
+    : QPaintDevice()
+{
+    if (!qt_pixmap_thread_test()) {
+        init(0, 0, QPixmapData::PixmapType);
+        return;
+    }
+    if (pixmap.paintingActive()) {                // make a deep copy
+        data = 0;
+        operator=(pixmap.copy());
+    } else {
+        data = pixmap.data;
+        data->ref.ref();
+    }
+}
+
+/*!
+    Constructs a pixmap from the given \a xpm data, which must be a
+    valid XPM image.
+
+    Errors are silently ignored.
+
+    Note that it's possible to squeeze the XPM variable a little bit
+    by using an unusual declaration:
+
+    \snippet doc/src/snippets/code/src_gui_image_qpixmap.cpp 0
+
+    The extra \c const makes the entire definition read-only, which is
+    slightly more efficient (for example, when the code is in a shared
+    library) and ROMable when the application is to be stored in ROM.
+*/
+#ifndef QT_NO_IMAGEFORMAT_XPM
+QPixmap::QPixmap(const char * const xpm[])
+    : QPaintDevice()
+{
+    init(0, 0, QPixmapData::PixmapType);
+    if (!xpm)
+        return;
+
+    QImage image(xpm);
+    if (!image.isNull()) {
+        if (data->pixelType() == QPixmapData::BitmapType)
+            *this = QBitmap::fromImage(image);
+        else
+            *this = fromImage(image);
+    }
+}
+#endif
+
+
+/*!
+    Destroys the pixmap.
+*/
+
+QPixmap::~QPixmap()
+{
+    deref();
+}
+
+/*!
+  \internal
+*/
+int QPixmap::devType() const
+{
+    return QInternal::Pixmap;
+}
+
+/*!
+    \fn QPixmap QPixmap::copy(int x, int y, int width, int height) const
+    \overload
+
+    Returns a deep copy of the subset of the pixmap that is specified
+    by the rectangle QRect( \a x, \a y, \a width, \a height).
+*/
+
+/*!
+    \fn QPixmap QPixmap::copy(const QRect &rectangle) const
+
+    Returns a deep copy of the subset of the pixmap that is specified
+    by the given \a rectangle. For more information on deep copies,
+    see the \l {Implicit Data Sharing} documentation.
+
+    If the given \a rectangle is empty, the whole image is copied.
+
+    \sa operator=(), QPixmap(), {QPixmap#Pixmap
+    Transformations}{Pixmap Transformations}
+*/
+QPixmap QPixmap::copy(const QRect &rect) const
+{
+    if (isNull())
+        return QPixmap();
+
+    const QRect r = rect.isEmpty() ? QRect(0, 0, width(), height()) : rect;
+
+    QPixmapData *d;
+    QGraphicsSystem* gs = QApplicationPrivate::graphicsSystem();
+    if (gs)
+        d = gs->createPixmapData(data->pixelType());
+    else
+        d = QGraphicsSystem::createDefaultPixmapData(data->pixelType());
+
+    d->copy(data, r);
+    return QPixmap(d);
+}
+
+/*!
+    \fn QPixmap::scroll(int dx, int dy, int x, int y, int width, int height, QRegion *exposed)
+
+    This convenience function is equivalent to calling QPixmap::scroll(\a dx,
+    \a dy, QRect(\a x, \a y, \a width, \a height), \a exposed).
+
+    \sa QWidget::scroll(), QGraphicsItem::scroll()
+*/
+
+/*!
+    Scrolls the area \a rect of this pixmap by (\a dx, \a dy). The exposed
+    region is left unchanged. You can optionally pass a pointer to an empty
+    QRegion to get the region that is \a exposed by the scroll operation.
+
+    \snippet doc/src/snippets/code/src_gui_image_qpixmap.cpp 2
+
+    You cannot scroll while there is an active painter on the pixmap.
+
+    \sa QWidget::scroll(), QGraphicsItem::scroll()
+*/
+void QPixmap::scroll(int dx, int dy, const QRect &rect, QRegion *exposed)
+{
+    if (isNull() || (dx == 0 && dy == 0))
+        return;
+    QRect dest = rect & this->rect();
+    QRect src = dest.translated(-dx, -dy) & dest;
+    if (src.isEmpty()) {
+        if (exposed)
+            *exposed += dest;
+        return;
+    }
+
+    detach();
+
+    if (!data->scroll(dx, dy, src)) {
+        // Fallback
+        QPixmap pix = *this;
+        QPainter painter(&pix);
+        painter.setCompositionMode(QPainter::CompositionMode_Source);
+        painter.drawPixmap(src.translated(dx, dy), *this, src);
+        painter.end();
+        *this = pix;
+    }
+
+    if (exposed) {
+        *exposed += dest;
+        *exposed -= src.translated(dx, dy);
+    }
+}
+
+/*!
+    Assigns the given \a pixmap to this pixmap and returns a reference
+    to this pixmap.
+
+    \sa copy(), QPixmap()
+*/
+
+QPixmap &QPixmap::operator=(const QPixmap &pixmap)
+{
+    if (paintingActive()) {
+        qWarning("QPixmap::operator=: Cannot assign to pixmap during painting");
+        return *this;
+    }
+    if (pixmap.paintingActive()) {                // make a deep copy
+        *this = pixmap.copy();
+    } else {
+        pixmap.data->ref.ref();                                // avoid 'x = x'
+        deref();
+        data = pixmap.data;
+    }
+    return *this;
+}
+
+/*!
+   Returns the pixmap as a QVariant.
+*/
+QPixmap::operator QVariant() const
+{
+    return QVariant(QVariant::Pixmap, this);
+}
+
+/*!
+    \fn bool QPixmap::operator!() const
+
+    Returns true if this is a null pixmap; otherwise returns false.
+
+    \sa isNull()
+*/
+
+/*!
+    \fn QPixmap::operator QImage() const
+
+    Returns the pixmap as a QImage.
+
+    Use the toImage() function instead.
+*/
+
+/*!
+    Converts the pixmap to a QImage. Returns a null image if the
+    conversion fails.
+
+    If the pixmap has 1-bit depth, the returned image will also be 1
+    bit deep. If the pixmap has 2- to 8-bit depth, the returned image
+    has 8-bit depth. If the pixmap has greater than 8-bit depth, the
+    returned image has 32-bit depth.
+
+    Note that for the moment, alpha masks on monochrome images are
+    ignored.
+
+    \sa fromImage(), {QImage#Image Formats}{Image Formats}
+*/
+QImage QPixmap::toImage() const
+{
+    if (isNull())
+        return QImage();
+
+    return data->toImage();
+}
+
+/*!
+    \fn QMatrix QPixmap::trueMatrix(const QTransform &matrix, int width, int height)
+
+    Returns the actual matrix used for transforming a pixmap with the
+    given \a width, \a height and \a matrix.
+
+    When transforming a pixmap using the transformed() function, the
+    transformation matrix is internally adjusted to compensate for
+    unwanted translation, i.e. transformed() returns the smallest
+    pixmap containing all transformed points of the original
+    pixmap. This function returns the modified matrix, which maps
+    points correctly from the original pixmap into the new pixmap.
+
+    \sa transformed(), {QPixmap#Pixmap Transformations}{Pixmap
+    Transformations}
+*/
+QTransform QPixmap::trueMatrix(const QTransform &m, int w, int h)
+{
+    return QImage::trueMatrix(m, w, h);
+}
+
+/*!
+  \overload
+
+  This convenience function loads the matrix \a m into a
+  QTransform and calls the overloaded function with the
+  QTransform and the width \a w and the height \a h.
+ */
+QMatrix QPixmap::trueMatrix(const QMatrix &m, int w, int h)
+{
+    return trueMatrix(QTransform(m), w, h).toAffine();
+}
+
+
+/*!
+    \fn bool QPixmap::isQBitmap() const
+
+    Returns true if this is a QBitmap; otherwise returns false.
+*/
+
+bool QPixmap::isQBitmap() const
+{
+    return data->type == QPixmapData::BitmapType;
+}
+
+/*!
+    \fn bool QPixmap::isNull() const
+
+    Returns true if this is a null pixmap; otherwise returns false.
+
+    A null pixmap has zero width, zero height and no contents. You
+    cannot draw in a null pixmap.
+*/
+bool QPixmap::isNull() const
+{
+    return data->width() == 0;
+}
+
+/*!
+    \fn int QPixmap::width() const
+
+    Returns the width of the pixmap.
+
+    \sa size(), {QPixmap#Pixmap Information}{Pixmap Information}
+*/
+int QPixmap::width() const
+{
+    return data->width();
+}
+
+/*!
+    \fn int QPixmap::height() const
+
+    Returns the height of the pixmap.
+
+    \sa size(), {QPixmap#Pixmap Information}{Pixmap Information}
+*/
+int QPixmap::height() const
+{
+    return data->height();
+}
+
+/*!
+    \fn QSize QPixmap::size() const
+
+    Returns the size of the pixmap.
+
+    \sa width(), height(), {QPixmap#Pixmap Information}{Pixmap
+    Information}
+*/
+QSize QPixmap::size() const
+{
+    return QSize(data->width(), data->height());
+}
+
+/*!
+    \fn QRect QPixmap::rect() const
+
+    Returns the pixmap's enclosing rectangle.
+
+    \sa {QPixmap#Pixmap Information}{Pixmap Information}
+*/
+QRect QPixmap::rect() const
+{
+    return QRect(0, 0, data->width(), data->height());
+}
+
+/*!
+    \fn int QPixmap::depth() const
+
+    Returns the depth of the pixmap.
+
+    The pixmap depth is also called bits per pixel (bpp) or bit planes
+    of a pixmap. A null pixmap has depth 0.
+
+    \sa defaultDepth(), {QPixmap#Pixmap Information}{Pixmap
+    Information}
+*/
+int QPixmap::depth() const
+{
+    return data->depth();
+}
+
+/*!
+    \fn void QPixmap::resize(const QSize &size)
+    \overload
+    \compat
+
+    Use QPixmap::copy() instead to get the pixmap with the new size.
+
+    \oldcode
+        pixmap.resize(size);
+    \newcode
+        pixmap = pixmap.copy(QRect(QPoint(0, 0), size));
+    \endcode
+*/
+#ifdef QT3_SUPPORT
+void QPixmap::resize_helper(const QSize &s)
+{
+    int w = s.width();
+    int h = s.height();
+    if (w < 1 || h < 1) {
+        *this = QPixmap();
+        return;
+    }
+
+    if (size() == s)
+        return;
+
+    // Create new pixmap
+    QPixmap pm(QSize(w, h), data->type);
+    bool uninit = false;
+#if defined(Q_WS_X11)
+    QX11PixmapData *x11Data = data->classId() == QPixmapData::X11Class ? static_cast<QX11PixmapData*>(data) : 0;
+    if (x11Data) {
+        pm.x11SetScreen(x11Data->xinfo.screen());
+        uninit = x11Data->uninit;
+    }
+#elif defined(Q_WS_MAC)
+    QMacPixmapData *macData = data->classId() == QPixmapData::MacClass ? static_cast<QMacPixmapData*>(data) : 0;
+    if (macData)
+        uninit = macData->uninit;
+#endif
+    if (!uninit && !isNull()) {
+        // Copy old pixmap
+        if (hasAlphaChannel())
+            pm.fill(Qt::transparent);
+        QPainter p(&pm);
+        p.drawPixmap(0, 0, *this, 0, 0, qMin(width(), w), qMin(height(), h));
+    }
+
+#if defined(Q_WS_MAC)
+#ifndef QT_MAC_NO_QUICKDRAW
+    if(macData && macData->qd_alpha)
+        macData->macQDUpdateAlpha();
+#endif
+#elif defined(Q_WS_X11)
+    if (x11Data && x11Data->x11_mask) {
+        QX11PixmapData *pmData = static_cast<QX11PixmapData*>(pm.data);
+        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);
+        XCopyArea(X11->display, x11Data->x11_mask, pmData->x11_mask, gc, 0, 0, qMin(width(), w), qMin(height(), h), 0, 0);
+        XFreeGC(X11->display, gc);
+    }
+#endif
+    *this = pm;
+}
+#endif
+
+/*!
+    \fn void QPixmap::resize(int width, int height)
+    \compat
+
+    Use QPixmap::copy() instead to get the pixmap with the new size.
+
+    \oldcode
+        pixmap.resize(10, 20);
+    \newcode
+        pixmap = pixmap.copy(0, 0, 10, 20);
+    \endcode
+*/
+
+/*!
+    \fn bool QPixmap::selfMask() const
+    \compat
+
+    Returns whether the pixmap is its own mask or not.
+
+    This function is no longer relevant since the concept of self
+    masking doesn't exists anymore.
+*/
+
+/*!
+    Sets a mask bitmap.
+
+    This function merges the \a mask with the pixmap's alpha channel. A pixel
+    value of 1 on the mask means the pixmap's pixel is unchanged; a value of 0
+    means the pixel is transparent. The mask must have the same size as this
+    pixmap.
+
+    Setting a null mask resets the mask, leaving the previously transparent
+    pixels black. The effect of this function is undefined when the pixmap is
+    being painted on.
+
+    This is potentially an expensive operation.
+
+    \sa mask(), {QPixmap#Pixmap Transformations}{Pixmap Transformations},
+    QBitmap
+*/
+void QPixmap::setMask(const QBitmap &mask)
+{
+    if (paintingActive()) {
+        qWarning("QPixmap::setMask: Cannot set mask while pixmap is being painted on");
+        return;
+    }
+
+    if (!mask.isNull() && mask.size() != size()) {
+        qWarning("QPixmap::setMask() mask size differs from pixmap size");
+        return;
+    }
+
+    if (static_cast<const QPixmap &>(mask).data == data) // trying to selfmask
+       return;
+
+    detach();
+    data->setMask(mask);
+}
+
+#ifndef QT_NO_IMAGE_HEURISTIC_MASK
+/*!
+    Creates and returns a heuristic mask for this pixmap.
+
+    The function works by selecting a color from one of the corners
+    and then chipping away pixels of that color, starting at all the
+    edges.  If \a clipTight is true (the default) the mask is just
+    large enough to cover the pixels; otherwise, the mask is larger
+    than the data pixels.
+
+    The mask may not be perfect but it should be reasonable, so you
+    can do things such as the following:
+
+    \snippet doc/src/snippets/code/src_gui_image_qpixmap.cpp 1
+
+    This function is slow because it involves converting to/from a
+    QImage, and non-trivial computations.
+
+    \sa QImage::createHeuristicMask(), createMaskFromColor()
+*/
+QBitmap QPixmap::createHeuristicMask(bool clipTight) const
+{
+    QBitmap m = QBitmap::fromImage(toImage().createHeuristicMask(clipTight));
+    return m;
+}
+#endif
+
+/*!
+    Creates and returns a mask for this pixmap based on the given \a
+    maskColor. If the \a mode is Qt::MaskInColor, all pixels matching the
+    maskColor will be opaque. If \a mode is Qt::MaskOutColor, all pixels
+    matching the maskColor will be transparent.
+
+    This function is slow because it involves converting to/from a
+    QImage.
+
+    \sa createHeuristicMask(), QImage::createMaskFromColor()
+*/
+QBitmap QPixmap::createMaskFromColor(const QColor &maskColor, Qt::MaskMode mode) const
+{
+    QImage image = toImage().convertToFormat(QImage::Format_ARGB32);
+    return QBitmap::fromImage(image.createMaskFromColor(maskColor.rgba(), mode));
+}
+
+/*! \overload
+
+    Creates and returns a mask for this pixmap based on the given \a
+    maskColor. Same as calling createMaskFromColor(maskColor,
+    Qt::MaskInColor)
+
+    \sa createHeuristicMask(), QImage::createMaskFromColor()
+*/
+QBitmap QPixmap::createMaskFromColor(const QColor &maskColor) const
+{
+    return createMaskFromColor(maskColor, Qt::MaskInColor);
+}
+
+/*!
+    Loads a pixmap from the file with the given \a fileName. Returns
+    true if the pixmap was successfully loaded; otherwise returns
+    false.
+
+    The loader attempts to read the pixmap using the specified \a
+    format. If the \a format is not specified (which is the default),
+    the loader probes the file for a header to guess the file format.
+
+    The file name can either refer to an actual file on disk or to one
+    of the application's embedded resources. See the
+    \l{resources.html}{Resource System} overview for details on how to
+    embed pixmaps and other resource files in the application's
+    executable.
+
+    If the data needs to be modified to fit in a lower-resolution
+    result (e.g. converting from 32-bit to 8-bit), use the \a flags to
+    control the conversion.
+
+    Note that QPixmaps are automatically added to the QPixmapCache
+    when loaded from a file; the key used is internal and can not
+    be acquired.
+
+    \sa loadFromData(), {QPixmap#Reading and Writing Image
+    Files}{Reading and Writing Image Files}
+*/
+
+bool QPixmap::load(const QString &fileName, const char *format, Qt::ImageConversionFlags flags)
+{
+    if (fileName.isEmpty())
+        return false;
+
+    QFileInfo info(fileName);
+    QString key = QLatin1String("qt_pixmap_") + info.absoluteFilePath() + QLatin1Char('_') + QString::number(info.lastModified().toTime_t()) + QLatin1Char('_') +
+                  QString::number(info.size()) + QLatin1Char('_') + QString::number(data->pixelType());
+
+    if (QPixmapCache::find(key, *this))
+        return true;
+
+    QImage image = QImageReader(fileName, format).read();
+    if (image.isNull())
+        return false;
+    QPixmap pm;
+    if (data->pixelType() == QPixmapData::BitmapType)
+        pm = QBitmap::fromImage(image, flags);
+    else
+        pm = fromImage(image, flags);
+    if (!pm.isNull()) {
+        *this = pm;
+        QPixmapCache::insert(key, *this);
+        return true;
+    }
+    return false;
+}
+
+/*!
+    \fn bool QPixmap::loadFromData(const uchar *data, uint len, const char *format, Qt::ImageConversionFlags flags)
+
+    Loads a pixmap from the \a len first bytes of the given binary \a
+    data.  Returns true if the pixmap was loaded successfully;
+    otherwise returns false.
+
+    The loader attempts to read the pixmap using the specified \a
+    format. If the \a format is not specified (which is the default),
+    the loader probes the file for a header to guess the file format.
+
+    If the data needs to be modified to fit in a lower-resolution
+    result (e.g. converting from 32-bit to 8-bit), use the \a flags to
+    control the conversion.
+
+    \sa load(), {QPixmap#Reading and Writing Image Files}{Reading and
+    Writing Image Files}
+*/
+
+bool QPixmap::loadFromData(const uchar *buf, uint len, const char *format, Qt::ImageConversionFlags flags)
+{
+    QByteArray a = QByteArray::fromRawData(reinterpret_cast<const char *>(buf), len);
+    QBuffer b(&a);
+    b.open(QIODevice::ReadOnly);
+
+    QImage image = QImageReader(&b, format).read();
+    QPixmap pm;
+    if (data->pixelType() == QPixmapData::BitmapType)
+        pm = QBitmap::fromImage(image, flags);
+    else
+        pm = fromImage(image, flags);
+    if (!pm.isNull()) {
+        *this = pm;
+        return true;
+    }
+    return false;
+}
+
+/*!
+    \fn bool QPixmap::loadFromData(const QByteArray &data, const char *format, Qt::ImageConversionFlags flags)
+
+    \overload
+
+    Loads a pixmap from the binary \a data using the specified \a
+    format and conversion \a flags.
+*/
+
+
+/*!
+    Saves the pixmap to the file with the given \a fileName using the
+    specified image file \a format and \a quality factor. Returns true
+    if successful; otherwise returns false.
+
+    The \a quality factor must be in the range [0,100] or -1. Specify
+    0 to obtain small compressed files, 100 for large uncompressed
+    files, and -1 to use the default settings.
+
+    If \a format is 0, an image format will be chosen from \a fileName's
+    suffix.
+
+    \sa {QPixmap#Reading and Writing Image Files}{Reading and Writing
+    Image Files}
+*/
+
+bool QPixmap::save(const QString &fileName, const char *format, int quality) const
+{
+    if (isNull())
+        return false;                                // nothing to save
+    QImageWriter writer(fileName, format);
+    return doImageIO(&writer, quality);
+}
+
+/*!
+    \overload
+
+    This function writes a QPixmap to the given \a device using the
+    specified image file \a format and \a quality factor. This can be
+    used, for example, to save a pixmap directly into a QByteArray:
+
+    \snippet doc/src/snippets/image/image.cpp 1
+*/
+
+bool QPixmap::save(QIODevice* device, const char* format, int quality) const
+{
+    if (isNull())
+        return false;                                // nothing to save
+    QImageWriter writer(device, format);
+    return doImageIO(&writer, quality);
+}
+
+/*! \internal
+*/
+bool QPixmap::doImageIO(QImageWriter *writer, int quality) const
+{
+    if (quality > 100  || quality < -1)
+        qWarning("QPixmap::save: quality out of range [-1,100]");
+    if (quality >= 0)
+        writer->setQuality(qMin(quality,100));
+    return writer->write(toImage());
+}
+
+
+// The implementation (and documentation) of
+// QPixmap::fill(const QWidget *, const QPoint &)
+// is in qwidget.cpp
+
+/*!
+    \fn void QPixmap::fill(const QWidget *widget, int x, int y)
+    \overload
+
+    Fills the pixmap with the \a widget's background color or pixmap.
+    The given point, (\a x, \a y), defines an offset in widget
+    coordinates to which the pixmap's top-left pixel will be mapped
+    to.
+*/
+
+/*!
+    Fills the pixmap with the given \a color.
+
+    \sa {QPixmap#Pixmap Transformations}{Pixmap Transformations}
+*/
+
+void QPixmap::fill(const QColor &color)
+{
+    if (isNull())
+        return;
+
+    detach();
+    data->fill(color);
+}
+
+/*! \obsolete
+    Returns a number that identifies the contents of this QPixmap
+    object. Distinct QPixmap objects can only have the same serial
+    number if they refer to the same contents (but they don't have
+    to).
+
+    Use cacheKey() instead.
+
+    \warning The serial number doesn't necessarily change when
+    the pixmap is altered. This means that it may be dangerous to use
+    it as a cache key. For caching pixmaps, we recommend using the
+    QPixmapCache class whenever possible.
+*/
+int QPixmap::serialNumber() const
+{
+    if (isNull())
+        return 0;
+    return data->serialNumber();
+}
+
+/*!
+    Returns a number that identifies this QPixmap. Distinct QPixmap
+    objects can only have the same cache key if they refer to the same
+    contents.
+
+    The cacheKey() will change when the pixmap is altered.
+*/
+qint64 QPixmap::cacheKey() const
+{
+    int classKey = data->classId();
+    if (classKey >= 1024)
+        classKey = -(classKey >> 10);
+    return ((((qint64) classKey) << 56)
+            | (((qint64) data->serialNumber()) << 32)
+            | ((qint64) (data->detach_no)));
+}
+
+static void sendResizeEvents(QWidget *target)
+{
+    QResizeEvent e(target->size(), QSize());
+    QApplication::sendEvent(target, &e);
+
+    const QObjectList children = target->children();
+    for (int i = 0; i < children.size(); ++i) {
+        QWidget *child = static_cast<QWidget*>(children.at(i));
+        if (child->isWidgetType() && !child->isWindow() && child->testAttribute(Qt::WA_PendingResizeEvent))
+            sendResizeEvents(child);
+    }
+}
+
+/*!
+    \fn QPixmap QPixmap::grabWidget(QWidget * widget, const QRect &rectangle)
+
+    Creates a pixmap and paints the given \a widget, restricted by the
+    given \a rectangle, in it. If the \a widget has any children, then
+    they are also painted in the appropriate positions.
+
+    If no rectangle is specified (the default) the entire widget is
+    painted.
+
+    If \a widget is 0, the specified rectangle doesn't overlap the
+    widget's rectangle, or an error occurs, the function will return a
+    null QPixmap.  If the rectangle is a superset of the given \a
+    widget, the areas outside the \a widget are covered with the
+    widget's background.
+
+    This function actually asks \a widget to paint itself (and its
+    children to paint themselves) by calling paintEvent() with painter
+    redirection turned on. But QPixmap also provides the grabWindow()
+    function which is a bit faster by grabbing pixels directly off the
+    screen. In addition, if there are overlaying windows,
+    grabWindow(), unlike grabWidget(), will see them.
+
+    \warning Do not grab a widget from its QWidget::paintEvent().
+    However, it is safe to grab a widget from another widget's
+    \l {QWidget::}{paintEvent()}.
+
+    \sa grabWindow()
+*/
+
+QPixmap QPixmap::grabWidget(QWidget * widget, const QRect &rect)
+{
+    if (!widget)
+        return QPixmap();
+
+    if (widget->testAttribute(Qt::WA_PendingResizeEvent) || !widget->testAttribute(Qt::WA_WState_Created))
+        sendResizeEvents(widget);
+
+    QRect r(rect);
+    if (r.width() < 0)
+        r.setWidth(widget->width() - rect.x());
+    if (r.height() < 0)
+        r.setHeight(widget->height() - rect.y());
+
+    if (!r.intersects(widget->rect()))
+        return QPixmap();
+
+    QPixmap res(r.size());
+    widget->render(&res, QPoint(), r,
+                   QWidget::DrawWindowBackground | QWidget::DrawChildren | QWidget::IgnoreMask);
+    return res;
+}
+
+/*!
+    \fn QPixmap QPixmap::grabWidget(QWidget *widget, int x, int y, int
+    width, int height)
+
+    \overload
+
+    Creates a pixmap and paints the given \a widget, restricted by
+    QRect(\a x, \a y, \a width, \a height), in it.
+
+    \warning Do not grab a widget from its QWidget::paintEvent().
+    However, it is safe to grab a widget from another widget's
+    \l {QWidget::}{paintEvent()}.
+*/
+
+
+/*!
+    \since 4.5
+
+    \enum QPixmap::ShareMode
+
+    This enum type defines the share modes that are available when
+    creating a QPixmap object from a raw X11 Pixmap handle.
+
+    \value ImplicitlyShared  This mode will cause the QPixmap object to
+    create a copy of the internal data before it is modified, thus
+    keeping the original X11 pixmap intact.
+
+    \value ExplicitlyShared  In this mode, the pixmap data will \e not be
+    copied before it is modified, which in effect will change the
+    original X11 pixmap.
+
+    \warning This enum is only used for X11 specific functions; using
+    it is non-portable.
+
+    \sa QPixmap::fromX11Pixmap()
+*/
+
+/*!
+    \since 4.5
+
+    \fn QPixmap QPixmap::fromX11Pixmap(Qt::HANDLE pixmap, QPixmap::ShareMode mode)
+
+    Creates a QPixmap from the native X11 Pixmap handle \a pixmap,
+    using \a mode as the share mode. The default share mode is
+    QPixmap::ImplicitlyShared, which means that a copy of the pixmap is
+    made if someone tries to modify it by e.g. drawing onto it.
+
+    QPixmap does \e not take ownership of the \a pixmap handle, and
+    have to be deleted by the user.
+
+    \warning This function is X11 specific; using it is non-portable.
+
+    \sa QPixmap::ShareMode
+*/
+
+
+#if defined(Q_WS_X11) || defined(Q_WS_QWS)
+
+/*!
+    Returns the pixmap's handle to the device context.
+
+    Note that, since QPixmap make use of \l {Implicit Data
+    Sharing}{implicit data sharing}, the detach() function must be
+    called explicitly to ensure that only \e this pixmap's data is
+    modified if the pixmap data is shared.
+
+    \warning This function is X11 specific; using it is non-portable.
+
+    \sa detach()
+*/
+
+Qt::HANDLE QPixmap::handle() const
+{
+#if defined(Q_WS_X11)
+    if (data->classId() == QPixmapData::X11Class)
+        return static_cast<QX11PixmapData*>(data)->handle();
+#endif
+    return 0;
+}
+#endif
+
+
+#ifdef QT3_SUPPORT
+static Qt::ImageConversionFlags colorModeToFlags(QPixmap::ColorMode mode)
+{
+    Qt::ImageConversionFlags flags = Qt::AutoColor;
+    switch (mode) {
+      case QPixmap::Color:
+        flags |= Qt::ColorOnly;
+        break;
+      case QPixmap::Mono:
+        flags |= Qt::MonoOnly;
+        break;
+      default:
+        break;// Nothing.
+    }
+    return flags;
+}
+
+/*!
+    Use the constructor that takes a Qt::ImageConversionFlag instead.
+*/
+
+QPixmap::QPixmap(const QString& fileName, const char *format, ColorMode mode)
+    : QPaintDevice()
+{
+    init(0, 0, QPixmapData::PixmapType);
+    if (!qt_pixmap_thread_test())
+        return;
+
+    load(fileName, format, colorModeToFlags(mode));
+}
+
+/*!
+    Constructs a pixmap from the QImage \a image.
+
+    Use the static fromImage() function instead.
+*/
+QPixmap::QPixmap(const QImage& image)
+    : QPaintDevice()
+{
+    init(0, 0, QPixmapData::PixmapType);
+    if (!qt_pixmap_thread_test())
+        return;
+
+    if (data->pixelType() == QPixmapData::BitmapType)
+        *this = QBitmap::fromImage(image);
+    else
+        *this = fromImage(image);
+}
+
+/*!
+    \overload
+
+    Converts the given \a image to a pixmap that is assigned to this
+    pixmap.
+
+    Use the static fromImage() function instead.
+*/
+
+QPixmap &QPixmap::operator=(const QImage &image)
+{
+    if (data->pixelType() == QPixmapData::BitmapType)
+        *this = QBitmap::fromImage(image);
+    else
+        *this = fromImage(image);
+    return *this;
+}
+
+/*!
+    Use the load() function that takes a Qt::ImageConversionFlag instead.
+*/
+
+bool QPixmap::load(const QString &fileName, const char *format, ColorMode mode)
+{
+    return load(fileName, format, colorModeToFlags(mode));
+}
+
+/*!
+    Use the loadFromData() function that takes a Qt::ImageConversionFlag instead.
+*/
+
+bool QPixmap::loadFromData(const uchar *buf, uint len, const char *format, ColorMode mode)
+{
+    return loadFromData(buf, len, format, colorModeToFlags(mode));
+}
+
+/*!
+    Use the static fromImage() function instead.
+*/
+bool QPixmap::convertFromImage(const QImage &image, ColorMode mode)
+{
+    if (data->pixelType() == QPixmapData::BitmapType)
+        *this = QBitmap::fromImage(image, colorModeToFlags(mode));
+    else
+        *this = fromImage(image, colorModeToFlags(mode));
+    return !isNull();
+}
+
+#endif
+
+/*****************************************************************************
+  QPixmap stream functions
+ *****************************************************************************/
+#if !defined(QT_NO_DATASTREAM)
+/*!
+    \relates QPixmap
+
+    Writes the given \a pixmap to the 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}
+*/
+
+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}
+*/
+
+QDataStream &operator>>(QDataStream &stream, QPixmap &pixmap)
+{
+    QImage image;
+    stream >> image;
+
+    if (image.isNull()) {
+        pixmap = QPixmap();
+    } else if (image.depth() == 1) {
+        pixmap = QBitmap::fromImage(image);
+    } else {
+        pixmap = QPixmap::fromImage(image);
+    }
+    return stream;
+}
+
+#endif //QT_NO_DATASTREAM
+
+#ifdef QT3_SUPPORT
+Q_GUI_EXPORT void copyBlt(QPixmap *dst, int dx, int dy,
+                          const QPixmap *src, int sx, int sy, int sw, int sh)
+{
+    Q_ASSERT_X(dst, "::copyBlt", "Destination pixmap must be non-null");
+    Q_ASSERT_X(src, "::copyBlt", "Source pixmap must be non-null");
+
+    if (src->hasAlphaChannel()) {
+        if (dst->paintEngine()->hasFeature(QPaintEngine::PorterDuff)) {
+            QPainter p(dst);
+            p.setCompositionMode(QPainter::CompositionMode_Source);
+            p.drawPixmap(dx, dy, *src, sx, sy, sw, sh);
+        } else {
+            QImage image = dst->toImage().convertToFormat(QImage::Format_ARGB32_Premultiplied);
+            QPainter p(&image);
+            p.setCompositionMode(QPainter::CompositionMode_Source);
+            p.drawPixmap(dx, dy, *src, sx, sy, sw, sh);
+            p.end();
+            *dst = QPixmap::fromImage(image);
+        }
+    } else {
+        QPainter p(dst);
+        p.drawPixmap(dx, dy, *src, sx, sy, sw, sh);
+    }
+
+}
+#endif
+
+/*!
+    \internal
+*/
+
+bool QPixmap::isDetached() const
+{
+    return data->ref == 1;
+}
+
+void QPixmap::deref()
+{
+    if (data && !data->ref.deref()) { // Destroy image if last ref
+#if !defined(QT_NO_DIRECT3D) && defined(Q_WS_WIN)
+        if (data->classId() == QPixmapData::RasterClass) {
+            QRasterPixmapData *rData = static_cast<QRasterPixmapData*>(data);
+            if (rData->texture)
+                rData->texture->Release();
+            rData->texture = 0;
+        }
+#endif
+        if (data->is_cached && qt_pixmap_cleanup_hook_64)
+            qt_pixmap_cleanup_hook_64(cacheKey());
+        delete data;
+        data = 0;
+    }
+}
+
+/*!
+    \fn QImage QPixmap::convertToImage() const
+
+    Use the toImage() function instead.
+*/
+
+/*!
+    \fn bool QPixmap::convertFromImage(const QImage &image, Qt::ImageConversionFlags flags)
+
+    Use the static fromImage() function instead.
+*/
+
+/*!
+    \fn QPixmap QPixmap::xForm(const QMatrix &matrix) const
+
+    Use transformed() instead.
+*/
+
+/*!
+    \fn QPixmap QPixmap::scaled(int width, int height,
+    Qt::AspectRatioMode aspectRatioMode, Qt::TransformationMode
+    transformMode) const
+
+    \overload
+
+    Returns a copy of the pixmap scaled to a rectangle with the given
+    \a width and \a height according to the given \a aspectRatioMode and
+    \a transformMode.
+
+    If either the \a width or the \a height is zero or negative, this
+    function returns a null pixmap.
+*/
+
+/*!
+    \fn QPixmap QPixmap::scaled(const QSize &size, Qt::AspectRatioMode
+    aspectRatioMode, Qt::TransformationMode transformMode) const
+
+    Scales the pixmap to the given \a size, using the aspect ratio and
+    transformation modes specified by \a aspectRatioMode and \a
+    transformMode.
+
+    \image qimage-scaling.png
+
+    \list
+    \i If \a aspectRatioMode is Qt::IgnoreAspectRatio, the pixmap
+       is scaled to \a size.
+    \i If \a aspectRatioMode is Qt::KeepAspectRatio, the pixmap is
+       scaled to a rectangle as large as possible inside \a size, preserving the aspect ratio.
+    \i If \a aspectRatioMode is Qt::KeepAspectRatioByExpanding,
+       the pixmap is scaled to a rectangle as small as possible
+       outside \a size, preserving the aspect ratio.
+    \endlist
+
+    If the given \a size is empty, this function returns a null
+    pixmap.
+
+    \sa isNull(), {QPixmap#Pixmap Transformations}{Pixmap
+    Transformations}
+
+*/
+QPixmap QPixmap::scaled(const QSize& s, Qt::AspectRatioMode aspectMode, Qt::TransformationMode mode) const
+{
+    if (isNull()) {
+        qWarning("QPixmap::scaled: Pixmap is a null pixmap");
+        return QPixmap();
+    }
+    if (s.isEmpty())
+        return QPixmap();
+
+    QSize newSize = size();
+    newSize.scale(s, aspectMode);
+    if (newSize == size())
+        return *this;
+
+    QPixmap pix;
+    QTransform wm;
+    wm.scale((qreal)newSize.width() / width(), (qreal)newSize.height() / height());
+    pix = transformed(wm, mode);
+    return pix;
+}
+
+/*!
+    \fn QPixmap QPixmap::scaledToWidth(int width, Qt::TransformationMode
+    mode) const
+
+    Returns a scaled copy of the image. The returned image is scaled
+    to the given \a width using the specified transformation \a mode.
+    The height of the pixmap is automatically calculated so that the
+    aspect ratio of the pixmap is preserved.
+
+    If \a width is 0 or negative, a null pixmap is returned.
+
+    \sa isNull(), {QPixmap#Pixmap Transformations}{Pixmap
+    Transformations}
+*/
+QPixmap QPixmap::scaledToWidth(int w, Qt::TransformationMode mode) const
+{
+    if (isNull()) {
+        qWarning("QPixmap::scaleWidth: Pixmap is a null pixmap");
+        return copy();
+    }
+    if (w <= 0)
+        return QPixmap();
+
+    QTransform wm;
+    qreal factor = (qreal) w / width();
+    wm.scale(factor, factor);
+    return transformed(wm, mode);
+}
+
+/*!
+    \fn QPixmap QPixmap::scaledToHeight(int height,
+    Qt::TransformationMode mode) const
+
+    Returns a scaled copy of the image. The returned image is scaled
+    to the given \a height using the specified transformation \a mode.
+    The width of the pixmap is automatically calculated so that the
+    aspect ratio of the pixmap is preserved.
+
+    If \a height is 0 or negative, a null pixmap is returned.
+
+    \sa isNull(), {QPixmap#Pixmap Transformations}{Pixmap
+    Transformations}
+*/
+QPixmap QPixmap::scaledToHeight(int h, Qt::TransformationMode mode) const
+{
+    if (isNull()) {
+        qWarning("QPixmap::scaleHeight: Pixmap is a null pixmap");
+        return copy();
+    }
+    if (h <= 0)
+        return QPixmap();
+
+    QTransform wm;
+    qreal factor = (qreal) h / height();
+    wm.scale(factor, factor);
+    return transformed(wm, mode);
+}
+
+/*!
+    Returns a copy of the pixmap that is transformed using the given
+    transformation \a transform and transformation \a mode. The original
+    pixmap is not changed.
+
+    The transformation \a transform is internally adjusted to compensate
+    for unwanted translation; i.e. the pixmap produced is the smallest
+    pixmap that contains all the transformed points of the original
+    pixmap. Use the trueMatrix() function to retrieve the actual
+    matrix used for transforming the pixmap.
+
+    This function is slow because it involves transformation to a
+    QImage, non-trivial computations and a transformation back to a
+    QPixmap.
+
+    \sa trueMatrix(), {QPixmap#Pixmap Transformations}{Pixmap
+    Transformations}
+*/
+QPixmap QPixmap::transformed(const QTransform &transform,
+                             Qt::TransformationMode mode) const
+{
+    if (isNull() || transform.type() <= QTransform::TxTranslate)
+        return *this;
+
+    return data->transformed(transform, mode);
+}
+
+/*!
+  \overload
+
+  This convenience function loads the \a matrix into a
+  QTransform and calls the overloaded function.
+ */
+QPixmap QPixmap::transformed(const QMatrix &matrix, Qt::TransformationMode mode) const
+{
+    return transformed(QTransform(matrix), mode);
+}
+
+
+
+
+
+
+
+
+/*!
+    \class QPixmap
+
+    \brief The QPixmap class is an off-screen image representation
+    that can be used as a paint device.
+
+    \ingroup multimedia
+    \ingroup shared
+    \mainclass
+
+    Qt provides four classes for handling image data: QImage, QPixmap,
+    QBitmap and QPicture. QImage is designed and optimized for I/O,
+    and for direct pixel access and manipulation, while QPixmap is
+    designed and optimized for showing images on screen. QBitmap is
+    only a convenience class that inherits QPixmap, ensuring a depth
+    of 1. The isQBitmap() function returns true if a QPixmap object is
+    really a bitmap, otherwise returns false. Finally, the QPicture class is a
+    paint device that records and replays QPainter commands.
+
+    A QPixmap can easily be displayed on the screen using QLabel or
+    one of QAbstractButton's subclasses (such as QPushButton and
+    QToolButton). QLabel has a pixmap property, whereas
+    QAbstractButton has an icon property. And because QPixmap is a
+    QPaintDevice subclass, QPainter can be used to draw directly onto
+    pixmaps.
+
+    In addition to the ordinary constructors, a QPixmap can be
+    constructed using the static grabWidget() and grabWindow()
+    functions which creates a QPixmap and paints the given widget, or
+    window, in it.
+
+    Note that the pixel data in a pixmap is internal and is managed by
+    the underlying window system. Pixels can only be accessed through
+    QPainter functions or by converting the QPixmap to a QImage.
+    Depending on the system, QPixmap is stored using a RGB32 or a
+    premultiplied alpha format. If the image has an alpha channel, and
+    if the system allows, the preferred format is premultiplied alpha.
+    Note also that QPixmap, unlike QImage, may be hardware dependent.
+    On X11 and Mac, a QPixmap is stored on the server side while a
+    QImage is stored on the client side (on Windows, these two classes
+    have an equivalent internal representation, i.e. both QImage and
+    QPixmap are stored on the client side and don't use any GDI
+    resources).
+
+    There are functions to convert between QImage and
+    QPixmap. Typically, the QImage class is used to load an image
+    file, optionally manipulating the image data, before the QImage
+    object is converted into a QPixmap to be shown on
+    screen. Alternatively, if no manipulation is desired, the image
+    file can be loaded directly into a QPixmap. On Windows, the
+    QPixmap class also supports conversion between \c HBITMAP and
+    QPixmap.
+
+    QPixmap provides a collection of functions that can be used to
+    obtain a variety of information about the pixmap. In addition,
+    there are several functions that enables transformation of the
+    pixmap.
+
+    QPixmap objects can be passed around by value since the QPixmap
+    class uses implicit data sharing. For more information, see the \l
+    {Implicit Data Sharing} documentation. QPixmap objects can also be
+    streamed.
+
+    \tableofcontents
+
+    \section1 Reading and Writing Image Files
+
+    QPixmap provides several ways of reading an image file: The file
+    can be loaded when constructing the QPixmap object, or by using
+    the load() or loadFromData() functions later on. When loading an
+    image, the file name can either refer to an actual file on disk or
+    to one of the application's embedded resources. See \l{The Qt
+    Resource System} overview for details on how to embed images and
+    other resource files in the application's executable.
+
+    Simply call the save() function to save a QPixmap object.
+
+    The complete list of supported file formats are available through
+    the QImageReader::supportedImageFormats() and
+    QImageWriter::supportedImageFormats() functions. New file formats
+    can be added as plugins. By default, Qt supports the following
+    formats:
+
+    \table
+    \header \o Format \o Description                      \o Qt's support
+    \row    \o BMP    \o Windows Bitmap                   \o Read/write
+    \row    \o GIF    \o Graphic Interchange Format (optional) \o Read
+    \row    \o JPG    \o Joint Photographic Experts Group \o Read/write
+    \row    \o JPEG   \o Joint Photographic Experts Group \o Read/write
+    \row    \o PNG    \o Portable Network Graphics        \o Read/write
+    \row    \o PBM    \o Portable Bitmap                  \o Read
+    \row    \o PGM    \o Portable Graymap                 \o Read
+    \row    \o PPM    \o Portable Pixmap                  \o Read/write
+    \row    \o XBM    \o X11 Bitmap                       \o Read/write
+    \row    \o XPM    \o X11 Pixmap                       \o Read/write
+    \endtable
+
+    \section1 Pixmap Information
+
+    QPixmap provides a collection of functions that can be used to
+    obtain a variety of information about the pixmap:
+
+    \table
+    \header
+    \o \o Available Functions
+    \row
+    \o Geometry
+    \o
+    The size(), width() and height() functions provide information
+    about the pixmap's size. The rect() function returns the image's
+    enclosing rectangle.
+
+    \row
+    \o Alpha component
+    \o
+
+    The hasAlphaChannel() returns true if the pixmap has a format that
+    respects the alpha channel, otherwise returns false, while the
+    hasAlpha() function returns true if the pixmap has an alpha
+    channel \e or a mask (otherwise false).
+
+    The alphaChannel() function returns the alpha channel as a new
+    QPixmap object, while the mask() function returns the mask as a
+    QBitmap object. The alpha channel and mask can be set using the
+    setAlphaChannel() and setMask() functions, respectively.
+
+    \row
+    \o Low-level information
+    \o
+
+    The depth() function returns the depth of the pixmap. The
+    defaultDepth() function returns the default depth, i.e. the depth
+    used by the application on the given screen.
+
+    The cacheKey() function returns a number that uniquely
+    identifies the contents of the QPixmap object.
+
+    The x11Info() function returns information about the configuration
+    of the X display used to display the widget.  The
+    x11PictureHandle() function returns the X11 Picture handle of the
+    pixmap for XRender support. Note that the two latter functions are
+    only available on x11.
+
+    \endtable
+
+    \section1 Pixmap Conversion
+
+    A QPixmap object can be converted into a QImage using the
+    toImage() function. Likewise, a QImage can be converted into a
+    QPixmap using the fromImage(). If this is too expensive an
+    operation, you can use QBitmap::fromImage() instead.
+
+    In addition, on Windows, the QPixmap class supports conversion to
+    and from HBitmap: the toWinHBITMAP() function creates a HBITMAP
+    equivalent to the QPixmap, based on the given HBitmapFormat, and
+    returns the HBITMAP handle. The fromWinHBITMAP() function returns
+    a QPixmap that is equivalent to the given bitmap which has the
+    specified format.
+
+    \section1 Pixmap Transformations
+
+    QPixmap supports a number of functions for creating a new pixmap
+    that is a transformed version of the original: The
+    createHeuristicMask() function creates and returns a 1-bpp
+    heuristic mask (i.e. a QBitmap) for this pixmap. It works by
+    selecting a color from one of the corners and then chipping away
+    pixels of that color, starting at all the edges. The
+    createMaskFromColor() function creates and returns a mask (i.e. a
+    QBitmap) for the pixmap based on a given color.
+
+
+    The scaled(), scaledToWidth() and scaledToHeight() functions
+    return scaled copies of the pixmap, while the copy() function
+    creates a QPixmap that is a plain copy of the original one.
+
+    The transformed() function returns a copy of the pixmap that is
+    transformed with the given transformation matrix and
+    transformation mode: Internally, the transformation matrix is
+    adjusted to compensate for unwanted translation,
+    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.
+
+    There are also functions for changing attributes of a pixmap.
+    in-place: The fill() function fills the entire image with the
+    given color, the setMask() function sets a mask bitmap, and the
+    setAlphaChannel() function sets the pixmap's alpha channel.
+
+    \sa QBitmap, QImage, QImageReader, QImageWriter
+*/
+
+
+/*!
+    \typedef QPixmap::DataPtr
+    \internal
+*/
+
+/*!
+    \fn DataPtr &QPixmap::data_ptr()
+    \internal
+*/
+
+/*!
+    Returns true if this pixmap has an alpha channel, \e or has a
+    mask, otherwise returns false.
+
+    \sa hasAlphaChannel(), alphaChannel(), mask()
+*/
+bool QPixmap::hasAlpha() const
+{
+    return (data->hasAlphaChannel() || !data->mask().isNull());
+}
+
+/*!
+    Returns true if the pixmap has a format that respects the alpha
+    channel, otherwise returns false.
+
+    \sa alphaChannel(), hasAlpha()
+*/
+bool QPixmap::hasAlphaChannel() const
+{
+    return data->hasAlphaChannel();
+}
+
+/*!
+  \reimp
+*/
+int QPixmap::metric(PaintDeviceMetric metric) const
+{
+    return data->metric(metric);
+}
+
+/*!
+    \fn void QPixmap::setAlphaChannel(const QPixmap &alphaChannel)
+
+    Sets the alpha channel of this pixmap to the given \a alphaChannel
+    by converting the \a alphaChannel into 32 bit and using the
+    intensity of the RGB pixel values.
+
+    The effect of this function is undefined when the pixmap is being
+    painted on.
+
+    \sa alphaChannel(), {QPixmap#Pixmap Transformations}{Pixmap
+    Transformations}
+ */
+void QPixmap::setAlphaChannel(const QPixmap &alphaChannel)
+{
+    if (alphaChannel.isNull())
+        return;
+
+    if (paintingActive()) {
+        qWarning("QPixmap::setAlphaChannel: "
+                 "Cannot set alpha channel while pixmap is being painted on");
+        return;
+    }
+
+    if (width() != alphaChannel.width() && height() != alphaChannel.height()) {
+        qWarning("QPixmap::setAlphaChannel: "
+                 "The pixmap and the alpha channel pixmap must have the same size");
+        return;
+    }
+
+    detach();
+    data->setAlphaChannel(alphaChannel);
+}
+
+/*!
+    Returns the alpha channel of the pixmap as a new grayscale QPixmap in which
+    each pixel's red, green, and blue values are given the alpha value of the
+    original pixmap. The color depth of the returned pixmap is the system depth
+    on X11 and 8-bit on Windows and Mac OS X.
+
+    You can use this function while debugging
+    to get a visible image of the alpha channel. If the pixmap doesn't have an
+    alpha channel, i.e., the alpha channel's value for all pixels equals
+    0xff), a null pixmap is returned. You can check this with the \c isNull()
+    function.
+
+    We show an example:
+
+    \snippet doc/src/snippets/alphachannel.cpp 0
+
+    \image alphachannelimage.png The pixmap and channelImage QPixmaps
+
+    \sa setAlphaChannel(), {QPixmap#Pixmap Information}{Pixmap
+    Information}
+*/
+QPixmap QPixmap::alphaChannel() const
+{
+    return data->alphaChannel();
+}
+
+/*!
+  \reimp
+*/
+QPaintEngine *QPixmap::paintEngine() const
+{
+    return data->paintEngine();
+}
+
+/*!
+    \fn QBitmap QPixmap::mask() const
+
+    Extracts a bitmap mask from the pixmap's alphachannel.
+
+    This is potentially an expensive operation.
+
+    \sa setMask(), {QPixmap#Pixmap Information}{Pixmap Information}
+*/
+QBitmap QPixmap::mask() const
+{
+    return data->mask();
+}
+
+/*!
+    Returns the default pixmap depth used by the application.
+
+    On Windows and Mac, the default depth is always 32. On X11 and
+    embedded, the depth of the screen will be returned by this
+    function.
+
+    \sa depth(), QColormap::depth(), {QPixmap#Pixmap Information}{Pixmap Information}
+
+*/
+int QPixmap::defaultDepth()
+{
+#if defined(Q_WS_QWS)
+    return QScreen::instance()->depth();
+#elif defined(Q_WS_X11)
+    return QX11Info::appDepth();
+#elif defined(Q_OS_WINCE)
+    return QColormap::instance().depth();
+#elif defined(Q_WS_WIN)
+    return 32; // XXX
+#elif defined(Q_WS_MAC)
+    return 32;
+#endif
+}
+
+typedef void (*_qt_pixmap_cleanup_hook_64)(qint64);
+extern _qt_pixmap_cleanup_hook_64 qt_pixmap_cleanup_hook_64;
+
+/*!
+    Detaches the pixmap from shared pixmap data.
+
+    A pixmap is automatically detached by Qt whenever its contents are
+    about to change. This is done in almost all QPixmap member
+    functions that modify the pixmap (fill(), fromImage(),
+    load(), etc.), and in QPainter::begin() on a pixmap.
+
+    There are two exceptions in which detach() must be called
+    explicitly, that is when calling the handle() or the
+    x11PictureHandle() function (only available on X11). Otherwise,
+    any modifications done using system calls, will be performed on
+    the shared data.
+
+    The detach() function returns immediately if there is just a
+    single reference or if the pixmap has not been initialized yet.
+*/
+void QPixmap::detach()
+{
+    QPixmapData::ClassId id = data->classId();
+    if (id == QPixmapData::RasterClass) {
+        QRasterPixmapData *rasterData = static_cast<QRasterPixmapData*>(data);
+        rasterData->image.detach();
+#if defined(Q_WS_WIN) && !defined(QT_NO_DIRECT3D)
+        if (rasterData->texture) {
+            rasterData->texture->Release();
+            rasterData->texture = 0;
+        }
+#endif
+    }
+
+    if (data->is_cached && qt_pixmap_cleanup_hook_64 && data->ref == 1)
+        qt_pixmap_cleanup_hook_64(cacheKey());
+
+#if defined(Q_WS_MAC)
+    QMacPixmapData *macData = id == QPixmapData::MacClass ? static_cast<QMacPixmapData*>(data) : 0;
+    if (macData) {
+        if (macData->cg_mask) {
+            CGImageRelease(macData->cg_mask);
+            macData->cg_mask = 0;
+        }
+    }
+#endif
+
+    if (data->ref != 1) {
+        *this = copy();
+#if defined(Q_WS_MAC) && !defined(QT_MAC_NO_QUICKDRAW)
+        if (id == QPixmapData::MacClass) {
+            macData->qd_alpha = 0;
+        }
+#endif
+    }
+    ++data->detach_no;
+
+#if defined(Q_WS_X11)
+    if (data->classId() == QPixmapData::X11Class) {
+        QX11PixmapData *d = static_cast<QX11PixmapData*>(data);
+        d->uninit = false;
+
+        // reset the cache data
+        if (d->hd2) {
+            XFreePixmap(X11->display, d->hd2);
+            d->hd2 = 0;
+        }
+    }
+#elif defined(Q_WS_MAC)
+    if (macData) {
+        macData->macReleaseCGImageRef();
+        macData->uninit = false;
+    }
+#endif
+}
+
+/*!
+    \fn QPixmap QPixmap::fromImage(const QImage &image, Qt::ImageConversionFlags flags)
+
+    Converts the given \a image to a pixmap using the specified \a
+    flags to control the conversion.  The \a flags argument is a
+    bitwise-OR of the \l{Qt::ImageConversionFlags}. Passing 0 for \a
+    flags sets all the default options.
+
+    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}
+*/
+QPixmap QPixmap::fromImage(const QImage &image, Qt::ImageConversionFlags flags)
+{
+    if (image.isNull())
+        return QPixmap();
+
+    QPixmapData *data;
+    QGraphicsSystem* gs = QApplicationPrivate::graphicsSystem();
+    if (gs)
+        data = gs->createPixmapData(QPixmapData::PixmapType);
+    else
+        data = QGraphicsSystem::createDefaultPixmapData(QPixmapData::PixmapType);
+
+    data->fromImage(image, flags);
+    return QPixmap(data);
+}
+
+/*!
+    \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,
+    \a height).
+
+    The arguments (\a{x}, \a{y}) specify the offset in the window,
+    whereas (\a{width}, \a{height}) specify the area to be copied.  If
+    \a width is negative, the function copies everything to the right
+    border of the window. If \a height is negative, the function
+    copies everything to the bottom of the window.
+
+    The window system identifier (\c WId) can be retrieved using the
+    QWidget::winId() function. The rationale for using a window
+    identifier and not a QWidget, is to enable grabbing of windows
+    that are not part of the application, window system frames, and so
+    on.
+
+    The grabWindow() function grabs pixels from the screen, not from
+    the window, i.e. if there is another window partially or entirely
+    over the one you grab, you get pixels from the overlying window,
+    too. The mouse cursor is generally not grabbed.
+
+    Note on X11that if the given \a window doesn't have the same depth
+    as the root window, and another window partially or entirely
+    obscures the one you grab, you will \e not get pixels from the
+    overlying window.  The contents of the obscured areas in the
+    pixmap will be undefined and uninitialized.
+
+    \warning In general, grabbing an area outside the screen is not
+    safe. This depends on the underlying window system.
+
+    \sa grabWidget(), {Screenshot Example}
+*/
+
+/*!
+  \internal
+*/
+QPixmapData* QPixmap::pixmapData() const
+{
+    return data;
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/image/qpixmap.h b/src/gui/image/qpixmap.h
new file mode 100644
index 0000000..cd3b465
--- /dev/null
+++ b/src/gui/image/qpixmap.h
@@ -0,0 +1,312 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPIXMAP_H
+#define QPIXMAP_H
+
+#include <QtGui/qpaintdevice.h>
+#include <QtGui/qcolor.h>
+#include <QtCore/qnamespace.h>
+#include <QtCore/qstring.h> // char*->QString conversion
+#include <QtGui/qimage.h>
+#include <QtGui/qtransform.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+class QImageWriter;
+class QColor;
+class QVariant;
+class QX11Info;
+
+class QPixmapData;
+
+class Q_GUI_EXPORT QPixmap : public QPaintDevice
+{
+public:
+    QPixmap();
+    explicit QPixmap(QPixmapData *data);
+    QPixmap(int w, int h);
+    QPixmap(const QSize &);
+    QPixmap(const QString& fileName, const char *format = 0, Qt::ImageConversionFlags flags = Qt::AutoColor);
+#ifndef QT_NO_IMAGEFORMAT_XPM
+    QPixmap(const char * const xpm[]);
+#endif
+    QPixmap(const QPixmap &);
+    ~QPixmap();
+
+    QPixmap &operator=(const QPixmap &);
+    operator QVariant() const;
+
+    bool isNull() const;
+    int devType() const;
+
+    int width() const;
+    int height() const;
+    QSize size() const;
+    QRect rect() const;
+    int depth() const;
+
+    static int defaultDepth();
+
+    void fill(const QColor &fillColor = Qt::white);
+    void fill(const QWidget *widget, const QPoint &ofs);
+    inline void fill(const QWidget *widget, int xofs, int yofs) { fill(widget, QPoint(xofs, yofs)); }
+
+    QBitmap mask() const;
+    void setMask(const QBitmap &);
+
+    QPixmap alphaChannel() const;
+    void setAlphaChannel(const QPixmap &);
+
+    bool hasAlpha() const;
+    bool hasAlphaChannel() const;
+
+#ifndef QT_NO_IMAGE_HEURISTIC_MASK
+    QBitmap createHeuristicMask(bool clipTight = true) const;
+#endif
+    QBitmap createMaskFromColor(const QColor &maskColor) const; // ### Qt 5: remove
+    QBitmap createMaskFromColor(const QColor &maskColor, Qt::MaskMode mode) const;
+
+    static QPixmap grabWindow(WId, int x=0, int y=0, int w=-1, int h=-1);
+    static QPixmap grabWidget(QWidget *widget, const QRect &rect);
+    static inline QPixmap grabWidget(QWidget *widget, int x=0, int y=0, int w=-1, int h=-1)
+    { return grabWidget(widget, QRect(x, y, w, h)); }
+
+
+    inline QPixmap scaled(int w, int h, Qt::AspectRatioMode aspectMode = Qt::IgnoreAspectRatio,
+                          Qt::TransformationMode mode = Qt::FastTransformation) const
+        { return scaled(QSize(w, h), aspectMode, mode); }
+    QPixmap scaled(const QSize &s, Qt::AspectRatioMode aspectMode = Qt::IgnoreAspectRatio,
+                   Qt::TransformationMode mode = Qt::FastTransformation) const;
+    QPixmap scaledToWidth(int w, Qt::TransformationMode mode = Qt::FastTransformation) const;
+    QPixmap scaledToHeight(int h, Qt::TransformationMode mode = Qt::FastTransformation) const;
+    QPixmap transformed(const QMatrix &, Qt::TransformationMode mode = Qt::FastTransformation) const;
+    static QMatrix trueMatrix(const QMatrix &m, int w, int h);
+    QPixmap transformed(const QTransform &, Qt::TransformationMode mode = Qt::FastTransformation) const;
+    static QTransform trueMatrix(const QTransform &m, int w, int h);
+
+    QImage toImage() const;
+    static QPixmap fromImage(const QImage &image, Qt::ImageConversionFlags flags = Qt::AutoColor);
+
+    bool load(const QString& fileName, const char *format = 0, Qt::ImageConversionFlags flags = Qt::AutoColor);
+    bool loadFromData(const uchar *buf, uint len, const char* format = 0, Qt::ImageConversionFlags flags = Qt::AutoColor);
+    inline bool loadFromData(const QByteArray &data, const char* format = 0, Qt::ImageConversionFlags flags = Qt::AutoColor);
+    bool save(const QString& fileName, const char* format = 0, int quality = -1) const;
+    bool save(QIODevice* device, const char* format = 0, int quality = -1) const;
+
+#if defined(Q_WS_WIN)
+    enum HBitmapFormat {
+        NoAlpha,
+        PremultipliedAlpha,
+        Alpha
+    };
+
+    HBITMAP toWinHBITMAP(HBitmapFormat format = NoAlpha) const;
+    static QPixmap fromWinHBITMAP(HBITMAP hbitmap, HBitmapFormat format = NoAlpha);
+#endif
+
+#if defined(Q_WS_MAC)
+    CGImageRef toMacCGImageRef() const;
+    static QPixmap fromMacCGImageRef(CGImageRef image);
+#endif
+
+    inline QPixmap copy(int x, int y, int width, int height) const;
+    QPixmap copy(const QRect &rect = QRect()) const;
+
+    inline void scroll(int dx, int dy, int x, int y, int width, int height, QRegion *exposed = 0);
+    void scroll(int dx, int dy, const QRect &rect, QRegion *exposed = 0);
+
+    int serialNumber() const;
+    qint64 cacheKey() const;
+
+    bool isDetached() const;
+    void detach();
+
+    bool isQBitmap() const;
+
+#if defined(Q_WS_QWS)
+    const uchar *qwsBits() const;
+    int qwsBytesPerLine() const;
+    QRgb *clut() const;
+    int numCols() const;
+#elif defined(Q_WS_MAC)
+    Qt::HANDLE macQDHandle() const;
+    Qt::HANDLE macQDAlphaHandle() const;
+    Qt::HANDLE macCGHandle() const;
+#elif defined(Q_WS_X11)
+    enum ShareMode { ImplicitlyShared, ExplicitlyShared };
+
+    static QPixmap fromX11Pixmap(Qt::HANDLE pixmap, ShareMode mode = ImplicitlyShared);
+    static int x11SetDefaultScreen(int screen);
+    void x11SetScreen(int screen);
+    const QX11Info &x11Info() const;
+    Qt::HANDLE x11PictureHandle() const;
+#endif
+
+#if defined(Q_WS_X11) || defined(Q_WS_QWS)
+    Qt::HANDLE handle() const;
+#endif
+
+    QPaintEngine *paintEngine() const;
+
+    inline bool operator!() const { return isNull(); }
+
+protected:
+    int metric(PaintDeviceMetric) const;
+
+#ifdef QT3_SUPPORT
+public:
+    enum ColorMode { Auto, Color, Mono };
+    QT3_SUPPORT_CONSTRUCTOR QPixmap(const QString& fileName, const char *format, ColorMode mode);
+    QT3_SUPPORT bool load(const QString& fileName, const char *format, ColorMode mode);
+    QT3_SUPPORT bool loadFromData(const uchar *buf, uint len, const char* format, ColorMode mode);
+    QT3_SUPPORT_CONSTRUCTOR QPixmap(const QImage& image);
+    QT3_SUPPORT QPixmap &operator=(const QImage &);
+    inline QT3_SUPPORT QImage convertToImage() const { return toImage(); }
+    QT3_SUPPORT bool convertFromImage(const QImage &, ColorMode mode);
+    QT3_SUPPORT bool convertFromImage(const QImage &img, Qt::ImageConversionFlags flags = Qt::AutoColor)
+        { (*this) = fromImage(img, flags); return !isNull(); }
+    inline QT3_SUPPORT operator QImage() const { return toImage(); }
+    inline QT3_SUPPORT QPixmap xForm(const QMatrix &matrix) const { return transformed(QTransform(matrix)); }
+    inline QT3_SUPPORT bool selfMask() const { return false; }
+private:
+    void resize_helper(const QSize &s);
+public:
+    inline QT3_SUPPORT void resize(const QSize &s) { resize_helper(s); }
+    inline QT3_SUPPORT void resize(int width, int height) { resize_helper(QSize(width, height)); }
+#endif
+
+private:
+    QPixmapData *data;
+
+    bool doImageIO(QImageWriter *io, int quality) const;
+
+    // ### Qt5: remove the following three lines
+    enum Type { PixmapType, BitmapType }; // must match QPixmapData::PixelType
+    QPixmap(const QSize &s, Type);
+    void init(int, int, Type = PixmapType);
+
+    QPixmap(const QSize &s, int type);
+    void init(int, int, int);
+    void deref();
+#if defined(Q_WS_WIN)
+    void initAlphaPixmap(uchar *bytes, int length, struct tagBITMAPINFO *bmi);
+#endif
+    Q_DUMMY_COMPARISON_OPERATOR(QPixmap)
+#ifdef Q_WS_MAC
+    friend CGContextRef qt_mac_cg_context(const QPaintDevice*);
+    friend CGImageRef qt_mac_create_imagemask(const QPixmap&, const QRectF&);
+    friend IconRef qt_mac_create_iconref(const QPixmap&);
+    friend quint32 *qt_mac_pixmap_get_base(const QPixmap*);
+    friend int qt_mac_pixmap_get_bytes_per_line(const QPixmap*);
+#endif
+    friend class QPixmapData;
+    friend class QX11PixmapData;
+    friend class QMacPixmapData;
+    friend class QBitmap;
+    friend class QPaintDevice;
+    friend class QPainter;
+    friend class QGLWidget;
+    friend class QX11PaintEngine;
+    friend class QCoreGraphicsPaintEngine;
+    friend class QWidgetPrivate;
+    friend class QRasterPaintEngine;
+    friend class QRasterBuffer;
+    friend class QDirect3DPaintEngine;
+    friend class QDirect3DPaintEnginePrivate;
+    friend class QDetachedPixmap;
+#if !defined(QT_NO_DATASTREAM)
+    friend Q_GUI_EXPORT QDataStream &operator>>(QDataStream &, QPixmap &);
+#endif
+    friend Q_GUI_EXPORT qint64 qt_pixmap_id(const QPixmap &pixmap);
+
+public:
+    QPixmapData* pixmapData() const;
+
+public:
+    typedef QPixmapData * DataPtr;
+    inline DataPtr &data_ptr() { return data; }
+};
+
+Q_DECLARE_SHARED(QPixmap)
+
+inline QPixmap QPixmap::copy(int ax, int ay, int awidth, int aheight) const
+{
+    return copy(QRect(ax, ay, awidth, aheight));
+}
+
+inline void QPixmap::scroll(int dx, int dy, int ax, int ay, int awidth, int aheight, QRegion *exposed)
+{
+    scroll(dx, dy, QRect(ax, ay, awidth, aheight), exposed);
+}
+
+inline bool QPixmap::loadFromData(const QByteArray &buf, const char *format,
+                                  Qt::ImageConversionFlags flags)
+{
+    return loadFromData(reinterpret_cast<const uchar *>(buf.constData()), buf.size(), format, flags);
+}
+
+/*****************************************************************************
+ QPixmap stream functions
+*****************************************************************************/
+
+#if !defined(QT_NO_DATASTREAM)
+Q_GUI_EXPORT QDataStream &operator<<(QDataStream &, const QPixmap &);
+Q_GUI_EXPORT QDataStream &operator>>(QDataStream &, QPixmap &);
+#endif
+
+/*****************************************************************************
+ QPixmap (and QImage) helper functions
+*****************************************************************************/
+#ifdef QT3_SUPPORT
+QT3_SUPPORT Q_GUI_EXPORT void copyBlt(QPixmap *dst, int dx, int dy, const QPixmap *src,
+                                    int sx=0, int sy=0, int sw=-1, int sh=-1);
+#endif // QT3_SUPPORT
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QPIXMAP_H
diff --git a/src/gui/image/qpixmap_mac.cpp b/src/gui/image/qpixmap_mac.cpp
new file mode 100644
index 0000000..b0075b2
--- /dev/null
+++ b/src/gui/image/qpixmap_mac.cpp
@@ -0,0 +1,1339 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+//#define QT_RASTER_PAINTENGINE
+
+#include "qpixmap.h"
+#include "qimage.h"
+#include "qapplication.h"
+#include "qbitmap.h"
+#include "qmatrix.h"
+#include "qtransform.h"
+#include "qlibrary.h"
+#include "qvarlengtharray.h"
+#include "qdebug.h"
+#include <private/qdrawhelper_p.h>
+#include <private/qpixmap_mac_p.h>
+#include <private/qpixmap_raster_p.h>
+#ifdef QT_RASTER_PAINTENGINE
+#  include <private/qpaintengine_raster_p.h>
+#endif
+#include <private/qpaintengine_mac_p.h>
+#include <private/qt_mac_p.h>
+#include <private/qt_cocoa_helpers_mac_p.h>
+
+#include <limits.h>
+#include <string.h>
+
+QT_BEGIN_NAMESPACE
+
+/*****************************************************************************
+  Externals
+ *****************************************************************************/
+extern const uchar *qt_get_bitflip_array(); //qimage.cpp
+extern CGContextRef qt_mac_cg_context(const QPaintDevice *pdev); //qpaintdevice_mac.cpp
+extern RgnHandle qt_mac_get_rgn(); //qregion_mac.cpp
+extern void qt_mac_dispose_rgn(RgnHandle r); //qregion_mac.cpp
+extern QRegion qt_mac_convert_mac_region(RgnHandle rgn); //qregion_mac.cpp
+
+static int qt_pixmap_serial = 0;
+
+Q_GUI_EXPORT quint32 *qt_mac_pixmap_get_base(const QPixmap *pix)
+{
+    return static_cast<QMacPixmapData*>(pix->data)->pixels;
+}
+
+Q_GUI_EXPORT int qt_mac_pixmap_get_bytes_per_line(const QPixmap *pix)
+{
+    return static_cast<QMacPixmapData*>(pix->data)->bytesPerRow;
+}
+
+void qt_mac_cgimage_data_free(void *info, const void *memoryToFree, size_t)
+{
+    QMacPixmapData *pmdata = static_cast<QMacPixmapData *>(info);
+    if (!pmdata) {
+        free(const_cast<void *>(memoryToFree));
+    } else {
+        if (QMacPixmapData::validDataPointers.contains(pmdata) == false) {
+            free(const_cast<void *>(memoryToFree));
+            return;
+        }
+        if (pmdata->pixels == pmdata->pixelsToFree) {
+            // something we aren't expecting, just free it.
+            Q_ASSERT(memoryToFree != pmdata->pixelsToFree);
+            free(const_cast<void *>(memoryToFree));
+        } else {
+            free(pmdata->pixelsToFree);
+            pmdata->pixelsToFree = static_cast<quint32 *>(const_cast<void *>(memoryToFree));
+        }
+        pmdata->cg_dataBeingReleased = 0;
+    }
+}
+
+CGImageRef qt_mac_image_to_cgimage(const QImage &image)
+{
+    int bitsPerColor = 8;
+    int bitsPerPixel = 32;
+    if (image.depth() == 1) {
+        bitsPerColor = 1;
+        bitsPerPixel = 1;
+    }
+    QCFType<CGDataProviderRef> provider =
+        CGDataProviderCreateWithData(0, image.bits(), image.bytesPerLine() * image.height(),
+                                     0);
+
+#if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4)
+    uint cgflags = kCGImageAlphaPremultipliedFirst;
+#ifdef kCGBitmapByteOrder32Host //only needed because CGImage.h added symbols in the minor version
+    if(QSysInfo::MacintoshVersion >= QSysInfo::MV_10_4)
+        cgflags |= kCGBitmapByteOrder32Host;
+#endif
+#else
+    CGImageAlphaInfo cgflags = kCGImageAlphaPremultipliedFirst;
+#endif
+
+    CGImageRef cgImage = CGImageCreate(image.width(), image.height(), bitsPerColor, bitsPerPixel,
+                                       image.bytesPerLine(),
+                                       QCoreGraphicsPaintEngine::macGenericColorSpace(),
+                                       cgflags, provider,
+                                       0,
+                                       0,
+                                       kCGRenderingIntentDefault);
+
+    return cgImage;
+}
+
+/*****************************************************************************
+  QPixmap member functions
+ *****************************************************************************/
+
+static inline QRgb qt_conv16ToRgb(ushort c) {
+    static const int qt_rbits = (565/100);
+    static const int qt_gbits = (565/10%10);
+    static const int qt_bbits = (565%10);
+    static const int qt_red_shift = qt_bbits+qt_gbits-(8-qt_rbits);
+    static const int qt_green_shift = qt_bbits-(8-qt_gbits);
+    static const int qt_neg_blue_shift = 8-qt_bbits;
+    static const int qt_blue_mask = (1<<qt_bbits)-1;
+    static const int qt_green_mask = (1<<(qt_gbits+qt_bbits))-((1<<qt_bbits)-1);
+    static const int qt_red_mask = (1<<(qt_rbits+qt_gbits+qt_bbits))-(1<<(qt_gbits+qt_bbits));
+
+    const int r=(c & qt_red_mask);
+    const int g=(c & qt_green_mask);
+    const int b=(c & qt_blue_mask);
+    const int tr = r >> qt_red_shift;
+    const int tg = g >> qt_green_shift;
+    const int tb = b << qt_neg_blue_shift;
+
+    return qRgb(tr,tg,tb);
+}
+
+QSet<QMacPixmapData*> QMacPixmapData::validDataPointers;
+
+QMacPixmapData::QMacPixmapData(PixelType type)
+    : QPixmapData(type, MacClass), w(0), h(0), d(0), has_alpha(0), has_mask(0),
+      uninit(true), pixels(0), pixelsToFree(0), bytesPerRow(0),
+      cg_data(0), cg_dataBeingReleased(0), cg_mask(0),
+#ifndef QT_MAC_NO_QUICKDRAW
+      qd_data(0), qd_alpha(0),
+#endif
+      pengine(0)
+{
+}
+
+#define BEST_BYTE_ALIGNMENT 16
+#define COMPTUE_BEST_BYTES_PER_ROW(bpr) \
+    (((bpr) + (BEST_BYTE_ALIGNMENT - 1)) & ~(BEST_BYTE_ALIGNMENT - 1))
+
+void QMacPixmapData::resize(int width, int height)
+{
+    setSerialNumber(++qt_pixmap_serial);
+
+    w = width;
+    h = height;
+    d = (pixelType() == BitmapType ? 1 : 32);
+    bool make_null = w <= 0 || h <= 0;                // create null pixmap
+    if (make_null || d == 0) {
+        w = 0;
+        h = 0;
+        d = 0;
+        if (!make_null)
+            qWarning("Qt: QPixmap: Invalid pixmap parameters");
+        return;
+    }
+
+    if (w < 1 || h < 1)
+        return;
+
+    //create the pixels
+    bytesPerRow = w * sizeof(quint32);  // Minimum bytes per row.
+
+    // Quartz2D likes things as a multple of 16 (for now).
+    bytesPerRow = COMPTUE_BEST_BYTES_PER_ROW(bytesPerRow);
+    macCreatePixels();
+}
+
+#undef COMPUTE_BEST_BYTES_PER_ROW
+
+void QMacPixmapData::fromImage(const QImage &img,
+                               Qt::ImageConversionFlags flags)
+{
+    setSerialNumber(++qt_pixmap_serial);
+
+    // the conversion code only handles format >=
+    // Format_ARGB32_Premultiplied at the moment..
+    if (img.format() > QImage::Format_ARGB32_Premultiplied) {
+        QImage image;
+        if (img.hasAlphaChannel())
+            image = img.convertToFormat(QImage::Format_ARGB32_Premultiplied);
+        else
+            image = img.convertToFormat(QImage::Format_RGB32);
+        fromImage(image, flags);
+        return;
+    }
+
+    w = img.width();
+    h = img.height();
+    d = (pixelType() == BitmapType ? 1 : img.depth());
+
+    QImage image = img;
+    int dd = QPixmap::defaultDepth();
+    bool force_mono = (dd == 1 ||
+                       (flags & Qt::ColorMode_Mask)==Qt::MonoOnly);
+    if (force_mono) {                         // must be monochrome
+        if (d != 1) {
+            image = image.convertToFormat(QImage::Format_MonoLSB, flags);  // dither
+            d = 1;
+        }
+    } else {                                    // can be both
+        bool conv8 = false;
+        if(d > 8 && dd <= 8) {               // convert to 8 bit
+            if ((flags & Qt::DitherMode_Mask) == Qt::AutoDither)
+                flags = (flags & ~Qt::DitherMode_Mask)
+                                   | Qt::PreferDither;
+            conv8 = true;
+        } else if ((flags & Qt::ColorMode_Mask) == Qt::ColorOnly) {
+            conv8 = d == 1;                     // native depth wanted
+        } else if (d == 1) {
+            if (image.numColors() == 2) {
+                QRgb c0 = image.color(0);       // Auto: convert to best
+                QRgb c1 = image.color(1);
+                conv8 = qMin(c0,c1) != qRgb(0,0,0) || qMax(c0,c1) != qRgb(255,255,255);
+            } else {
+                // eg. 1-color monochrome images (they do exist).
+                conv8 = true;
+            }
+        }
+        if (conv8) {
+            image = image.convertToFormat(QImage::Format_Indexed8, flags);
+            d = 8;
+        }
+    }
+
+    if (image.depth()==1) {
+        image.setColor(0, QColor(Qt::color0).rgba());
+        image.setColor(1, QColor(Qt::color1).rgba());
+    }
+
+    if (d == 16 || d == 24) {
+        image = image.convertToFormat(QImage::Format_RGB32, flags);
+        fromImage(image, flags);
+        return;
+    }
+
+    // different size or depth, make a new pixmap
+    resize(w, h);
+
+    quint32 *dptr = pixels, *drow;
+    const uint dbpr = bytesPerRow;
+
+    const QImage::Format sfmt = image.format();
+    const unsigned short sbpr = image.bytesPerLine();
+
+    // use const_cast to prevent a detach
+    const uchar *sptr = const_cast<const QImage &>(image).bits(), *srow;
+
+    for (int y = 0; y < h; ++y) {
+        drow = dptr + (y * (dbpr / 4));
+        srow = sptr + (y * sbpr);
+        switch(sfmt) {
+        case QImage::Format_MonoLSB:
+        case QImage::Format_Mono:{
+            for (int x = 0; x < w; ++x) {
+                char one_bit = *(srow + (x / 8));
+                if (sfmt == QImage::Format_Mono)
+                    one_bit = one_bit >> (7 - (x % 8));
+                else
+                    one_bit = one_bit >> (x % 8);
+                if ((one_bit & 0x01))
+                    *(drow+x) = 0x00000000;
+                else
+                    *(drow+x) = 0xFFFFFFFF;
+            }
+            break;
+        }
+        case QImage::Format_Indexed8:
+            for (int x = 0; x < w; ++x) {
+                *(drow+x) = PREMUL(image.color(*(srow + x)));
+            }
+            break;
+        case QImage::Format_RGB32:
+            for (int x = 0; x < w; ++x)
+                *(drow+x) = *(((quint32*)srow) + x) | 0xFF000000;
+            break;
+        case QImage::Format_ARGB32:
+        case QImage::Format_ARGB32_Premultiplied:
+            for (int x = 0; x < w; ++x) {
+                if(sfmt == QImage::Format_RGB32)
+                    *(drow+x) = 0xFF000000 | (*(((quint32*)srow) + x) & 0x00FFFFFF);
+                else if(sfmt == QImage::Format_ARGB32_Premultiplied)
+                    *(drow+x) = *(((quint32*)srow) + x);
+                else
+                    *(drow+x) = PREMUL(*(((quint32*)srow) + x));
+            }
+            break;
+        default:
+            qWarning("Qt: internal: Oops: Forgot a format [%d] %s:%d", sfmt,
+                     __FILE__, __LINE__);
+            break;
+        }
+    }
+    if (sfmt != QImage::Format_RGB32) { //setup the alpha
+        bool alphamap = image.depth() == 32;
+        if (sfmt == QImage::Format_Indexed8) {
+            const QVector<QRgb> rgb = image.colorTable();
+            for (int i = 0, count = image.numColors(); i < count; ++i) {
+                const int alpha = qAlpha(rgb[i]);
+                if (alpha != 0xff) {
+                    alphamap = true;
+                    break;
+                }
+            }
+        }
+        macSetHasAlpha(alphamap);
+    }
+    uninit = false;
+}
+
+int get_index(QImage * qi,QRgb mycol)
+{
+    int loopc;
+    for(loopc=0;loopc<qi->numColors();loopc++) {
+        if(qi->color(loopc)==mycol)
+            return loopc;
+    }
+    qi->setNumColors(qi->numColors()+1);
+    qi->setColor(qi->numColors(),mycol);
+    return qi->numColors();
+}
+
+QImage QMacPixmapData::toImage() const
+{
+    QImage::Format format = QImage::Format_MonoLSB;
+    if (d != 1) //Doesn't support index color modes
+        format = (has_alpha ? QImage::Format_ARGB32_Premultiplied :
+                  QImage::Format_RGB32);
+
+    QImage image(w, h, format);
+    quint32 *sptr = pixels, *srow;
+    const uint sbpr = bytesPerRow;
+    if (format == QImage::Format_MonoLSB) {
+        image.fill(0);
+        image.setNumColors(2);
+        image.setColor(0, QColor(Qt::color0).rgba());
+        image.setColor(1, QColor(Qt::color1).rgba());
+        for (int y = 0; y < h; ++y) {
+            uchar *scanLine = image.scanLine(y);
+            srow = sptr + (y * (sbpr/4));
+            for (int x = 0; x < w; ++x) {
+                if (!(*(srow + x) & RGB_MASK))
+                    scanLine[x >> 3] |= (1 << (x & 7));
+            }
+        }
+    } else {
+        for (int y = 0; y < h; ++y) {
+            srow = sptr + (y * (sbpr / 4));
+            memcpy(image.scanLine(y), srow, w * 4);
+        }
+
+    }
+
+    return image;
+}
+
+void QMacPixmapData::fill(const QColor &fillColor)
+
+{
+    { //we don't know what backend to use so we cannot paint here
+        quint32 *dptr = pixels;
+        Q_ASSERT_X(dptr, "QPixmap::fill", "No dptr");
+        const quint32 colr = PREMUL(fillColor.rgba());
+        const int nbytes = bytesPerRow * h;
+        if (!colr) {
+            memset(dptr, 0, nbytes);
+        } else {
+            for (uint i = 0; i < nbytes / sizeof(quint32); ++i)
+                *(dptr + i) = colr;
+        }
+    }
+    macSetHasAlpha(fillColor.alpha() != 255);
+}
+
+QPixmap QMacPixmapData::alphaChannel() const
+{
+    if (!has_alpha)
+        return QPixmap();
+
+    QMacPixmapData *alpha = new QMacPixmapData(PixmapType);
+    alpha->resize(w, h);
+    macGetAlphaChannel(alpha, false);
+    return QPixmap(alpha);
+}
+
+void QMacPixmapData::setAlphaChannel(const QPixmap &alpha)
+{
+    has_mask = true;
+    QMacPixmapData *alphaData = static_cast<QMacPixmapData*>(alpha.data);
+    macSetAlphaChannel(alphaData, false);
+}
+
+QBitmap QMacPixmapData::mask() const
+{
+    if (!has_mask && !has_alpha)
+        return QBitmap();
+
+    QMacPixmapData *mask = new QMacPixmapData(BitmapType);
+    mask->resize(w, h);
+    macGetAlphaChannel(mask, true);
+    return QPixmap(mask);
+}
+
+void QMacPixmapData::setMask(const QBitmap &mask)
+{
+    if (mask.isNull()) {
+        QMacPixmapData opaque(PixmapType);
+        opaque.resize(w, h);
+        opaque.fill(QColor(255, 255, 255, 255));
+        macSetAlphaChannel(&opaque, true);
+        has_alpha = has_mask = false;
+        return;
+    }
+
+    has_alpha = false;
+    has_mask = true;
+    QMacPixmapData *maskData = static_cast<QMacPixmapData*>(mask.data);
+    macSetAlphaChannel(maskData, true);
+}
+
+int QMacPixmapData::metric(QPaintDevice::PaintDeviceMetric theMetric) const
+{
+    switch (theMetric) {
+    case QPaintDevice::PdmWidth:
+        return w;
+    case QPaintDevice::PdmHeight:
+        return h;
+    case QPaintDevice::PdmWidthMM:
+        return qRound(metric(QPaintDevice::PdmWidth) * 25.4 / qreal(metric(QPaintDevice::PdmDpiX)));
+    case QPaintDevice::PdmHeightMM:
+        return qRound(metric(QPaintDevice::PdmHeight) * 25.4 / qreal(metric(QPaintDevice::PdmDpiY)));
+    case QPaintDevice::PdmNumColors:
+        return 1 << d;
+    case QPaintDevice::PdmDpiX:
+    case QPaintDevice::PdmPhysicalDpiX: {
+        extern float qt_mac_defaultDpi_x(); //qpaintdevice_mac.cpp
+        return int(qt_mac_defaultDpi_x());
+    }
+    case QPaintDevice::PdmDpiY:
+    case QPaintDevice::PdmPhysicalDpiY: {
+        extern float qt_mac_defaultDpi_y(); //qpaintdevice_mac.cpp
+        return int(qt_mac_defaultDpi_y());
+    }
+    case QPaintDevice::PdmDepth:
+        return d;
+    default:
+        qWarning("QPixmap::metric: Invalid metric command");
+    }
+    return 0;
+}
+
+QMacPixmapData::~QMacPixmapData()
+{
+    validDataPointers.remove(this);
+#ifndef QT_MAC_NO_QUICKDRAW
+    macQDDisposeAlpha();
+    if (qd_data) {
+        DisposeGWorld(qd_data);
+        qd_data = 0;
+    }
+#endif
+    if (cg_mask) {
+        CGImageRelease(cg_mask);
+        cg_mask = 0;
+    }
+
+    delete pengine;  // Make sure we aren't drawing on the context anymore.
+    if (cg_data) {
+        CGImageRelease(cg_data);
+    } else if (!cg_dataBeingReleased && pixels != pixelsToFree) {
+        free(pixels);
+    }
+    free(pixelsToFree);
+}
+
+void QMacPixmapData::macSetAlphaChannel(const QMacPixmapData *pix, bool asMask)
+{
+    if (!pixels || !h || !w || pix->w != w || pix->h != h)
+        return;
+
+    quint32 *dptr = pixels, *drow;
+    const uint dbpr = bytesPerRow;
+    const unsigned short sbpr = pix->bytesPerRow;
+    quint32 *sptr = pix->pixels, *srow;
+    for (int y=0; y < h; ++y) {
+        drow = dptr + (y * (dbpr/4));
+        srow = sptr + (y * (sbpr/4));
+        if(d == 1) {
+            for (int x=0; x < w; ++x) {
+                if((*(srow+x) & RGB_MASK))
+                    *(drow+x) = 0xFFFFFFFF;
+            }
+        } else if(d == 8) {
+            for (int x=0; x < w; ++x)
+                *(drow+x) = (*(drow+x) & RGB_MASK) | (*(srow+x) << 24);
+        } else if(asMask) {
+            for (int x=0; x < w; ++x) {
+                if(*(srow+x) & RGB_MASK)
+                    *(drow+x) = (*(drow+x) & RGB_MASK);
+                else
+                    *(drow+x) = (*(drow+x) & RGB_MASK) | 0xFF000000;
+                *(drow+x) = PREMUL(*(drow+x));
+            }
+        } else {
+            for (int x=0; x < w; ++x) {
+                const uchar alpha = qGray(qRed(*(srow+x)), qGreen(*(srow+x)), qBlue(*(srow+x)));
+                const uchar destAlpha = qt_div_255(alpha * qAlpha(*(drow+x)));
+#if 1
+                *(drow+x) = (*(drow+x) & RGB_MASK) | (destAlpha << 24);
+#else
+                *(drow+x) = qRgba(qt_div_255(qRed(*(drow+x) * alpha)),
+                                  qt_div_255(qGreen(*(drow+x) * alpha)),
+                                  qt_div_255(qBlue(*(drow+x) * alpha)), destAlpha);
+#endif
+                *(drow+x) = PREMUL(*(drow+x));
+            }
+        }
+    }
+    macSetHasAlpha(true);
+}
+
+void QMacPixmapData::macGetAlphaChannel(QMacPixmapData *pix, bool asMask) const
+{
+    quint32 *dptr = pix->pixels, *drow;
+    const uint dbpr = pix->bytesPerRow;
+    const unsigned short sbpr = bytesPerRow;
+    quint32 *sptr = pixels, *srow;
+    for(int y=0; y < h; ++y) {
+        drow = dptr + (y * (dbpr/4));
+        srow = sptr + (y * (sbpr/4));
+        if(asMask) {
+            for (int x = 0; x < w; ++x) {
+                if (*(srow + x) & qRgba(0, 0, 0, 255))
+                    *(drow + x) = 0x00000000;
+                else
+                    *(drow + x) = 0xFFFFFFFF;
+            }
+        } else {
+            for (int x = 0; x < w; ++x) {
+                const int alpha = qAlpha(*(srow + x));
+                *(drow + x) = qRgb(alpha, alpha, alpha);
+            }
+        }
+    }
+}
+
+void QMacPixmapData::macSetHasAlpha(bool b)
+{
+    has_alpha = b;
+#ifndef QT_MAC_NO_QUICKDRAW
+    macQDDisposeAlpha(); //let it get created lazily
+#endif
+    macReleaseCGImageRef();
+}
+
+#ifndef QT_MAC_NO_QUICKDRAW
+void QMacPixmapData::macQDDisposeAlpha()
+{
+    if (qd_alpha) {
+        DisposeGWorld(qd_alpha);
+        qd_alpha = 0;
+    }
+}
+
+void QMacPixmapData::macQDUpdateAlpha()
+{
+    macQDDisposeAlpha(); // get rid of alpha pixmap
+    if (!has_alpha && !has_mask)
+        return;
+
+    //setup
+    Rect rect;
+    SetRect(&rect, 0, 0, w, h);
+    const int params = alignPix | stretchPix | newDepth;
+    NewGWorld(&qd_alpha, 32, &rect, 0, 0, params);
+    int *dptr = (int *)GetPixBaseAddr(GetGWorldPixMap(qd_alpha)), *drow;
+    unsigned short dbpr = GetPixRowBytes(GetGWorldPixMap(qd_alpha));
+    const int *sptr = (int*)pixels, *srow;
+    const uint sbpr = bytesPerRow;
+    uchar clr;
+    for (int y = 0; y < h; ++y) {
+        drow = (int*)((char *)dptr + (y * dbpr));
+        srow = (int*)((char *)sptr + (y * sbpr));
+        for (int x=0; x < w; x++) {
+            clr = qAlpha(*(srow + x));
+            *(drow + x) = qRgba(~clr, ~clr, ~clr, 0);
+        }
+    }
+}
+#endif
+
+void QMacPixmapData::macCreateCGImageRef()
+{
+    Q_ASSERT(cg_data == 0);
+    //create the cg data
+    CGColorSpaceRef colorspace = QCoreGraphicsPaintEngine::macDisplayColorSpace();
+    QCFType<CGDataProviderRef> provider = CGDataProviderCreateWithData(this,
+                                                              pixels, bytesPerRow * h,
+                                                              qt_mac_cgimage_data_free);
+    validDataPointers.insert(this);
+#if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4)
+    uint cgflags = kCGImageAlphaPremultipliedFirst;
+#ifdef kCGBitmapByteOrder32Host //only needed because CGImage.h added symbols in the minor version
+    if(QSysInfo::MacintoshVersion >= QSysInfo::MV_10_4)
+        cgflags |= kCGBitmapByteOrder32Host;
+#endif
+#else
+    CGImageAlphaInfo cgflags = kCGImageAlphaPremultipliedFirst;
+#endif
+    cg_data = CGImageCreate(w, h, 8, 32, bytesPerRow, colorspace,
+                            cgflags, provider, 0, 0, kCGRenderingIntentDefault);
+}
+
+void QMacPixmapData::macReleaseCGImageRef()
+{
+    if (!cg_data)
+        return;  // There's nothing we need to do
+
+    cg_dataBeingReleased = cg_data;
+    CGImageRelease(cg_data);
+    cg_data = 0;
+
+    if (pixels != pixelsToFree) {
+        macCreatePixels();
+    } else {
+        pixelsToFree = 0;
+    }
+}
+
+
+// We create our space in memory to paint on here. If we already have existing pixels
+// copy them over. This is to preserve the fact that CGImageRef's are immutable.
+void QMacPixmapData::macCreatePixels()
+{
+    const int numBytes = bytesPerRow * h;
+    quint32 *base_pixels;
+    if (pixelsToFree && pixelsToFree != pixels) {
+        // Reuse unused block of memory lying around from a previous callback.
+        base_pixels = pixelsToFree;
+        pixelsToFree = 0;
+    } else {
+        // We need a block of memory to do stuff with.
+        base_pixels = static_cast<quint32 *>(malloc(numBytes));
+    }
+
+    if (pixels)
+        memcpy(base_pixels, pixels, numBytes);
+    pixels = base_pixels;
+}
+
+#if 0
+QPixmap QMacPixmapData::transformed(const QTransform &transform,
+                                    Qt::TransformationMode mode) const
+{
+    int w, h;  // size of target pixmap
+    const int ws = width();
+    const int hs = height();
+
+    QTransform mat(transform.m11(), transform.m12(),
+                   transform.m21(), transform.m22(), 0., 0.);
+    if (transform.m12() == 0.0F  && transform.m21() == 0.0F &&
+        transform.m11() >= 0.0F  && transform.m22() >= 0.0F)
+    {
+        h = int(qAbs(mat.m22()) * hs + 0.9999);
+        w = int(qAbs(mat.m11()) * ws + 0.9999);
+        h = qAbs(h);
+        w = qAbs(w);
+    } else { // rotation or shearing
+        QPolygonF a(QRectF(0,0,ws+1,hs+1));
+        a = mat.map(a);
+        QRectF r = a.boundingRect().normalized();
+        w = int(r.width() + 0.9999);
+        h = int(r.height() + 0.9999);
+    }
+    mat = QPixmap::trueMatrix(mat, ws, hs);
+    if (!h || !w)
+        return QPixmap();
+
+    // create destination
+    QMacPixmapData *pm = new QMacPixmapData(pixelType(), w, h);
+    const quint32 *sptr = pixels;
+    quint32 *dptr = pm->pixels;
+    memset(dptr, 0, (pm->bytesPerRow * pm->h));
+
+    // do the transform
+    if (mode == Qt::SmoothTransformation) {
+#warning QMacPixmapData::transformed not properly implemented
+        qWarning("QMacPixmapData::transformed not properly implemented");
+#if 0
+        QPainter p(&pm);
+        p.setRenderHint(QPainter::Antialiasing);
+        p.setRenderHint(QPainter::SmoothPixmapTransform);
+        p.setTransform(mat);
+        p.drawPixmap(0, 0, *this);
+#endif
+    } else {
+        bool invertible;
+        mat = mat.inverted(&invertible);
+        if (!invertible)
+            return QPixmap();
+
+        const int bpp = 32;
+        const int xbpl = (w * bpp) / 8;
+        if (!qt_xForm_helper(mat, 0, QT_XFORM_TYPE_MSBFIRST, bpp,
+                             (uchar*)dptr, xbpl, (pm->bytesPerRow) - xbpl,
+                             h, (uchar*)sptr, (bytesPerRow), ws, hs)) {
+            qWarning("QMacPixmapData::transform(): failure");
+            return QPixmap();
+        }
+    }
+
+    // update the alpha
+    pm->macSetHasAlpha(true);
+    return QPixmap(pm);
+}
+#endif
+
+QT_BEGIN_INCLUDE_NAMESPACE
+#include <OpenGL/OpenGL.h>
+#include <OpenGL/gl.h>
+QT_END_INCLUDE_NAMESPACE
+
+// Load and resolve the symbols we need from OpenGL manually so QtGui doesn't have to link against the OpenGL framework.
+typedef CGLError (*PtrCGLChoosePixelFormat)(const CGLPixelFormatAttribute *, CGLPixelFormatObj *,  long *);
+typedef CGLError (*PtrCGLClearDrawable)(CGLContextObj);
+typedef CGLError (*PtrCGLCreateContext)(CGLPixelFormatObj, CGLContextObj, CGLContextObj *);
+typedef CGLError (*PtrCGLDestroyContext)(CGLContextObj);
+typedef CGLError (*PtrCGLDestroyPixelFormat)(CGLPixelFormatObj);
+typedef CGLError (*PtrCGLSetCurrentContext)(CGLContextObj);
+typedef CGLError (*PtrCGLSetFullScreen)(CGLContextObj);
+typedef void (*PtrglFinish)();
+typedef void (*PtrglPixelStorei)(GLenum, GLint);
+typedef void (*PtrglReadBuffer)(GLenum);
+typedef void (*PtrglReadPixels)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *);
+
+static PtrCGLChoosePixelFormat ptrCGLChoosePixelFormat = 0;
+static PtrCGLClearDrawable ptrCGLClearDrawable = 0;
+static PtrCGLCreateContext ptrCGLCreateContext = 0;
+static PtrCGLDestroyContext ptrCGLDestroyContext = 0;
+static PtrCGLDestroyPixelFormat ptrCGLDestroyPixelFormat = 0;
+static PtrCGLSetCurrentContext ptrCGLSetCurrentContext = 0;
+static PtrCGLSetFullScreen ptrCGLSetFullScreen = 0;
+static PtrglFinish ptrglFinish = 0;
+static PtrglPixelStorei ptrglPixelStorei = 0;
+static PtrglReadBuffer ptrglReadBuffer = 0;
+static PtrglReadPixels ptrglReadPixels = 0;
+
+static bool resolveOpenGLSymbols()
+{
+    if (ptrCGLChoosePixelFormat == 0) {
+        QLibrary library(QLatin1String("/System/Library/Frameworks/OpenGL.framework/OpenGL"));
+        ptrCGLChoosePixelFormat = (PtrCGLChoosePixelFormat)(library.resolve("CGLChoosePixelFormat"));
+        ptrCGLClearDrawable = (PtrCGLClearDrawable)(library.resolve("CGLClearDrawable"));
+        ptrCGLCreateContext = (PtrCGLCreateContext)(library.resolve("CGLCreateContext"));
+        ptrCGLDestroyContext = (PtrCGLDestroyContext)(library.resolve("CGLDestroyContext"));
+        ptrCGLDestroyPixelFormat = (PtrCGLDestroyPixelFormat)(library.resolve("CGLDestroyPixelFormat"));
+        ptrCGLSetCurrentContext = (PtrCGLSetCurrentContext)(library.resolve("CGLSetCurrentContext"));
+        ptrCGLSetFullScreen = (PtrCGLSetFullScreen)(library.resolve("CGLSetFullScreen"));
+        ptrglFinish = (PtrglFinish)(library.resolve("glFinish"));
+        ptrglPixelStorei = (PtrglPixelStorei)(library.resolve("glPixelStorei"));
+        ptrglReadBuffer = (PtrglReadBuffer)(library.resolve("glReadBuffer"));
+        ptrglReadPixels = (PtrglReadPixels)(library.resolve("glReadPixels"));
+    }
+    return ptrCGLChoosePixelFormat && ptrCGLClearDrawable && ptrCGLCreateContext
+        && ptrCGLDestroyContext && ptrCGLDestroyPixelFormat && ptrCGLSetCurrentContext
+        && ptrCGLSetFullScreen && ptrglFinish && ptrglPixelStorei
+        && ptrglReadBuffer && ptrglReadPixels;
+}
+
+// Inverts the given pixmap in the y direction.
+static void qt_mac_flipPixmap(void *data, int rowBytes, int height)
+{
+    int bottom = height - 1;
+    void *base = data;
+    void *buffer = malloc(rowBytes);
+
+    int top = 0;
+    while ( top < bottom )
+    {
+        void *topP = (void *)((top * rowBytes) + (intptr_t)base);
+        void *bottomP = (void *)((bottom * rowBytes) + (intptr_t)base);
+
+        bcopy( topP, buffer, rowBytes );
+        bcopy( bottomP, topP, rowBytes );
+        bcopy( buffer, bottomP, rowBytes );
+
+        ++top;
+        --bottom;
+    }
+    free(buffer);
+}
+
+// Grabs displayRect from display and places it into buffer.
+static void qt_mac_grabDisplayRect(CGDirectDisplayID display, const QRect &displayRect, void *buffer)
+{
+    if (display == kCGNullDirectDisplay)
+        return;
+
+    CGLPixelFormatAttribute attribs[] = {
+        kCGLPFAFullScreen,
+        kCGLPFADisplayMask,
+        (CGLPixelFormatAttribute)0,    /* Display mask bit goes here */
+        (CGLPixelFormatAttribute)0
+    };
+
+    attribs[2] = (CGLPixelFormatAttribute)CGDisplayIDToOpenGLDisplayMask(display);
+
+    // Build a full-screen GL context
+    CGLPixelFormatObj pixelFormatObj;
+    long numPixelFormats;
+
+    ptrCGLChoosePixelFormat( attribs, &pixelFormatObj, &numPixelFormats );
+
+    if (!pixelFormatObj)    // No full screen context support
+        return;
+
+    CGLContextObj glContextObj;
+    ptrCGLCreateContext(pixelFormatObj, 0, &glContextObj);
+    ptrCGLDestroyPixelFormat(pixelFormatObj) ;
+    if (!glContextObj)
+        return;
+
+    ptrCGLSetCurrentContext(glContextObj);
+    ptrCGLSetFullScreen(glContextObj) ;
+
+    ptrglReadBuffer(GL_FRONT);
+
+    ptrglFinish(); // Finish all OpenGL commands
+    ptrglPixelStorei(GL_PACK_ALIGNMENT, 4);  // Force 4-byte alignment
+    ptrglPixelStorei(GL_PACK_ROW_LENGTH, 0);
+    ptrglPixelStorei(GL_PACK_SKIP_ROWS, 0);
+    ptrglPixelStorei(GL_PACK_SKIP_PIXELS, 0);
+
+    // Fetch the data in XRGB format, matching the bitmap context.
+    ptrglReadPixels(GLint(displayRect.x()), GLint(displayRect.y()),
+                    GLint(displayRect.width()), GLint(displayRect.height()),
+#ifdef __BIG_ENDIAN__
+                    GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, buffer
+#else
+                    GL_BGRA, GL_UNSIGNED_INT_8_8_8_8, buffer
+#endif
+        );
+
+    ptrCGLSetCurrentContext(0);
+    ptrCGLClearDrawable(glContextObj); // disassociate from full screen
+    ptrCGLDestroyContext(glContextObj); // and destroy the context
+}
+
+static CGImageRef qt_mac_createImageFromBitmapContext(CGContextRef c)
+{
+    void *rasterData = CGBitmapContextGetData(c);
+    const int width = CGBitmapContextGetBytesPerRow(c),
+             height = CGBitmapContextGetHeight(c);
+    size_t imageDataSize = width*height;
+
+    if(!rasterData)
+        return 0;
+
+    // Create the data provider from the image data, using
+    // the image releaser function releaseBitmapContextImageData.
+    CGDataProviderRef dataProvider = CGDataProviderCreateWithData(0, rasterData,
+                                                                  imageDataSize,
+                                                                  qt_mac_cgimage_data_free);
+
+    if(!dataProvider)
+        return 0;
+
+    uint bitmapInfo = 0;
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4
+    if(CGBitmapContextGetBitmapInfo)
+        bitmapInfo = CGBitmapContextGetBitmapInfo(c);
+    else
+#endif
+        bitmapInfo = CGBitmapContextGetAlphaInfo(c);
+    return CGImageCreate(width, height, CGBitmapContextGetBitsPerComponent(c),
+                         CGBitmapContextGetBitsPerPixel(c), CGBitmapContextGetBytesPerRow(c),
+                         CGBitmapContextGetColorSpace(c), bitmapInfo, dataProvider,
+                         0, true, kCGRenderingIntentDefault);
+}
+
+// Returns a pixmap containing the screen contents at rect.
+static QPixmap qt_mac_grabScreenRect(const QRect &rect)
+{
+    if (!resolveOpenGLSymbols())
+        return QPixmap();
+
+    const int maxDisplays = 128; // 128 displays should be enough for everyone.
+    CGDirectDisplayID displays[maxDisplays];
+    CGDisplayCount displayCount;
+    const CGRect cgRect = CGRectMake(rect.x(), rect.y(), rect.width(), rect.height());
+    const CGDisplayErr err = CGGetDisplaysWithRect(cgRect, maxDisplays, displays, &displayCount);
+
+    if (err && displayCount == 0)
+        return QPixmap();
+
+    long bytewidth = rect.width() * 4; // Assume 4 bytes/pixel for now
+    bytewidth = (bytewidth + 3) & ~3; // Align to 4 bytes
+    QVarLengthArray<char> buffer(rect.height() * bytewidth);
+
+    for (uint i = 0; i < displayCount; ++i) {
+        const CGRect bounds = CGDisplayBounds(displays[i]);
+        // Translate to display-local coordinates
+        QRect displayRect = rect.translated(qRound(-bounds.origin.x), qRound(-bounds.origin.y));
+        // Adjust for inverted y axis.
+        displayRect.moveTop(qRound(bounds.size.height) - displayRect.y() - rect.height());
+        qt_mac_grabDisplayRect(displays[i], displayRect, buffer.data());
+    }
+
+    qt_mac_flipPixmap(buffer.data(), bytewidth, rect.height());
+    QCFType<CGContextRef> bitmap = CGBitmapContextCreate(buffer.data(), rect.width(),
+                                                         rect.height(), 8, bytewidth,
+                                        QCoreGraphicsPaintEngine::macGenericColorSpace(),
+                                        kCGImageAlphaNoneSkipFirst);
+
+#if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4)
+    if(QSysInfo::MacintoshVersion >= QSysInfo::MV_10_4) {
+        QCFType<CGImageRef> image = CGBitmapContextCreateImage(bitmap);
+        return QPixmap::fromMacCGImageRef(image);
+    } else
+#endif
+    {
+        QCFType<CGImageRef> image = qt_mac_createImageFromBitmapContext(bitmap);
+        if (!image)
+            return QPixmap();
+        return QPixmap::fromMacCGImageRef(image);
+    }
+}
+
+#ifndef QT_MAC_USE_COCOA // no QuickDraw in 64-bit mode
+static QPixmap qt_mac_grabScreenRect_10_3(int x, int y, int w, int h, QWidget *widget)
+{
+    QPixmap pm = QPixmap(w, h);
+    extern WindowPtr qt_mac_window_for(const QWidget *); // qwidget_mac.cpp
+    const BitMap *windowPort = 0;
+    if((widget->windowType() == Qt::Desktop)) {
+        GDHandle gdh;
+          if(!(gdh=GetMainDevice()))
+              qDebug("Qt: internal: Unexpected condition reached: %s:%d", __FILE__, __LINE__);
+          windowPort = (BitMap*)(*(*gdh)->gdPMap);
+    } else {
+        windowPort = GetPortBitMapForCopyBits(GetWindowPort(qt_mac_window_for(widget)));
+    }
+    const BitMap *pixmapPort = GetPortBitMapForCopyBits(static_cast<GWorldPtr>(pm.macQDHandle()));
+    Rect macSrcRect, macDstRect;
+    SetRect(&macSrcRect, x, y, x + w, y + h);
+    SetRect(&macDstRect, 0, 0, w, h);
+    CopyBits(windowPort, pixmapPort, &macSrcRect, &macDstRect, srcCopy, 0);
+    return pm;
+}
+#endif
+
+QPixmap QPixmap::grabWindow(WId window, int x, int y, int w, int h)
+{
+    QWidget *widget = QWidget::find(window);
+    if (widget == 0)
+        return QPixmap();
+
+    if(w == -1)
+        w = widget->width() - x;
+    if(h == -1)
+        h = widget->height() - y;
+
+    QPoint globalCoord(0, 0);
+    globalCoord = widget->mapToGlobal(globalCoord);
+    QRect rect(globalCoord.x() + x, globalCoord.y() + y, w, h);
+
+#ifdef QT_MAC_USE_COCOA
+    return qt_mac_grabScreenRect(rect);
+#else
+#if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4)
+    if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_4) {
+        return qt_mac_grabScreenRect(rect);
+    } else
+#endif
+   {
+        return qt_mac_grabScreenRect_10_3(x, y, w, h, widget);
+   }
+#endif // ifdef Q_WS_MAC64
+}
+
+/*! \internal
+
+    Returns the QuickDraw CGrafPtr of the pixmap. 0 is returned if it can't
+    be obtained. Do not hold the pointer around for long as it can be
+    relocated.
+
+    \warning This function is only available on Mac OS X.
+*/
+
+Qt::HANDLE QPixmap::macQDHandle() const
+{
+#ifndef QT_MAC_NO_QUICKDRAW
+    QMacPixmapData *d = static_cast<QMacPixmapData*>(data);
+    if (!d->qd_data) { //create the qd data
+        Rect rect;
+        SetRect(&rect, 0, 0, d->w, d->h);
+        unsigned long qdformat = k32ARGBPixelFormat;
+        GWorldFlags qdflags = 0;
+#if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4)
+        if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_4) {
+            //we play such games so we can use the same buffer in CG as QD this
+            //makes our merge much simpler, at some point the hacks will go away
+            //because QD will be removed, but until that day this keeps them coexisting
+            if (QSysInfo::ByteOrder == QSysInfo::LittleEndian)
+                qdformat = k32BGRAPixelFormat;
+#if 0
+            qdflags |= kNativeEndianPixMap;
+#endif
+        }
+#endif
+        if(NewGWorldFromPtr(&d->qd_data, qdformat, &rect, 0, 0, qdflags,
+                            (char*)d->pixels, d->bytesPerRow) != noErr)
+            qWarning("Qt: internal: QPixmap::init error (%d %d %d %d)", rect.left, rect.top, rect.right, rect.bottom);
+    }
+    return d->qd_data;
+#else
+    return 0;
+#endif
+}
+
+/*! \internal
+
+    Returns the QuickDraw CGrafPtr of the pixmap's alpha channel. 0 is
+    returned if it can't be obtained. Do not hold the pointer around for
+    long as it can be relocated.
+
+    \warning This function is only available on Mac OS X.
+*/
+
+Qt::HANDLE QPixmap::macQDAlphaHandle() const
+{
+#ifndef QT_MAC_NO_QUICKDRAW
+    QMacPixmapData *d = static_cast<QMacPixmapData*>(data);
+    if (d->has_alpha || d->has_mask) {
+        if (!d->qd_alpha) //lazily created
+            d->macQDUpdateAlpha();
+        return d->qd_alpha;
+    }
+#endif
+    return 0;
+}
+
+/*! \internal
+
+    Returns the CoreGraphics CGContextRef of the pixmap. 0 is returned if
+    it can't be obtained. It is the caller's responsiblity to
+    CGContextRelease the context when finished using it.
+
+    \warning This function is only available on Mac OS X.
+*/
+
+Qt::HANDLE QPixmap::macCGHandle() const
+{
+    if (data->classId() == QPixmapData::MacClass) {
+        QMacPixmapData *d = static_cast<QMacPixmapData *>(data);
+        if (!d->cg_data)
+            d->macCreateCGImageRef();
+        CGImageRef ret = d->cg_data;
+        CGImageRetain(ret);
+        return ret;
+    } else if (data->classId() == QPixmapData::RasterClass) {
+        return qt_mac_image_to_cgimage(static_cast<QRasterPixmapData *>(data)->image);
+    }
+    return 0;
+}
+
+bool QMacPixmapData::hasAlphaChannel() const
+{
+    return has_alpha;
+}
+
+CGImageRef qt_mac_create_imagemask(const QPixmap &pixmap, const QRectF &sr)
+{
+    QMacPixmapData *px = static_cast<QMacPixmapData*>(pixmap.data);
+    if (px->cg_mask) {
+        if (px->cg_mask_rect == sr) {
+            CGImageRetain(px->cg_mask); //reference for the caller
+            return px->cg_mask;
+        }
+        CGImageRelease(px->cg_mask);
+        px->cg_mask = 0;
+    }
+
+    const int sx = qRound(sr.x()), sy = qRound(sr.y()), sw = qRound(sr.width()), sh = qRound(sr.height());
+    const int sbpr = px->bytesPerRow;
+    const uint nbytes = sw * sh;
+    //  alpha is always 255 for bitmaps, ignore it in this case.
+    const quint32 mask = px->depth() == 1 ? 0x00ffffff : 0xffffffff;
+    quint8 *dptr = static_cast<quint8 *>(malloc(nbytes));
+    quint32 *sptr = px->pixels, *srow;
+    for(int y = sy, offset=0; y < sh; ++y) {
+        srow = sptr + (y * (sbpr / 4));
+        for(int x = sx; x < sw; ++x)
+            *(dptr+(offset++)) = (*(srow+x) & mask) ? 255 : 0;
+    }
+    QCFType<CGDataProviderRef> provider = CGDataProviderCreateWithData(0, dptr, nbytes, qt_mac_cgimage_data_free);
+    px->cg_mask = CGImageMaskCreate(sw, sh, 8, 8, nbytes / sh, provider, 0, 0);
+    px->cg_mask_rect = sr;
+    CGImageRetain(px->cg_mask); //reference for the caller
+    return px->cg_mask;
+}
+
+#ifndef QT_MAC_USE_COCOA
+IconRef qt_mac_create_iconref(const QPixmap &px)
+{
+    if (px.isNull())
+        return 0;
+
+    QMacSavedPortInfo pi; //save the current state
+    //create icon
+    IconFamilyHandle iconFamily = reinterpret_cast<IconFamilyHandle>(NewHandle(0));
+    //create data
+    {
+        struct {
+            OSType mac_type;
+            int width, height, depth;
+            bool mask;
+        } images[] = {
+            { kThumbnail32BitData, 128, 128, 32, false },
+            { kThumbnail8BitMask, 128, 128, 8, true },
+            { 0, 0, 0, 0, false } //end marker
+        };
+        for(int i = 0; images[i].mac_type; i++) {
+            //get QPixmap data
+            QImage scaled_px = px.toImage().scaled(images[i].width, images[i].height);
+
+            quint32 *sptr = (quint32 *) scaled_px.bits();
+            quint32 *srow;
+            uint sbpr = scaled_px.bytesPerLine();
+
+            //get Handle data
+            const int dbpr = images[i].width * (images[i].depth/8);
+            Handle hdl = NewHandle(dbpr*images[i].height);
+            if(!sptr) { //handle null pixmap
+                memset((*hdl), '\0', dbpr*images[i].height);
+            } else if(images[i].mask) {
+                if(images[i].mac_type == kThumbnail8BitMask) {
+                    for(int y = 0, hindex = 0; y < images[i].height; ++y) {
+                        srow = sptr + (y * (sbpr/4));
+                        for(int x = 0; x < images[i].width; ++x)
+                            *((*hdl)+(hindex++)) = qAlpha(*(srow+x));
+                    }
+                }
+            } else {
+                char *dest = (*hdl);
+#if defined(__i386__)
+                if(images[i].depth == 32) {
+                    for(int y = 0; y < images[i].height; ++y) {
+                        uint *source = (uint*)((const uchar*)sptr+(sbpr*y));
+                        for(int x = 0; x < images[i].width; ++x, dest += 4)
+                            *((uint*)dest) = CFSwapInt32(*(source + x));
+                    }
+                } else
+#endif
+                {
+                    for(int y = 0; y < images[i].height; ++y)
+                        memcpy(dest+(y*dbpr), ((const uchar*)sptr+(sbpr*y)), dbpr);
+                }
+            }
+
+            //set the family data to the Handle
+            OSStatus set = SetIconFamilyData(iconFamily, images[i].mac_type, hdl);
+            if(set != noErr)
+                qWarning("%s: %d -- Unable to create icon data[%d]!! %ld",
+                         __FILE__, __LINE__, i, long(set));
+            DisposeHandle(hdl);
+        }
+    }
+
+    //acquire and cleanup
+    IconRef ret;
+    static int counter = 0;
+    const OSType kQtCreator = 'CUTE';
+    RegisterIconRefFromIconFamily(kQtCreator, (OSType)counter, iconFamily, &ret);
+    AcquireIconRef(ret);
+    UnregisterIconRef(kQtCreator, (OSType)counter);
+    DisposeHandle(reinterpret_cast<Handle>(iconFamily));
+    counter++;
+    return ret;
+
+}
+#endif
+
+QPixmap qt_mac_convert_iconref(const IconRef icon, int width, int height)
+{
+    QPixmap ret(width, height);
+    ret.fill(QColor(0, 0, 0, 0));
+
+    CGRect rect = CGRectMake(0, 0, width, height);
+
+    CGContextRef ctx = qt_mac_cg_context(&ret);
+    CGAffineTransform old_xform = CGContextGetCTM(ctx);
+    CGContextConcatCTM(ctx, CGAffineTransformInvert(old_xform));
+    CGContextConcatCTM(ctx, CGAffineTransformIdentity);
+
+    ::RGBColor b;
+    b.blue = b.green = b.red = 255*255;
+    PlotIconRefInContext(ctx, &rect, kAlignNone, kTransformNone, &b, kPlotIconRefNormalFlags, icon);
+    CGContextRelease(ctx);
+    return ret;
+}
+
+/*! \internal */
+QPaintEngine* QMacPixmapData::paintEngine() const
+{
+    if (!pengine) {
+        QMacPixmapData *that = const_cast<QMacPixmapData*>(this);
+#ifdef QT_RASTER_PAINTENGINE
+        if (qgetenv("QT_MAC_USE_COREGRAPHICS").isNull())
+            that->pengine = new QRasterPaintEngine();
+        else
+            that->pengine = new QCoreGraphicsPaintEngine();
+#else
+        that->pengine = new QCoreGraphicsPaintEngine();
+#endif
+    }
+    return pengine;
+}
+
+void QMacPixmapData::copy(const QPixmapData *data, const QRect &rect)
+{
+    if (data->pixelType() == BitmapType) {
+        QBitmap::fromImage(toImage().copy(rect));
+        return;
+    }
+
+    const QMacPixmapData *macData = static_cast<const QMacPixmapData*>(data);
+
+    resize(rect.width(), rect.height());
+
+    has_alpha = macData->has_alpha;
+    has_mask = macData->has_mask;
+    uninit = false;
+
+    const int x = rect.x();
+    const int y = rect.y();
+    char *dest = reinterpret_cast<char*>(pixels);
+    const char *src = reinterpret_cast<const char*>(macData->pixels + x) + y * macData->bytesPerRow;
+    for (int i = 0; i < h; ++i) {
+        memcpy(dest, src, w * 4);
+        dest += bytesPerRow;
+        src += macData->bytesPerRow;
+    }
+
+    has_alpha = macData->has_alpha;
+    has_mask = macData->has_mask;
+}
+
+bool QMacPixmapData::scroll(int dx, int dy, const QRect &rect)
+{
+    Q_UNUSED(dx);
+    Q_UNUSED(dy);
+    Q_UNUSED(rect);
+    return false;
+}
+
+/*!
+    \since 4.2
+
+    Creates a \c CGImageRef equivalent to the QPixmap. Returns the \c CGImageRef handle.
+
+    It is the caller's responsibility to release the \c CGImageRef data
+    after use.
+
+    \warning This function is only available on Mac OS X.
+
+    \sa fromMacCGImageRef()
+*/
+CGImageRef QPixmap::toMacCGImageRef() const
+{
+    return (CGImageRef)macCGHandle();
+}
+
+/*!
+    \since 4.2
+
+    Returns a QPixmap that is equivalent to the given \a image.
+
+    \warning This function is only available on Mac OS X.
+
+    \sa toMacCGImageRef(), {QPixmap#Pixmap Conversion}{Pixmap Conversion}
+*/
+QPixmap QPixmap::fromMacCGImageRef(CGImageRef image)
+{
+    const size_t w = CGImageGetWidth(image),
+                 h = CGImageGetHeight(image);
+    QPixmap ret(w, h);
+    CGRect rect = CGRectMake(0, 0, w, h);
+    CGContextRef ctx = qt_mac_cg_context(&ret);
+    qt_mac_drawCGImage(ctx, &rect, image);
+    CGContextRelease(ctx);
+    return ret;
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/image/qpixmap_mac_p.h b/src/gui/image/qpixmap_mac_p.h
new file mode 100644
index 0000000..2b22e6b
--- /dev/null
+++ b/src/gui/image/qpixmap_mac_p.h
@@ -0,0 +1,137 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPIXMAP_MAC_P_H
+#define QPIXMAP_MAC_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/private/qpixmapdata_p.h>
+#include <QtGui/private/qpixmapdatafactory_p.h>
+#include <QtGui/private/qt_mac_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QMacPixmapData : public QPixmapData
+{
+public:
+    QMacPixmapData(PixelType type);
+    ~QMacPixmapData();
+
+    void resize(int width, int height);
+    void fromImage(const QImage &image, Qt::ImageConversionFlags flags);
+    void copy(const QPixmapData *data, const QRect &rect);
+    bool scroll(int dx, int dy, const QRect &rect);
+
+    int metric(QPaintDevice::PaintDeviceMetric metric) const;
+    void fill(const QColor &color);
+    QBitmap mask() const;
+    void setMask(const QBitmap &mask);
+    bool hasAlphaChannel() const;
+//     QPixmap transformed(const QTransform &matrix,
+//                         Qt::TransformationMode mode) const;
+    void setAlphaChannel(const QPixmap &alphaChannel);
+    QPixmap alphaChannel() const;
+    QImage toImage() const;
+    QPaintEngine* paintEngine() const;
+
+private:
+    int w, h, d;
+
+    uint has_alpha : 1, has_mask : 1, uninit : 1;
+
+    void macSetHasAlpha(bool b);
+    void macGetAlphaChannel(QMacPixmapData *, bool asMask) const;
+    void macSetAlphaChannel(const QMacPixmapData *, bool asMask);
+    void macCreateCGImageRef();
+    void macCreatePixels();
+    void macReleaseCGImageRef();
+    /*
+        pixels stores the pixmap data. pixelsToFree is either 0 or some memory
+        block that was bound to a CGImageRef and released, and for which the
+        release callback has been called. There are two uses to pixelsToFree:
+
+        1. If pixels == pixelsToFree, then we know that the CGImageRef is done\
+           with the data and we can modify pixels without breaking CGImageRef's
+           mutability invariant.
+
+        2. If pixels != pixelsToFree and pixelsToFree != 0, then we can reuse
+           pixelsToFree later on instead of malloc'ing memory.
+    */
+    quint32 *pixels;
+    quint32 *pixelsToFree;
+    uint bytesPerRow;
+    QRectF cg_mask_rect;
+    CGImageRef cg_data, cg_dataBeingReleased, cg_mask;
+#ifndef QT_MAC_NO_QUICKDRAW
+    GWorldPtr qd_data, qd_alpha;
+    void macQDDisposeAlpha();
+    void macQDUpdateAlpha();
+#endif
+    static QSet<QMacPixmapData*> validDataPointers;
+
+    QPaintEngine *pengine;
+
+    friend class QPixmap;
+    friend class QRasterBuffer;
+    friend class QRasterPaintEngine;
+    friend class QCoreGraphicsPaintEngine;
+    friend CGImageRef qt_mac_create_imagemask(const QPixmap&, const QRectF&);
+    friend quint32 *qt_mac_pixmap_get_base(const QPixmap*);
+    friend int qt_mac_pixmap_get_bytes_per_line(const QPixmap*);
+    friend void qt_mac_cgimage_data_free(void *, const void*, size_t);
+    friend IconRef qt_mac_create_iconref(const QPixmap&);
+    friend CGContextRef qt_mac_cg_context(const QPaintDevice*);
+    friend QColor qcolorForThemeTextColor(ThemeTextColor themeColor);
+};
+
+QT_END_NAMESPACE
+
+#endif // QPIXMAP_MAC_P_H
diff --git a/src/gui/image/qpixmap_qws.cpp b/src/gui/image/qpixmap_qws.cpp
new file mode 100644
index 0000000..6cc7981
--- /dev/null
+++ b/src/gui/image/qpixmap_qws.cpp
@@ -0,0 +1,164 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <qpixmap.h>
+#include <qapplication.h>
+#include <qwidget.h>
+#include <qdesktopwidget.h>
+#include <qscreen_qws.h>
+#include <qwsdisplay_qws.h>
+#include <private/qdrawhelper_p.h>
+#include <private/qpixmap_raster_p.h>
+
+QPixmap QPixmap::grabWindow(WId window, int x, int y, int w, int h)
+{
+    QWidget *widget = QWidget::find(window);
+    if (!widget)
+        return QPixmap();
+
+    QRect grabRect = widget->frameGeometry();
+    if (!widget->isWindow())
+        grabRect.translate(widget->parentWidget()->mapToGlobal(QPoint()));
+    if (w < 0)
+        w = widget->width() - x;
+    if (h < 0)
+        h = widget->height() - y;
+    grabRect &= QRect(x, y, w, h).translated(widget->mapToGlobal(QPoint()));
+
+    QScreen *screen = qt_screen;
+    QDesktopWidget *desktop = QApplication::desktop();
+    if (!desktop)
+        return QPixmap();
+    if (desktop->numScreens() > 1) {
+        const int screenNo = desktop->screenNumber(widget);
+        if (screenNo != -1)
+            screen = qt_screen->subScreens().at(screenNo);
+        grabRect = grabRect.translated(-screen->region().boundingRect().topLeft());
+    }
+
+    if (screen->pixelFormat() == QImage::Format_Invalid) {
+        qWarning("QPixmap::grabWindow(): Unable to copy pixels from framebuffer");
+        return QPixmap();
+    }
+
+    if (screen->isTransformed()) {
+        const QSize screenSize(screen->width(), screen->height());
+        grabRect = screen->mapToDevice(grabRect, screenSize);
+    }
+
+    QWSDisplay::grab(false);
+    QPixmap pixmap;
+    QImage img(screen->base(),
+               screen->deviceWidth(), screen->deviceHeight(),
+               screen->linestep(), screen->pixelFormat());
+    img = img.copy(grabRect);
+    QWSDisplay::ungrab();
+
+    if (screen->isTransformed()) {
+        QMatrix matrix;
+        switch (screen->transformOrientation()) {
+        case 1: matrix.rotate(90); break;
+        case 2: matrix.rotate(180); break;
+        case 3: matrix.rotate(270); break;
+        default: break;
+        }
+        img = img.transformed(matrix);
+    }
+
+    if (screen->pixelType() == QScreen::BGRPixel)
+        img = img.rgbSwapped();
+
+    return QPixmap::fromImage(img);
+}
+
+/*!
+    \internal
+*/
+QRgb* QPixmap::clut() const
+{
+    if (data->classId() == QPixmapData::RasterClass) {
+        const QRasterPixmapData *d = static_cast<const QRasterPixmapData*>(data);
+        return d->image.colorTable().data();
+    }
+
+    return 0;
+}
+
+/*!
+    \internal
+*/
+int QPixmap::numCols() const
+{
+    if (data->classId() == QPixmapData::RasterClass) {
+        const QRasterPixmapData *d = static_cast<const QRasterPixmapData*>(data);
+        return d->image.numColors();
+    }
+
+    return 0;
+}
+
+/*!
+    \internal
+    \since 4.1
+*/
+const uchar* QPixmap::qwsBits() const
+{
+    if (data->classId() == QPixmapData::RasterClass) {
+        const QRasterPixmapData *d = static_cast<const QRasterPixmapData*>(data);
+        return d->image.bits();
+    }
+
+    return 0;
+}
+
+/*!
+    \internal
+    \since 4.1
+*/
+int QPixmap::qwsBytesPerLine() const
+{
+    if (data->classId() == QPixmapData::RasterClass) {
+        const QRasterPixmapData *d = static_cast<const QRasterPixmapData*>(data);
+        return d->image.bytesPerLine();
+    }
+
+    return 0;
+}
diff --git a/src/gui/image/qpixmap_raster.cpp b/src/gui/image/qpixmap_raster.cpp
new file mode 100644
index 0000000..145b02a
--- /dev/null
+++ b/src/gui/image/qpixmap_raster.cpp
@@ -0,0 +1,360 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qpixmap.h"
+
+#include "qpixmap_raster_p.h"
+#include "qnativeimage_p.h"
+#include "qimage_p.h"
+
+#include "qbitmap.h"
+#include "qimage.h"
+#include <private/qwidget_p.h>
+#include <private/qdrawhelper_p.h>
+
+#if !defined(QT_NO_DIRECT3D) && defined(Q_WS_WIN)
+#include <private/qpaintengine_d3d_p.h>
+#include <d3d9.h>
+extern QDirect3DPaintEngine *qt_d3dEngine();
+#endif
+
+QT_BEGIN_NAMESPACE
+
+const uchar qt_pixmap_bit_mask[] = { 0x01, 0x02, 0x04, 0x08,
+                                     0x10, 0x20, 0x40, 0x80 };
+
+QRasterPixmapData::QRasterPixmapData(PixelType type)
+    : QPixmapData(type, RasterClass)
+#if defined(Q_WS_WIN) && !defined(QT_NO_DIRECT3D)
+    , texture(0)
+#endif
+{
+}
+
+QRasterPixmapData::~QRasterPixmapData()
+{
+}
+
+void QRasterPixmapData::resize(int width, int height)
+{
+    QImage::Format format;
+#ifdef Q_WS_QWS
+    if (pixelType() == BitmapType) {
+        format = QImage::Format_Mono;
+    } else {
+        format = QScreen::instance()->pixelFormat();
+        if (format == QImage::Format_Invalid)
+            format = QImage::Format_ARGB32_Premultiplied;
+        else if (format == QImage::Format_Indexed8) // currently not supported
+            format = QImage::Format_RGB444;
+    }
+#else
+    if (pixelType() == BitmapType)
+        format = QImage::Format_MonoLSB;
+    else
+        format = QNativeImage::systemFormat();
+#endif
+
+    image = QImage(width, height, format);
+
+    if (pixelType() == BitmapType && !image.isNull()) {
+        image.setNumColors(2);
+        image.setColor(0, QColor(Qt::color0).rgba());
+        image.setColor(1, QColor(Qt::color1).rgba());
+    }
+
+    setSerialNumber(image.serialNumber());
+}
+
+void QRasterPixmapData::fromImage(const QImage &sourceImage,
+                                  Qt::ImageConversionFlags flags)
+{
+    Q_UNUSED(flags);
+
+#ifdef Q_WS_QWS
+    QImage::Format format;
+    if (pixelType() == BitmapType) {
+        format = QImage::Format_Mono;
+    } else {
+        format = QScreen::instance()->pixelFormat();
+        if (format == QImage::Format_Invalid)
+            format = QImage::Format_ARGB32_Premultiplied;
+        else if (format == QImage::Format_Indexed8) // currently not supported
+            format = QImage::Format_RGB444;
+    }
+
+    if (sourceImage.hasAlphaChannel()
+        && ((flags & Qt::NoOpaqueDetection)
+            || const_cast<QImage &>(sourceImage).data_ptr()->checkForAlphaPixels())) {
+        switch (format) {
+            case QImage::Format_RGB16:
+                format = QImage::Format_ARGB8565_Premultiplied;
+                break;
+            case QImage::Format_RGB666:
+                format = QImage::Format_ARGB6666_Premultiplied;
+                break;
+            case QImage::Format_RGB555:
+                format = QImage::Format_ARGB8555_Premultiplied;
+                break;
+            case QImage::Format_RGB444:
+                format = QImage::Format_ARGB4444_Premultiplied;
+                break;
+            default:
+                format = QImage::Format_ARGB32_Premultiplied;
+                break;
+        }
+    } else if (format == QImage::Format_Invalid) {
+        format = QImage::Format_ARGB32_Premultiplied;
+    }
+
+    image = sourceImage.convertToFormat(format);
+#else
+    if (pixelType() == BitmapType) {
+        image = sourceImage.convertToFormat(QImage::Format_MonoLSB);
+    } else {
+        if (sourceImage.depth() == 1) {
+            image = sourceImage.hasAlphaChannel()
+                    ? sourceImage.convertToFormat(QImage::Format_ARGB32_Premultiplied)
+                    : sourceImage.convertToFormat(QImage::Format_RGB32);
+        } else {
+
+            QImage::Format opaqueFormat = QNativeImage::systemFormat();
+            QImage::Format alphaFormat = QImage::Format_ARGB32_Premultiplied;
+
+            switch (opaqueFormat) {
+            case QImage::Format_RGB16:
+                alphaFormat = QImage::Format_ARGB8565_Premultiplied;
+                break;
+            default: // We don't care about the others...
+                break;
+            }
+
+            if (!sourceImage.hasAlphaChannel()
+                || ((flags & Qt::NoOpaqueDetection) == 0
+                    && !const_cast<QImage &>(sourceImage).data_ptr()->checkForAlphaPixels())) {
+                image = sourceImage.convertToFormat(opaqueFormat);
+            } else {
+                image = sourceImage.convertToFormat(alphaFormat);
+            }
+        }
+    }
+#endif
+
+    setSerialNumber(image.serialNumber());
+}
+
+// from qwindowsurface.cpp
+extern void qt_scrollRectInImage(QImage &img, const QRect &rect, const QPoint &offset);
+
+bool QRasterPixmapData::scroll(int dx, int dy, const QRect &rect)
+{
+    if (!image.isNull())
+        qt_scrollRectInImage(image, rect, QPoint(dx, dy));
+    return true;
+}
+
+void QRasterPixmapData::fill(const QColor &color)
+{
+    uint pixel;
+
+    if (image.depth() == 1) {
+        int gray = qGray(color.rgba());
+        // Pick the best approximate color in the image's colortable.
+        if (qAbs(qGray(image.color(0)) - gray) < qAbs(qGray(image.color(1)) - gray))
+            pixel = 0;
+        else
+            pixel = 1;
+    } else if (image.depth() >= 15) {
+        int alpha = color.alpha();
+        if (alpha != 255) {
+            if (!image.hasAlphaChannel()) {
+                QImage::Format toFormat;
+                if (image.format() == QImage::Format_RGB16)
+                    toFormat = QImage::Format_ARGB8565_Premultiplied;
+                else if (image.format() == QImage::Format_RGB666)
+                    toFormat = QImage::Format_ARGB6666_Premultiplied;
+                else if (image.format() == QImage::Format_RGB555)
+                    toFormat = QImage::Format_ARGB8555_Premultiplied;
+                else if (image.format() == QImage::Format_RGB444)
+                    toFormat = QImage::Format_ARGB4444_Premultiplied;
+                else
+                    toFormat = QImage::Format_ARGB32_Premultiplied;
+                image = QImage(image.width(), image.height(), toFormat);
+            }
+
+            switch (image.format()) {
+            case QImage::Format_ARGB8565_Premultiplied:
+                pixel = qargb8565(color.rgba()).rawValue();
+                break;
+            case QImage::Format_ARGB8555_Premultiplied:
+                pixel = qargb8555(color.rgba()).rawValue();
+                break;
+            case QImage::Format_ARGB6666_Premultiplied:
+                pixel = qargb6666(color.rgba()).rawValue();
+                break;
+            case QImage::Format_ARGB4444_Premultiplied:
+                pixel = qargb4444(color.rgba()).rawValue();
+                break;
+            default:
+                pixel = PREMUL(color.rgba());
+                break;
+            }
+        } else {
+            switch (image.format()) {
+            case QImage::Format_RGB16:
+                pixel = qt_colorConvert<quint16, quint32>(color.rgba(), 0);
+                break;
+            case QImage::Format_RGB444:
+                pixel = qrgb444(color.rgba()).rawValue();
+                break;
+            case QImage::Format_RGB555:
+                pixel = qrgb555(color.rgba()).rawValue();
+                break;
+            case QImage::Format_RGB666:
+                pixel = qrgb666(color.rgba()).rawValue();
+                break;
+            case QImage::Format_RGB888:
+                pixel = qrgb888(color.rgba()).rawValue();
+                break;
+            default:
+                pixel = color.rgba();
+                break;
+            }
+        }
+    } else {
+        pixel = 0;
+        // ### what about 8 bits
+    }
+
+    image.fill(pixel);
+}
+
+void QRasterPixmapData::setMask(const QBitmap &mask)
+{
+    if (mask.size().isEmpty()) {
+        if (image.depth() != 1) { // hw: ????
+            image = image.convertToFormat(QImage::Format_RGB32);
+        }
+    } else {
+        const int w = image.width();
+        const int h = image.height();
+
+        switch (image.depth()) {
+        case 1: {
+            const QImage imageMask = mask.toImage().convertToFormat(image.format());
+            for (int y = 0; y < h; ++y) {
+                const uchar *mscan = imageMask.scanLine(y);
+                uchar *tscan = image.scanLine(y);
+                int bytesPerLine = image.bytesPerLine();
+                for (int i = 0; i < bytesPerLine; ++i)
+                    tscan[i] &= mscan[i];
+            }
+            break;
+        }
+        default: {
+            const QImage imageMask = mask.toImage().convertToFormat(QImage::Format_MonoLSB);
+            image = image.convertToFormat(QImage::Format_ARGB32_Premultiplied);
+            for (int y = 0; y < h; ++y) {
+                const uchar *mscan = imageMask.scanLine(y);
+                QRgb *tscan = (QRgb *)image.scanLine(y);
+                for (int x = 0; x < w; ++x) {
+                    if (!(mscan[x>>3] & qt_pixmap_bit_mask[x&7]))
+                        tscan[x] = 0;
+                }
+            }
+            break;
+        }
+        }
+    }
+}
+
+bool QRasterPixmapData::hasAlphaChannel() const
+{
+    return image.hasAlphaChannel();
+}
+
+QImage QRasterPixmapData::toImage() const
+{
+    return image;
+}
+
+void QRasterPixmapData::setAlphaChannel(const QPixmap &alphaChannel)
+{
+    image.setAlphaChannel(alphaChannel.toImage());
+}
+
+QPaintEngine* QRasterPixmapData::paintEngine() const
+{
+    return image.paintEngine();
+}
+
+extern int qt_defaultDpiX();
+extern int qt_defaultDpiY();
+
+int QRasterPixmapData::metric(QPaintDevice::PaintDeviceMetric metric) const
+{
+    // override the image dpi with the screen dpi when rendering to a pixmap
+    const int dpmX = qRound(qt_defaultDpiX() * 100 / qreal(2.54));
+    const int dpmY = qRound(qt_defaultDpiY() * 100 / qreal(2.54));
+    switch (metric) {
+    case QPaintDevice::PdmWidthMM:
+        return qRound(image.width() * 1000 / dpmX);
+    case QPaintDevice::PdmHeightMM:
+        return qRound(image.height() * 1000 / dpmY);
+    case QPaintDevice::PdmDpiX:
+        return qRound(dpmX * qreal(0.0254));
+    case QPaintDevice::PdmDpiY:
+        return qRound(dpmY * qreal(0.0254));
+    case QPaintDevice::PdmPhysicalDpiX:
+        return qRound(dpmX * qreal(0.0254));
+    case QPaintDevice::PdmPhysicalDpiY:
+        return qRound(dpmY * qreal(0.0254));
+    default:
+        return image.metric(metric);
+    }
+}
+
+QImage* QRasterPixmapData::buffer()
+{
+    return &image;
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/image/qpixmap_raster_p.h b/src/gui/image/qpixmap_raster_p.h
new file mode 100644
index 0000000..48d5cf8
--- /dev/null
+++ b/src/gui/image/qpixmap_raster_p.h
@@ -0,0 +1,106 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPIXMAPDATA_RASTER_P_H
+#define QPIXMAPDATA_RASTER_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/private/qpixmapdata_p.h>
+#include <QtGui/private/qpixmapdatafactory_p.h>
+
+#ifdef Q_WS_WIN
+# include "qt_windows.h"
+# ifndef QT_NO_DIRECT3D
+#  include <d3d9.h>
+# endif
+#endif
+
+QT_BEGIN_NAMESPACE
+
+class Q_GUI_EXPORT QRasterPixmapData : public QPixmapData
+{
+public:
+    QRasterPixmapData(PixelType type);
+    ~QRasterPixmapData();
+
+    void resize(int width, int height);
+    void fromFile(const QString &filename, Qt::ImageConversionFlags flags);
+    void fromImage(const QImage &image, Qt::ImageConversionFlags flags);
+
+    bool scroll(int dx, int dy, const QRect &rect);
+    void fill(const QColor &color);
+    void setMask(const QBitmap &mask);
+    bool hasAlphaChannel() const;
+    void setAlphaChannel(const QPixmap &alphaChannel);
+    QImage toImage() const;
+    QPaintEngine* paintEngine() const;
+    QImage* buffer();
+
+protected:
+    int metric(QPaintDevice::PaintDeviceMetric metric) const;
+
+private:
+#if defined(Q_WS_WIN) && !defined(QT_NO_DIRECT3D)
+    friend class QDirect3DPaintEnginePrivate;
+    IDirect3DTexture9 *texture;
+#endif
+    friend class QPixmap;
+    friend class QBitmap;
+    friend class QDetachedPixmap;
+    friend class QRasterPaintEngine;
+    QImage image;
+};
+
+QT_END_NAMESPACE
+
+#endif // QPIXMAPDATA_RASTER_P_H
+
+
diff --git a/src/gui/image/qpixmap_win.cpp b/src/gui/image/qpixmap_win.cpp
new file mode 100644
index 0000000..3ec441b
--- /dev/null
+++ b/src/gui/image/qpixmap_win.cpp
@@ -0,0 +1,481 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qpixmap.h"
+#include "qpixmap_raster_p.h"
+
+#include "qbitmap.h"
+#include "qimage.h"
+#include "qwidget.h"
+#include "qpainter.h"
+#include "qdatastream.h"
+#include "qbuffer.h"
+#include "qapplication.h"
+#include "qevent.h"
+#include "qfile.h"
+#include "qfileinfo.h"
+#include "qdatetime.h"
+#include "qpixmapcache.h"
+#include "qimagereader.h"
+#include "qimagewriter.h"
+#include "qdebug.h"
+#include "qt_windows.h"
+
+#if defined(Q_OS_WINCE)
+#include <winbase.h>
+#include "qguifunctions_wince.h"
+extern bool qt_wince_is_high_dpi();
+extern bool qt_wince_is_pocket_pc();
+#endif
+
+#ifndef CAPTUREBLT
+#define CAPTUREBLT ((DWORD)0x40000000)
+#endif
+
+QT_BEGIN_NAMESPACE
+
+QPixmap QPixmap::grabWindow(WId winId, int x, int y, int w, int h )
+{
+    RECT r;
+    GetClientRect(winId, &r);
+
+    if (w < 0) w = r.right - r.left;
+    if (h < 0) h = r.bottom - r.top;
+
+#ifdef Q_OS_WINCE_WM
+    if (qt_wince_is_pocket_pc()) {
+        QWidget *widget = QWidget::find(winId);
+        if (qobject_cast<QDesktopWidget *>(widget)) {
+            RECT rect = {0,0,0,0};
+            AdjustWindowRectEx(&rect, WS_BORDER | WS_CAPTION, FALSE, 0);
+            int magicNumber = qt_wince_is_high_dpi() ? 4 : 2;
+            y += rect.top - magicNumber;
+        }
+    }
+#endif
+
+    // Create and setup bitmap
+    HDC display_dc = GetDC(0);
+    HDC bitmap_dc = CreateCompatibleDC(display_dc);
+    HBITMAP bitmap = CreateCompatibleBitmap(display_dc, w, h);
+    HGDIOBJ null_bitmap = SelectObject(bitmap_dc, bitmap);
+
+    // copy data
+    HDC window_dc = GetDC(winId);
+    BitBlt(bitmap_dc, 0, 0, w, h, window_dc, x, y, SRCCOPY
+#ifndef Q_OS_WINCE
+                                    | CAPTUREBLT
+#endif
+            );
+
+    // clean up all but bitmap
+    ReleaseDC(winId, window_dc);
+    SelectObject(bitmap_dc, null_bitmap);
+    DeleteDC(bitmap_dc);
+
+    QPixmap pixmap = QPixmap::fromWinHBITMAP(bitmap);
+
+    DeleteObject(bitmap);
+    ReleaseDC(0, display_dc);
+
+    return pixmap;
+}
+
+
+
+/*!
+    \enum QPixmap::HBitmapFormat
+
+    This enum defines how the conversion between \c HBITMAP
+    and QPixmap is performed.
+
+    \warning This enum is only available on Windows.
+
+    \value NoAlpha The alpha channel is ignored and always treated as
+    being set to fully opaque. This is preferred if the \c HBITMAP is
+    used with standard GDI calls, such as \c BitBlt().
+
+    \value PremultipliedAlpha The \c HBITMAP is treated as having an
+    alpha channel and premultiplied colors. This is preferred if the
+    \c HBITMAP is accessed through the \c AlphaBlend() GDI function.
+
+    \value Alpha The \c HBITMAP is treated as having a plain alpha
+    channel. This is the preferred format if the \c HBITMAP is going
+    to be used as an application icon or systray icon.
+
+    \sa fromWinHBITMAP(), toWinHBITMAP()
+*/
+
+/*!
+    Creates a \c HBITMAP equivalent to the QPixmap, based on the given
+    \a format. Returns the \c HBITMAP handle.
+
+    It is the caller's responsibility to free the \c HBITMAP data
+    after use.
+
+    \warning This function is only available on Windows.
+
+    \sa fromWinHBITMAP()
+*/
+HBITMAP QPixmap::toWinHBITMAP(HBitmapFormat format) const
+{
+    HBITMAP bitmap = 0;
+    if (data->classId() == QPixmapData::RasterClass) {
+        QRasterPixmapData* d = static_cast<QRasterPixmapData*>(data);
+        int w = d->image.width();
+        int h = d->image.height();
+
+        HDC display_dc = GetDC(0);
+
+        // Define the header
+        BITMAPINFO bmi;
+        memset(&bmi, 0, sizeof(bmi));
+        bmi.bmiHeader.biSize        = sizeof(BITMAPINFOHEADER);
+        bmi.bmiHeader.biWidth       = w;
+        bmi.bmiHeader.biHeight      = -h;
+        bmi.bmiHeader.biPlanes      = 1;
+        bmi.bmiHeader.biBitCount    = 32;
+        bmi.bmiHeader.biCompression = BI_RGB;
+        bmi.bmiHeader.biSizeImage   = w * h * 4;
+
+        // Create the pixmap
+        uchar *pixels = 0;
+        bitmap = CreateDIBSection(display_dc, &bmi, DIB_RGB_COLORS, (void **) &pixels, 0, 0);
+        ReleaseDC(0, display_dc);
+        if (!bitmap) {
+            qErrnoWarning("QPixmap::toWinHBITMAP(), failed to create dibsection");
+            return 0;
+        }
+        if (!pixels) {
+            qErrnoWarning("QPixmap::toWinHBITMAP(), did not allocate pixel data");
+            return 0;
+        }
+
+        // Copy over the data
+        QImage::Format imageFormat = QImage::Format_ARGB32;
+        if (format == NoAlpha)
+            imageFormat = QImage::Format_RGB32;
+        else if (format == PremultipliedAlpha)
+            imageFormat = QImage::Format_ARGB32_Premultiplied;
+        const QImage image = d->image.convertToFormat(imageFormat);
+        int bytes_per_line = w * 4;
+        for (int y=0; y<h; ++y)
+            memcpy(pixels + y * bytes_per_line, image.scanLine(y), bytes_per_line);
+
+    } else {
+        QPixmapData *data = new QRasterPixmapData(depth() == 1 ?
+                                                  QPixmapData::BitmapType : QPixmapData::PixmapType);
+        data->fromImage(toImage(), Qt::AutoColor);
+        return QPixmap(data).toWinHBITMAP(format);
+    }
+    return bitmap;
+}
+
+/*!
+    Returns a QPixmap that is equivalent to the given \a bitmap. The
+    conversion is based on the specified \a format.
+
+    \warning This function is only available on Windows.
+
+    \sa toWinHBITMAP(), {QPixmap#Pixmap Conversion}{Pixmap Conversion}
+
+*/
+QPixmap QPixmap::fromWinHBITMAP(HBITMAP bitmap, HBitmapFormat format)
+{
+    // Verify size
+    BITMAP bitmap_info;
+    memset(&bitmap_info, 0, sizeof(BITMAP));
+
+    int res;
+    QT_WA({
+            res = GetObjectW(bitmap, sizeof(BITMAP), &bitmap_info);
+        } , {
+              res = GetObjectA(bitmap, sizeof(BITMAP), &bitmap_info);
+          });
+
+    if (!res) {
+        qErrnoWarning("QPixmap::fromWinHBITMAP(), failed to get bitmap info");
+        return QPixmap();
+    }
+    int w = bitmap_info.bmWidth;
+    int h = bitmap_info.bmHeight;
+
+    BITMAPINFO bmi;
+    memset(&bmi, 0, sizeof(bmi));
+    bmi.bmiHeader.biSize        = sizeof(BITMAPINFOHEADER);
+    bmi.bmiHeader.biWidth       = w;
+    bmi.bmiHeader.biHeight      = -h;
+    bmi.bmiHeader.biPlanes      = 1;
+    bmi.bmiHeader.biBitCount    = 32;
+    bmi.bmiHeader.biCompression = BI_RGB;
+    bmi.bmiHeader.biSizeImage   = w * h * 4;
+
+    QImage result;
+    // Get bitmap bits
+    uchar *data = (uchar *) qMalloc(bmi.bmiHeader.biSizeImage);
+
+    HDC display_dc = GetDC(0);
+    if (GetDIBits(display_dc, bitmap, 0, h, data, &bmi, DIB_RGB_COLORS)) {
+
+        QImage::Format imageFormat = QImage::Format_ARGB32_Premultiplied;
+        uint mask = 0;
+        if (format == NoAlpha) {
+            imageFormat = QImage::Format_RGB32;
+            mask = 0xff000000;
+        }
+
+        // Create image and copy data into image.
+        QImage image(w, h, imageFormat);
+        if (!image.isNull()) { // failed to alloc?
+            int bytes_per_line = w * sizeof(QRgb);
+            for (int y=0; y<h; ++y) {
+                QRgb *dest = (QRgb *) image.scanLine(y);
+                const QRgb *src = (const QRgb *) (data + y * bytes_per_line);
+                for (int x=0; x<w; ++x) {
+                    const uint pixel = src[x];
+                    if ((pixel & 0xff000000) == 0 && (pixel & 0x00ffffff) != 0)
+                        dest[x] = pixel | 0xff000000;
+                    else
+                        dest[x] = pixel | mask;
+                }
+            }
+        }
+        result = image;
+    } else {
+        qWarning("QPixmap::fromWinHBITMAP(), failed to get bitmap bits");
+    }
+    ReleaseDC(0, display_dc);
+    qFree(data);
+    return fromImage(result);
+}
+
+#ifdef Q_WS_WIN
+#ifndef Q_OS_WINCE
+
+static QImage qt_fromWinHBITMAP(HDC hdc, HBITMAP bitmap, int w, int h)
+{
+    BITMAPINFO bmi;
+    memset(&bmi, 0, sizeof(bmi));
+    bmi.bmiHeader.biSize        = sizeof(BITMAPINFOHEADER);
+    bmi.bmiHeader.biWidth       = w;
+    bmi.bmiHeader.biHeight      = -h;
+    bmi.bmiHeader.biPlanes      = 1;
+    bmi.bmiHeader.biBitCount    = 32;
+    bmi.bmiHeader.biCompression = BI_RGB;
+    bmi.bmiHeader.biSizeImage   = w * h * 4;
+
+    QImage image(w, h, QImage::Format_ARGB32_Premultiplied);
+    if (image.isNull())
+        return image;
+
+    // Get bitmap bits
+    uchar *data = (uchar *) qMalloc(bmi.bmiHeader.biSizeImage);
+
+    if (GetDIBits(hdc, bitmap, 0, h, data, &bmi, DIB_RGB_COLORS)) {
+        // Create image and copy data into image.
+        for (int y=0; y<h; ++y) {
+            void *dest = (void *) image.scanLine(y);
+            void *src = data + y * image.bytesPerLine();
+            memcpy(dest, src, image.bytesPerLine());
+        }
+    } else {
+        qWarning("qt_fromWinHBITMAP(), failed to get bitmap bits");
+    }
+
+    return image;
+}
+
+QPixmap convertHIconToPixmap( const HICON icon)
+{
+    bool foundAlpha = false;
+    HDC screenDevice = GetDC(0);
+    HDC hdc = CreateCompatibleDC(screenDevice);
+    ReleaseDC(0, screenDevice);
+
+    ICONINFO iconinfo;
+    bool result = GetIconInfo(icon, &iconinfo); //x and y Hotspot describes the icon center
+    if (!result)
+        qWarning("convertHIconToPixmap(), failed to GetIconInfo()");
+
+    int w = iconinfo.xHotspot * 2;
+    int h = iconinfo.yHotspot * 2;
+
+    BITMAPINFOHEADER bitmapInfo;
+    bitmapInfo.biSize        = sizeof(BITMAPINFOHEADER);
+    bitmapInfo.biWidth       = w;
+    bitmapInfo.biHeight      = h;
+    bitmapInfo.biPlanes      = 1;
+    bitmapInfo.biBitCount    = 32;
+    bitmapInfo.biCompression = BI_RGB;
+    bitmapInfo.biSizeImage   = 0;
+    bitmapInfo.biXPelsPerMeter = 0;
+    bitmapInfo.biYPelsPerMeter = 0;
+    bitmapInfo.biClrUsed       = 0;
+    bitmapInfo.biClrImportant  = 0;
+    DWORD* bits;
+
+    HBITMAP winBitmap = CreateDIBSection(hdc, (BITMAPINFO*)&bitmapInfo, DIB_RGB_COLORS, (VOID**)&bits, NULL, 0);
+    HGDIOBJ oldhdc = (HBITMAP)SelectObject(hdc, winBitmap);
+    DrawIconEx( hdc, 0, 0, icon, iconinfo.xHotspot * 2, iconinfo.yHotspot * 2, 0, 0, DI_NORMAL);
+    QImage image = qt_fromWinHBITMAP(hdc, winBitmap, w, h);
+
+    for (int y = 0 ; y < h && !foundAlpha ; y++) {
+        QRgb *scanLine= reinterpret_cast<QRgb *>(image.scanLine(y));
+        for (int x = 0; x < w ; x++) {
+            if (qAlpha(scanLine[x]) != 0) {
+                foundAlpha = true;
+                break;
+            }
+        }
+    }
+    if (!foundAlpha) {
+        //If no alpha was found, we use the mask to set alpha values
+        DrawIconEx( hdc, 0, 0, icon, w, h, 0, 0, DI_MASK);
+        QImage mask = qt_fromWinHBITMAP(hdc, winBitmap, w, h);
+
+        for (int y = 0 ; y < h ; y++){
+            QRgb *scanlineImage = reinterpret_cast<QRgb *>(image.scanLine(y));
+            QRgb *scanlineMask = mask.isNull() ? 0 : reinterpret_cast<QRgb *>(mask.scanLine(y));
+            for (int x = 0; x < w ; x++){
+                if (scanlineMask && qRed(scanlineMask[x]) != 0)
+                    scanlineImage[x] = 0; //mask out this pixel
+                else
+                    scanlineImage[x] |= 0xff000000; // set the alpha channel to 255
+            }
+        }
+    }
+    //dispose resources created by iconinfo call
+    DeleteObject(iconinfo.hbmMask);
+    DeleteObject(iconinfo.hbmColor);
+
+    SelectObject(hdc, oldhdc); //restore state
+    DeleteObject(winBitmap);
+    DeleteDC(hdc);
+    return QPixmap::fromImage(image);
+}
+#else //ifndef Q_OS_WINCE
+QPixmap convertHIconToPixmap( const HICON icon, bool large)
+{
+    HDC screenDevice = GetDC(0);
+    HDC hdc = CreateCompatibleDC(screenDevice);
+    ReleaseDC(0, screenDevice);
+
+    int size = large ? 64 : 32;
+
+    BITMAPINFO bmi;
+    memset(&bmi, 0, sizeof(bmi));
+    bmi.bmiHeader.biSize        = sizeof(BITMAPINFO);
+    bmi.bmiHeader.biWidth       = size;
+    bmi.bmiHeader.biHeight      = -size;
+    bmi.bmiHeader.biPlanes      = 1;
+    bmi.bmiHeader.biBitCount    = 32;
+    bmi.bmiHeader.biCompression = BI_RGB;
+    bmi.bmiHeader.biSizeImage   = size*size*4;
+
+    uchar* bits;
+
+    HBITMAP winBitmap = CreateDIBSection(hdc, &bmi, DIB_RGB_COLORS, (void**) &bits, 0, 0);
+    if (winBitmap )
+        memset(bits, 0xff, size*size*4);
+    if (!winBitmap) {
+        qWarning("convertHIconToPixmap(), failed to CreateDIBSection()");
+        return QPixmap();
+    }
+
+    HGDIOBJ oldhdc = (HBITMAP)SelectObject(hdc, winBitmap);
+    if (!DrawIconEx( hdc, 0, 0, icon, size, size, 0, 0, DI_NORMAL))
+        qWarning("convertHIconToPixmap(), failed to DrawIcon()");
+
+    uint mask = 0xff000000;
+    // Create image and copy data into image.
+    QImage image(size, size, QImage::Format_ARGB32);
+
+    if (!image.isNull()) { // failed to alloc?
+        int bytes_per_line = size * sizeof(QRgb);
+        for (int y=0; y<size; ++y) {
+            QRgb *dest = (QRgb *) image.scanLine(y);
+            const QRgb *src = (const QRgb *) (bits + y * bytes_per_line);
+            for (int x=0; x<size; ++x) {
+                dest[x] = src[x];
+            }
+        }
+    }
+    if (!DrawIconEx( hdc, 0, 0, icon, size, size, 0, 0, DI_MASK))
+        qWarning("convertHIconToPixmap(), failed to DrawIcon()");
+    if (!image.isNull()) { // failed to alloc?
+        int bytes_per_line = size * sizeof(QRgb);
+        for (int y=0; y<size; ++y) {
+            QRgb *dest = (QRgb *) image.scanLine(y);
+            const QRgb *src = (const QRgb *) (bits + y * bytes_per_line);
+            for (int x=0; x<size; ++x) {
+                if (!src[x])
+                    dest[x] = dest[x] | mask;
+            }
+        }
+    }
+    SelectObject(hdc, oldhdc); //restore state
+    DeleteObject(winBitmap);
+    DeleteDC(hdc);
+    return QPixmap::fromImage(image);
+}
+#endif //ifndef Q_OS_WINCE
+
+QPixmap loadIconFromShell32( int resourceId, int size )
+{
+#ifdef Q_OS_WINCE
+    HMODULE hmod = LoadLibrary((const wchar_t *) QString::fromLatin1("ceshell.dll").utf16());
+#else
+    HMODULE hmod = LoadLibraryA("shell32.dll");
+#endif
+    if( hmod ) {
+        HICON iconHandle = (HICON)LoadImage(hmod, MAKEINTRESOURCE(resourceId), IMAGE_ICON, size, size, 0);
+        if( iconHandle ) {
+            QPixmap iconpixmap = convertHIconToPixmap( iconHandle );
+            DestroyIcon(iconHandle);
+            return iconpixmap;
+        }
+    }
+    return QPixmap();
+}
+
+#endif
+
+QT_END_NAMESPACE
diff --git a/src/gui/image/qpixmap_x11.cpp b/src/gui/image/qpixmap_x11.cpp
new file mode 100644
index 0000000..9d99d2e
--- /dev/null
+++ b/src/gui/image/qpixmap_x11.cpp
@@ -0,0 +1,2301 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+// Uncomment the next line to enable the MIT Shared Memory extension
+//
+// WARNING:  This has some problems:
+//
+//    1. Consumes a 800x600 pixmap
+//    2. Qt does not handle the ShmCompletion message, so you will
+//        get strange effects if you xForm() repeatedly.
+//
+// #define QT_MITSHM
+
+#if defined(Q_OS_WIN32) && defined(QT_MITSHM)
+#undef QT_MITSHM
+#endif
+
+#include "qplatformdefs.h"
+
+#include "qdebug.h"
+#include "qiodevice.h"
+#include "qpixmap_x11_p.h"
+#include "qbitmap.h"
+#include "qcolormap.h"
+#include "qimage.h"
+#include "qmatrix.h"
+#include "qapplication.h"
+#include <private/qpaintengine_x11_p.h>
+#include <private/qt_x11_p.h>
+#include "qx11info_x11.h"
+#include <private/qdrawhelper_p.h>
+
+#include <stdlib.h>
+
+#if defined(Q_CC_MIPS)
+#  define for if(0){}else for
+#endif
+
+QT_BEGIN_NAMESPACE
+
+QPixmap qt_toX11Pixmap(const QImage &image)
+{
+    QPixmapData *data =
+        new QX11PixmapData(image.depth() == 1
+                           ? QPixmapData::BitmapType
+                           : QPixmapData::PixmapType);
+
+    data->fromImage(image, Qt::AutoColor);
+
+    return QPixmap(data);
+}
+
+QPixmap qt_toX11Pixmap(const QPixmap &pixmap)
+{
+    if (pixmap.isNull())
+        return QPixmap();
+
+    if (QPixmap(pixmap).data_ptr()->classId() == QPixmapData::X11Class)
+        return pixmap;
+
+    return qt_toX11Pixmap(pixmap.toImage());
+}
+
+// For thread-safety:
+//   image->data does not belong to X11, so we must free it ourselves.
+
+inline static void qSafeXDestroyImage(XImage *x)
+{
+    if (x->data) {
+        free(x->data);
+        x->data = 0;
+    }
+    XDestroyImage(x);
+}
+
+QBitmap QX11PixmapData::mask_to_bitmap(int screen) const
+{
+    if (!x11_mask)
+        return QBitmap();
+    QPixmap::x11SetDefaultScreen(screen);
+    QBitmap bm(w, h);
+    GC gc = XCreateGC(X11->display, bm.handle(), 0, 0);
+    XCopyArea(X11->display, x11_mask, bm.handle(), gc, 0, 0,
+              bm.data->width(), bm.data->height(), 0, 0);
+    XFreeGC(X11->display, gc);
+    return bm;
+}
+
+Qt::HANDLE QX11PixmapData::bitmap_to_mask(const QBitmap &bitmap, int screen)
+{
+    if (bitmap.isNull())
+        return 0;
+    QBitmap bm = bitmap;
+    bm.x11SetScreen(screen);
+
+    Pixmap mask = XCreatePixmap(X11->display, RootWindow(X11->display, screen),
+                                bm.data->width(), bm.data->height(), 1);
+    GC gc = XCreateGC(X11->display, mask, 0, 0);
+    XCopyArea(X11->display, bm.handle(), mask, gc, 0, 0,
+              bm.data->width(), bm.data->height(), 0, 0);
+    XFreeGC(X11->display, gc);
+    return mask;
+}
+
+
+/*****************************************************************************
+  MIT Shared Memory Extension support: makes xForm noticeably (~20%) faster.
+ *****************************************************************************/
+
+#if defined(QT_MITSHM)
+
+static bool               xshminit = false;
+static XShmSegmentInfo xshminfo;
+static XImage              *xshmimg = 0;
+static Pixmap               xshmpm  = 0;
+
+static void qt_cleanup_mitshm()
+{
+    if (xshmimg == 0)
+        return;
+    Display *dpy = QX11Info::appDisplay();
+    if (xshmpm) {
+        XFreePixmap(dpy, xshmpm);
+        xshmpm = 0;
+    }
+    XShmDetach(dpy, &xshminfo); xshmimg->data = 0;
+    qSafeXDestroyImage(xshmimg); xshmimg = 0;
+    shmdt(xshminfo.shmaddr);
+    shmctl(xshminfo.shmid, IPC_RMID, 0);
+}
+
+static bool qt_create_mitshm_buffer(const QPaintDevice* dev, int w, int h)
+{
+    static int major, minor;
+    static Bool pixmaps_ok;
+    Display *dpy = dev->data->xinfo->display();
+    int dd         = dev->x11Depth();
+    Visual *vis         = (Visual*)dev->x11Visual();
+
+    if (xshminit) {
+        qt_cleanup_mitshm();
+    } else {
+        if (!XShmQueryVersion(dpy, &major, &minor, &pixmaps_ok))
+            return false;                        // MIT Shm not supported
+        qAddPostRoutine(qt_cleanup_mitshm);
+        xshminit = true;
+    }
+
+    xshmimg = XShmCreateImage(dpy, vis, dd, ZPixmap, 0, &xshminfo, w, h);
+    if (!xshmimg)
+        return false;
+
+    bool ok;
+    xshminfo.shmid = shmget(IPC_PRIVATE,
+                             xshmimg->bytes_per_line * xshmimg->height,
+                             IPC_CREAT | 0777);
+    ok = xshminfo.shmid != -1;
+    if (ok) {
+        xshmimg->data = (char*)shmat(xshminfo.shmid, 0, 0);
+        xshminfo.shmaddr = xshmimg->data;
+        ok = (xshminfo.shmaddr != (char*)-1);
+    }
+    xshminfo.readOnly = false;
+    if (ok)
+        ok = XShmAttach(dpy, &xshminfo);
+    if (!ok) {
+        qSafeXDestroyImage(xshmimg);
+        xshmimg = 0;
+        if (xshminfo.shmaddr)
+            shmdt(xshminfo.shmaddr);
+        if (xshminfo.shmid != -1)
+            shmctl(xshminfo.shmid, IPC_RMID, 0);
+        return false;
+    }
+    if (pixmaps_ok)
+        xshmpm = XShmCreatePixmap(dpy, DefaultRootWindow(dpy), xshmimg->data,
+                                   &xshminfo, w, h, dd);
+
+    return true;
+}
+
+#else
+
+// If extern, need a dummy.
+//
+// static bool qt_create_mitshm_buffer(QPaintDevice*, int, int)
+// {
+//     return false;
+// }
+
+#endif // QT_MITSHM
+
+
+/*****************************************************************************
+  Internal functions
+ *****************************************************************************/
+
+extern const uchar *qt_get_bitflip_array();                // defined in qimage.cpp
+
+// Returns position of highest bit set or -1 if none
+static int highest_bit(uint v)
+{
+    int i;
+    uint b = (uint)1 << 31;
+    for (i=31; ((b & v) == 0) && i>=0;         i--)
+        b >>= 1;
+    return i;
+}
+
+// Returns position of lowest set bit in 'v' as an integer (0-31), or -1
+static int lowest_bit(uint v)
+{
+    int i;
+    ulong lb;
+    lb = 1;
+    for (i=0; ((v & lb) == 0) && i<32;  i++, lb<<=1) {}
+    return i==32 ? -1 : i;
+}
+
+// Counts the number of bits set in 'v'
+static uint n_bits(uint v)
+{
+    int i = 0;
+    while (v) {
+        v = v & (v - 1);
+        i++;
+    }
+    return i;
+}
+
+static uint *red_scale_table   = 0;
+static uint *green_scale_table = 0;
+static uint *blue_scale_table  = 0;
+
+static void cleanup_scale_tables()
+{
+    delete[] red_scale_table;
+    delete[] green_scale_table;
+    delete[] blue_scale_table;
+}
+
+/*
+  Could do smart bitshifting, but the "obvious" algorithm only works for
+  nBits >= 4. This is more robust.
+*/
+static void build_scale_table(uint **table, uint nBits)
+{
+    if (nBits > 7) {
+        qWarning("build_scale_table: internal error, nBits = %i", nBits);
+        return;
+    }
+    if (!*table) {
+        static bool firstTable = true;
+        if (firstTable) {
+            qAddPostRoutine(cleanup_scale_tables);
+            firstTable = false;
+        }
+        *table = new uint[256];
+    }
+    int   maxVal   = (1 << nBits) - 1;
+    int   valShift = 8 - nBits;
+    int i;
+    for(i = 0 ; i < maxVal + 1 ; i++)
+        (*table)[i << valShift] = i*255/maxVal;
+}
+
+static int defaultScreen = -1;
+
+/*****************************************************************************
+  QPixmap member functions
+ *****************************************************************************/
+
+static int qt_pixmap_serial = 0;
+int Q_GUI_EXPORT qt_x11_preferred_pixmap_depth = 0;
+
+QX11PixmapData::QX11PixmapData(PixelType type)
+    : QPixmapData(type, X11Class), hd(0), w(0), h(0), d(0),
+      uninit(true), read_only(false), x11_mask(0), picture(0), mask_picture(0), hd2(0),
+      share_mode(QPixmap::ImplicitlyShared), pengine(0)
+{
+}
+
+void QX11PixmapData::resize(int width, int height)
+{
+    setSerialNumber(++qt_pixmap_serial);
+
+    w = width;
+    h = height;
+
+    if (defaultScreen >= 0 && defaultScreen != xinfo.screen()) {
+        QX11InfoData* xd = xinfo.getX11Data(true);
+        xd->screen = defaultScreen;
+        xd->depth = QX11Info::appDepth(xd->screen);
+        xd->cells = QX11Info::appCells(xd->screen);
+        xd->colormap = QX11Info::appColormap(xd->screen);
+        xd->defaultColormap = QX11Info::appDefaultColormap(xd->screen);
+        xd->visual = (Visual *)QX11Info::appVisual(xd->screen);
+        xd->defaultVisual = QX11Info::appDefaultVisual(xd->screen);
+        xinfo.setX11Data(xd);
+    }
+
+    int dd = xinfo.depth();
+
+    if (qt_x11_preferred_pixmap_depth)
+        dd = qt_x11_preferred_pixmap_depth;
+
+    bool make_null = w <= 0 || h <= 0;                // create null pixmap
+    d = (pixelType() == BitmapType ? 1 : dd);
+    if (make_null || d == 0) {
+        w = 0;
+        h = 0;
+        hd = 0;
+        picture = 0;
+        d = 0;
+        if (!make_null)
+            qWarning("QPixmap: Invalid pixmap parameters");
+        return;
+    }
+    hd = (Qt::HANDLE)XCreatePixmap(X11->display,
+                                   RootWindow(X11->display, xinfo.screen()),
+                                   w, h, d);
+#ifndef QT_NO_XRENDER
+    if (X11->use_xrender) {
+        XRenderPictFormat *format = d == 1
+                                    ? XRenderFindStandardFormat(X11->display, PictStandardA1)
+                                    : XRenderFindVisualFormat(X11->display, (Visual *)xinfo.visual());
+        picture = XRenderCreatePicture(X11->display, hd, format, 0, 0);
+    }
+#endif // QT_NO_XRENDER
+}
+
+void QX11PixmapData::fromImage(const QImage &img,
+                               Qt::ImageConversionFlags flags)
+{
+    setSerialNumber(++qt_pixmap_serial);
+
+    w = img.width();
+    h = img.height();
+    d = img.depth();
+
+    if (defaultScreen >= 0 && defaultScreen != xinfo.screen()) {
+        QX11InfoData* xd = xinfo.getX11Data(true);
+        xd->screen = defaultScreen;
+        xd->depth = QX11Info::appDepth(xd->screen);
+        xd->cells = QX11Info::appCells(xd->screen);
+        xd->colormap = QX11Info::appColormap(xd->screen);
+        xd->defaultColormap = QX11Info::appDefaultColormap(xd->screen);
+        xd->visual = (Visual *)QX11Info::appVisual(xd->screen);
+        xd->defaultVisual = QX11Info::appDefaultVisual(xd->screen);
+        xinfo.setX11Data(xd);
+    }
+
+    if (pixelType() == BitmapType) {
+        bitmapFromImage(img);
+        return;
+    }
+
+    if (uint(w) >= 32768 || uint(h) >= 32768) {
+        w = h = 0;
+        return;
+    }
+
+    int dd = X11->use_xrender && img.hasAlphaChannel() ? 32 : xinfo.depth();
+    if (qt_x11_preferred_pixmap_depth)
+        dd = qt_x11_preferred_pixmap_depth;
+
+    QImage image = img;
+
+    // must be monochrome
+    if (dd == 1 || (flags & Qt::ColorMode_Mask) == Qt::MonoOnly) {
+        if (d != 1) {
+            // dither
+            image = image.convertToFormat(QImage::Format_MonoLSB, flags);
+            d = 1;
+        }
+    } else { // can be both
+        bool conv8 = false;
+        if (d > 8 && dd <= 8) { // convert to 8 bit
+            if ((flags & Qt::DitherMode_Mask) == Qt::AutoDither)
+                flags = (flags & ~Qt::DitherMode_Mask)
+                        | Qt::PreferDither;
+            conv8 = true;
+        } else if ((flags & Qt::ColorMode_Mask) == Qt::ColorOnly) {
+            conv8 = (d == 1);                        // native depth wanted
+        } else if (d == 1) {
+            if (image.numColors() == 2) {
+                QRgb c0 = image.color(0);        // Auto: convert to best
+                QRgb c1 = image.color(1);
+                conv8 = qMin(c0,c1) != qRgb(0,0,0) || qMax(c0,c1) != qRgb(255,255,255);
+            } else {
+                // eg. 1-color monochrome images (they do exist).
+                conv8 = true;
+            }
+        }
+        if (conv8) {
+            image = image.convertToFormat(QImage::Format_Indexed8, flags);
+            d = 8;
+        }
+    }
+
+    if (d == 1 || d == 16 || d == 24) {
+        image = image.convertToFormat(QImage::Format_RGB32, flags);
+        fromImage(image, Qt::AutoColor);
+        return;
+    }
+
+    Display *dpy   = X11->display;
+    Visual *visual = (Visual *)xinfo.visual();
+    XImage *xi = 0;
+    bool    trucol = (visual->c_class >= TrueColor);
+    int     nbytes = image.numBytes();
+    uchar  *newbits= 0;
+
+#ifndef QT_NO_XRENDER
+    if (X11->use_xrender && image.hasAlphaChannel()) {
+        const QImage &cimage = image;
+
+        d = 32;
+
+        if (QX11Info::appDepth() != d) {
+            if (xinfo.x11data) {
+                xinfo.x11data->depth = d;
+            } else {
+                QX11InfoData *xd = xinfo.getX11Data(true);
+                xd->screen = QX11Info::appScreen();
+                xd->depth = d;
+                xd->cells = QX11Info::appCells();
+                xd->colormap = QX11Info::appColormap();
+                xd->defaultColormap = QX11Info::appDefaultColormap();
+                xd->visual = (Visual *)QX11Info::appVisual();
+                xd->defaultVisual = QX11Info::appDefaultVisual();
+                xinfo.setX11Data(xd);
+            }
+        }
+
+        hd = (Qt::HANDLE)XCreatePixmap(dpy, RootWindow(dpy, xinfo.screen()),
+                                       w, h, d);
+        picture = XRenderCreatePicture(X11->display, hd,
+                                       XRenderFindStandardFormat(X11->display, PictStandardARGB32), 0, 0);
+
+        xi = XCreateImage(dpy, visual, d, ZPixmap, 0, 0, w, h, 32, 0);
+        Q_CHECK_PTR(xi);
+        newbits = (uchar *)malloc(xi->bytes_per_line*h);
+        Q_CHECK_PTR(newbits);
+        xi->data = (char *)newbits;
+
+        switch(cimage.format()) {
+        case QImage::Format_Indexed8: {
+            QVector<QRgb> colorTable = cimage.colorTable();
+            uint *xidata = (uint *)xi->data;
+            for (int y = 0; y < h; ++y) {
+                const uchar *p = cimage.scanLine(y);
+                for (int x = 0; x < w; ++x) {
+                    const QRgb rgb = colorTable[p[x]];
+                    const int a = qAlpha(rgb);
+                    if (a == 0xff)
+                        *xidata = rgb;
+                    else
+                        // RENDER expects premultiplied alpha
+                        *xidata = qRgba(qt_div_255(qRed(rgb) * a),
+                                        qt_div_255(qGreen(rgb) * a),
+                                        qt_div_255(qBlue(rgb) * a),
+                                        a);
+                    ++xidata;
+                }
+            }
+        }
+            break;
+        case QImage::Format_RGB32: {
+            uint *xidata = (uint *)xi->data;
+            for (int y = 0; y < h; ++y) {
+                const QRgb *p = (const QRgb *) cimage.scanLine(y);
+                for (int x = 0; x < w; ++x)
+                    *xidata++ = p[x] | 0xff000000;
+            }
+        }
+            break;
+        case QImage::Format_ARGB32: {
+            uint *xidata = (uint *)xi->data;
+            for (int y = 0; y < h; ++y) {
+                const QRgb *p = (const QRgb *) cimage.scanLine(y);
+                for (int x = 0; x < w; ++x) {
+                    const QRgb rgb = p[x];
+                    const int a = qAlpha(rgb);
+                    if (a == 0xff)
+                        *xidata = rgb;
+                    else
+                        // RENDER expects premultiplied alpha
+                        *xidata = qRgba(qt_div_255(qRed(rgb) * a),
+                                        qt_div_255(qGreen(rgb) * a),
+                                        qt_div_255(qBlue(rgb) * a),
+                                        a);
+                    ++xidata;
+                }
+            }
+
+        }
+            break;
+        case QImage::Format_ARGB32_Premultiplied: {
+            uint *xidata = (uint *)xi->data;
+            for (int y = 0; y < h; ++y) {
+                const QRgb *p = (const QRgb *) cimage.scanLine(y);
+                memcpy(xidata, p, w*sizeof(QRgb));
+                xidata += w;
+            }
+        }
+            break;
+        default:
+            Q_ASSERT(false);
+        }
+
+        if ((xi->byte_order == MSBFirst) != (QSysInfo::ByteOrder == QSysInfo::BigEndian)) {
+            uint *xidata = (uint *)xi->data;
+            uint *xiend = xidata + w*h;
+            while (xidata < xiend) {
+                *xidata = (*xidata >> 24)
+                          | ((*xidata >> 8) & 0xff00)
+                          | ((*xidata << 8) & 0xff0000)
+                          | (*xidata << 24);
+                ++xidata;
+            }
+        }
+
+        GC gc = XCreateGC(dpy, hd, 0, 0);
+        XPutImage(dpy, hd, gc, xi, 0, 0, 0, 0, w, h);
+        XFreeGC(dpy, gc);
+
+        qSafeXDestroyImage(xi);
+
+        return;
+    }
+#endif // QT_NO_XRENDER
+
+    if (trucol) {                                // truecolor display
+        if (image.format() == QImage::Format_ARGB32_Premultiplied)
+            image = image.convertToFormat(QImage::Format_ARGB32);
+
+        const QImage &cimage = image;
+        QRgb  pix[256];                                // pixel translation table
+        const bool  d8 = (d == 8);
+        const uint  red_mask          = (uint)visual->red_mask;
+        const uint  green_mask  = (uint)visual->green_mask;
+        const uint  blue_mask          = (uint)visual->blue_mask;
+        const int   red_shift          = highest_bit(red_mask)   - 7;
+        const int   green_shift = highest_bit(green_mask) - 7;
+        const int   blue_shift  = highest_bit(blue_mask)  - 7;
+        const uint  rbits = highest_bit(red_mask) - lowest_bit(red_mask) + 1;
+        const uint  gbits = highest_bit(green_mask) - lowest_bit(green_mask) + 1;
+        const uint  bbits = highest_bit(blue_mask) - lowest_bit(blue_mask) + 1;
+
+        if (d8) {                                // setup pixel translation
+            QVector<QRgb> ctable = cimage.colorTable();
+            for (int i=0; i < cimage.numColors(); i++) {
+                int r = qRed  (ctable[i]);
+                int g = qGreen(ctable[i]);
+                int b = qBlue (ctable[i]);
+                r = red_shift        > 0 ? r << red_shift   : r >> -red_shift;
+                g = green_shift > 0 ? g << green_shift : g >> -green_shift;
+                b = blue_shift        > 0 ? b << blue_shift  : b >> -blue_shift;
+                pix[i] = (b & blue_mask) | (g & green_mask) | (r & red_mask)
+                         | ~(blue_mask | green_mask | red_mask);
+            }
+        }
+
+        xi = XCreateImage(dpy, visual, dd, ZPixmap, 0, 0, w, h, 32, 0);
+        Q_CHECK_PTR(xi);
+        newbits = (uchar *)malloc(xi->bytes_per_line*h);
+        Q_CHECK_PTR(newbits);
+        if (!newbits)                                // no memory
+            return;
+        int bppc = xi->bits_per_pixel;
+
+        bool contig_bits = n_bits(red_mask) == rbits &&
+                           n_bits(green_mask) == gbits &&
+                           n_bits(blue_mask) == bbits;
+        bool dither_tc =
+            // Want it?
+            (flags & Qt::Dither_Mask) != Qt::ThresholdDither &&
+            (flags & Qt::DitherMode_Mask) != Qt::AvoidDither &&
+            // Need it?
+            bppc < 24 && !d8 &&
+            // Can do it? (Contiguous bits?)
+            contig_bits;
+
+        static bool init=false;
+        static int D[16][16];
+        if (dither_tc && !init) {
+            // I also contributed this code to XV - WWA.
+            /*
+              The dither matrix, D, is obtained with this formula:
+
+              D2 = [0 2]
+              [3 1]
+
+
+              D2*n = [4*Dn       4*Dn+2*Un]
+              [4*Dn+3*Un  4*Dn+1*Un]
+            */
+            int n,i,j;
+            init=1;
+
+            /* Set D2 */
+            D[0][0]=0;
+            D[1][0]=2;
+            D[0][1]=3;
+            D[1][1]=1;
+
+            /* Expand using recursive definition given above */
+            for (n=2; n<16; n*=2) {
+                for (i=0; i<n; i++) {
+                    for (j=0; j<n; j++) {
+                        D[i][j]*=4;
+                        D[i+n][j]=D[i][j]+2;
+                        D[i][j+n]=D[i][j]+3;
+                        D[i+n][j+n]=D[i][j]+1;
+                    }
+                }
+            }
+            init=true;
+        }
+
+        enum { BPP8,
+               BPP16_565, BPP16_555,
+               BPP16_MSB, BPP16_LSB,
+               BPP24_888,
+               BPP24_MSB, BPP24_LSB,
+               BPP32_8888,
+               BPP32_MSB, BPP32_LSB
+        } mode = BPP8;
+
+        bool same_msb_lsb = (xi->byte_order == MSBFirst) == (QSysInfo::ByteOrder == QSysInfo::BigEndian);
+
+        if(bppc == 8) // 8 bit
+            mode = BPP8;
+        else if(bppc == 16) { // 16 bit MSB/LSB
+            if(red_shift == 8 && green_shift == 3 && blue_shift == -3 && !d8 && same_msb_lsb)
+                mode = BPP16_565;
+            else if(red_shift == 7 && green_shift == 2 && blue_shift == -3 && !d8 && same_msb_lsb)
+                mode = BPP16_555;
+            else
+                mode = (xi->byte_order == LSBFirst) ? BPP16_LSB : BPP16_MSB;
+        } else if(bppc == 24) { // 24 bit MSB/LSB
+            if (red_shift == 16 && green_shift == 8 && blue_shift == 0 && !d8 && same_msb_lsb)
+                mode = BPP24_888;
+            else
+                mode = (xi->byte_order == LSBFirst) ? BPP24_LSB : BPP24_MSB;
+        } else if(bppc == 32) { // 32 bit MSB/LSB
+            if(red_shift == 16 && green_shift == 8 && blue_shift == 0 && !d8 && same_msb_lsb)
+                mode = BPP32_8888;
+            else
+                mode = (xi->byte_order == LSBFirst) ? BPP32_LSB : BPP32_MSB;
+        } else
+            qFatal("Logic error 3");
+
+#define GET_PIXEL                                                       \
+        uint pixel;                                                     \
+        if (d8) pixel = pix[*src++];                                    \
+        else {                                                          \
+            int r = qRed  (*p);                                         \
+            int g = qGreen(*p);                                         \
+            int b = qBlue (*p++);                                       \
+            r = red_shift   > 0                                         \
+                ? r << red_shift   : r >> -red_shift;                   \
+            g = green_shift > 0                                         \
+                ? g << green_shift : g >> -green_shift;                 \
+            b = blue_shift  > 0                                         \
+                ? b << blue_shift  : b >> -blue_shift;                  \
+            pixel = (r & red_mask)|(g & green_mask) | (b & blue_mask)   \
+                    | ~(blue_mask | green_mask | red_mask);             \
+        }
+
+#define GET_PIXEL_DITHER_TC                                             \
+        int r = qRed  (*p);                                             \
+        int g = qGreen(*p);                                             \
+        int b = qBlue (*p++);                                           \
+        const int thres = D[x%16][y%16];                                \
+        if (r <= (255-(1<<(8-rbits))) && ((r<<rbits) & 255)             \
+            > thres)                                                    \
+            r += (1<<(8-rbits));                                        \
+        if (g <= (255-(1<<(8-gbits))) && ((g<<gbits) & 255)             \
+            > thres)                                                    \
+            g += (1<<(8-gbits));                                        \
+        if (b <= (255-(1<<(8-bbits))) && ((b<<bbits) & 255)             \
+            > thres)                                                    \
+            b += (1<<(8-bbits));                                        \
+        r = red_shift   > 0                                             \
+            ? r << red_shift   : r >> -red_shift;                       \
+        g = green_shift > 0                                             \
+            ? g << green_shift : g >> -green_shift;                     \
+        b = blue_shift  > 0                                             \
+            ? b << blue_shift  : b >> -blue_shift;                      \
+        uint pixel = (r & red_mask)|(g & green_mask) | (b & blue_mask);
+
+// again, optimized case
+// can't be optimized that much :(
+#define GET_PIXEL_DITHER_TC_OPT(red_shift,green_shift,blue_shift,red_mask,green_mask,blue_mask, \
+                                rbits,gbits,bbits)                      \
+        const int thres = D[x%16][y%16];                                \
+        int r = qRed  (*p);                                             \
+        if (r <= (255-(1<<(8-rbits))) && ((r<<rbits) & 255)             \
+            > thres)                                                    \
+            r += (1<<(8-rbits));                                        \
+        int g = qGreen(*p);                                             \
+        if (g <= (255-(1<<(8-gbits))) && ((g<<gbits) & 255)             \
+            > thres)                                                    \
+            g += (1<<(8-gbits));                                        \
+        int b = qBlue (*p++);                                           \
+        if (b <= (255-(1<<(8-bbits))) && ((b<<bbits) & 255)             \
+            > thres)                                                    \
+            b += (1<<(8-bbits));                                        \
+        uint pixel = ((r red_shift) & red_mask)                         \
+                     | ((g green_shift) & green_mask)                   \
+                     | ((b blue_shift) & blue_mask);
+
+#define CYCLE(body)                                             \
+        for (int y=0; y<h; y++) {                               \
+            const uchar* src = cimage.scanLine(y);              \
+            uchar* dst = newbits + xi->bytes_per_line*y;        \
+            const QRgb* p = (const QRgb *)src;                  \
+            body                                                \
+                }
+
+        if (dither_tc) {
+            switch (mode) {
+            case BPP16_565:
+                CYCLE(
+                    quint16* dst16 = (quint16*)dst;
+                    for (int x=0; x<w; x++) {
+                        GET_PIXEL_DITHER_TC_OPT(<<8,<<3,>>3,0xf800,0x7e0,0x1f,5,6,5)
+                            *dst16++ = pixel;
+                    }
+                    )
+                    break;
+            case BPP16_555:
+                CYCLE(
+                    quint16* dst16 = (quint16*)dst;
+                    for (int x=0; x<w; x++) {
+                        GET_PIXEL_DITHER_TC_OPT(<<7,<<2,>>3,0x7c00,0x3e0,0x1f,5,5,5)
+                            *dst16++ = pixel;
+                    }
+                    )
+                    break;
+            case BPP16_MSB:                        // 16 bit MSB
+                CYCLE(
+                    for (int x=0; x<w; x++) {
+                        GET_PIXEL_DITHER_TC
+                            *dst++ = (pixel >> 8);
+                        *dst++ = pixel;
+                    }
+                    )
+                    break;
+            case BPP16_LSB:                        // 16 bit LSB
+                CYCLE(
+                    for (int x=0; x<w; x++) {
+                        GET_PIXEL_DITHER_TC
+                            *dst++ = pixel;
+                        *dst++ = pixel >> 8;
+                    }
+                    )
+                    break;
+            default:
+                qFatal("Logic error");
+            }
+        } else {
+            switch (mode) {
+            case BPP8:                        // 8 bit
+                CYCLE(
+                    Q_UNUSED(p);
+                    for (int x=0; x<w; x++)
+                        *dst++ = pix[*src++];
+                    )
+                    break;
+            case BPP16_565:
+                CYCLE(
+                    quint16* dst16 = (quint16*)dst;
+                    for (int x = 0; x < w; x++) {
+                        *dst16++ = ((*p >> 8) & 0xf800)
+                                   | ((*p >> 5) & 0x7e0)
+                                   | ((*p >> 3) & 0x1f);
+                        ++p;
+                    }
+                    )
+                    break;
+            case BPP16_555:
+                CYCLE(
+                    quint16* dst16 = (quint16*)dst;
+                    for (int x=0; x<w; x++) {
+                        *dst16++ = ((*p >> 9) & 0x7c00)
+                                   | ((*p >> 6) & 0x3e0)
+                                   | ((*p >> 3) & 0x1f);
+                        ++p;
+                    }
+                    )
+                    break;
+            case BPP16_MSB:                        // 16 bit MSB
+                CYCLE(
+                    for (int x=0; x<w; x++) {
+                        GET_PIXEL
+                            *dst++ = (pixel >> 8);
+                        *dst++ = pixel;
+                    }
+                    )
+                    break;
+            case BPP16_LSB:                        // 16 bit LSB
+                CYCLE(
+                    for (int x=0; x<w; x++) {
+                        GET_PIXEL
+                            *dst++ = pixel;
+                        *dst++ = pixel >> 8;
+                    }
+                    )
+                    break;
+            case BPP24_888:                        // 24 bit MSB
+                CYCLE(
+                    for (int x=0; x<w; x++) {
+                        *dst++ = qRed  (*p);
+                        *dst++ = qGreen(*p);
+                        *dst++ = qBlue (*p++);
+                    }
+                    )
+                    break;
+            case BPP24_MSB:                        // 24 bit MSB
+                CYCLE(
+                    for (int x=0; x<w; x++) {
+                        GET_PIXEL
+                            *dst++ = pixel >> 16;
+                        *dst++ = pixel >> 8;
+                        *dst++ = pixel;
+                    }
+                    )
+                    break;
+            case BPP24_LSB:                        // 24 bit LSB
+                CYCLE(
+                    for (int x=0; x<w; x++) {
+                        GET_PIXEL
+                            *dst++ = pixel;
+                        *dst++ = pixel >> 8;
+                        *dst++ = pixel >> 16;
+                    }
+                    )
+                    break;
+            case BPP32_8888:
+                CYCLE(
+                    memcpy(dst, p, w * 4);
+                    )
+                    break;
+            case BPP32_MSB:                        // 32 bit MSB
+                CYCLE(
+                    for (int x=0; x<w; x++) {
+                        GET_PIXEL
+                            *dst++ = pixel >> 24;
+                        *dst++ = pixel >> 16;
+                        *dst++ = pixel >> 8;
+                        *dst++ = pixel;
+                    }
+                    )
+                    break;
+            case BPP32_LSB:                        // 32 bit LSB
+                CYCLE(
+                    for (int x=0; x<w; x++) {
+                        GET_PIXEL
+                            *dst++ = pixel;
+                        *dst++ = pixel >> 8;
+                        *dst++ = pixel >> 16;
+                        *dst++ = pixel >> 24;
+                    }
+                    )
+                    break;
+            default:
+                qFatal("Logic error 2");
+            }
+        }
+        xi->data = (char *)newbits;
+    }
+
+    if (d == 8 && !trucol) {                        // 8 bit pixmap
+        int  pop[256];                                // pixel popularity
+
+        if (image.numColors() == 0)
+            image.setNumColors(1);
+
+        const QImage &cimage = image;
+        memset(pop, 0, sizeof(int)*256);        // reset popularity array
+        for (int i = 0; i < h; i++) {                        // for each scanline...
+            const uchar* p = cimage.scanLine(i);
+            const uchar *end = p + w;
+            while (p < end)                        // compute popularity
+                pop[*p++]++;
+        }
+
+        newbits = (uchar *)malloc(nbytes);        // copy image into newbits
+        Q_CHECK_PTR(newbits);
+        if (!newbits)                                // no memory
+            return;
+        uchar* p = newbits;
+        memcpy(p, cimage.bits(), nbytes);        // copy image data into newbits
+
+        /*
+         * The code below picks the most important colors. It is based on the
+         * diversity algorithm, implemented in XV 3.10. XV is (C) by John Bradley.
+         */
+
+        struct PIX {                                // pixel sort element
+            uchar r,g,b,n;                        // color + pad
+            int          use;                                // popularity
+            int          index;                        // index in colormap
+            int          mindist;
+        };
+        int ncols = 0;
+        for (int i=0; i< cimage.numColors(); i++) { // compute number of colors
+            if (pop[i] > 0)
+                ncols++;
+        }
+        for (int i = cimage.numColors(); i < 256; i++) // ignore out-of-range pixels
+            pop[i] = 0;
+
+        // works since we make sure above to have at least
+        // one color in the image
+        if (ncols == 0)
+            ncols = 1;
+
+        PIX pixarr[256];                        // pixel array
+        PIX pixarr_sorted[256];                        // pixel array (sorted)
+        memset(pixarr, 0, ncols*sizeof(PIX));
+        PIX *px                   = &pixarr[0];
+        int  maxpop = 0;
+        int  maxpix = 0;
+        uint j = 0;
+        QVector<QRgb> ctable = cimage.colorTable();
+        for (int i = 0; i < 256; i++) {                // init pixel array
+            if (pop[i] > 0) {
+                px->r = qRed  (ctable[i]);
+                px->g = qGreen(ctable[i]);
+                px->b = qBlue (ctable[i]);
+                px->n = 0;
+                px->use = pop[i];
+                if (pop[i] > maxpop) {        // select most popular entry
+                    maxpop = pop[i];
+                    maxpix = j;
+                }
+                px->index = i;
+                px->mindist = 1000000;
+                px++;
+                j++;
+            }
+        }
+        pixarr_sorted[0] = pixarr[maxpix];
+        pixarr[maxpix].use = 0;
+
+        for (int i = 1; i < ncols; i++) {                // sort pixels
+            int minpix = -1, mindist = -1;
+            px = &pixarr_sorted[i-1];
+            int r = px->r;
+            int g = px->g;
+            int b = px->b;
+            int dist;
+            if ((i & 1) || i<10) {                // sort on max distance
+                for (int j=0; j<ncols; j++) {
+                    px = &pixarr[j];
+                    if (px->use) {
+                        dist = (px->r - r)*(px->r - r) +
+                               (px->g - g)*(px->g - g) +
+                               (px->b - b)*(px->b - b);
+                        if (px->mindist > dist)
+                            px->mindist = dist;
+                        if (px->mindist > mindist) {
+                            mindist = px->mindist;
+                            minpix = j;
+                        }
+                    }
+                }
+            } else {                                // sort on max popularity
+                for (int j=0; j<ncols; j++) {
+                    px = &pixarr[j];
+                    if (px->use) {
+                        dist = (px->r - r)*(px->r - r) +
+                               (px->g - g)*(px->g - g) +
+                               (px->b - b)*(px->b - b);
+                        if (px->mindist > dist)
+                            px->mindist = dist;
+                        if (px->use > mindist) {
+                            mindist = px->use;
+                            minpix = j;
+                        }
+                    }
+                }
+            }
+            pixarr_sorted[i] = pixarr[minpix];
+            pixarr[minpix].use = 0;
+        }
+
+        QColormap cmap = QColormap::instance(xinfo.screen());
+        uint pix[256];                                // pixel translation table
+        px = &pixarr_sorted[0];
+        for (int i = 0; i < ncols; i++) {                // allocate colors
+            QColor c(px->r, px->g, px->b);
+            pix[px->index] = cmap.pixel(c);
+            px++;
+        }
+
+        p = newbits;
+        for (int i = 0; i < nbytes; i++) {                // translate pixels
+            *p = pix[*p];
+            p++;
+        }
+    }
+
+    if (!xi) {                                // X image not created
+        xi = XCreateImage(dpy, visual, dd, ZPixmap, 0, 0, w, h, 32, 0);
+        if (xi->bits_per_pixel == 16) {        // convert 8 bpp ==> 16 bpp
+            ushort *p2;
+            int            p2inc = xi->bytes_per_line/sizeof(ushort);
+            ushort *newerbits = (ushort *)malloc(xi->bytes_per_line * h);
+            Q_CHECK_PTR(newerbits);
+            if (!newerbits)                                // no memory
+                return;
+            uchar* p = newbits;
+            for (int y = 0; y < h; y++) {                // OOPS: Do right byte order!!
+                p2 = newerbits + p2inc*y;
+                for (int x = 0; x < w; x++)
+                    *p2++ = *p++;
+            }
+            free(newbits);
+            newbits = (uchar *)newerbits;
+        } else if (xi->bits_per_pixel != 8) {
+            qWarning("QPixmap::fromImage: Display not supported "
+                     "(bpp=%d)", xi->bits_per_pixel);
+        }
+        xi->data = (char *)newbits;
+    }
+
+    hd = (Qt::HANDLE)XCreatePixmap(X11->display,
+                                   RootWindow(X11->display, xinfo.screen()),
+                                   w, h, dd);
+
+    GC gc = XCreateGC(dpy, hd, 0, 0);
+    XPutImage(dpy, hd, gc, xi, 0, 0, 0, 0, w, h);
+    XFreeGC(dpy, gc);
+
+    qSafeXDestroyImage(xi);
+    d = dd;
+
+#ifndef QT_NO_XRENDER
+    if (X11->use_xrender) {
+        XRenderPictFormat *format = d == 1
+                                    ? XRenderFindStandardFormat(X11->display, PictStandardA1)
+                                    : XRenderFindVisualFormat(X11->display, (Visual *)xinfo.visual());
+        picture = XRenderCreatePicture(X11->display, hd, format, 0, 0);
+    }
+#endif
+
+    if (image.hasAlphaChannel()) {
+        QBitmap m = QBitmap::fromImage(image.createAlphaMask(flags));
+        setMask(m);
+    }
+}
+
+void QX11PixmapData::bitmapFromImage(const QImage &image)
+{
+    QImage img = image.convertToFormat(QImage::Format_MonoLSB);
+    const QRgb c0 = QColor(Qt::black).rgb();
+    const QRgb c1 = QColor(Qt::white).rgb();
+    if (img.color(0) == c0 && img.color(1) == c1) {
+        img.invertPixels();
+        img.setColor(0, c1);
+        img.setColor(1, c0);
+    }
+
+    char  *bits;
+    uchar *tmp_bits;
+    w = img.width();
+    h = img.height();
+    d = 1;
+    int bpl = (w + 7) / 8;
+    int ibpl = img.bytesPerLine();
+    if (bpl != ibpl) {
+        tmp_bits = new uchar[bpl*h];
+        bits = (char *)tmp_bits;
+        uchar *p, *b;
+        int y;
+        b = tmp_bits;
+        p = img.scanLine(0);
+        for (y = 0; y < h; y++) {
+            memcpy(b, p, bpl);
+            b += bpl;
+            p += ibpl;
+        }
+    } else {
+        bits = (char *)img.bits();
+        tmp_bits = 0;
+    }
+    hd = (Qt::HANDLE)XCreateBitmapFromData(xinfo.display(),
+                                           RootWindow(xinfo.display(), xinfo.screen()),
+                                           bits, w, h);
+
+#ifndef QT_NO_XRENDER
+    if (X11->use_xrender)
+        picture = XRenderCreatePicture(X11->display, hd,
+                                       XRenderFindStandardFormat(X11->display, PictStandardA1), 0, 0);
+#endif // QT_NO_XRENDER
+
+    if (tmp_bits)                                // Avoid purify complaint
+        delete [] tmp_bits;
+}
+
+void QX11PixmapData::fill(const QColor &fillColor)
+{
+    if (fillColor.alpha() != 255) {
+#ifndef QT_NO_XRENDER
+        if (X11->use_xrender) {
+            if (!picture || d != 32)
+                convertToARGB32(/*preserveContents = */false);
+
+            ::Picture src  = X11->getSolidFill(xinfo.screen(), fillColor);
+            XRenderComposite(X11->display, PictOpSrc, src, 0, picture,
+                             0, 0, width(), height(),
+                             0, 0, width(), height());
+        } else
+#endif
+        {
+            QImage im(width(), height(), QImage::Format_ARGB32_Premultiplied);
+            im.fill(PREMUL(fillColor.rgba()));
+            release();
+            fromImage(im, Qt::AutoColor | Qt::OrderedAlphaDither);
+        }
+        return;
+    }
+
+    GC gc = XCreateGC(X11->display, hd, 0, 0);
+    if (depth() == 1) {
+        XSetForeground(X11->display, gc, qGray(fillColor.rgb()) > 127 ? 0 : 1);
+    } else if (X11->use_xrender && d >= 24) {
+        XSetForeground(X11->display, gc, fillColor.rgba());
+    } else {
+        XSetForeground(X11->display, gc,
+                       QColormap::instance(xinfo.screen()).pixel(fillColor));
+    }
+    XFillRectangle(X11->display, hd, gc, 0, 0, width(), height());
+    XFreeGC(X11->display, gc);
+}
+
+QX11PixmapData::~QX11PixmapData()
+{
+    release();
+}
+
+void QX11PixmapData::release()
+{
+    delete pengine;
+    pengine = 0;
+
+    if (!X11)
+        return;
+
+    if (x11_mask) {
+#ifndef QT_NO_XRENDER
+        if (mask_picture)
+            XRenderFreePicture(X11->display, mask_picture);
+        mask_picture = 0;
+#endif
+        XFreePixmap(X11->display, x11_mask);
+        x11_mask = 0;
+    }
+
+    if (hd) {
+#ifndef QT_NO_XRENDER
+        if (picture) {
+            XRenderFreePicture(X11->display, picture);
+            picture = 0;
+        }
+#endif // QT_NO_XRENDER
+
+        if (hd2) {
+            XFreePixmap(xinfo.display(), hd2);
+            hd2 = 0;
+        }
+        if (!read_only)
+            XFreePixmap(xinfo.display(), hd);
+        hd = 0;
+    }
+}
+
+QPixmap QX11PixmapData::alphaChannel() const
+{
+    if (!hasAlphaChannel())
+        return QPixmap();
+    QImage im(toImage());
+    return QPixmap::fromImage(im.alphaChannel(), Qt::OrderedDither);
+}
+
+void QX11PixmapData::setAlphaChannel(const QPixmap &alpha)
+{
+    QImage image(toImage());
+    image.setAlphaChannel(alpha.toImage());
+    release();
+    fromImage(image, Qt::OrderedDither | Qt::OrderedAlphaDither);
+}
+
+
+QBitmap QX11PixmapData::mask() const
+{
+    QBitmap mask;
+#ifndef QT_NO_XRENDER
+    if (picture && d == 32) {
+        // #### slow - there must be a better way..
+        mask = QBitmap::fromImage(toImage().createAlphaMask());
+    } else
+#endif
+    if (d == 1) {
+        QX11PixmapData *that = const_cast<QX11PixmapData*>(this);
+        mask = QPixmap(that);
+    } else {
+        mask = mask_to_bitmap(xinfo.screen());
+    }
+    return mask;
+}
+
+
+/*!
+    Sets a mask bitmap.
+
+    The \a newmask bitmap defines the clip mask for this pixmap. Every
+    pixel in \a newmask corresponds to a pixel in this pixmap. Pixel
+    value 1 means opaque and pixel value 0 means transparent. The mask
+    must have the same size as this pixmap.
+
+    \warning Setting the mask on a pixmap will cause any alpha channel
+    data to be cleared. For example:
+    \snippet doc/src/snippets/image/image.cpp 2
+    Now, alpha and alphacopy are visually different.
+
+    Setting a null mask resets the mask.
+
+    The effect of this function is undefined when the pixmap is being
+    painted on.
+
+    \sa mask(), {QPixmap#Pixmap Transformations}{Pixmap
+    Transformations}, QBitmap
+*/
+void QX11PixmapData::setMask(const QBitmap &newmask)
+{
+    if (newmask.isNull()) { // clear mask
+#ifndef QT_NO_XRENDER
+        if (picture && d == 32) {
+            QX11PixmapData newData(pixelType());
+            newData.resize(w, h);
+            newData.fill(Qt::black);
+            XRenderComposite(X11->display, PictOpOver,
+                             picture, 0, newData.picture,
+                             0, 0, 0, 0, 0, 0, w, h);
+            release();
+            *this = newData;
+            newData.hd = 0;
+            newData.x11_mask = 0;
+            newData.picture = 0;
+            newData.mask_picture = 0;
+            newData.hd2 = 0;
+        } else
+#endif
+            if (x11_mask) {
+#ifndef QT_NO_XRENDER
+                if (picture) {
+                    XRenderPictureAttributes attrs;
+                    attrs.alpha_map = 0;
+                    XRenderChangePicture(X11->display, picture, CPAlphaMap,
+                                         &attrs);
+                }
+                if (mask_picture)
+                    XRenderFreePicture(X11->display, mask_picture);
+                mask_picture = 0;
+#endif
+                XFreePixmap(X11->display, x11_mask);
+                x11_mask = 0;
+            }
+        return;
+    }
+
+#ifndef QT_NO_XRENDER
+    if (picture && d == 32) {
+        XRenderComposite(X11->display, PictOpSrc,
+                         picture, newmask.x11PictureHandle(),
+                         picture, 0, 0, 0, 0, 0, 0, w, h);
+    } else
+#endif
+        if (depth() == 1) {
+            XGCValues vals;
+            vals.function = GXand;
+            GC gc = XCreateGC(X11->display, hd, GCFunction, &vals);
+            XCopyArea(X11->display, newmask.handle(), hd, gc, 0, 0,
+                      width(), height(), 0, 0);
+            XFreeGC(X11->display, gc);
+        } else {
+            // ##### should or the masks together
+            if (x11_mask) {
+                XFreePixmap(X11->display, x11_mask);
+#ifndef QT_NO_XRENDER
+                if (mask_picture)
+                    XRenderFreePicture(X11->display, mask_picture);
+#endif
+            }
+            x11_mask = QX11PixmapData::bitmap_to_mask(newmask, xinfo.screen());
+#ifndef QT_NO_XRENDER
+            if (picture) {
+                mask_picture = XRenderCreatePicture(X11->display, x11_mask,
+                                                    XRenderFindStandardFormat(X11->display, PictStandardA1), 0, 0);
+                XRenderPictureAttributes attrs;
+                attrs.alpha_map = mask_picture;
+                XRenderChangePicture(X11->display, picture, CPAlphaMap, &attrs);
+            }
+#endif
+        }
+}
+
+int QX11PixmapData::metric(QPaintDevice::PaintDeviceMetric metric) const
+{
+    switch (metric) {
+    case QPaintDevice::PdmWidth:
+        return w;
+    case QPaintDevice::PdmHeight:
+        return h;
+    case QPaintDevice::PdmNumColors:
+        return 1 << d;
+    case QPaintDevice::PdmDepth:
+        return d;
+    case QPaintDevice::PdmWidthMM: {
+        const int screen = xinfo.screen();
+        const int mm = DisplayWidthMM(X11->display, screen) * w
+                       / DisplayWidth(X11->display, screen);
+        return mm;
+    }
+    case QPaintDevice::PdmHeightMM: {
+        const int screen = xinfo.screen();
+        const int mm = (DisplayHeightMM(X11->display, screen) * h)
+                       / DisplayHeight(X11->display, screen);
+        return mm;
+    }
+    case QPaintDevice::PdmDpiX:
+    case QPaintDevice::PdmPhysicalDpiX:
+        return QX11Info::appDpiX(xinfo.screen());
+    case QPaintDevice::PdmDpiY:
+    case QPaintDevice::PdmPhysicalDpiY:
+        return QX11Info::appDpiY(xinfo.screen());
+    default:
+        qWarning("QX11PixmapData::metric(): Invalid metric");
+        return 0;
+    }
+}
+
+/*!
+    Converts the pixmap to a QImage. Returns a null image if the
+    conversion fails.
+
+    If the pixmap has 1-bit depth, the returned image will also be 1
+    bit deep. If the pixmap has 2- to 8-bit depth, the returned image
+    has 8-bit depth. If the pixmap has greater than 8-bit depth, the
+    returned image has 32-bit depth.
+
+    Note that for the moment, alpha masks on monochrome images are
+    ignored.
+
+    \sa fromImage(), {QImage#Image Formats}{Image Formats}
+*/
+
+QImage QX11PixmapData::toImage() const
+{
+    int d = depth();
+    Visual *visual = (Visual *)xinfo.visual();
+    bool trucol = (visual->c_class >= TrueColor) && d > 1;
+
+    QImage::Format format = QImage::Format_Mono;
+    if (d > 1 && d <= 8) {
+        d = 8;
+        format = QImage::Format_Indexed8;
+    }
+    // we could run into the situation where d == 8 AND trucol is true, which can
+    // cause problems when converting to and from images.  in this case, always treat
+    // the depth as 32...
+    if (d > 8 || trucol) {
+        d = 32;
+        format = QImage::Format_RGB32;
+    }
+
+    XImage *xi = XGetImage(X11->display, hd, 0, 0, w, h, AllPlanes,
+                           (d == 1) ? XYPixmap : ZPixmap);
+
+    Q_CHECK_PTR(xi);
+    if (!xi)
+        return QImage();
+
+    if (picture && depth() == 32) {
+        QImage image(w, h, QImage::Format_ARGB32_Premultiplied);
+        memcpy(image.bits(), xi->data, xi->bytes_per_line * xi->height);
+
+        // we may have to swap the byte order
+        if ((QSysInfo::ByteOrder == QSysInfo::LittleEndian && xi->byte_order == MSBFirst)
+            || (QSysInfo::ByteOrder == QSysInfo::BigEndian))
+        {
+            for (int i=0; i < image.height(); i++) {
+                uint *p = (uint*)image.scanLine(i);
+                uint *end = p + image.width();
+                if ((xi->byte_order == LSBFirst && QSysInfo::ByteOrder == QSysInfo::BigEndian)
+                    || (xi->byte_order == MSBFirst && QSysInfo::ByteOrder == QSysInfo::LittleEndian)) {
+                    while (p < end) {
+                        *p = ((*p << 24) & 0xff000000) | ((*p << 8) & 0x00ff0000)
+                             | ((*p >> 8) & 0x0000ff00) | ((*p >> 24) & 0x000000ff);
+                        p++;
+                    }
+                } else if (xi->byte_order == MSBFirst && QSysInfo::ByteOrder == QSysInfo::BigEndian) {
+                    while (p < end) {
+                        *p = ((*p << 16) & 0x00ff0000) | ((*p >> 16) & 0x000000ff)
+                             | ((*p ) & 0xff00ff00);
+                        p++;
+                    }
+                }
+            }
+        }
+
+        // throw away image data
+        qSafeXDestroyImage(xi);
+
+        return image;
+    }
+
+    if (d == 1 && xi->bitmap_bit_order == LSBFirst)
+        format = QImage::Format_MonoLSB;
+    if (x11_mask && format == QImage::Format_RGB32)
+        format = QImage::Format_ARGB32;
+
+    QImage image(w, h, format);
+    if (image.isNull())                        // could not create image
+        return image;
+
+    QImage alpha;
+    if (x11_mask) {
+        alpha = mask().toImage();
+    }
+    bool ale = alpha.format() == QImage::Format_MonoLSB;
+
+    if (trucol) {                                // truecolor
+        const uint red_mask = (uint)visual->red_mask;
+        const uint green_mask = (uint)visual->green_mask;
+        const uint blue_mask = (uint)visual->blue_mask;
+        const int  red_shift = highest_bit(red_mask) - 7;
+        const int  green_shift = highest_bit(green_mask) - 7;
+        const int  blue_shift = highest_bit(blue_mask) - 7;
+
+        const uint red_bits = n_bits(red_mask);
+        const uint green_bits = n_bits(green_mask);
+        const uint blue_bits = n_bits(blue_mask);
+
+        static uint red_table_bits = 0;
+        static uint green_table_bits = 0;
+        static uint blue_table_bits = 0;
+
+        if (red_bits < 8 && red_table_bits != red_bits) {
+            build_scale_table(&red_scale_table, red_bits);
+            red_table_bits = red_bits;
+        }
+        if (blue_bits < 8 && blue_table_bits != blue_bits) {
+            build_scale_table(&blue_scale_table, blue_bits);
+            blue_table_bits = blue_bits;
+        }
+        if (green_bits < 8 && green_table_bits != green_bits) {
+            build_scale_table(&green_scale_table, green_bits);
+            green_table_bits = green_bits;
+        }
+
+        int  r, g, b;
+
+        QRgb *dst;
+        uchar *src;
+        uint pixel;
+        int bppc = xi->bits_per_pixel;
+
+        if (bppc > 8 && xi->byte_order == LSBFirst)
+            bppc++;
+
+        for (int y = 0; y < h; ++y) {
+            uchar* asrc = x11_mask ? alpha.scanLine(y) : 0;
+            dst = (QRgb *)image.scanLine(y);
+            src = (uchar *)xi->data + xi->bytes_per_line*y;
+            for (int x = 0; x < w; x++) {
+                switch (bppc) {
+                case 8:
+                    pixel = *src++;
+                    break;
+                case 16:                        // 16 bit MSB
+                    pixel = src[1] | (uint)src[0] << 8;
+                    src += 2;
+                    break;
+                case 17:                        // 16 bit LSB
+                    pixel = src[0] | (uint)src[1] << 8;
+                    src += 2;
+                    break;
+                case 24:                        // 24 bit MSB
+                    pixel = src[2] | (uint)src[1] << 8 | (uint)src[0] << 16;
+                    src += 3;
+                    break;
+                case 25:                        // 24 bit LSB
+                    pixel = src[0] | (uint)src[1] << 8 | (uint)src[2] << 16;
+                    src += 3;
+                    break;
+                case 32:                        // 32 bit MSB
+                    pixel = src[3] | (uint)src[2] << 8 | (uint)src[1] << 16 | (uint)src[0] << 24;
+                    src += 4;
+                    break;
+                case 33:                        // 32 bit LSB
+                    pixel = src[0] | (uint)src[1] << 8 | (uint)src[2] << 16 | (uint)src[3] << 24;
+                    src += 4;
+                    break;
+                default:                        // should not really happen
+                    x = w;                        // leave loop
+                    y = h;
+                    pixel = 0;                // eliminate compiler warning
+                    qWarning("QPixmap::convertToImage: Invalid depth %d", bppc);
+                }
+                if (red_shift > 0)
+                    r = (pixel & red_mask) >> red_shift;
+                else
+                    r = (pixel & red_mask) << -red_shift;
+                if (green_shift > 0)
+                    g = (pixel & green_mask) >> green_shift;
+                else
+                    g = (pixel & green_mask) << -green_shift;
+                if (blue_shift > 0)
+                    b = (pixel & blue_mask) >> blue_shift;
+                else
+                    b = (pixel & blue_mask) << -blue_shift;
+
+                if (red_bits < 8)
+                    r = red_scale_table[r];
+                if (green_bits < 8)
+                    g = green_scale_table[g];
+                if (blue_bits < 8)
+                    b = blue_scale_table[b];
+
+                if (x11_mask) {
+                    if (ale) {
+                        *dst++ = (asrc[x >> 3] & (1 << (x & 7))) ? qRgba(r, g, b, 0xff) : 0;
+                    } else {
+                        *dst++ = (asrc[x >> 3] & (0x80 >> (x & 7))) ? qRgba(r, g, b, 0xff) : 0;
+                    }
+                } else {
+                    *dst++ = qRgb(r, g, b);
+                }
+            }
+        }
+    } else if (xi->bits_per_pixel == d) {        // compatible depth
+        char *xidata = xi->data;                // copy each scanline
+        int bpl = qMin(image.bytesPerLine(),xi->bytes_per_line);
+        for (int y=0; y<h; y++) {
+            memcpy(image.scanLine(y), xidata, bpl);
+            xidata += xi->bytes_per_line;
+        }
+    } else {
+        /* Typically 2 or 4 bits display depth */
+        qWarning("QPixmap::convertToImage: Display not supported (bpp=%d)",
+                 xi->bits_per_pixel);
+        return QImage();
+    }
+
+    if (d == 1) {                                // bitmap
+        image.setNumColors(2);
+        image.setColor(0, qRgb(255,255,255));
+        image.setColor(1, qRgb(0,0,0));
+    } else if (!trucol) {                        // pixmap with colormap
+        register uchar *p;
+        uchar *end;
+        uchar  use[256];                        // pixel-in-use table
+        uchar  pix[256];                        // pixel translation table
+        int    ncols, bpl;
+        memset(use, 0, 256);
+        memset(pix, 0, 256);
+        bpl = image.bytesPerLine();
+
+        if (x11_mask) {                         // which pixels are used?
+            for (int i = 0; i < h; i++) {
+                uchar* asrc = alpha.scanLine(i);
+                p = image.scanLine(i);
+                if (ale) {
+                    for (int x = 0; x < w; x++) {
+                        if (asrc[x >> 3] & (1 << (x & 7)))
+                            use[*p] = 1;
+                        ++p;
+                    }
+                } else {
+                    for (int x = 0; x < w; x++) {
+                        if (asrc[x >> 3] & (0x80 >> (x & 7)))
+                            use[*p] = 1;
+                        ++p;
+                    }
+                }
+            }
+        } else {
+            for (int i = 0; i < h; i++) {
+                p = image.scanLine(i);
+                end = p + bpl;
+                while (p < end)
+                    use[*p++] = 1;
+            }
+        }
+        ncols = 0;
+        for (int i = 0; i < 256; i++) {                // build translation table
+            if (use[i])
+                pix[i] = ncols++;
+        }
+        for (int i = 0; i < h; i++) {                        // translate pixels
+            p = image.scanLine(i);
+            end = p + bpl;
+            while (p < end) {
+                *p = pix[*p];
+                p++;
+            }
+        }
+        if (x11_mask) {
+            int trans;
+            if (ncols < 256) {
+                trans = ncols++;
+                image.setNumColors(ncols);        // create color table
+                image.setColor(trans, 0x00000000);
+            } else {
+                image.setNumColors(ncols);        // create color table
+                // oh dear... no spare "transparent" pixel.
+                // use first pixel in image (as good as any).
+                trans = image.scanLine(0)[0];
+            }
+            for (int i = 0; i < h; i++) {
+                uchar* asrc = alpha.scanLine(i);
+                p = image.scanLine(i);
+                if (ale) {
+                    for (int x = 0; x < w; x++) {
+                        if (!(asrc[x >> 3] & (1 << (x & 7))))
+                            *p = trans;
+                        ++p;
+                    }
+                } else {
+                    for (int x = 0; x < w; x++) {
+                        if (!(asrc[x >> 3] & (1 << (7 -(x & 7)))))
+                            *p = trans;
+                        ++p;
+                    }
+                }
+            }
+        } else {
+            image.setNumColors(ncols);        // create color table
+        }
+        QVector<QColor> colors = QColormap::instance(xinfo.screen()).colormap();
+        int j = 0;
+        for (int i=0; i<colors.size(); i++) {                // translate pixels
+            if (use[i])
+                image.setColor(j++, 0xff000000 | colors.at(i).rgb());
+        }
+    }
+
+    qSafeXDestroyImage(xi);
+
+    return image;
+}
+
+/*!
+    Returns a copy of the pixmap that is transformed using the given
+    transformation \a matrix and transformation \a mode. The original
+    pixmap is not changed.
+
+    The transformation \a matrix is internally adjusted to compensate
+    for unwanted translation; i.e. the pixmap produced is the smallest
+    pixmap that contains all the transformed points of the original
+    pixmap. Use the trueMatrix() function to retrieve the actual
+    matrix used for transforming the pixmap.
+
+    This function is slow because it involves transformation to a
+    QImage, non-trivial computations and a transformation back to a
+    QPixmap.
+
+    \sa trueMatrix(), {QPixmap#Pixmap Transformations}{Pixmap
+    Transformations}
+*/
+QPixmap QX11PixmapData::transformed(const QTransform &transform,
+                                    Qt::TransformationMode mode ) const
+{
+    if (mode == Qt::SmoothTransformation || transform.type() >= QTransform::TxProject) {
+        QImage image = toImage();
+        return QPixmap::fromImage(image.transformed(transform, mode));
+    }
+
+    uint   w = 0;
+    uint   h = 0;                               // size of target pixmap
+    uint   ws, hs;                              // size of source pixmap
+    uchar *dptr;                                // data in target pixmap
+    uint   dbpl, dbytes;                        // bytes per line/bytes total
+    uchar *sptr;                                // data in original pixmap
+    int    sbpl;                                // bytes per line in original
+    int    bpp;                                 // bits per pixel
+    bool   depth1 = depth() == 1;
+    Display *dpy = X11->display;
+
+    ws = width();
+    hs = height();
+
+    QTransform mat(transform.m11(), transform.m12(), transform.m13(),
+                   transform.m21(), transform.m22(), transform.m23(),
+                   0., 0., 1);
+    bool complex_xform = false;
+    qreal scaledWidth;
+    qreal scaledHeight;
+
+    if (mat.type() <= QTransform::TxScale) {
+        scaledHeight = qAbs(mat.m22()) * hs + 0.9999;
+        scaledWidth = qAbs(mat.m11()) * ws + 0.9999;
+        h = qAbs(int(scaledHeight));
+        w = qAbs(int(scaledWidth));
+    } else {                                        // rotation or shearing
+        QPolygonF a(QRectF(0, 0, ws, hs));
+        a = mat.map(a);
+        QRect r = a.boundingRect().toAlignedRect();
+        w = r.width();
+        h = r.height();
+        scaledWidth = w;
+        scaledHeight = h;
+        complex_xform = true;
+    }
+    mat = QPixmap::trueMatrix(mat, ws, hs); // true matrix
+
+    bool invertible;
+    mat = mat.inverted(&invertible);  // invert matrix
+
+    if (h == 0 || w == 0 || !invertible
+        || qAbs(scaledWidth) >= 32768 || qAbs(scaledHeight) >= 32768 )
+	// error, return null pixmap
+        return QPixmap();
+
+#if defined(QT_MITSHM)
+    static bool try_once = true;
+    if (try_once) {
+        try_once = false;
+        if (!xshminit)
+            qt_create_mitshm_buffer(this, 800, 600);
+    }
+
+    bool use_mitshm = xshmimg && !depth1 &&
+                      xshmimg->width >= w && xshmimg->height >= h;
+#endif
+    XImage *xi = XGetImage(X11->display, handle(), 0, 0, ws, hs, AllPlanes,
+                           depth1 ? XYPixmap : ZPixmap);
+
+    if (!xi)
+        return QPixmap();
+
+    sbpl = xi->bytes_per_line;
+    sptr = (uchar *)xi->data;
+    bpp         = xi->bits_per_pixel;
+
+    if (depth1)
+        dbpl = (w+7)/8;
+    else
+        dbpl = ((w*bpp+31)/32)*4;
+    dbytes = dbpl*h;
+
+#if defined(QT_MITSHM)
+    if (use_mitshm) {
+        dptr = (uchar *)xshmimg->data;
+        uchar fillbyte = bpp == 8 ? white.pixel() : 0xff;
+        for (int y=0; y<h; y++)
+            memset(dptr + y*xshmimg->bytes_per_line, fillbyte, dbpl);
+    } else {
+#endif
+        dptr = (uchar *)malloc(dbytes);        // create buffer for bits
+        Q_CHECK_PTR(dptr);
+        if (depth1)                                // fill with zeros
+            memset(dptr, 0, dbytes);
+        else if (bpp == 8)                        // fill with background color
+            memset(dptr, WhitePixel(X11->display, xinfo.screen()), dbytes);
+        else
+            memset(dptr, 0, dbytes);
+#if defined(QT_MITSHM)
+    }
+#endif
+
+    // #define QT_DEBUG_XIMAGE
+#if defined(QT_DEBUG_XIMAGE)
+    qDebug("----IMAGE--INFO--------------");
+    qDebug("width............. %d", xi->width);
+    qDebug("height............ %d", xi->height);
+    qDebug("xoffset........... %d", xi->xoffset);
+    qDebug("format............ %d", xi->format);
+    qDebug("byte order........ %d", xi->byte_order);
+    qDebug("bitmap unit....... %d", xi->bitmap_unit);
+    qDebug("bitmap bit order.. %d", xi->bitmap_bit_order);
+    qDebug("depth............. %d", xi->depth);
+    qDebug("bytes per line.... %d", xi->bytes_per_line);
+    qDebug("bits per pixel.... %d", xi->bits_per_pixel);
+#endif
+
+    int type;
+    if (xi->bitmap_bit_order == MSBFirst)
+        type = QT_XFORM_TYPE_MSBFIRST;
+    else
+        type = QT_XFORM_TYPE_LSBFIRST;
+    int        xbpl, p_inc;
+    if (depth1) {
+        xbpl  = (w+7)/8;
+        p_inc = dbpl - xbpl;
+    } else {
+        xbpl  = (w*bpp)/8;
+        p_inc = dbpl - xbpl;
+#if defined(QT_MITSHM)
+        if (use_mitshm)
+            p_inc = xshmimg->bytes_per_line - xbpl;
+#endif
+    }
+
+    if (!qt_xForm_helper(mat, xi->xoffset, type, bpp, dptr, xbpl, p_inc, h, sptr, sbpl, ws, hs)){
+        qWarning("QPixmap::transform: display not supported (bpp=%d)",bpp);
+        QPixmap pm;
+        return pm;
+    }
+
+    qSafeXDestroyImage(xi);
+
+    if (depth1) {                                // mono bitmap
+        QBitmap bm = QBitmap::fromData(QSize(w, h), dptr,
+                                       BitmapBitOrder(X11->display) == MSBFirst
+                                       ? QImage::Format_Mono
+                                       : QImage::Format_MonoLSB);
+        free(dptr);
+        return bm;
+    } else {                                        // color pixmap
+        QPixmap pm;
+        QX11PixmapData *x11Data = static_cast<QX11PixmapData*>(pm.data);
+        x11Data->uninit = false;
+        x11Data->xinfo = xinfo;
+        x11Data->d = d;
+        x11Data->w = w;
+        x11Data->h = h;
+        x11Data->hd = (Qt::HANDLE)XCreatePixmap(X11->display,
+                                                RootWindow(X11->display, xinfo.screen()),
+                                                w, h, d);
+#ifndef QT_NO_XRENDER
+        if (X11->use_xrender) {
+            XRenderPictFormat *format = x11Data->d == 32
+                                        ? XRenderFindStandardFormat(X11->display, PictStandardARGB32)
+                                        : XRenderFindVisualFormat(X11->display, (Visual *) x11Data->xinfo.visual());
+            x11Data->picture = XRenderCreatePicture(X11->display, x11Data->hd, format, 0, 0);
+        }
+#endif // QT_NO_XRENDER
+
+        GC gc = XCreateGC(X11->display, x11Data->hd, 0, 0);
+#if defined(QT_MITSHM)
+        if (use_mitshm) {
+            XCopyArea(dpy, xshmpm, x11Data->hd, gc, 0, 0, w, h, 0, 0);
+        } else
+#endif
+        {
+            xi = XCreateImage(dpy, (Visual*)x11Data->xinfo.visual(),
+                              x11Data->d,
+                              ZPixmap, 0, (char *)dptr, w, h, 32, 0);
+            XPutImage(dpy, pm.handle(), gc, xi, 0, 0, 0, 0, w, h);
+            qSafeXDestroyImage(xi);
+        }
+        XFreeGC(X11->display, gc);
+
+        if (x11_mask) { // xform mask, too
+            pm.setMask(mask_to_bitmap(xinfo.screen()).transformed(transform));
+        } else if (d != 32 && complex_xform) { // need a mask!
+            QBitmap mask(ws, hs);
+            mask.fill(Qt::color1);
+            pm.setMask(mask.transformed(transform));
+        }
+        return pm;
+    }
+}
+
+/*!
+  \internal
+*/
+int QPixmap::x11SetDefaultScreen(int screen)
+{
+    int old = defaultScreen;
+    defaultScreen = screen;
+    return old;
+}
+
+/*!
+  \internal
+*/
+void QPixmap::x11SetScreen(int screen)
+{
+    if (paintingActive()) {
+        qWarning("QPixmap::x11SetScreen(): Cannot change screens during painting");
+        return;
+    }
+
+    if (data->classId() != QPixmapData::X11Class)
+        return;
+
+    if (screen < 0)
+        screen = QX11Info::appScreen();
+
+    QX11PixmapData *x11Data = static_cast<QX11PixmapData*>(data);
+    if (screen == x11Data->xinfo.screen())
+        return; // nothing to do
+
+    if (isNull()) {
+        QX11InfoData* xd = x11Data->xinfo.getX11Data(true);
+        xd->screen = screen;
+        xd->depth = QX11Info::appDepth(screen);
+        xd->cells = QX11Info::appCells(screen);
+        xd->colormap = QX11Info::appColormap(screen);
+        xd->defaultColormap = QX11Info::appDefaultColormap(screen);
+        xd->visual = (Visual *)QX11Info::appVisual(screen);
+        xd->defaultVisual = QX11Info::appDefaultVisual(screen);
+        x11Data->xinfo.setX11Data(xd);
+        return;
+    }
+#if 0
+    qDebug("QPixmap::x11SetScreen for %p from %d to %d. Size is %d/%d", x11Data, x11Data->xinfo.screen(), screen, width(), height());
+#endif
+
+    x11SetDefaultScreen(screen);
+    *this = qt_toX11Pixmap(toImage());
+}
+
+QPixmap QPixmap::grabWindow(WId window, int x, int y, int w, int h)
+{
+    if (w == 0 || h == 0)
+        return QPixmap();
+
+    Display *dpy = X11->display;
+    XWindowAttributes window_attr;
+    if (!XGetWindowAttributes(dpy, window, &window_attr))
+        return QPixmap();
+
+    if (w < 0)
+        w = window_attr.width - x;
+    if (h < 0)
+        h = window_attr.height - y;
+
+    // determine the screen
+    int scr;
+    for (scr = 0; scr < ScreenCount(dpy); ++scr) {
+        if (window_attr.root == RootWindow(dpy, scr))        // found it
+            break;
+    }
+    if (scr >= ScreenCount(dpy))                // sanity check
+        return QPixmap();
+
+
+    // get the depth of the root window
+    XWindowAttributes root_attr;
+    if (!XGetWindowAttributes(dpy, window_attr.root, &root_attr))
+        return QPixmap();
+
+    if (window_attr.depth == root_attr.depth) {
+        // if the depth of the specified window and the root window are the
+        // same, grab pixels from the root window (so that we get the any
+        // overlapping windows and window manager frames)
+
+        // map x and y to the root window
+        WId unused;
+        if (!XTranslateCoordinates(dpy, window, window_attr.root, x, y,
+                                   &x, &y, &unused))
+            return QPixmap();
+
+        window = window_attr.root;
+        window_attr = root_attr;
+    }
+
+    QX11PixmapData *data = new QX11PixmapData(QPixmapData::PixmapType);
+
+    void qt_x11_getX11InfoForWindow(QX11Info * xinfo, const XWindowAttributes &a);
+    qt_x11_getX11InfoForWindow(&data->xinfo,window_attr);
+
+    data->resize(w, h);
+
+    QPixmap pm(data);
+
+    data->uninit = false;
+    pm.x11SetScreen(scr);
+
+    GC gc = XCreateGC(dpy, pm.handle(), 0, 0);
+    XSetSubwindowMode(dpy, gc, IncludeInferiors);
+    XCopyArea(dpy, window, pm.handle(), gc, x, y, w, h, 0, 0);
+    XFreeGC(dpy, gc);
+
+    return pm;
+}
+
+bool QX11PixmapData::hasAlphaChannel() const
+{
+    return d == 32;
+}
+
+/*!
+    Returns information about the configuration of the X display used to display
+    the widget.
+
+    \warning This function is only available on X11.
+
+    \sa {QPixmap#Pixmap Information}{Pixmap Information}
+*/
+const QX11Info &QPixmap::x11Info() const
+{
+    if (data->classId() == QPixmapData::X11Class)
+        return static_cast<QX11PixmapData*>(data)->xinfo;
+    else {
+        static QX11Info nullX11Info;
+        return nullX11Info;
+    }
+}
+
+#if !defined(QT_NO_XRENDER)
+static XRenderPictFormat *qt_renderformat_for_depth(const QX11Info &xinfo, int depth)
+{
+    if (depth == 1)
+        return XRenderFindStandardFormat(X11->display, PictStandardA1);
+    else if (depth == 32)
+        return XRenderFindStandardFormat(X11->display, PictStandardARGB32);
+    else
+        return XRenderFindVisualFormat(X11->display, (Visual *)xinfo.visual());
+}
+#endif
+
+QPaintEngine* QX11PixmapData::paintEngine() const
+{
+    QX11PixmapData *that = const_cast<QX11PixmapData*>(this);
+
+    if (read_only && share_mode == QPixmap::ImplicitlyShared) {
+        // if someone wants to draw onto us, copy the shared contents
+        // and turn it into a fully fledged QPixmap
+        ::Pixmap hd_copy = XCreatePixmap(X11->display, RootWindow(X11->display, xinfo.screen()),
+                                         w, h, d);
+#if !defined(QT_NO_XRENDER)
+        XRenderPictFormat *format = qt_renderformat_for_depth(xinfo, d);
+        ::Picture picture_copy = XRenderCreatePicture(X11->display, hd_copy, format, 0, 0);
+
+        if (picture && d == 32) {
+            XRenderComposite(X11->display, PictOpSrc, picture, 0, picture_copy,
+                             0, 0, 0, 0, 0, 0, w, h);
+            XRenderFreePicture(X11->display, picture);
+            that->picture = picture_copy;
+        } else
+#endif
+        {
+            GC gc = XCreateGC(X11->display, hd_copy, 0, 0);
+            XCopyArea(X11->display, hd, hd_copy, gc, 0, 0, w, h, 0, 0);
+            XFreeGC(X11->display, gc);
+        }
+        that->hd = hd_copy;
+        that->read_only = false;
+    }
+
+    if (!that->pengine)
+        that->pengine = new QX11PaintEngine;
+    return that->pengine;
+}
+
+/*!
+    Returns the X11 Picture handle of the pixmap for XRender
+    support.
+
+    This function will return 0 if XRender support is not compiled
+    into Qt, if the XRender extension is not supported on the X11
+    display, or if the handle could not be created. Use of this
+    function is not portable.
+
+    \warning This function is only available on X11.
+
+    \sa {QPixmap#Pixmap Information}{Pixmap Information}
+*/
+
+Qt::HANDLE QPixmap::x11PictureHandle() const
+{
+#ifndef QT_NO_XRENDER
+    if (data->classId() == QPixmapData::X11Class)
+        return static_cast<QX11PixmapData*>(data)->picture;
+    else
+        return 0;
+#else
+    return 0;
+#endif // QT_NO_XRENDER
+}
+
+Qt::HANDLE QX11PixmapData::x11ConvertToDefaultDepth()
+{
+#ifndef QT_NO_XRENDER
+    if (d == QX11Info::appDepth() || !X11->use_xrender)
+        return hd;
+    if (!hd2) {
+        hd2 = XCreatePixmap(xinfo.display(), hd, w, h, QX11Info::appDepth());
+        XRenderPictFormat *format = XRenderFindVisualFormat(xinfo.display(),
+                                                            (Visual*) xinfo.visual());
+        Picture pic = XRenderCreatePicture(xinfo.display(), hd2, format, 0, 0);
+        XRenderComposite(xinfo.display(), PictOpSrc, picture,
+                         XNone, pic, 0, 0, 0, 0, 0, 0, w, h);
+        XRenderFreePicture(xinfo.display(), pic);
+    }
+    return hd2;
+#else
+    return hd;
+#endif
+}
+
+void QX11PixmapData::copy(const QPixmapData *data, const QRect &rect)
+{
+    if (data->pixelType() == BitmapType) {
+        fromImage(data->toImage().copy(rect), Qt::AutoColor);
+        return;
+    }
+
+    const QX11PixmapData *x11Data = static_cast<const QX11PixmapData*>(data);
+
+    setSerialNumber(++qt_pixmap_serial);
+
+    uninit = false;
+    xinfo = x11Data->xinfo;
+    d = x11Data->d;
+    w = rect.width();
+    h = rect.height();
+    hd = (Qt::HANDLE)XCreatePixmap(X11->display,
+                                   RootWindow(X11->display, x11Data->xinfo.screen()),
+                                   w, h, d);
+#ifndef QT_NO_XRENDER
+    if (X11->use_xrender) {
+        XRenderPictFormat *format = d == 32
+                                    ? XRenderFindStandardFormat(X11->display, PictStandardARGB32)
+                                    : XRenderFindVisualFormat(X11->display, (Visual *)xinfo.visual());
+        picture = XRenderCreatePicture(X11->display, hd, format, 0, 0);
+    }
+#endif // QT_NO_XRENDER
+    if (x11Data->x11_mask) {
+        x11_mask = XCreatePixmap(X11->display, hd, w, h, 1);
+#ifndef QT_NO_XRENDER
+        if (X11->use_xrender) {
+            mask_picture = XRenderCreatePicture(X11->display, x11_mask,
+                                                XRenderFindStandardFormat(X11->display, PictStandardA1), 0, 0);
+            XRenderPictureAttributes attrs;
+            attrs.alpha_map = x11Data->mask_picture;
+            XRenderChangePicture(X11->display, x11Data->picture, CPAlphaMap, &attrs);
+        }
+#endif
+    }
+
+#if !defined(QT_NO_XRENDER)
+    if (x11Data->picture && x11Data->d == 32) {
+        XRenderComposite(X11->display, PictOpSrc,
+                         x11Data->picture, 0, picture,
+                         rect.x(), rect.y(), 0, 0, 0, 0, w, h);
+    } else
+#endif
+    {
+        GC gc = XCreateGC(X11->display, hd, 0, 0);
+        XCopyArea(X11->display, x11Data->hd, hd, gc,
+                  rect.x(), rect.y(), w, h, 0, 0);
+        if (x11Data->x11_mask) {
+            GC monogc = XCreateGC(X11->display, x11_mask, 0, 0);
+            XCopyArea(X11->display, x11Data->x11_mask, x11_mask, monogc,
+                      rect.x(), rect.y(), w, h, 0, 0);
+            XFreeGC(X11->display, monogc);
+        }
+        XFreeGC(X11->display, gc);
+    }
+}
+
+bool QX11PixmapData::scroll(int dx, int dy, const QRect &rect)
+{
+    GC gc = XCreateGC(X11->display, hd, 0, 0);
+    XCopyArea(X11->display, hd, hd, gc,
+              rect.left(), rect.top(), rect.width(), rect.height(),
+              rect.left() + dx, rect.top() + dy);
+    XFreeGC(X11->display, gc);
+    return true;
+}
+
+#if !defined(QT_NO_XRENDER)
+void QX11PixmapData::convertToARGB32(bool preserveContents)
+{
+    if (!X11->use_xrender)
+        return;
+
+    // Q_ASSERT(count == 1);
+    if (read_only && share_mode == QPixmap::ExplicitlyShared)
+        return;
+
+    Pixmap pm = XCreatePixmap(X11->display, RootWindow(X11->display, xinfo.screen()),
+                              w, h, 32);
+    Picture p = XRenderCreatePicture(X11->display, pm,
+                                     XRenderFindStandardFormat(X11->display, PictStandardARGB32), 0, 0);
+    if (picture) {
+        if (preserveContents)
+            XRenderComposite(X11->display, PictOpSrc, picture, 0, p, 0, 0, 0, 0, 0, 0, w, h);
+        if (!read_only)
+            XRenderFreePicture(X11->display, picture);
+    }
+    if (hd && !read_only)
+        XFreePixmap(X11->display, hd);
+    if (x11_mask) {
+        XFreePixmap(X11->display, x11_mask);
+        if (mask_picture)
+            XRenderFreePicture(X11->display, mask_picture);
+        x11_mask = 0;
+        mask_picture = 0;
+    }
+    hd = pm;
+    picture = p;
+    d = 32;
+}
+#endif
+
+QPixmap QPixmap::fromX11Pixmap(Qt::HANDLE pixmap, QPixmap::ShareMode mode)
+{
+    Window root;
+    int x;
+    int y;
+    uint width;
+    uint height;
+    uint border_width;
+    uint depth;
+    XWindowAttributes win_attribs;
+    int num_screens = ScreenCount(X11->display);
+    int screen = 0;
+
+    XGetGeometry(X11->display, pixmap, &root, &x, &y, &width, &height, &border_width, &depth);
+    XGetWindowAttributes(X11->display, root, &win_attribs);
+
+    for (; screen < num_screens; ++screen) {
+        if (win_attribs.screen == ScreenOfDisplay(X11->display, screen))
+            break;
+    }
+
+    QX11PixmapData *data = new QX11PixmapData(depth == 1 ? QPixmapData::BitmapType : QPixmapData::PixmapType);
+    data->setSerialNumber(++qt_pixmap_serial);
+    data->read_only = true;
+    data->share_mode = mode;
+    data->uninit = false;
+    data->w = width;
+    data->h = height;
+    data->d = depth;
+    data->hd = pixmap;
+
+    if (defaultScreen >= 0 && defaultScreen != screen) {
+        QX11InfoData* xd = data->xinfo.getX11Data(true);
+        xd->screen = defaultScreen;
+        xd->depth = QX11Info::appDepth(xd->screen);
+        xd->cells = QX11Info::appCells(xd->screen);
+        xd->colormap = QX11Info::appColormap(xd->screen);
+        xd->defaultColormap = QX11Info::appDefaultColormap(xd->screen);
+        xd->visual = (Visual *)QX11Info::appVisual(xd->screen);
+        xd->defaultVisual = QX11Info::appDefaultVisual(xd->screen);
+        data->xinfo.setX11Data(xd);
+    }
+
+#ifndef QT_NO_XRENDER
+    if (X11->use_xrender) {
+        XRenderPictFormat *format = qt_renderformat_for_depth(data->xinfo, depth);
+        data->picture = XRenderCreatePicture(X11->display, data->hd, format, 0, 0);
+    }
+#endif // QT_NO_XRENDER
+
+    return QPixmap(data);
+}
+
+
+QT_END_NAMESPACE
diff --git a/src/gui/image/qpixmap_x11_p.h b/src/gui/image/qpixmap_x11_p.h
new file mode 100644
index 0000000..c526402
--- /dev/null
+++ b/src/gui/image/qpixmap_x11_p.h
@@ -0,0 +1,132 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPIXMAPDATA_X11_P_H
+#define QPIXMAPDATA_X11_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/private/qpixmapdata_p.h>
+#include <QtGui/private/qpixmapdatafactory_p.h>
+
+#include "QtGui/qx11info_x11.h"
+
+QT_BEGIN_NAMESPACE
+
+class QX11PaintEngine;
+
+class Q_GUI_EXPORT QX11PixmapData : public QPixmapData
+{
+public:
+    QX11PixmapData(PixelType type);
+//     QX11PixmapData(PixelType type, int width, int height);
+//     QX11PixmapData(PixelType type, const QImage &image,
+//                    Qt::ImageConversionFlags flags);
+    ~QX11PixmapData();
+
+    void resize(int width, int height);
+    void fromImage(const QImage &image, Qt::ImageConversionFlags flags);
+    void copy(const QPixmapData *data, const QRect &rect);
+    bool scroll(int dx, int dy, const QRect &rect);
+
+    void fill(const QColor &color);
+    QBitmap mask() const;
+    void setMask(const QBitmap &mask);
+    bool hasAlphaChannel() const;
+    void setAlphaChannel(const QPixmap &alphaChannel);
+    QPixmap alphaChannel() const;
+    QPixmap transformed(const QTransform &transform,
+                        Qt::TransformationMode mode) const;
+    QImage toImage() const;
+    QPaintEngine* paintEngine() const;
+
+    Qt::HANDLE handle() const { return hd; }
+    Qt::HANDLE x11ConvertToDefaultDepth();
+
+protected:
+    int metric(QPaintDevice::PaintDeviceMetric metric) const;
+
+private:
+    friend class QPixmap;
+    friend class QBitmap;
+    friend class QX11PaintEngine;
+    friend class QX11WindowSurface;
+    friend class QRasterWindowSurface;
+
+    void release();
+
+    QBitmap mask_to_bitmap(int screen) const;
+    static Qt::HANDLE bitmap_to_mask(const QBitmap &, int screen);
+    void bitmapFromImage(const QImage &image);
+
+    Qt::HANDLE hd;
+
+    int w, h;
+    short d;
+    uint uninit : 1;
+    uint read_only : 1;
+
+    QX11Info xinfo;
+    Qt::HANDLE x11_mask;
+    Qt::HANDLE picture;
+    Qt::HANDLE mask_picture;
+    Qt::HANDLE hd2; // sorted in the default display depth
+#ifndef QT_NO_XRENDER
+    void convertToARGB32(bool preserveContents = true);
+#endif
+    QPixmap::ShareMode share_mode;
+
+    QX11PaintEngine *pengine;
+};
+
+QT_END_NAMESPACE
+
+#endif // QPIXMAPDATA_X11_P_H
+
diff --git a/src/gui/image/qpixmapcache.cpp b/src/gui/image/qpixmapcache.cpp
new file mode 100644
index 0000000..4253f8d
--- /dev/null
+++ b/src/gui/image/qpixmapcache.cpp
@@ -0,0 +1,320 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qpixmapcache.h"
+#include "qcache.h"
+#include "qobject.h"
+#include "qdebug.h"
+
+#include "qpaintengine.h"
+#include <private/qimage_p.h>
+#include <private/qpixmap_raster_p.h>
+
+QT_BEGIN_NAMESPACE
+
+/*!
+    \class QPixmapCache
+
+    \brief The QPixmapCache class provides an application-wide cache for pixmaps.
+
+    \ingroup environment
+    \ingroup multimedia
+
+    This class is a tool for optimized drawing with QPixmap. You can
+    use it to store temporary pixmaps that are expensive to generate
+    without using more storage space than cacheLimit(). Use insert()
+    to insert pixmaps, find() to find them, and clear() to empty the
+    cache.
+
+    QPixmapCache contains no member data, only static functions to
+    access the global pixmap cache. It creates an internal QCache
+    object for caching the pixmaps.
+
+    The cache associates a pixmap with a string (key). If two pixmaps
+    are inserted into the cache using equal keys, then the last pixmap
+    will hide the first pixmap. The QHash and QCache classes do
+    exactly the same.
+
+    The cache becomes full when the total size of all pixmaps in the
+    cache exceeds cacheLimit(). The initial cache limit is 1024 KB (1
+    MB); it is changed with setCacheLimit(). A pixmap takes roughly
+    (\e{width} * \e{height} * \e{depth})/8 bytes of memory.
+
+    The \e{Qt Quarterly} article
+    \l{http://doc.trolltech.com/qq/qq12-qpixmapcache.html}{Optimizing
+    with QPixmapCache} explains how to use QPixmapCache to speed up
+    applications by caching the results of painting.
+
+    \sa QCache, QPixmap
+*/
+
+#if defined(Q_WS_QWS) || defined(Q_OS_WINCE)
+static int cache_limit = 2048; // 2048 KB cache limit for embedded
+#else
+static int cache_limit = 10240; // 10 MB cache limit for desktop
+#endif
+
+// XXX: hw: is this a general concept we need to abstract?
+class QDetachedPixmap : public QPixmap
+{
+public:
+    QDetachedPixmap(const QPixmap &pix) : QPixmap(pix)
+    {
+        if (data && data->classId() == QPixmapData::RasterClass) {
+            QRasterPixmapData *d = static_cast<QRasterPixmapData*>(data);
+            if (!d->image.isNull() && d->image.d->paintEngine
+                && !d->image.d->paintEngine->isActive())
+            {
+                delete d->image.d->paintEngine;
+                d->image.d->paintEngine = 0;
+            }
+        }
+    }
+};
+
+class QPMCache : public QObject, public QCache<qint64, QDetachedPixmap>
+{
+    Q_OBJECT
+public:
+    QPMCache()
+        : QObject(0),
+          QCache<qint64, QDetachedPixmap>(cache_limit * 1024),
+          theid(0), ps(0), t(false) { }
+    ~QPMCache() { }
+
+    void timerEvent(QTimerEvent *);
+    bool insert(const QString& key, const QPixmap &pixmap, int cost);
+    bool remove(const QString &key);
+
+    QPixmap *object(const QString &key) const;
+
+private:
+    QHash<QString, qint64> cacheKeys;
+    int theid;
+    int ps;
+    bool t;
+};
+QT_BEGIN_INCLUDE_NAMESPACE
+#include "qpixmapcache.moc"
+QT_END_INCLUDE_NAMESPACE
+
+/*
+  This is supposed to cut the cache size down by about 80-90% in a
+  minute once the application becomes idle, to let any inserted pixmap
+  remain in the cache for some time before it becomes a candidate for
+  cleaning-up, and to not cut down the size of the cache while the
+  cache is in active use.
+
+  When the last pixmap has been deleted from the cache, kill the
+  timer so Qt won't keep the CPU from going into sleep mode.
+*/
+
+void QPMCache::timerEvent(QTimerEvent *)
+{
+    int mc = maxCost();
+    bool nt = totalCost() == ps;
+    setMaxCost(nt ? totalCost() * 3 / 4 : totalCost() -1);
+    setMaxCost(mc);
+    ps = totalCost();
+
+    QHash<QString, qint64>::iterator it = cacheKeys.begin();
+    while (it != cacheKeys.end()) {
+        if (!contains(it.value())) {
+            it = cacheKeys.erase(it);
+        } else {
+            ++it;
+        }
+    }
+
+    if (!size()) {
+        killTimer(theid);
+        theid = 0;
+    } else if (nt != t) {
+        killTimer(theid);
+        theid = startTimer(nt ? 10000 : 30000);
+        t = nt;
+    }
+}
+
+QPixmap *QPMCache::object(const QString &key) const
+{
+    return QCache<qint64, QDetachedPixmap>::object(cacheKeys.value(key, -1));
+}
+
+
+bool QPMCache::insert(const QString& key, const QPixmap &pixmap, int cost)
+{
+    qint64 cacheKey = pixmap.cacheKey();
+    if (QCache<qint64, QDetachedPixmap>::object(cacheKey)) {
+        cacheKeys.insert(key, cacheKey);
+        return true;
+    }
+    bool success = QCache<qint64, QDetachedPixmap>::insert(cacheKey, new QDetachedPixmap(pixmap), cost);
+    if (success) {
+        cacheKeys.insert(key, cacheKey);
+        if (!theid) {
+            theid = startTimer(30000);
+            t = false;
+        }
+    }
+    return success;
+}
+
+bool QPMCache::remove(const QString &key)
+{
+    qint64 cacheKey = cacheKeys.value(key, -1);
+    cacheKeys.remove(key);
+    return QCache<qint64, QDetachedPixmap>::remove(cacheKey);
+}
+
+Q_GLOBAL_STATIC(QPMCache, pm_cache)
+
+/*!
+  \obsolete
+    \overload
+
+    Returns the pixmap associated with the \a key in the cache, or
+    null if there is no such pixmap.
+
+    \warning If valid, you should copy the pixmap immediately (this is
+    fast). Subsequent insertions into the cache could cause the
+    pointer to become invalid. For this reason, we recommend you use
+    find(const QString&, QPixmap&) instead.
+
+    Example:
+    \snippet doc/src/snippets/code/src_gui_image_qpixmapcache.cpp 0
+*/
+
+QPixmap *QPixmapCache::find(const QString &key)
+{
+    return pm_cache()->object(key);
+}
+
+
+/*!
+    Looks for a cached pixmap associated with the \a key in the cache.
+    If the pixmap is found, the function sets \a pm to that pixmap and
+    returns true; otherwise it leaves \a pm alone and returns false.
+
+    Example:
+    \snippet doc/src/snippets/code/src_gui_image_qpixmapcache.cpp 1
+*/
+
+bool QPixmapCache::find(const QString &key, QPixmap& pm)
+{
+    QPixmap *ptr = pm_cache()->object(key);
+    if (ptr)
+        pm = *ptr;
+    return ptr != 0;
+}
+
+
+/*!
+    Inserts a copy of the pixmap \a pm associated with the \a key into
+    the cache.
+
+    All pixmaps inserted by the Qt library have a key starting with
+    "$qt", so your own pixmap keys should never begin "$qt".
+
+    When a pixmap is inserted and the cache is about to exceed its
+    limit, it removes pixmaps until there is enough room for the
+    pixmap to be inserted.
+
+    The oldest pixmaps (least recently accessed in the cache) are
+    deleted when more space is needed.
+
+    The function returns true if the object was inserted into the
+    cache; otherwise it returns false.
+
+    \sa setCacheLimit()
+*/
+
+bool QPixmapCache::insert(const QString &key, const QPixmap &pm)
+{
+    return pm_cache()->insert(key, pm, pm.width() * pm.height() * pm.depth() / 8);
+}
+
+/*!
+    Returns the cache limit (in kilobytes).
+
+    The default cache limit is 2048 KB for Embedded, 10240 KB for Desktops.
+
+    \sa setCacheLimit()
+*/
+
+int QPixmapCache::cacheLimit()
+{
+    return cache_limit;
+}
+
+/*!
+    Sets the cache limit to \a n kilobytes.
+
+    The default setting is 1024 kilobytes.
+
+    \sa cacheLimit()
+*/
+
+void QPixmapCache::setCacheLimit(int n)
+{
+    cache_limit = n;
+    pm_cache()->setMaxCost(1024 * cache_limit);
+}
+
+/*!
+  Removes the pixmap associated with \a key from the cache.
+*/
+void QPixmapCache::remove(const QString &key)
+{
+    pm_cache()->remove(key);
+}
+
+
+/*!
+    Removes all pixmaps from the cache.
+*/
+
+void QPixmapCache::clear()
+{
+    pm_cache()->clear();
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/image/qpixmapcache.h b/src/gui/image/qpixmapcache.h
new file mode 100644
index 0000000..2750a88
--- /dev/null
+++ b/src/gui/image/qpixmapcache.h
@@ -0,0 +1,69 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPIXMAPCACHE_H
+#define QPIXMAPCACHE_H
+
+#include <QtGui/qpixmap.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+class Q_GUI_EXPORT QPixmapCache
+{
+public:
+    static int cacheLimit();
+    static void setCacheLimit(int);
+    static QPixmap *find(const QString &key);
+    static bool find(const QString &key, QPixmap&);
+    static bool insert(const QString &key, const QPixmap&);
+    static void remove(const QString &key);
+    static void clear();
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QPIXMAPCACHE_H
diff --git a/src/gui/image/qpixmapdata.cpp b/src/gui/image/qpixmapdata.cpp
new file mode 100644
index 0000000..245a866
--- /dev/null
+++ b/src/gui/image/qpixmapdata.cpp
@@ -0,0 +1,187 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qpixmapdata_p.h"
+#include <QtGui/qbitmap.h>
+#include <QtGui/qimagereader.h>
+
+QT_BEGIN_NAMESPACE
+
+const uchar qt_pixmap_bit_mask[] = { 0x01, 0x02, 0x04, 0x08,
+                                     0x10, 0x20, 0x40, 0x80 };
+
+QPixmapData::QPixmapData(PixelType pixelType, int objectId)
+    : ref(0), detach_no(0), type(pixelType), id(objectId), ser_no(0), is_cached(false)
+{
+
+}
+
+QPixmapData::~QPixmapData()
+{
+}
+
+void QPixmapData::fromFile(const QString &fileName, const char *format,
+                           Qt::ImageConversionFlags flags)
+{
+    const QImage image = QImageReader(fileName, format).read();
+    if (image.isNull())
+        return;
+
+    fromImage(image, flags);
+}
+
+void QPixmapData::copy(const QPixmapData *data, const QRect &rect)
+{
+    fromImage(data->toImage().copy(rect), Qt::AutoColor);
+}
+
+bool QPixmapData::scroll(int dx, int dy, const QRect &rect)
+{
+    Q_UNUSED(dx);
+    Q_UNUSED(dy);
+    Q_UNUSED(rect);
+    return false;
+}
+
+void QPixmapData::setMask(const QBitmap &mask)
+{
+    if (mask.size().isEmpty()) {
+        if (depth() != 1)
+            fromImage(toImage().convertToFormat(QImage::Format_RGB32),
+                      Qt::AutoColor);
+    } else {
+        QImage image = toImage();
+        const int w = image.width();
+        const int h = image.height();
+
+        switch (image.depth()) {
+        case 1: {
+            const QImage imageMask = mask.toImage().convertToFormat(image.format());
+            for (int y = 0; y < h; ++y) {
+                const uchar *mscan = imageMask.scanLine(y);
+                uchar *tscan = image.scanLine(y);
+                int bytesPerLine = image.bytesPerLine();
+                for (int i = 0; i < bytesPerLine; ++i)
+                    tscan[i] &= mscan[i];
+            }
+            break;
+        }
+        default: {
+            const QImage imageMask = mask.toImage().convertToFormat(QImage::Format_MonoLSB);
+            image = image.convertToFormat(QImage::Format_ARGB32_Premultiplied);
+            for (int y = 0; y < h; ++y) {
+                const uchar *mscan = imageMask.scanLine(y);
+                QRgb *tscan = (QRgb *)image.scanLine(y);
+                for (int x = 0; x < w; ++x) {
+                    if (!(mscan[x>>3] & qt_pixmap_bit_mask[x&7]))
+                        tscan[x] = 0;
+                }
+            }
+            break;
+        }
+        }
+        fromImage(image, Qt::AutoColor);
+    }
+}
+
+QBitmap QPixmapData::mask() const
+{
+    if (!hasAlphaChannel())
+        return QBitmap();
+
+    const QImage img = toImage();
+    const QImage image = (img.depth() < 32 ? img.convertToFormat(QImage::Format_ARGB32_Premultiplied) : img);
+    const int w = image.width();
+    const int h = image.height();
+
+    QImage mask(w, h, QImage::Format_MonoLSB);
+    if (mask.isNull()) // allocation failed
+        return QBitmap();
+
+    mask.setNumColors(2);
+    mask.setColor(0, QColor(Qt::color0).rgba());
+    mask.setColor(1, QColor(Qt::color1).rgba());
+
+    const int bpl = mask.bytesPerLine();
+
+    for (int y = 0; y < h; ++y) {
+        const QRgb *src = reinterpret_cast<const QRgb*>(image.scanLine(y));
+        uchar *dest = mask.scanLine(y);
+        memset(dest, 0, bpl);
+        for (int x = 0; x < w; ++x) {
+            if (qAlpha(*src) > 0)
+                dest[x >> 3] |= qt_pixmap_bit_mask[x & 7];
+            ++src;
+        }
+    }
+
+    return QBitmap::fromImage(mask);
+}
+
+QPixmap QPixmapData::transformed(const QTransform &matrix,
+                                 Qt::TransformationMode mode) const
+{
+    return QPixmap::fromImage(toImage().transformed(matrix, mode));
+}
+
+void QPixmapData::setAlphaChannel(const QPixmap &alphaChannel)
+{
+    QImage image = toImage();
+    image.setAlphaChannel(alphaChannel.toImage());
+    fromImage(image, Qt::AutoColor);
+}
+
+QPixmap QPixmapData::alphaChannel() const
+{
+    return QPixmap::fromImage(toImage().alphaChannel());
+}
+
+void QPixmapData::setSerialNumber(int serNo)
+{
+    ser_no = serNo;
+}
+
+QImage* QPixmapData::buffer()
+{
+    return 0;
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/image/qpixmapdata_p.h b/src/gui/image/qpixmapdata_p.h
new file mode 100644
index 0000000..df26c42
--- /dev/null
+++ b/src/gui/image/qpixmapdata_p.h
@@ -0,0 +1,141 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPIXMAPDATA_P_H
+#define QPIXMAPDATA_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/qpixmap.h>
+#include <QtCore/qatomic.h>
+
+QT_BEGIN_NAMESPACE
+
+class Q_GUI_EXPORT QPixmapData
+{
+public:
+    enum PixelType {
+        // WARNING: Do not change the first two
+        // Must match QPixmap::Type
+        PixmapType, BitmapType
+    };
+    enum ClassId { RasterClass, X11Class, MacClass, DirectFBClass,
+                   OpenGLClass, OpenVGClass, CustomClass = 1024 };
+
+    QPixmapData(PixelType pixelpType, int classId);
+    virtual ~QPixmapData();
+
+    virtual void resize(int width, int height) = 0;
+    virtual void fromImage(const QImage &image,
+                           Qt::ImageConversionFlags flags) = 0;
+    virtual void fromFile(const QString &filename, const char *format,
+                          Qt::ImageConversionFlags flags);
+    virtual void copy(const QPixmapData *data, const QRect &rect);
+    virtual bool scroll(int dx, int dy, const QRect &rect);
+
+    virtual int metric(QPaintDevice::PaintDeviceMetric metric) const = 0;
+    virtual void fill(const QColor &color) = 0;
+    virtual QBitmap mask() const;
+    virtual void setMask(const QBitmap &mask);
+    virtual bool hasAlphaChannel() const = 0;
+    virtual QPixmap transformed(const QTransform &matrix,
+                                Qt::TransformationMode mode) const;
+    virtual void setAlphaChannel(const QPixmap &alphaChannel);
+    virtual QPixmap alphaChannel() const;
+    virtual QImage toImage() const = 0;
+    virtual QPaintEngine* paintEngine() const = 0;
+
+    inline int serialNumber() const { return ser_no; }
+
+    inline PixelType pixelType() const { return type; }
+    inline ClassId classId() const { return static_cast<ClassId>(id); }
+
+    virtual QImage* buffer();
+
+    int width() const { return metric(QPaintDevice::PdmWidth); }
+    int height() const { return metric(QPaintDevice::PdmHeight); }
+    int numColors() const { return metric(QPaintDevice::PdmNumColors); }
+    int depth() const { return metric(QPaintDevice::PdmDepth); }
+
+protected:
+    void setSerialNumber(int serNo);
+
+private:
+    friend class QPixmap;
+    friend class QGLContextPrivate;
+
+    QAtomicInt ref;
+    int detach_no;
+
+    PixelType type;
+    int id;
+    int ser_no;
+    uint is_cached;
+};
+
+#ifdef Q_WS_WIN
+#ifndef Q_OS_WINCE
+QPixmap convertHIconToPixmap( const HICON icon);
+#else
+QPixmap convertHIconToPixmap( const HICON icon, bool large = false);
+#endif
+QPixmap loadIconFromShell32( int resourceId, int size );
+#endif
+
+#  define QT_XFORM_TYPE_MSBFIRST 0
+#  define QT_XFORM_TYPE_LSBFIRST 1
+#  if defined(Q_WS_WIN)
+#    define QT_XFORM_TYPE_WINDOWSPIXMAP 2
+#  endif
+extern bool qt_xForm_helper(const QTransform&, int, int, int, uchar*, int, int, int, const uchar*, int, int, int);
+
+QT_END_NAMESPACE
+
+#endif // QPIXMAPDATA_P_H
diff --git a/src/gui/image/qpixmapdatafactory.cpp b/src/gui/image/qpixmapdatafactory.cpp
new file mode 100644
index 0000000..699489d
--- /dev/null
+++ b/src/gui/image/qpixmapdatafactory.cpp
@@ -0,0 +1,105 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qpixmapdatafactory_p.h"
+
+#ifdef Q_WS_QWS
+# include <QtGui/qscreen_qws.h>
+#endif
+#ifdef Q_WS_X11
+# include <private/qpixmap_x11_p.h>
+#endif
+#ifdef Q_WS_WIN
+# include <private/qpixmap_raster_p.h>
+#endif
+#ifdef Q_WS_MAC
+# include <private/qpixmap_mac_p.h>
+#endif
+
+#include "private/qapplication_p.h"
+#include "private/qgraphicssystem_p.h"
+
+QT_BEGIN_NAMESPACE
+
+#if !defined(Q_WS_QWS)
+
+class QSimplePixmapDataFactory : public QPixmapDataFactory
+{
+public:
+    ~QSimplePixmapDataFactory() {}
+    QPixmapData* create(QPixmapData::PixelType type);
+};
+
+QPixmapData* QSimplePixmapDataFactory::create(QPixmapData::PixelType type)
+{
+    if (QApplicationPrivate::graphicsSystem())
+        return QApplicationPrivate::graphicsSystem()->createPixmapData(type);
+
+#if defined(Q_WS_X11)
+    return new QX11PixmapData(type);
+#elif defined(Q_WS_WIN)
+    return new QRasterPixmapData(type);
+#elif defined(Q_WS_MAC)
+    return new QMacPixmapData(type);
+#else
+#error QSimplePixmapDataFactory::create() not implemented
+#endif
+}
+
+Q_GLOBAL_STATIC(QSimplePixmapDataFactory, factory);
+
+#endif // !defined(Q_WS_QWS)
+
+QPixmapDataFactory::~QPixmapDataFactory()
+{
+}
+
+QPixmapDataFactory* QPixmapDataFactory::instance(int screen)
+{
+    Q_UNUSED(screen);
+#ifdef Q_WS_QWS
+    return QScreen::instance()->pixmapDataFactory();
+#else
+    return factory();
+#endif
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/image/qpixmapdatafactory_p.h b/src/gui/image/qpixmapdatafactory_p.h
new file mode 100644
index 0000000..65e3f11
--- /dev/null
+++ b/src/gui/image/qpixmapdatafactory_p.h
@@ -0,0 +1,81 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPIXMAPDATAFACTORY_P_H
+#define QPIXMAPDATAFACTORY_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 <QtCore/qstring.h>
+#include <QtGui/qimage.h>
+#include <QtGui/private/qpixmapdata_p.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+class QPixmapData;
+
+class Q_GUI_EXPORT QPixmapDataFactory
+{
+public:
+    static QPixmapDataFactory* instance(int screen = 0);
+    virtual ~QPixmapDataFactory();
+
+    virtual QPixmapData* create(QPixmapData::PixelType type) = 0;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QPIXMAPDATAFACTORY_P_H
diff --git a/src/gui/image/qpixmapfilter.cpp b/src/gui/image/qpixmapfilter.cpp
new file mode 100644
index 0000000..8631c8c
--- /dev/null
+++ b/src/gui/image/qpixmapfilter.cpp
@@ -0,0 +1,849 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <qglobal.h>
+
+#include <QDebug>
+
+#include "qpainter.h"
+#include "qpixmap.h"
+#include "qpixmapfilter_p.h"
+#include "qvarlengtharray.h"
+
+#include "private/qapplication_p.h"
+#include "private/qgraphicssystem_p.h"
+#include "private/qpaintengineex_p.h"
+#include "private/qpaintengine_raster_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QPixmapFilterPrivate : public QObjectPrivate
+{
+    Q_DECLARE_PUBLIC(QPixmapFilter)
+public:
+    QPixmapFilter::FilterType type;
+};
+
+/*!
+    \class QPixmapFilter
+    \since 4.5
+    \ingroup multimedia
+
+    \brief The QPixmapFilter class provides the basic functionality for
+    pixmap filter classes. Pixmap filter can be for example colorize or blur.
+
+    QPixmapFilter is the base class for every pixmap filter. QPixmapFilter is
+    an abstract class and cannot itself be instantiated. It provides a standard
+    interface for filter processing.
+
+    \internal
+*/
+
+/*!
+    \enum QPixmapFilter::FilterType
+
+    \internal
+
+    This enum describes the types of filter that can be applied to pixmaps.
+
+    \value ConvolutionFilter  A filter that is used to calculate the convolution
+                              of the image with a kernel. See
+                              QPixmapConvolutionFilter for more information.
+    \value ColorizeFilter     A filter that is used to change the overall color
+                              of an image. See QPixmapColorizeFilter for more
+                              information.
+    \value DropShadowFilter   A filter that is used to add a drop shadow to an
+                              image. See QPixmapDropShadowFilter for more
+                              information.
+
+    \value UserFilter   The first filter type that can be used for
+                        application-specific purposes.
+*/
+
+
+/*!
+    Constructs a default QPixmapFilter with the given \a type.
+
+    This constructor should be used when subclassing QPixmapFilter to
+    create custom user filters.
+
+    \internal
+*/
+QPixmapFilter::QPixmapFilter(FilterType type, QObject *parent)
+    : QObject(*new QPixmapFilterPrivate, parent)
+{
+    d_func()->type = type;
+}
+
+
+
+/*!
+   \internal
+*/
+QPixmapFilter::QPixmapFilter(QPixmapFilterPrivate&d, QPixmapFilter::FilterType type, QObject *parent)
+    : QObject(d, parent)
+{
+    d_func()->type = type;
+}
+
+
+/*!
+    Destroys the pixmap filter.
+
+    \internal
+*/
+QPixmapFilter::~QPixmapFilter()
+{
+}
+
+/*!
+    Returns the type of the filter. All standard pixmap filter classes
+    are associated with a unique value.
+
+    \internal
+*/
+QPixmapFilter::FilterType QPixmapFilter::type() const
+{
+    Q_D(const QPixmapFilter);
+    return d->type;
+}
+
+/*!
+    Returns the bounding rectangle that is affected by the pixmap
+    filter if the filter is applied to the specified \a rect.
+
+    \internal
+*/
+QRectF QPixmapFilter::boundingRectFor(const QRectF &rect) const
+{
+    return rect;
+}
+
+/*!
+    \fn void QPixmapFilter::draw(QPainter *painter, const QPointF &p, const QPixmap &src, const QRectF& srcRect) const
+
+    Uses \a painter to draw filtered result of \a src at the point
+    specified by \a p. If \a srcRect is specified the it will
+    be used as a source rectangle to only draw a part of the source.
+
+    draw() will affect the area which boundingRectFor() returns.
+
+    \internal
+*/
+
+/*!
+    \class QPixmapConvolutionFilter
+    \since 4.5
+    \ingroup multimedia
+
+    \brief The QPixmapConvolutionFilter class provides convolution
+    filtering for pixmaps.
+
+    QPixmapConvolutionFilter implements a convolution pixmap filter,
+    which is applied when \l{QPixmapFilter::}{draw()} is called. A
+    convolution filter lets you distort an image by setting the values
+    of a matrix of qreal values called its
+    \l{setConvolutionKernel()}{kernel}. The matrix's values are
+    usually between -1.0 and 1.0.
+
+    \omit
+    In convolution filtering, the pixel value is calculated from the
+    neighboring pixels based on the weighting convolution kernel.
+    This needs explaining to be useful.
+    \endomit
+
+    Example:
+    \snippet doc/src/snippets/code/src_gui_image_qpixmapfilter.cpp 1
+
+    \sa {Pixmap Filters Example}, QPixmapColorizeFilter, QPixmapDropShadowFilter
+
+
+    \internal
+*/
+
+class QPixmapConvolutionFilterPrivate : public QPixmapFilterPrivate
+{
+public:
+    QPixmapConvolutionFilterPrivate(): convolutionKernel(0), kernelWidth(0), kernelHeight(0), convoluteAlpha(false) {}
+    ~QPixmapConvolutionFilterPrivate() {
+        delete[] convolutionKernel;
+    }
+
+    qreal *convolutionKernel;
+    int kernelWidth;
+    int kernelHeight;
+    bool convoluteAlpha;
+};
+
+
+/*!
+    Constructs a pixmap convolution filter.
+
+    By default there is no convolution kernel.
+
+    \internal
+*/
+QPixmapConvolutionFilter::QPixmapConvolutionFilter(QObject *parent)
+    : QPixmapFilter(*new QPixmapConvolutionFilterPrivate, ConvolutionFilter, parent)
+{
+    Q_D(QPixmapConvolutionFilter);
+    d->convoluteAlpha = true;
+}
+
+/*!
+    Destructor of pixmap convolution filter.
+
+    \internal
+*/
+QPixmapConvolutionFilter::~QPixmapConvolutionFilter()
+{
+}
+
+/*!
+     Sets convolution kernel with the given number of \a rows and \a columns.
+     Values from \a kernel are copied to internal data structure.
+
+     To preserve the intensity of the pixmap, the sum of all the
+     values in the convolution kernel should add up to 1.0. A sum
+     greater than 1.0 produces a lighter result and a sum less than 1.0
+     produces a darker and transparent result.
+
+    \internal
+*/
+void QPixmapConvolutionFilter::setConvolutionKernel(const qreal *kernel, int rows, int columns)
+{
+    Q_D(QPixmapConvolutionFilter);
+    delete [] d->convolutionKernel;
+    d->convolutionKernel = new qreal[rows * columns];
+    memcpy(d->convolutionKernel, kernel, sizeof(qreal) * rows * columns);
+    d->kernelWidth = columns;
+    d->kernelHeight = rows;
+}
+
+/*!
+    Gets the convolution kernel data.
+
+    \internal
+*/
+const qreal *QPixmapConvolutionFilter::convolutionKernel() const
+{
+    Q_D(const QPixmapConvolutionFilter);
+    return d->convolutionKernel;
+}
+
+/*!
+    Gets the number of rows in the convolution kernel.
+
+    \internal
+*/
+int QPixmapConvolutionFilter::rows() const
+{
+    Q_D(const QPixmapConvolutionFilter);
+    return d->kernelHeight;
+}
+
+/*!
+    Gets the number of columns in the convolution kernel.
+
+    \internal
+*/
+int QPixmapConvolutionFilter::columns() const
+{
+    Q_D(const QPixmapConvolutionFilter);
+    return d->kernelWidth;
+}
+
+
+/*!
+    \reimp
+
+    \internal
+*/
+QRectF QPixmapConvolutionFilter::boundingRectFor(const QRectF &rect) const
+{
+    Q_D(const QPixmapConvolutionFilter);
+    return rect.adjusted(-d->kernelWidth / 2, -d->kernelHeight / 2, (d->kernelWidth - 1) / 2, (d->kernelHeight - 1) / 2);
+}
+
+// Convolutes the image
+static void convolute(
+        QImage *destImage,
+        const QPointF &pos,
+        const QImage &srcImage,
+        const QRectF &srcRect,
+        QPainter::CompositionMode mode,
+        qreal *kernel,
+        int kernelWidth,
+        int kernelHeight )
+{
+    const QImage processImage = (srcImage.format() != QImage::Format_ARGB32_Premultiplied ) ?               srcImage.convertToFormat(QImage::Format_ARGB32_Premultiplied) : srcImage;
+    // TODO: support also other formats directly without copying
+
+    int *fixedKernel = new int[kernelWidth*kernelHeight];
+    for(int i = 0; i < kernelWidth*kernelHeight; i++)
+    {
+        fixedKernel[i] = (int)(65536 * kernel[i]);
+    }
+    QRectF trect = srcRect.isNull() ? processImage.rect() : srcRect;
+    trect.moveTo(pos);
+    QRectF bounded = trect.adjusted(-kernelWidth / 2, -kernelHeight / 2, (kernelWidth - 1) / 2, (kernelHeight - 1) / 2);
+    QRect rect = bounded.toAlignedRect();
+    QRect targetRect = rect.intersected(destImage->rect());
+
+    QRectF srect = srcRect.isNull() ? processImage.rect() : srcRect;
+    QRectF sbounded = srect.adjusted(-kernelWidth / 2, -kernelHeight / 2, (kernelWidth - 1) / 2, (kernelHeight - 1) / 2);
+    QPoint srcStartPoint = sbounded.toAlignedRect().topLeft()+(targetRect.topLeft()-rect.topLeft());
+
+    const uint *sourceStart = (uint*)processImage.scanLine(0);
+    uint *outputStart = (uint*)destImage->scanLine(0);
+
+    int yk = srcStartPoint.y();
+    for (int y = targetRect.top(); y <= targetRect.bottom(); y++) {
+        uint* output = outputStart + (destImage->bytesPerLine()/sizeof(uint))*y+targetRect.left();
+        int xk = srcStartPoint.x();
+        for(int x = targetRect.left(); x <= targetRect.right(); x++) {
+            int r = 0;
+            int g = 0;
+            int b = 0;
+            int a = 0;
+
+            // some out of bounds pre-checking to avoid inner-loop ifs
+            int kernely = -kernelHeight/2;
+            int starty = 0;
+            int endy = kernelHeight;
+            if(yk+kernely+endy >= srcImage.height())
+                endy = kernelHeight-((yk+kernely+endy)-srcImage.height())-1;
+            if(yk+kernely < 0)
+                starty = -(yk+kernely);
+
+            int kernelx = -kernelWidth/2;
+            int startx = 0;
+            int endx = kernelWidth;
+            if(xk+kernelx+endx >= srcImage.width())
+                endx = kernelWidth-((xk+kernelx+endx)-srcImage.width())-1;
+            if(xk+kernelx < 0)
+                startx = -(xk+kernelx);
+
+            for (int ys = starty; ys < endy; ys ++) {
+                const uint *pix = sourceStart + (processImage.bytesPerLine()/sizeof(uint))*(yk+kernely+ys) + ((xk+kernelx+startx));
+                const uint *endPix = pix+endx-startx;
+                int kernelPos = ys*kernelWidth+startx;
+                while (pix < endPix) {
+                    int factor = fixedKernel[kernelPos++];
+                    a += (((*pix) & 0xff000000)>>24) * factor;
+                    r += (((*pix) & 0x00ff0000)>>16) * factor;
+                    g += (((*pix) & 0x0000ff00)>>8 ) * factor;
+                    b += (((*pix) & 0x000000ff)    ) * factor;
+                    pix++;
+                }
+            }
+
+            r = qBound((int)0, r >> 16, (int)255);
+            g = qBound((int)0, g >> 16, (int)255);
+            b = qBound((int)0, b >> 16, (int)255);
+            a = qBound((int)0, a >> 16, (int)255);
+            // composition mode checking could be moved outside of loop
+            if(mode == QPainter::CompositionMode_Source) {
+                uint color = (a<<24)+(r<<16)+(g<<8)+b;
+                *output++ = color;
+            } else {
+                uint current = *output;
+                uchar ca = (current&0xff000000)>>24;
+                uchar cr = (current&0x00ff0000)>>16;
+                uchar cg = (current&0x0000ff00)>>8;
+                uchar cb = (current&0x000000ff);
+                uint color =
+                        (((ca*(255-a) >> 8)+a) << 24)+
+                        (((cr*(255-a) >> 8)+r) << 16)+
+                        (((cg*(255-a) >> 8)+g) << 8)+
+                        (((cb*(255-a) >> 8)+b));
+                *output++ = color;;
+            }
+            xk++;
+        }
+        yk++;
+    }
+}
+
+/*!
+    \reimp
+
+    \internal
+*/
+void QPixmapConvolutionFilter::draw(QPainter *painter, const QPointF &p, const QPixmap &src, const QRectF& srcRect) const
+{
+    Q_D(const QPixmapConvolutionFilter);
+    if (!painter->isActive())
+        return;
+
+    if(d->kernelWidth<=0 || d->kernelHeight <= 0)
+        return;
+
+    QPixmapFilter *filter = painter->paintEngine() && painter->paintEngine()->isExtended() ?
+        static_cast<QPaintEngineEx *>(painter->paintEngine())->createPixmapFilter(type()) : 0;
+    QPixmapConvolutionFilter *convolutionFilter = static_cast<QPixmapConvolutionFilter*>(filter);
+    if (convolutionFilter) {
+        convolutionFilter->setConvolutionKernel(d->convolutionKernel, d->kernelWidth, d->kernelHeight);
+        convolutionFilter->d_func()->convoluteAlpha = d->convoluteAlpha;
+        convolutionFilter->draw(painter, p, src, srcRect);
+        delete convolutionFilter;
+        return;
+    }
+
+    // falling back to raster implementation
+
+    QImage *target = 0;
+    if (painter->paintEngine()->paintDevice()->devType() == QInternal::Image) {
+        target = static_cast<QImage *>(painter->paintEngine()->paintDevice());
+
+        QTransform mat = painter->combinedTransform();
+
+        if (mat.type() > QTransform::TxTranslate) {
+            // Disabled because of transformation...
+            target = 0;
+        } else {
+            QRasterPaintEngine *pe = static_cast<QRasterPaintEngine *>(painter->paintEngine());
+            if (pe->clipType() == QRasterPaintEngine::ComplexClip)
+                // disabled because of complex clipping...
+                target = 0;
+            else {
+                QRectF clip = pe->clipBoundingRect();
+                QRectF rect = boundingRectFor(srcRect.isEmpty() ? src.rect() : srcRect);
+                QTransform x = painter->deviceTransform();
+                if (!clip.contains(rect.translated(x.dx() + p.x(), x.dy() + p.y()))) {
+                    target = 0;
+                }
+
+            }
+        }
+    }
+
+    if (target) {
+        QTransform x = painter->deviceTransform();
+        QPointF offset(x.dx(), x.dy());
+
+        convolute(target, p+offset, src.toImage(), srcRect, QPainter::CompositionMode_SourceOver, d->convolutionKernel, d->kernelWidth, d->kernelHeight);
+    } else {
+        QRect srect = srcRect.isNull() ? src.rect() : srcRect.toRect();
+        QRect rect = boundingRectFor(srect).toRect();
+        QImage result = QImage(rect.size(), QImage::Format_ARGB32_Premultiplied);
+        QPoint offset = srect.topLeft() - rect.topLeft();
+        convolute(&result,
+                  offset,
+                  src.toImage(),
+                  srect,
+                  QPainter::CompositionMode_Source,
+                  d->convolutionKernel,
+                  d->kernelWidth,
+                  d->kernelHeight);
+        painter->drawImage(p - offset, result);
+    }
+}
+
+// grayscales the image to dest (could be same). If rect isn't defined
+// destination image size is used to determine the dimension of grayscaling
+// process.
+static void grayscale(const QImage &image, QImage &dest, const QRect& rect = QRect())
+{
+    QRect destRect = rect;
+    QRect srcRect = rect;
+    if (rect.isNull()) {
+        srcRect = dest.rect();
+        destRect = dest.rect();
+    }
+    if (image != dest) {
+        destRect.moveTo(QPoint(0, 0));
+    }
+
+    unsigned int *data = (unsigned int *)image.bits();
+    unsigned int *outData = (unsigned int *)dest.bits();
+
+    if (dest.size() == image.size() && image.rect() == srcRect) {
+        // a bit faster loop for grayscaling everything
+        int pixels = dest.width() * dest.height();
+        for (int i = 0; i < pixels; ++i) {
+            int val = qGray(data[i]);
+            outData[i] = qRgba(val, val, val, qAlpha(data[i]));
+        }
+    } else {
+        int yd = destRect.top();
+        for (int y = srcRect.top(); y <= srcRect.bottom() && y < image.height(); y++) {
+            data = (unsigned int*)image.scanLine(y);
+            outData = (unsigned int*)dest.scanLine(yd++);
+            int xd = destRect.left();
+            for (int x = srcRect.left(); x <= srcRect.right() && x < image.width(); x++) {
+                int val = qGray(data[x]);
+                outData[xd++] = qRgba(val, val, val, qAlpha(data[x]));
+            }
+        }
+    }
+}
+
+/*!
+    \class QPixmapColorizeFilter
+    \since 4.5
+    \ingroup multimedia
+
+    \brief The QPixmapColorizeFilter class provides colorizing
+    filtering for pixmaps.
+
+    A colorize filter gives the pixmap a tint of its color(). The
+    filter first grayscales the pixmap and then converts those to
+    colorized values using QPainter::CompositionMode_Screen with the
+    chosen color. The alpha-channel is not changed.
+
+    Example:
+    \snippet doc/src/snippets/code/src_gui_image_qpixmapfilter.cpp 0
+
+    \sa QPainter::CompositionMode
+
+    \internal
+*/
+class QPixmapColorizeFilterPrivate : public QPixmapFilterPrivate
+{
+    Q_DECLARE_PUBLIC(QPixmapColorizeFilter)
+public:
+    QColor color;
+};
+
+/*!
+    Constructs an pixmap colorize filter.
+
+    Default color value for colorizing is QColor(0, 0, 192).
+
+    \internal
+*/
+QPixmapColorizeFilter::QPixmapColorizeFilter(QObject *parent)
+    : QPixmapFilter(*new QPixmapColorizeFilterPrivate, ColorizeFilter, parent)
+{
+    d_func()->color = QColor(0, 0, 192);
+}
+
+/*!
+    Gets the color of the colorize filter.
+
+    \internal
+*/
+QColor QPixmapColorizeFilter::color() const
+{
+    Q_D(const QPixmapColorizeFilter);
+    return d->color;
+}
+
+/*!
+    Sets the color of the colorize filter to the \a color specified.
+
+    \internal
+*/
+void QPixmapColorizeFilter::setColor(const QColor &color)
+{
+    Q_D(QPixmapColorizeFilter);
+    d->color = color;
+}
+
+/*!
+    \reimp
+
+    \internal
+*/
+void QPixmapColorizeFilter::draw(QPainter *painter, const QPointF &dest, const QPixmap &src, const QRectF &srcRect) const
+{
+    Q_D(const QPixmapColorizeFilter);
+    QPixmapFilter *filter = painter->paintEngine() && painter->paintEngine()->isExtended() ?
+        static_cast<QPaintEngineEx *>(painter->paintEngine())->createPixmapFilter(type()) : 0;
+    QPixmapColorizeFilter *colorizeFilter = static_cast<QPixmapColorizeFilter*>(filter);
+    if (colorizeFilter) {
+        colorizeFilter->setColor(d->color);
+        colorizeFilter->draw(painter, dest, src, srcRect);
+        delete colorizeFilter;
+        return;
+    }
+
+    // falling back to raster implementation
+
+    QImage srcImage;
+    QImage destImage;
+
+    if (srcRect.isNull()) {
+        srcImage = src.toImage();
+        srcImage = srcImage.convertToFormat(srcImage.hasAlphaChannel() ? QImage::Format_ARGB32_Premultiplied : QImage::Format_RGB32);
+        destImage = QImage(srcImage.size(), srcImage.format());
+    } else {
+        QRect rect = srcRect.toAlignedRect().intersected(src.rect());
+
+        srcImage = src.copy(rect).toImage();
+        srcImage = srcImage.convertToFormat(srcImage.hasAlphaChannel() ? QImage::Format_ARGB32_Premultiplied : QImage::Format_RGB32);
+        destImage = QImage(rect.size(), srcImage.format());
+    }
+
+    // do colorizing
+    QPainter destPainter(&destImage);
+    grayscale(srcImage, destImage, srcImage.rect());
+    destPainter.setCompositionMode(QPainter::CompositionMode_Screen);
+    destPainter.fillRect(srcImage.rect(), d->color);
+    destPainter.end();
+
+    if (srcImage.hasAlphaChannel())
+        destImage.setAlphaChannel(srcImage.alphaChannel());
+
+    painter->drawImage(dest, destImage);
+}
+
+class QPixmapDropShadowFilterPrivate : public QPixmapFilterPrivate
+{
+public:
+    QPixmapDropShadowFilterPrivate()
+            : offset(8, 8),
+            radius(1),
+            color(63, 63, 63, 255) {
+    }
+
+    QPointF offset;
+    qreal radius;
+    QColor color;
+
+    QPixmapConvolutionFilter *convolution;
+};
+
+/*!
+    \class QPixmapDropShadowFilter
+    \since 4.5
+    \ingroup multimedia
+
+    \brief The QPixmapDropShadowFilter class is a convenience class
+    for drawing pixmaps with drop shadows.
+
+    The drop shadow is produced by taking a copy of the source pixmap
+    and applying a color to the copy using a
+    QPainter::CompositionMode_DestinationIn operation. This produces a
+    homogeneously-colored pixmap which is then drawn using a
+    QPixmapConvolutionFilter at an offset. The original pixmap is
+    drawn on top.
+
+    The QPixmapDropShadowFilter class provides some customization
+    options to specify how the drop shadow should appear. The color of
+    the drop shadow can be modified using the setColor() function, the
+    drop shadow offset can be modified using the setOffset() function,
+    and the blur radius of the drop shadow can be changed through the
+    setBlurRadius() function.
+
+    By default, the drop shadow is a dark gray shadow, blurred with a
+    radius of 1 at an offset of 8 pixels towards the lower right.
+
+    Example:
+    \snippet doc/src/snippets/code/src_gui_image_qpixmapfilter.cpp 2
+
+    \sa QPixmapColorizeFilter, QPixmapConvolutionFilter
+
+    \internal
+ */
+
+/*!
+    Constructs drop shadow filter.
+
+    \internal
+*/
+QPixmapDropShadowFilter::QPixmapDropShadowFilter(QObject *parent)
+    : QPixmapFilter(*new QPixmapDropShadowFilterPrivate, DropShadowFilter, parent)
+{
+    Q_D(QPixmapDropShadowFilter);
+    d->convolution = new QPixmapConvolutionFilter;
+
+    setBlurRadius(1);
+}
+
+/*!
+    Destroys drop shadow filter.
+
+    \internal
+*/
+QPixmapDropShadowFilter::~QPixmapDropShadowFilter()
+{
+    Q_D(QPixmapDropShadowFilter);
+    delete d->convolution;
+}
+
+/*!
+    Returns the radius in pixels of the blur on the drop shadow.
+
+    A smaller radius results in a sharper shadow.
+
+    \sa color(), offset()
+
+    \internal
+*/
+qreal QPixmapDropShadowFilter::blurRadius() const
+{
+    Q_D(const QPixmapDropShadowFilter);
+    return d->radius;
+}
+
+/*!
+    Sets the radius in pixels of the blur on the drop shadow to the \a radius specified.
+
+    Using a smaller radius results in a sharper shadow.
+
+    \sa setColor(), setOffset()
+
+    \internal
+*/
+void QPixmapDropShadowFilter::setBlurRadius(qreal radius)
+{
+    Q_D(QPixmapDropShadowFilter);
+
+    d->radius = radius;
+
+    int dim = 2 * qRound(radius) + 1;
+    QVarLengthArray<qreal> arr(dim * dim);
+    qreal f = 1 / qreal(dim * dim);
+    for (int i = 0; i < dim * dim; ++i)
+        arr[i] = f;
+    d->convolution->setConvolutionKernel(arr.data(), dim, dim);
+}
+
+/*!
+    Returns the color of the drop shadow.
+
+    \sa blurRadius(), offset()
+
+    \internal
+*/
+QColor QPixmapDropShadowFilter::color() const
+{
+    Q_D(const QPixmapDropShadowFilter);
+    return d->color;
+}
+
+/*!
+    Sets the color of the drop shadow to the \a color specified.
+
+    \sa setBlurRadius(), setOffset()
+
+    \internal
+*/
+void QPixmapDropShadowFilter::setColor(const QColor &color)
+{
+    Q_D(QPixmapDropShadowFilter);
+    d->color = color;
+}
+
+/*!
+    Returns the shadow offset in pixels.
+
+    \sa blurRadius(), color()
+
+    \internal
+*/
+QPointF QPixmapDropShadowFilter::offset() const
+{
+    Q_D(const QPixmapDropShadowFilter);
+    return d->offset;
+}
+
+/*!
+    Sets the shadow offset in pixels to the \a offset specified.
+
+    \sa setBlurRadius(), setColor()
+
+    \internal
+*/
+void QPixmapDropShadowFilter::setOffset(const QPointF &offset)
+{
+    Q_D(QPixmapDropShadowFilter);
+    d->offset = offset;
+}
+
+/*!
+    \fn void QPixmapDropShadowFilter::setOffset(qreal dx, qreal dy)
+    \overload
+
+    Sets the shadow offset in pixels to be the displacement specified by the
+    horizontal \a dx and vertical \a dy coordinates.
+
+    \sa setBlurRadius(), setColor()
+
+    \internal
+*/
+
+/*!
+    \reimp
+
+    \internal
+ */
+QRectF QPixmapDropShadowFilter::boundingRectFor(const QRectF &rect) const
+{
+    Q_D(const QPixmapDropShadowFilter);
+
+    qreal x1 = qMin(rect.left(), rect.left() + d->offset.x() - d->radius);
+    qreal y1 = qMin(rect.top(), rect.top() + d->offset.y() - d->radius);
+    qreal x2 = qMax(rect.right(), rect.right() + d->offset.x() + d->radius);
+    qreal y2 = qMax(rect.bottom(), rect.bottom() + d->offset.y() + d->radius);
+
+    return QRectF(x1, y1, x2 - x1, y2 - y1);
+}
+
+/*!
+    \reimp
+
+    \internal
+ */
+void QPixmapDropShadowFilter::draw(QPainter *p,
+                                   const QPointF &pos,
+                                   const QPixmap &px,
+                                   const QRectF &src) const
+{
+    Q_D(const QPixmapDropShadowFilter);
+
+    QPixmap tmp = src.isNull() ? px : px.copy(src.toRect());
+    QPainter tmpPainter(&tmp);
+
+    // blacken the image...
+    tmpPainter.setCompositionMode(QPainter::CompositionMode_SourceIn);
+    tmpPainter.fillRect(0, 0, tmp.width(), tmp.height(), d->color);
+    tmpPainter.end();
+
+    // draw the blurred drop shadow...
+    d->convolution->draw(p, pos + d->offset, tmp);
+
+    // Draw the actual pixmap...
+    p->drawPixmap(pos, px, src);
+}
+QT_END_NAMESPACE
diff --git a/src/gui/image/qpixmapfilter_p.h b/src/gui/image/qpixmapfilter_p.h
new file mode 100644
index 0000000..d494c98
--- /dev/null
+++ b/src/gui/image/qpixmapfilter_p.h
@@ -0,0 +1,165 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPIXMAPFILTER_H
+#define QPIXMAPFILTER_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 <QtCore/qnamespace.h>
+#include <QtGui/qpixmap.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+class QPainter;
+class QPixmapData;
+
+class QPixmapFilterPrivate;
+
+class Q_GUI_EXPORT QPixmapFilter : public QObject
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(QPixmapFilter)
+public:
+    virtual ~QPixmapFilter() = 0;
+
+    enum FilterType {
+        ConvolutionFilter,
+        ColorizeFilter,
+        DropShadowFilter,
+
+        UserFilter = 1024
+    };
+
+    FilterType type() const;
+
+    virtual QRectF boundingRectFor(const QRectF &rect) const;
+
+    virtual void draw(QPainter *painter, const QPointF &p, const QPixmap &src, const QRectF &srcRect = QRectF()) const = 0;
+
+protected:
+    QPixmapFilter(QPixmapFilterPrivate &d, FilterType type, QObject *parent);
+    QPixmapFilter(FilterType type, QObject *parent);
+};
+
+class QPixmapConvolutionFilterPrivate;
+
+class Q_GUI_EXPORT QPixmapConvolutionFilter : public QPixmapFilter
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(QPixmapConvolutionFilter)
+
+public:
+    QPixmapConvolutionFilter(QObject *parent = 0);
+    ~QPixmapConvolutionFilter();
+
+    void setConvolutionKernel(const qreal *matrix, int rows, int columns);
+
+    QRectF boundingRectFor(const QRectF &rect) const;
+    void draw(QPainter *painter, const QPointF &dest, const QPixmap &src, const QRectF &srcRect = QRectF()) const;
+
+private:
+    friend class QGLPixmapConvolutionFilter;
+    friend class QVGPixmapConvolutionFilter;
+    const qreal *convolutionKernel() const;
+    int rows() const;
+    int columns() const;
+};
+
+class QPixmapColorizeFilterPrivate;
+
+class Q_GUI_EXPORT QPixmapColorizeFilter : public QPixmapFilter
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(QPixmapColorizeFilter)
+
+public:
+    QPixmapColorizeFilter(QObject *parent = 0);
+
+    void setColor(const QColor& color);
+    QColor color() const;
+
+    void draw(QPainter *painter, const QPointF &dest, const QPixmap &src, const QRectF &srcRect = QRectF()) const;
+};
+
+class QPixmapDropShadowFilterPrivate;
+
+class Q_GUI_EXPORT QPixmapDropShadowFilter : public QPixmapFilter
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(QPixmapDropShadowFilter)
+
+public:
+    QPixmapDropShadowFilter(QObject *parent = 0);
+    ~QPixmapDropShadowFilter();
+
+    QRectF boundingRectFor(const QRectF &rect) const;
+    void draw(QPainter *p, const QPointF &pos, const QPixmap &px, const QRectF &src = QRectF()) const;
+
+    qreal blurRadius() const;
+    void setBlurRadius(qreal radius);
+
+    QColor color() const;
+    void setColor(const QColor &color);
+
+    QPointF offset() const;
+    void setOffset(const QPointF &offset);
+    inline void setOffset(qreal dx, qreal dy) { setOffset(QPointF(dx, dy)); }
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QPIXMAPFILTER_H
diff --git a/src/gui/image/qpnghandler.cpp b/src/gui/image/qpnghandler.cpp
new file mode 100644
index 0000000..0a55910
--- /dev/null
+++ b/src/gui/image/qpnghandler.cpp
@@ -0,0 +1,973 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "private/qpnghandler_p.h"
+
+#ifndef QT_NO_IMAGEFORMAT_PNG
+#include <qcoreapplication.h>
+#include <qiodevice.h>
+#include <qimage.h>
+#include <qlist.h>
+#include <qtextcodec.h>
+#include <qvariant.h>
+#include <qvector.h>
+
+#include <png.h>
+#include <pngconf.h>
+
+#ifdef Q_OS_WINCE
+#define CALLBACK_CALL_TYPE        __cdecl
+#else
+#define CALLBACK_CALL_TYPE
+#endif
+
+QT_BEGIN_NAMESPACE
+
+#if defined(Q_OS_WINCE) && defined(STANDARDSHELL_UI_MODEL)
+#  define Q_INTERNAL_WIN_NO_THROW __declspec(nothrow)
+#else
+#  define Q_INTERNAL_WIN_NO_THROW
+#endif
+
+/*
+  All PNG files load to the minimal QImage equivalent.
+
+  All QImage formats output to reasonably efficient PNG equivalents.
+  Never to grayscale.
+*/
+
+#if defined(Q_C_CALLBACKS)
+extern "C" {
+#endif
+
+class QPNGImageWriter {
+public:
+    explicit QPNGImageWriter(QIODevice*);
+    ~QPNGImageWriter();
+
+    enum DisposalMethod { Unspecified, NoDisposal, RestoreBackground, RestoreImage };
+    void setDisposalMethod(DisposalMethod);
+    void setLooping(int loops=0); // 0 == infinity
+    void setFrameDelay(int msecs);
+    void setGamma(float);
+
+    bool writeImage(const QImage& img, int x, int y);
+    bool writeImage(const QImage& img, int quality, const QString &description, int x, int y);
+    bool writeImage(const QImage& img)
+        { return writeImage(img, 0, 0); }
+    bool writeImage(const QImage& img, int quality, const QString &description)
+        { return writeImage(img, quality, description, 0, 0); }
+
+    QIODevice* device() { return dev; }
+
+private:
+    QIODevice* dev;
+    int frames_written;
+    DisposalMethod disposal;
+    int looping;
+    int ms_delay;
+    float gamma;
+};
+
+static
+void CALLBACK_CALL_TYPE iod_read_fn(png_structp png_ptr, png_bytep data, png_size_t length)
+{
+    QIODevice *in = (QIODevice *)png_get_io_ptr(png_ptr);
+
+    while (length) {
+        int nr = in->read((char*)data, length);
+        if (nr <= 0) {
+            png_error(png_ptr, "Read Error");
+            return;
+        }
+        length -= nr;
+    }
+}
+
+
+static
+void CALLBACK_CALL_TYPE qpiw_write_fn(png_structp png_ptr, png_bytep data, png_size_t length)
+{
+    QPNGImageWriter* qpiw = (QPNGImageWriter*)png_get_io_ptr(png_ptr);
+    QIODevice* out = qpiw->device();
+
+    uint nr = out->write((char*)data, length);
+    if (nr != length) {
+        png_error(png_ptr, "Write Error");
+        return;
+    }
+}
+
+
+static
+void CALLBACK_CALL_TYPE qpiw_flush_fn(png_structp /* png_ptr */)
+{
+}
+
+#if defined(Q_C_CALLBACKS)
+}
+#endif
+
+static
+void setup_qt(QImage& image, png_structp png_ptr, png_infop info_ptr, float screen_gamma=0.0)
+{
+    if (screen_gamma != 0.0 && png_get_valid(png_ptr, info_ptr, PNG_INFO_gAMA)) {
+        double file_gamma;
+        png_get_gAMA(png_ptr, info_ptr, &file_gamma);
+        png_set_gamma(png_ptr, screen_gamma, file_gamma);
+    }
+
+    png_uint_32 width;
+    png_uint_32 height;
+    int bit_depth;
+    int color_type;
+    png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, 0, 0, 0);
+
+    if (color_type == PNG_COLOR_TYPE_GRAY) {
+        // Black & White or 8-bit grayscale
+        if (bit_depth == 1 && info_ptr->channels == 1) {
+            png_set_invert_mono(png_ptr);
+            png_read_update_info(png_ptr, info_ptr);
+            if (image.size() != QSize(width, height) || image.format() != QImage::Format_Mono) {
+                image = QImage(width, height, QImage::Format_Mono);
+                if (image.isNull())
+                    return;
+            }
+            image.setNumColors(2);
+            image.setColor(1, qRgb(0,0,0));
+            image.setColor(0, qRgb(255,255,255));
+        } else if (bit_depth == 16 && png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
+            png_set_expand(png_ptr);
+            png_set_strip_16(png_ptr);
+            png_set_gray_to_rgb(png_ptr);
+            if (image.size() != QSize(width, height) || image.format() != QImage::Format_ARGB32) {
+                image = QImage(width, height, QImage::Format_ARGB32);
+                if (image.isNull())
+                    return;
+            }
+            if (QSysInfo::ByteOrder == QSysInfo::BigEndian)
+                png_set_swap_alpha(png_ptr);
+
+            png_read_update_info(png_ptr, info_ptr);
+        } else {
+            if (bit_depth == 16)
+                png_set_strip_16(png_ptr);
+            else if (bit_depth < 8)
+                png_set_packing(png_ptr);
+            int ncols = bit_depth < 8 ? 1 << bit_depth : 256;
+            png_read_update_info(png_ptr, info_ptr);
+            if (image.size() != QSize(width, height) || image.format() != QImage::Format_Indexed8) {
+                image = QImage(width, height, QImage::Format_Indexed8);
+                if (image.isNull())
+                    return;
+            }
+            image.setNumColors(ncols);
+            for (int i=0; i<ncols; i++) {
+                int c = i*255/(ncols-1);
+                image.setColor(i, qRgba(c,c,c,0xff));
+            }
+            if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
+                const int g = info_ptr->trans_values.gray;
+                if (g < ncols) {
+                    image.setColor(g, 0);
+                }
+            }
+        }
+    } else if (color_type == PNG_COLOR_TYPE_PALETTE
+               && png_get_valid(png_ptr, info_ptr, PNG_INFO_PLTE)
+               && info_ptr->num_palette <= 256)
+    {
+        // 1-bit and 8-bit color
+        if (bit_depth != 1)
+            png_set_packing(png_ptr);
+        png_read_update_info(png_ptr, info_ptr);
+        png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, 0, 0, 0);
+        QImage::Format format = bit_depth == 1 ? QImage::Format_Mono : QImage::Format_Indexed8;
+        if (image.size() != QSize(width, height) || image.format() != format) {
+            image = QImage(width, height, format);
+            if (image.isNull())
+                return;
+        }
+        image.setNumColors(info_ptr->num_palette);
+        int i = 0;
+        if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
+            while (i < info_ptr->num_trans) {
+                image.setColor(i, qRgba(
+                    info_ptr->palette[i].red,
+                    info_ptr->palette[i].green,
+                    info_ptr->palette[i].blue,
+                    info_ptr->trans[i]
+                   )
+               );
+                i++;
+            }
+        }
+        while (i < info_ptr->num_palette) {
+            image.setColor(i, qRgba(
+                info_ptr->palette[i].red,
+                info_ptr->palette[i].green,
+                info_ptr->palette[i].blue,
+                0xff
+               )
+           );
+            i++;
+        }
+    } else {
+        // 32-bit
+        if (bit_depth == 16)
+            png_set_strip_16(png_ptr);
+
+        png_set_expand(png_ptr);
+
+        if (color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+            png_set_gray_to_rgb(png_ptr);
+
+        QImage::Format format = QImage::Format_ARGB32;
+        // Only add filler if no alpha, or we can get 5 channel data.
+        if (!(color_type & PNG_COLOR_MASK_ALPHA)
+            && !png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
+            png_set_filler(png_ptr, 0xff, QSysInfo::ByteOrder == QSysInfo::BigEndian ?
+                           PNG_FILLER_BEFORE : PNG_FILLER_AFTER);
+            // We want 4 bytes, but it isn't an alpha channel
+            format = QImage::Format_RGB32;
+        }
+        if (image.size() != QSize(width, height) || image.format() != format) {
+            image = QImage(width, height, format);
+            if (image.isNull())
+                return;
+        }
+
+        if (QSysInfo::ByteOrder == QSysInfo::BigEndian)
+            png_set_swap_alpha(png_ptr);
+
+        png_read_update_info(png_ptr, info_ptr);
+    }
+
+    // Qt==ARGB==Big(ARGB)==Little(BGRA)
+    if (QSysInfo::ByteOrder == QSysInfo::LittleEndian) {
+        png_set_bgr(png_ptr);
+    }
+}
+
+
+#if defined(Q_C_CALLBACKS)
+extern "C" {
+#endif
+static void CALLBACK_CALL_TYPE qt_png_warning(png_structp /*png_ptr*/, png_const_charp message)
+{
+    qWarning("libpng warning: %s", message);
+}
+
+#if defined(Q_C_CALLBACKS)
+}
+#endif
+
+class QPngHandlerPrivate
+{
+public:
+    enum State {
+        Ready,
+        ReadHeader,
+        Error
+    };
+
+    QPngHandlerPrivate(QPngHandler *qq)
+        : gamma(0.0), quality(2), png_ptr(0), info_ptr(0),
+          end_info(0), row_pointers(0), state(Ready), q(qq)
+    { }
+
+    float gamma;
+    int quality;
+    QString description;
+
+    png_struct *png_ptr;
+    png_info *info_ptr;
+    png_info *end_info;
+    png_byte **row_pointers;
+
+    bool readPngHeader();
+    bool readPngImage(QImage *image);
+
+    QImage::Format readImageFormat();
+
+    State state;
+
+    QPngHandler *q;
+};
+
+/*!
+    \internal
+*/
+bool Q_INTERNAL_WIN_NO_THROW QPngHandlerPrivate::readPngHeader()
+{
+    state = Error;
+    png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,0,0,0);
+    if (!png_ptr)
+        return false;
+
+    png_set_error_fn(png_ptr, 0, 0, qt_png_warning);
+
+    info_ptr = png_create_info_struct(png_ptr);
+    if (!info_ptr) {
+        png_destroy_read_struct(&png_ptr, 0, 0);
+        png_ptr = 0;
+        return false;
+    }
+
+    end_info = png_create_info_struct(png_ptr);
+    if (!end_info) {
+        png_destroy_read_struct(&png_ptr, &info_ptr, 0);
+        png_ptr = 0;
+        return false;
+    }
+
+    if (setjmp(png_jmpbuf(png_ptr))) {
+        png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
+        png_ptr = 0;
+        return false;
+    }
+
+    png_set_read_fn(png_ptr, q->device(), iod_read_fn);
+    png_read_info(png_ptr, info_ptr);
+
+#ifndef QT_NO_IMAGE_TEXT
+    png_textp text_ptr;
+    int num_text=0;
+    png_get_text(png_ptr,info_ptr,&text_ptr,&num_text);
+
+    while (num_text--) {
+        QString key, value;
+#if defined(PNG_iTXt_SUPPORTED)
+        if (text_ptr->lang) {
+            QTextCodec *codec = QTextCodec::codecForName(text_ptr->lang);
+            if (codec) {
+                key = codec->toUnicode(text_ptr->lang_key);
+                value = codec->toUnicode(QByteArray(text_ptr->text, text_ptr->itxt_length));
+            } else {
+                key = QString::fromLatin1(text_ptr->key);
+                value = QString::fromLatin1(QByteArray(text_ptr->text, int(text_ptr->text_length)));
+            }
+        } else
+#endif
+        {
+            key = QString::fromLatin1(text_ptr->key);
+            value = QString::fromLatin1(QByteArray(text_ptr->text, int(text_ptr->text_length)));
+        }
+        if (!description.isEmpty())
+            description += QLatin1String("\n\n");
+        description += key + QLatin1String(": ") + value.simplified();
+        text_ptr++;
+    }
+#endif
+
+    state = ReadHeader;
+    return true;
+}
+
+/*!
+    \internal
+*/
+bool Q_INTERNAL_WIN_NO_THROW QPngHandlerPrivate::readPngImage(QImage *outImage)
+{
+    if (state == Error)
+        return false;
+
+    if (state == Ready && !readPngHeader()) {
+        state = Error;
+        return false;
+    }
+
+    row_pointers = 0;
+    if (setjmp(png_jmpbuf(png_ptr))) {
+        png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
+        delete [] row_pointers;
+        png_ptr = 0;
+        state = Error;
+        return false;
+    }
+
+    setup_qt(*outImage, png_ptr, info_ptr, gamma);
+
+    if (outImage->isNull()) {
+        png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
+        delete [] row_pointers;
+        png_ptr = 0;
+        state = Error;
+        return false;
+    }
+
+    png_uint_32 width;
+    png_uint_32 height;
+    int bit_depth;
+    int color_type;
+    png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
+                 0, 0, 0);
+
+    uchar *data = outImage->bits();
+    int bpl = outImage->bytesPerLine();
+    row_pointers = new png_bytep[height];
+
+    for (uint y = 0; y < height; y++)
+        row_pointers[y] = data + y * bpl;
+
+    png_read_image(png_ptr, row_pointers);
+
+#if 0 // libpng takes care of this.
+    png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)
+        if (outImage->depth()==32 && png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
+            QRgb trans = 0xFF000000 | qRgb(
+                (info_ptr->trans_values.red << 8 >> bit_depth)&0xff,
+                (info_ptr->trans_values.green << 8 >> bit_depth)&0xff,
+                (info_ptr->trans_values.blue << 8 >> bit_depth)&0xff);
+            for (uint y=0; y<height; y++) {
+                for (uint x=0; x<info_ptr->width; x++) {
+                    if (((uint**)jt)[y][x] == trans) {
+                        ((uint**)jt)[y][x] &= 0x00FFFFFF;
+                    } else {
+                    }
+                }
+            }
+        }
+#endif
+
+    outImage->setDotsPerMeterX(png_get_x_pixels_per_meter(png_ptr,info_ptr));
+    outImage->setDotsPerMeterY(png_get_y_pixels_per_meter(png_ptr,info_ptr));
+
+#ifndef QT_NO_IMAGE_TEXT
+    png_textp text_ptr;
+    int num_text=0;
+    png_get_text(png_ptr,info_ptr,&text_ptr,&num_text);
+    while (num_text--) {
+        outImage->setText(text_ptr->key,0,QString::fromAscii(text_ptr->text));
+        text_ptr++;
+    }
+
+    foreach (const QString &pair, description.split(QLatin1String("\n\n"))) {
+        int index = pair.indexOf(QLatin1Char(':'));
+        if (index >= 0 && pair.indexOf(QLatin1Char(' ')) < index) {
+            outImage->setText(QLatin1String("Description"), pair.simplified());
+        } else {
+            QString key = pair.left(index);
+            outImage->setText(key, pair.mid(index + 2).simplified());
+        }
+    }
+#endif
+
+    png_read_end(png_ptr, end_info);
+    png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
+    delete [] row_pointers;
+    png_ptr = 0;
+    state = Ready;
+
+    // sanity check palette entries
+    if (color_type == PNG_COLOR_TYPE_PALETTE
+        && outImage->format() == QImage::Format_Indexed8) {
+        int color_table_size = outImage->numColors();
+        for (int y=0; y<(int)height; ++y) {
+            uchar *p = outImage->scanLine(y);
+            uchar *end = p + width;
+            while (p < end) {
+                if (*p >= color_table_size)
+                    *p = 0;
+                ++p;
+            }
+        }
+    }
+
+    return true;
+}
+
+QImage::Format QPngHandlerPrivate::readImageFormat()
+{
+        QImage::Format format = QImage::Format_Invalid;
+        png_uint_32 width, height;
+        int bit_depth, color_type;
+        if (info_ptr->color_type == PNG_COLOR_TYPE_GRAY) {
+            // Black & White or 8-bit grayscale
+            if (info_ptr->bit_depth == 1 && info_ptr->channels == 1) {
+                format = QImage::Format_Mono;
+            } else if (info_ptr->bit_depth == 16 && png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
+                format = QImage::Format_ARGB32;
+            } else {
+                format = QImage::Format_Indexed8;
+            }
+        } else if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE
+                && png_get_valid(png_ptr, info_ptr, PNG_INFO_PLTE)
+                   && info_ptr->num_palette <= 256)
+        {
+            // 1-bit and 8-bit color
+            if (info_ptr->bit_depth != 1)
+                png_set_packing(png_ptr);
+            png_read_update_info(png_ptr, info_ptr);
+            png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, 0, 0, 0);
+            format = bit_depth == 1 ? QImage::Format_Mono : QImage::Format_Indexed8;
+        } else {
+            // 32-bit
+            if (info_ptr->bit_depth == 16)
+                png_set_strip_16(png_ptr);
+
+            format = QImage::Format_ARGB32;
+            // Only add filler if no alpha, or we can get 5 channel data.
+            if (!(info_ptr->color_type & PNG_COLOR_MASK_ALPHA)
+                && !png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
+                // We want 4 bytes, but it isn't an alpha channel
+                format = QImage::Format_RGB32;
+            }
+        }
+
+        return format;
+}
+
+QPNGImageWriter::QPNGImageWriter(QIODevice* iod) :
+    dev(iod),
+    frames_written(0),
+    disposal(Unspecified),
+    looping(-1),
+    ms_delay(-1),
+    gamma(0.0)
+{
+}
+
+QPNGImageWriter::~QPNGImageWriter()
+{
+}
+
+void QPNGImageWriter::setDisposalMethod(DisposalMethod dm)
+{
+    disposal = dm;
+}
+
+void QPNGImageWriter::setLooping(int loops)
+{
+    looping = loops;
+}
+
+void QPNGImageWriter::setFrameDelay(int msecs)
+{
+    ms_delay = msecs;
+}
+
+void QPNGImageWriter::setGamma(float g)
+{
+    gamma = g;
+}
+
+
+#ifndef QT_NO_IMAGE_TEXT
+static void set_text(const QImage &image, png_structp png_ptr, png_infop info_ptr,
+                     const QString &description)
+{
+    QMap<QString, QString> text;
+    foreach (const QString &key, image.textKeys()) {
+        if (!key.isEmpty())
+            text.insert(key, image.text(key));
+    }
+    foreach (const QString &pair, description.split(QLatin1String("\n\n"))) {
+        int index = pair.indexOf(QLatin1Char(':'));
+        if (index >= 0 && pair.indexOf(QLatin1Char(' ')) < index) {
+            QString s = pair.simplified();
+            if (!s.isEmpty())
+                text.insert(QLatin1String("Description"), s);
+        } else {
+            QString key = pair.left(index);
+            if (!key.simplified().isEmpty())
+                text.insert(key, pair.mid(index + 2).simplified());
+        }
+    }
+
+    if (text.isEmpty())
+        return;
+
+    png_textp text_ptr = new png_text[text.size()];
+
+    QMap<QString, QString>::ConstIterator it = text.constBegin();
+    int i = 0;
+    while (it != text.constEnd()) {
+        QString t = it.value();
+        if (t.length() < 40)
+            text_ptr[i].compression = PNG_TEXT_COMPRESSION_NONE;
+        else
+            text_ptr[i].compression = PNG_TEXT_COMPRESSION_zTXt;
+        text_ptr[i].key = qstrdup(it.key().left(79).toLatin1().constData());
+
+#ifndef PNG_iTXt_SUPPORTED
+        QByteArray value = it.value().toLatin1();
+        text_ptr[i].text = qstrdup(value.constData());
+        text_ptr[i].text_length = value.size();
+#else
+        QByteArray value = it.value().toUtf8();
+        text_ptr[i].text = qstrdup(value.constData());
+        text_ptr[i].text_length = 0;
+        text_ptr[i].itxt_length = value.size();
+        text_ptr[i].lang = "UTF-8";
+        text_ptr[i].lang_key = qstrdup(it.key().toUtf8().constData());
+#endif
+        ++i;
+        ++it;
+    }
+
+    png_set_text(png_ptr, info_ptr, text_ptr, i);
+    for (i = 0; i < text.size(); ++i) {
+        delete [] text_ptr[i].key;
+        delete [] text_ptr[i].text;
+#ifdef PNG_iTXt_SUPPORTED
+        delete [] text_ptr[i].lang_key;
+#endif
+    }
+    delete [] text_ptr;
+}
+#endif
+
+bool QPNGImageWriter::writeImage(const QImage& image, int off_x, int off_y)
+{
+    return writeImage(image, -1, QString(), off_x, off_y);
+}
+
+bool Q_INTERNAL_WIN_NO_THROW QPNGImageWriter::writeImage(const QImage& image_in, int quality_in, const QString &description,
+                                 int off_x_in, int off_y_in)
+{
+#ifdef QT_NO_IMAGE_TEXT
+    Q_UNUSED(description);
+#endif
+
+    QImage image;
+    switch (image_in.format()) {
+    case QImage::Format_ARGB32_Premultiplied:
+    case QImage::Format_ARGB4444_Premultiplied:
+    case QImage::Format_ARGB8555_Premultiplied:
+    case QImage::Format_ARGB8565_Premultiplied:
+    case QImage::Format_ARGB6666_Premultiplied:
+        image = image_in.convertToFormat(QImage::Format_ARGB32);
+        break;
+    case QImage::Format_RGB16:
+    case QImage::Format_RGB444:
+    case QImage::Format_RGB555:
+    case QImage::Format_RGB666:
+    case QImage::Format_RGB888:
+        image = image_in.convertToFormat(QImage::Format_RGB32);
+        break;
+    default:
+        image = image_in;
+        break;
+    }
+
+    QPoint offset = image.offset();
+    int off_x = off_x_in + offset.x();
+    int off_y = off_y_in + offset.y();
+
+    png_structp png_ptr;
+    png_infop info_ptr;
+    png_bytep* row_pointers;
+
+    png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,0,0,0);
+    if (!png_ptr) {
+        return false;
+    }
+
+    png_set_error_fn(png_ptr, 0, 0, qt_png_warning);
+
+    info_ptr = png_create_info_struct(png_ptr);
+    if (!info_ptr) {
+        png_destroy_write_struct(&png_ptr, 0);
+        return false;
+    }
+
+    if (setjmp(png_jmpbuf(png_ptr))) {
+        png_destroy_write_struct(&png_ptr, &info_ptr);
+        return false;
+    }
+
+    int quality = quality_in;
+    if (quality >= 0) {
+        if (quality > 9) {
+            qWarning("PNG: Quality %d out of range", quality);
+            quality = 9;
+        }
+        png_set_compression_level(png_ptr, quality);
+    }
+
+    if (gamma != 0.0) {
+        png_set_gAMA(png_ptr, info_ptr, 1.0/gamma);
+    }
+
+    png_set_write_fn(png_ptr, (void*)this, qpiw_write_fn, qpiw_flush_fn);
+
+    info_ptr->channels =
+        (image.depth() == 32)
+        ? (image.format() == QImage::Format_RGB32 ? 3 : 4)
+        : 1;
+
+    png_set_IHDR(png_ptr, info_ptr, image.width(), image.height(),
+        image.depth() == 1 ? 1 : 8 /* per channel */,
+        image.depth() == 32
+            ? image.format() == QImage::Format_RGB32
+                ? PNG_COLOR_TYPE_RGB
+                : PNG_COLOR_TYPE_RGB_ALPHA
+            : PNG_COLOR_TYPE_PALETTE, 0, 0, 0);
+
+
+    //png_set_sBIT(png_ptr, info_ptr, 8);
+    info_ptr->sig_bit.red = 8;
+    info_ptr->sig_bit.green = 8;
+    info_ptr->sig_bit.blue = 8;
+
+    if (image.format() == QImage::Format_MonoLSB)
+       png_set_packswap(png_ptr);
+
+    png_colorp palette = 0;
+    png_bytep copy_trans = 0;
+    if (image.numColors()) {
+        // Paletted
+        int num_palette = image.numColors();
+        palette = new png_color[num_palette];
+        png_set_PLTE(png_ptr, info_ptr, palette, num_palette);
+        int* trans = new int[num_palette];
+        int num_trans = 0;
+        for (int i=0; i<num_palette; i++) {
+            QRgb rgb=image.color(i);
+            info_ptr->palette[i].red = qRed(rgb);
+            info_ptr->palette[i].green = qGreen(rgb);
+            info_ptr->palette[i].blue = qBlue(rgb);
+            trans[i] = rgb >> 24;
+            if (trans[i] < 255) {
+                num_trans = i+1;
+            }
+        }
+        if (num_trans) {
+            copy_trans = new png_byte[num_trans];
+            for (int i=0; i<num_trans; i++)
+                copy_trans[i] = trans[i];
+            png_set_tRNS(png_ptr, info_ptr, copy_trans, num_trans, 0);
+        }
+        delete [] trans;
+    }
+
+    if (image.format() != QImage::Format_RGB32) {
+        info_ptr->sig_bit.alpha = 8;
+    }
+
+    // Swap ARGB to RGBA (normal PNG format) before saving on
+    // BigEndian machines
+    if (QSysInfo::ByteOrder == QSysInfo::BigEndian) {
+        png_set_swap_alpha(png_ptr);
+    }
+
+    // Qt==ARGB==Big(ARGB)==Little(BGRA)
+    if (QSysInfo::ByteOrder == QSysInfo::LittleEndian) {
+        png_set_bgr(png_ptr);
+    }
+
+    if (off_x || off_y) {
+        png_set_oFFs(png_ptr, info_ptr, off_x, off_y, PNG_OFFSET_PIXEL);
+    }
+
+    if (frames_written > 0)
+        png_set_sig_bytes(png_ptr, 8);
+
+    if (image.dotsPerMeterX() > 0 || image.dotsPerMeterY() > 0) {
+        png_set_pHYs(png_ptr, info_ptr,
+                image.dotsPerMeterX(), image.dotsPerMeterY(),
+                PNG_RESOLUTION_METER);
+    }
+
+#ifndef QT_NO_IMAGE_TEXT
+    set_text(image, png_ptr, info_ptr, description);
+#endif
+    png_write_info(png_ptr, info_ptr);
+
+    if (image.depth() != 1)
+        png_set_packing(png_ptr);
+
+    if (image.format() == QImage::Format_RGB32)
+        png_set_filler(png_ptr, 0,
+            QSysInfo::ByteOrder == QSysInfo::BigEndian ?
+                PNG_FILLER_BEFORE : PNG_FILLER_AFTER);
+
+    if (looping >= 0 && frames_written == 0) {
+        uchar data[13] = "NETSCAPE2.0";
+        //                0123456789aBC
+        data[0xB] = looping%0x100;
+        data[0xC] = looping/0x100;
+        png_write_chunk(png_ptr, (png_byte*)"gIFx", data, 13);
+    }
+    if (ms_delay >= 0 || disposal!=Unspecified) {
+        uchar data[4];
+        data[0] = disposal;
+        data[1] = 0;
+        data[2] = (ms_delay/10)/0x100; // hundredths
+        data[3] = (ms_delay/10)%0x100;
+        png_write_chunk(png_ptr, (png_byte*)"gIFg", data, 4);
+    }
+
+    png_uint_32 width;
+    png_uint_32 height;
+    int bit_depth;
+    int color_type;
+    png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
+        0, 0, 0);
+
+    const uchar *data = image.bits();
+    int bpl = image.bytesPerLine();
+    row_pointers = new png_bytep[height];
+    uint y;
+    for (y=0; y<height; y++) {
+        row_pointers[y] = (png_bytep)(data + y * bpl);
+    }
+    png_write_image(png_ptr, row_pointers);
+    delete [] row_pointers;
+
+    png_write_end(png_ptr, info_ptr);
+    frames_written++;
+
+    if (palette)
+        delete [] palette;
+    if (copy_trans)
+        delete [] copy_trans;
+
+    png_destroy_write_struct(&png_ptr, &info_ptr);
+
+    return true;
+}
+
+static bool write_png_image(const QImage &image, QIODevice *device,
+                            int quality, float gamma, const QString &description)
+{
+    QPNGImageWriter writer(device);
+    if (quality >= 0) {
+        quality = qMin(quality, 100);
+        quality = (100-quality) * 9 / 91; // map [0,100] -> [9,0]
+    }
+    writer.setGamma(gamma);
+    return writer.writeImage(image, quality, description);
+}
+
+QPngHandler::QPngHandler()
+    : d(new QPngHandlerPrivate(this))
+{
+}
+
+QPngHandler::~QPngHandler()
+{
+    if (d->png_ptr)
+        png_destroy_read_struct(&d->png_ptr, &d->info_ptr, &d->end_info);
+    delete d;
+}
+
+bool QPngHandler::canRead() const
+{
+    if (d->state == QPngHandlerPrivate::Ready) {
+        if (!canRead(device()))
+            return false;
+        setFormat("png");
+        return true;
+    }
+    return d->state != QPngHandlerPrivate::Error;
+}
+
+bool QPngHandler::canRead(QIODevice *device)
+{
+    if (!device) {
+        qWarning("QPngHandler::canRead() called with no device");
+        return false;
+    }
+
+    return device->peek(8) == "\x89\x50\x4E\x47\x0D\x0A\x1A\x0A";
+}
+
+bool QPngHandler::read(QImage *image)
+{
+    if (!canRead())
+        return false;
+    return d->readPngImage(image);
+}
+
+bool QPngHandler::write(const QImage &image)
+{
+    return write_png_image(image, device(), d->quality, d->gamma, d->description);
+}
+
+bool QPngHandler::supportsOption(ImageOption option) const
+{
+    return option == Gamma
+        || option == Description
+        || option == ImageFormat
+        || option == Quality
+        || option == Size;
+}
+
+QVariant QPngHandler::option(ImageOption option) const
+{
+    if (d->state == QPngHandlerPrivate::Error)
+        return QVariant();
+    if (d->state == QPngHandlerPrivate::Ready && !d->readPngHeader())
+        return QVariant();
+
+    if (option == Gamma)
+        return d->gamma;
+    else if (option == Quality)
+        return d->quality;
+    else if (option == Description)
+        return d->description;
+    else if (option == Size)
+        return QSize(d->info_ptr->width, d->info_ptr->height);
+    else if (option == ImageFormat)
+        return d->readImageFormat();
+    return 0;
+}
+
+void QPngHandler::setOption(ImageOption option, const QVariant &value)
+{
+    if (option == Gamma)
+        d->gamma = value.toDouble();
+    else if (option == Quality)
+        d->quality = value.toInt();
+    else if (option == Description)
+        d->description = value.toString();
+}
+
+QByteArray QPngHandler::name() const
+{
+    return "png";
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_IMAGEFORMAT_PNG
diff --git a/src/gui/image/qpnghandler_p.h b/src/gui/image/qpnghandler_p.h
new file mode 100644
index 0000000..543fa0f
--- /dev/null
+++ b/src/gui/image/qpnghandler_p.h
@@ -0,0 +1,88 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPNGHANDLER_P_H
+#define QPNGHANDLER_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of the QLibrary class.  This header file may change from
+// version to version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "QtGui/qimageiohandler.h"
+
+#ifndef QT_NO_IMAGEFORMAT_PNG
+
+QT_BEGIN_NAMESPACE
+
+class QPngHandlerPrivate;
+class QPngHandler : public QImageIOHandler
+{
+public:
+    QPngHandler();
+    ~QPngHandler();
+
+    bool canRead() const;
+    bool read(QImage *image);
+    bool write(const QImage &image);
+
+    QByteArray name() const;
+
+    QVariant option(ImageOption option) const;
+    void setOption(ImageOption option, const QVariant &value);
+    bool supportsOption(ImageOption option) const;
+
+    static bool canRead(QIODevice *device);
+
+private:
+    QPngHandlerPrivate *d;
+};
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_IMAGEFORMAT_PNG
+#endif // QPNGHANDLER_P_H
diff --git a/src/gui/image/qppmhandler.cpp b/src/gui/image/qppmhandler.cpp
new file mode 100644
index 0000000..902f764
--- /dev/null
+++ b/src/gui/image/qppmhandler.cpp
@@ -0,0 +1,531 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "private/qppmhandler_p.h"
+
+#ifndef QT_NO_IMAGEFORMAT_PPM
+
+#include <qimage.h>
+#include <qvariant.h>
+#include <qvector.h>
+#include <ctype.h>
+
+QT_BEGIN_NAMESPACE
+
+/*****************************************************************************
+  PBM/PGM/PPM (ASCII and RAW) image read/write functions
+ *****************************************************************************/
+
+static int read_pbm_int(QIODevice *d)
+{
+    char c;
+    int          val = -1;
+    bool  digit;
+    const int buflen = 100;
+    char  buf[buflen];
+    for (;;) {
+        if (!d->getChar(&c))                // end of file
+            break;
+        digit = isdigit((uchar) c);
+        if (val != -1) {
+            if (digit) {
+                val = 10*val + c - '0';
+                continue;
+            } else {
+                if (c == '#')                        // comment
+                    d->readLine(buf, buflen);
+                break;
+            }
+        }
+        if (digit)                                // first digit
+            val = c - '0';
+        else if (isspace((uchar) c))
+            continue;
+        else if (c == '#')
+            d->readLine(buf, buflen);
+        else
+            break;
+    }
+    return val;
+}
+
+static bool read_pbm_header(QIODevice *device, char& type, int& w, int& h, int& mcc)
+{
+    char buf[3];
+    if (device->read(buf, 3) != 3)                        // read P[1-6]<white-space>
+        return false;
+
+    if (!(buf[0] == 'P' && isdigit((uchar) buf[1]) && isspace((uchar) buf[2])))
+        return false;
+
+    type = buf[1];
+    if (type < '1' || type > '6')
+        return false;
+
+    w = read_pbm_int(device);                        // get image width
+    h = read_pbm_int(device);                        // get image height
+
+    if (type == '1' || type == '4')
+        mcc = 1;                                  // ignore max color component
+    else
+        mcc = read_pbm_int(device);               // get max color component
+
+    if (w <= 0 || w > 32767 || h <= 0 || h > 32767 || mcc <= 0)
+        return false;                                        // weird P.M image
+
+    return true;
+}
+
+static bool read_pbm_body(QIODevice *device, char type, int w, int h, int mcc, QImage *outImage)
+{
+    int nbits, y;
+    int pbm_bpl;
+    bool raw;
+
+    QImage::Format format;
+    switch (type) {
+        case '1':                                // ascii PBM
+        case '4':                                // raw PBM
+            nbits = 1;
+            format = QImage::Format_Mono;
+            break;
+        case '2':                                // ascii PGM
+        case '5':                                // raw PGM
+            nbits = 8;
+            format = QImage::Format_Indexed8;
+            break;
+        case '3':                                // ascii PPM
+        case '6':                                // raw PPM
+            nbits = 32;
+            format = QImage::Format_RGB32;
+            break;
+        default:
+            return false;
+    }
+    raw = type >= '4';
+
+    int maxc = mcc;
+    if (maxc > 255)
+        maxc = 255;
+    if (outImage->size() != QSize(w, h) || outImage->format() != format) {
+        *outImage = QImage(w, h, format);
+        if (outImage->isNull())
+            return false;
+    }
+
+    pbm_bpl = (nbits*w+7)/8;                        // bytes per scanline in PBM
+
+    if (raw) {                                // read raw data
+        if (nbits == 32) {                        // type 6
+            pbm_bpl = mcc < 256 ? 3*w : 6*w;
+            uchar *buf24 = new uchar[pbm_bpl], *b;
+            QRgb  *p;
+            QRgb  *end;
+            for (y=0; y<h; y++) {
+                if (device->read((char *)buf24, pbm_bpl) != pbm_bpl) {
+                    delete[] buf24;
+                    return false;
+                }
+                p = (QRgb *)outImage->scanLine(y);
+                end = p + w;
+                b = buf24;
+                while (p < end) {
+                    if (mcc < 256) {
+                        *p++ = qRgb(b[0],b[1],b[2]);
+                        b += 3;
+                    } else {
+                        *p++ = qRgb(((int(b[0]) * 256 + int(b[1]) + 1) * 256) / (mcc + 1) - 1,
+                                    ((int(b[2]) * 256 + int(b[3]) + 1) * 256) / (mcc + 1) - 1,
+                                    ((int(b[4]) * 256 + int(b[5]) + 1) * 256) / (mcc + 1) - 1);
+                        b += 6;
+                    }
+                }
+            }
+            delete[] buf24;
+        } else {                                // type 4,5
+            for (y=0; y<h; y++) {
+                if (device->read((char *)outImage->scanLine(y), pbm_bpl)
+                        != pbm_bpl)
+                    return false;
+            }
+        }
+    } else {                                        // read ascii data
+        register uchar *p;
+        int n;
+        for (y=0; y<h; y++) {
+            p = outImage->scanLine(y);
+            n = pbm_bpl;
+            if (nbits == 1) {
+                int b;
+                int bitsLeft = w;
+                while (n--) {
+                    b = 0;
+                    for (int i=0; i<8; i++) {
+                        if (i < bitsLeft)
+                            b = (b << 1) | (read_pbm_int(device) & 1);
+                        else
+                            b = (b << 1) | (0 & 1); // pad it our self if we need to
+                    }
+                    bitsLeft -= 8;
+                    *p++ = b;
+                }
+            } else if (nbits == 8) {
+                if (mcc == maxc) {
+                    while (n--) {
+                        *p++ = read_pbm_int(device);
+                    }
+                } else {
+                    while (n--) {
+                        *p++ = read_pbm_int(device) * maxc / mcc;
+                    }
+                }
+            } else {                                // 32 bits
+                n /= 4;
+                int r, g, b;
+                if (mcc == maxc) {
+                    while (n--) {
+                        r = read_pbm_int(device);
+                        g = read_pbm_int(device);
+                        b = read_pbm_int(device);
+                        *((QRgb*)p) = qRgb(r, g, b);
+                        p += 4;
+                    }
+                } else {
+                    while (n--) {
+                        r = read_pbm_int(device) * maxc / mcc;
+                        g = read_pbm_int(device) * maxc / mcc;
+                        b = read_pbm_int(device) * maxc / mcc;
+                        *((QRgb*)p) = qRgb(r, g, b);
+                        p += 4;
+                    }
+                }
+            }
+        }
+    }
+
+    if (nbits == 1) {                                // bitmap
+        outImage->setNumColors(2);
+        outImage->setColor(0, qRgb(255,255,255)); // white
+        outImage->setColor(1, qRgb(0,0,0));        // black
+    } else if (nbits == 8) {                        // graymap
+        outImage->setNumColors(maxc+1);
+        for (int i=0; i<=maxc; i++)
+            outImage->setColor(i, qRgb(i*255/maxc,i*255/maxc,i*255/maxc));
+    }
+
+    return true;
+}
+
+static bool write_pbm_image(QIODevice *out, const QImage &sourceImage, const QByteArray &sourceFormat)
+{
+    QByteArray str;
+    QImage image = sourceImage;
+    QByteArray format = sourceFormat;
+
+    format = format.left(3);                        // ignore RAW part
+    bool gray = format == "pgm";
+
+    if (format == "pbm") {
+        image = image.convertToFormat(QImage::Format_MonoLSB);
+    } else if (image.depth() == 1) {
+        image = image.convertToFormat(QImage::Format_Indexed8);
+    } else {
+        switch (image.format()) {
+        case QImage::Format_RGB16:
+        case QImage::Format_RGB666:
+        case QImage::Format_RGB555:
+        case QImage::Format_RGB888:
+        case QImage::Format_RGB444:
+            image = image.convertToFormat(QImage::Format_RGB32);
+            break;
+        case QImage::Format_ARGB8565_Premultiplied:
+        case QImage::Format_ARGB6666_Premultiplied:
+        case QImage::Format_ARGB8555_Premultiplied:
+        case QImage::Format_ARGB4444_Premultiplied:
+            image = image.convertToFormat(QImage::Format_ARGB32);
+            break;
+        default:
+            break;
+        }
+    }
+
+    if (image.depth() == 1 && image.numColors() == 2) {
+        if (qGray(image.color(0)) < qGray(image.color(1))) {
+            // 0=dark/black, 1=light/white - invert
+            image.detach();
+            for (int y=0; y<image.height(); y++) {
+                uchar *p = image.scanLine(y);
+                uchar *end = p + image.bytesPerLine();
+                while (p < end)
+                    *p++ ^= 0xff;
+            }
+        }
+    }
+
+    uint w = image.width();
+    uint h = image.height();
+
+    str = "P\n";
+    str += QByteArray::number(w);
+    str += ' ';
+    str += QByteArray::number(h);
+    str += '\n';
+
+    switch (image.depth()) {
+        case 1: {
+            str.insert(1, '4');
+            if (out->write(str, str.length()) != str.length())
+                return false;
+            w = (w+7)/8;
+            for (uint y=0; y<h; y++) {
+                uchar* line = image.scanLine(y);
+                if (w != (uint)out->write((char*)line, w))
+                    return false;
+            }
+            }
+            break;
+
+        case 8: {
+            str.insert(1, gray ? '5' : '6');
+            str.append("255\n");
+            if (out->write(str, str.length()) != str.length())
+                return false;
+            QVector<QRgb> color = image.colorTable();
+            uint bpl = w*(gray ? 1 : 3);
+            uchar *buf   = new uchar[bpl];
+            for (uint y=0; y<h; y++) {
+                uchar *b = image.scanLine(y);
+                uchar *p = buf;
+                uchar *end = buf+bpl;
+                if (gray) {
+                    while (p < end) {
+                        uchar g = (uchar)qGray(color[*b++]);
+                        *p++ = g;
+                    }
+                } else {
+                    while (p < end) {
+                        QRgb rgb = color[*b++];
+                        *p++ = qRed(rgb);
+                        *p++ = qGreen(rgb);
+                        *p++ = qBlue(rgb);
+                    }
+                }
+                if (bpl != (uint)out->write((char*)buf, bpl))
+                    return false;
+            }
+            delete [] buf;
+            }
+            break;
+
+        case 32: {
+            str.insert(1, gray ? '5' : '6');
+            str.append("255\n");
+            if (out->write(str, str.length()) != str.length())
+                return false;
+            uint bpl = w*(gray ? 1 : 3);
+            uchar *buf = new uchar[bpl];
+            for (uint y=0; y<h; y++) {
+                QRgb  *b = (QRgb*)image.scanLine(y);
+                uchar *p = buf;
+                uchar *end = buf+bpl;
+                if (gray) {
+                    while (p < end) {
+                        uchar g = (uchar)qGray(*b++);
+                        *p++ = g;
+                    }
+                } else {
+                    while (p < end) {
+                        QRgb rgb = *b++;
+                        *p++ = qRed(rgb);
+                        *p++ = qGreen(rgb);
+                        *p++ = qBlue(rgb);
+                    }
+                }
+                if (bpl != (uint)out->write((char*)buf, bpl))
+                    return false;
+            }
+            delete [] buf;
+            }
+            break;
+
+    default:
+        return false;
+    }
+
+    return true;
+}
+
+QPpmHandler::QPpmHandler()
+    : state(Ready)
+{
+}
+
+bool QPpmHandler::readHeader()
+{
+    state = Error;
+    if (!read_pbm_header(device(), type, width, height, mcc))
+        return false;
+    state = ReadHeader;
+    return true;
+}
+
+bool QPpmHandler::canRead() const
+{
+    if (state == Ready) {
+        if (!canRead(device(), &subType))
+            return false;
+        setFormat(subType);
+        return true;
+    }
+    return state != Error;
+}
+
+bool QPpmHandler::canRead(QIODevice *device, QByteArray *subType)
+{
+    if (!device) {
+        qWarning("QPpmHandler::canRead() called with no device");
+        return false;
+    }
+
+    char head[2];
+    if (device->peek(head, sizeof(head)) != sizeof(head))
+        return false;
+
+    if (head[0] != 'P')
+        return false;
+
+    if (head[1] == '1' || head[1] == '4') {
+        if (subType)
+            *subType = "pbm";
+    } else if (head[1] == '2' || head[1] == '5') {
+        if (subType)
+            *subType = "pgm";
+    } else if (head[1] == '3' || head[1] == '6') {
+        if (subType)
+            *subType = "ppm";
+    } else {
+        return false;
+    }
+    return true;
+}
+
+bool QPpmHandler::read(QImage *image)
+{
+    if (state == Error)
+        return false;
+
+    if (state == Ready && !readHeader()) {
+        state = Error;
+        return false;
+    }
+
+    if (!read_pbm_body(device(), type, width, height, mcc, image)) {
+        state = Error;
+        return false;
+    }
+
+    state = Ready;
+    return true;
+}
+
+bool QPpmHandler::write(const QImage &image)
+{
+    return write_pbm_image(device(), image, subType);
+}
+
+bool QPpmHandler::supportsOption(ImageOption option) const
+{
+    return option == SubType
+        || option == Size
+        || option == ImageFormat;
+}
+
+QVariant QPpmHandler::option(ImageOption option) const
+{
+    if (option == SubType) {
+        return subType;
+    } else if (option == Size) {
+        if (state == Error)
+            return QVariant();
+        if (state == Ready && !const_cast<QPpmHandler*>(this)->readHeader())
+            return QVariant();
+        return QSize(width, height);
+    } else if (option == ImageFormat) {
+        if (state == Error)
+            return QVariant();
+        if (state == Ready && !const_cast<QPpmHandler*>(this)->readHeader())
+            return QVariant();
+        QImage::Format format = QImage::Format_Invalid;
+        switch (type) {
+            case '1':                                // ascii PBM
+            case '4':                                // raw PBM
+            format = QImage::Format_Mono;
+            break;
+            case '2':                                // ascii PGM
+            case '5':                                // raw PGM
+                format = QImage::Format_Indexed8;
+                break;
+            case '3':                                // ascii PPM
+            case '6':                                // raw PPM
+                format = QImage::Format_RGB32;
+                break;
+            default:
+                break;
+        }
+        return format;
+    }
+    return QVariant();
+}
+
+void QPpmHandler::setOption(ImageOption option, const QVariant &value)
+{
+    if (option == SubType)
+        subType = value.toByteArray().toLower();
+}
+
+QByteArray QPpmHandler::name() const
+{
+    return subType.isEmpty() ? QByteArray("ppm") : subType;
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_IMAGEFORMAT_PPM
diff --git a/src/gui/image/qppmhandler_p.h b/src/gui/image/qppmhandler_p.h
new file mode 100644
index 0000000..c40c51d
--- /dev/null
+++ b/src/gui/image/qppmhandler_p.h
@@ -0,0 +1,98 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPPMHANDLER_P_H
+#define QPPMHANDLER_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of the QLibrary class.  This header file may change from
+// version to version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "QtGui/qimageiohandler.h"
+
+#ifndef QT_NO_IMAGEFORMAT_PPM
+
+QT_BEGIN_NAMESPACE
+
+class QByteArray;
+class QPpmHandler : public QImageIOHandler
+{
+public:
+    QPpmHandler();
+    bool canRead() const;
+    bool read(QImage *image);
+    bool write(const QImage &image);
+
+    QByteArray name() const;
+
+    static bool canRead(QIODevice *device, QByteArray *subType = 0);
+
+    QVariant option(ImageOption option) const;
+    void setOption(ImageOption option, const QVariant &value);
+    bool supportsOption(ImageOption option) const;
+
+private:
+    bool readHeader();
+    enum State {
+        Ready,
+        ReadHeader,
+        Error
+    };
+    State state;
+    char type;
+    int width;
+    int height;
+    int mcc;
+    mutable QByteArray subType;
+};
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_IMAGEFORMAT_PPM
+
+#endif // QPPMHANDLER_P_H
diff --git a/src/gui/image/qxbmhandler.cpp b/src/gui/image/qxbmhandler.cpp
new file mode 100644
index 0000000..351bc25
--- /dev/null
+++ b/src/gui/image/qxbmhandler.cpp
@@ -0,0 +1,350 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <qplatformdefs.h>
+#include "private/qxbmhandler_p.h"
+
+#ifndef QT_NO_IMAGEFORMAT_XBM
+
+#include <qimage.h>
+#include <qiodevice.h>
+#include <qvariant.h>
+
+#include <stdio.h>
+#include <ctype.h>
+
+QT_BEGIN_NAMESPACE
+
+/*****************************************************************************
+  X bitmap image read/write functions
+ *****************************************************************************/
+
+static inline int hex2byte(register char *p)
+{
+    return ((isdigit((uchar) *p) ? *p - '0' : toupper((uchar) *p) - 'A' + 10) << 4) |
+           (isdigit((uchar) *(p+1)) ? *(p+1) - '0' : toupper((uchar) *(p+1)) - 'A' + 10);
+}
+
+static bool read_xbm_header(QIODevice *device, int& w, int& h)
+{
+    const int buflen = 300;
+    char buf[buflen + 1];
+    QRegExp r1(QLatin1String("^#define[ \t]+[a-zA-Z0-9._]+[ \t]+"));
+    QRegExp r2(QLatin1String("[0-9]+"));
+
+    qint64 readBytes = 0;
+
+    // "#define .._width <num>"
+    readBytes = device->readLine(buf, buflen);
+    if (readBytes <= 0)
+	return false;
+    buf[readBytes - 1] = '\0';
+
+    // skip initial comment, if any
+    while (buf[0] != '#' && (readBytes = device->readLine( buf, buflen )) > 0) {}
+
+    if (readBytes <= 0)
+	return false;
+    buf[readBytes - 1] = '\0';
+    QString sbuf;
+    sbuf = QString::fromLatin1(buf);
+
+    if (r1.indexIn(sbuf) == 0 &&
+         r2.indexIn(sbuf, r1.matchedLength()) == r1.matchedLength())
+        w = QByteArray(&buf[r1.matchedLength()]).trimmed().toInt();
+
+    // "#define .._height <num>"
+    readBytes = device->readLine(buf, buflen);
+    if (readBytes <= 0)
+	return false;
+    buf[readBytes - 1] = '\0';
+
+    sbuf = QString::fromLatin1(buf);
+
+    if (r1.indexIn(sbuf) == 0 &&
+         r2.indexIn(sbuf, r1.matchedLength()) == r1.matchedLength())
+        h = QByteArray(&buf[r1.matchedLength()]).trimmed().toInt();
+
+    // format error
+    if (w <= 0 || w > 32767 || h <= 0 || h > 32767)
+        return false;
+
+    return true;
+}
+
+static bool read_xbm_body(QIODevice *device, int w, int h, QImage *outImage)
+{
+    const int buflen = 300;
+    char buf[buflen + 1];
+
+    qint64 readBytes = 0;
+
+    // scan for database
+    for (;;) {
+        if ((readBytes = device->readLine(buf, buflen)) <= 0) {
+            // end of file
+            return false;
+        }
+
+        buf[readBytes] = '\0';
+        if (QByteArray::fromRawData(buf, readBytes).contains("0x"))
+            break;
+    }
+
+    if (outImage->size() != QSize(w, h) || outImage->format() != QImage::Format_MonoLSB) {
+        *outImage = QImage(w, h, QImage::Format_MonoLSB);
+        if (outImage->isNull())
+            return false;
+    }
+
+    outImage->setNumColors(2);
+    outImage->setColor(0, qRgb(255,255,255));        // white
+    outImage->setColor(1, qRgb(0,0,0));                // black
+
+    int           x = 0, y = 0;
+    uchar *b = outImage->scanLine(0);
+    char  *p = buf + QByteArray::fromRawData(buf, readBytes).indexOf("0x");
+    w = (w+7)/8;                                // byte width
+
+    while (y < h) {                                // for all encoded bytes...
+        if (p) {                                // p = "0x.."
+            *b++ = hex2byte(p+2);
+            p += 2;
+            if (++x == w && ++y < h) {
+                b = outImage->scanLine(y);
+                x = 0;
+            }
+            p = strstr(p, "0x");
+        } else {                                // read another line
+            if ((readBytes = device->readLine(buf,buflen)) <= 0)        // EOF ==> truncated image
+                break;
+            p = buf + QByteArray::fromRawData(buf, readBytes).indexOf("0x");
+        }
+    }
+
+    return true;
+}
+
+static bool read_xbm_image(QIODevice *device, QImage *outImage)
+{
+    int w = 0, h = 0;
+    if (!read_xbm_header(device, w, h))
+        return false;
+    return read_xbm_body(device, w, h, outImage);
+}
+
+static bool write_xbm_image(const QImage &sourceImage, QIODevice *device, const QString &fileName)
+{
+    QImage image = sourceImage;
+    int	       w = image.width();
+    int	       h = image.height();
+    int	       i;
+    QString    s = fileName; // get file base name
+    int        msize = s.length() + 100;
+    char *buf = new char[msize];
+
+    qsnprintf(buf, msize, "#define %s_width %d\n", s.toAscii().data(), w);
+    device->write(buf, qstrlen(buf));
+    qsnprintf(buf, msize, "#define %s_height %d\n", s.toAscii().data(), h);
+    device->write(buf, qstrlen(buf));
+    qsnprintf(buf, msize, "static char %s_bits[] = {\n ", s.toAscii().data());
+    device->write(buf, qstrlen(buf));
+
+    if (image.format() != QImage::Format_MonoLSB)
+        image = image.convertToFormat(QImage::Format_MonoLSB);
+
+    bool invert = qGray(image.color(0)) < qGray(image.color(1));
+    char hexrep[16];
+    for (i=0; i<10; i++)
+	hexrep[i] = '0' + i;
+    for (i=10; i<16; i++)
+	hexrep[i] = 'a' -10 + i;
+    if (invert) {
+	char t;
+	for (i=0; i<8; i++) {
+	    t = hexrep[15-i];
+	    hexrep[15-i] = hexrep[i];
+	    hexrep[i] = t;
+	}
+    }
+    int bcnt = 0;
+    register char *p = buf;
+    int bpl = (w+7)/8;
+    for (int y = 0; y < h; ++y) {
+        uchar *b = image.scanLine(y);
+        for (i = 0; i < bpl; ++i) {
+            *p++ = '0'; *p++ = 'x';
+            *p++ = hexrep[*b >> 4];
+            *p++ = hexrep[*b++ & 0xf];
+
+            if (i < bpl - 1 || y < h - 1) {
+                *p++ = ',';
+                if (++bcnt > 14) {
+                    *p++ = '\n';
+                    *p++ = ' ';
+                    *p   = '\0';
+                    if ((int)qstrlen(buf) != device->write(buf, qstrlen(buf))) {
+                        delete [] buf;
+                        return false;
+                    }
+                    p = buf;
+                    bcnt = 0;
+                }
+            }
+        }
+    }
+#if defined(_MSC_VER) && _MSC_VER >= 1400
+    strcpy_s(p, sizeof(" };\n"), " };\n");
+#else
+    strcpy(p, " };\n");
+#endif
+    if ((int)qstrlen(buf) != device->write(buf, qstrlen(buf))) {
+        delete [] buf;
+        return false;
+    }
+
+    delete [] buf;
+    return true;
+}
+
+QXbmHandler::QXbmHandler()
+    : state(Ready)
+{
+}
+
+bool QXbmHandler::readHeader()
+{
+    state = Error;
+    if (!read_xbm_header(device(), width, height))
+        return false;
+    state = ReadHeader;
+    return true;
+}
+
+bool QXbmHandler::canRead() const
+{
+    if (state == Ready) {
+        if (!canRead(device()))
+            return false;
+        setFormat("xbm");
+        return true;
+    }
+    return state != Error;
+}
+
+bool QXbmHandler::canRead(QIODevice *device)
+{
+    QImage image;
+
+    // it's impossible to tell whether we can load an XBM or not when
+    // it's from a sequential device, as the only way to do it is to
+    // attempt to parse the whole image.
+    if (device->isSequential())
+        return false;
+
+    qint64 oldPos = device->pos();
+    bool success = read_xbm_image(device, &image);
+    device->seek(oldPos);
+
+    return success;
+}
+
+bool QXbmHandler::read(QImage *image)
+{
+    if (state == Error)
+        return false;
+    
+    if (state == Ready && !readHeader()) {
+        state = Error;
+        return false;
+    }
+
+    if (!read_xbm_body(device(), width, height, image)) {
+        state = Error;
+        return false;
+    }
+
+    state = Ready;
+    return true;
+}
+
+bool QXbmHandler::write(const QImage &image)
+{
+    return write_xbm_image(image, device(), fileName);
+}
+
+bool QXbmHandler::supportsOption(ImageOption option) const
+{
+    return option == Name
+        || option == Size
+        || option == ImageFormat;
+}
+
+QVariant QXbmHandler::option(ImageOption option) const
+{
+    if (option == Name) {
+        return fileName;
+    } else if (option == Size) {
+        if (state == Error)
+            return QVariant();
+        if (state == Ready && !const_cast<QXbmHandler*>(this)->readHeader())
+            return QVariant();
+        return QSize(width, height);
+    } else if (option == ImageFormat) {
+        return QImage::Format_MonoLSB;
+    }
+    return QVariant();
+}
+
+void QXbmHandler::setOption(ImageOption option, const QVariant &value)
+{
+    if (option == Name)
+        fileName = value.toString();
+}
+
+QByteArray QXbmHandler::name() const
+{
+    return "xbm";
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_IMAGEFORMAT_XBM
diff --git a/src/gui/image/qxbmhandler_p.h b/src/gui/image/qxbmhandler_p.h
new file mode 100644
index 0000000..ffbbfe4
--- /dev/null
+++ b/src/gui/image/qxbmhandler_p.h
@@ -0,0 +1,95 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QXBMHANDLER_P_H
+#define QXBMHANDLER_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of the QLibrary class.  This header file may change from
+// version to version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "QtGui/qimageiohandler.h"
+
+#ifndef QT_NO_IMAGEFORMAT_XBM
+
+QT_BEGIN_NAMESPACE
+
+class QXbmHandler : public QImageIOHandler
+{
+public:
+    QXbmHandler();
+    bool canRead() const;
+    bool read(QImage *image);
+    bool write(const QImage &image);
+
+    QByteArray name() const;
+
+    static bool canRead(QIODevice *device);
+
+    QVariant option(ImageOption option) const;
+    void setOption(ImageOption option, const QVariant &value);
+    bool supportsOption(ImageOption option) const;
+
+private:
+    bool readHeader();
+    enum State {
+        Ready,
+        ReadHeader,
+        Error
+    };
+    State state;
+    int width;
+    int height;
+    QString fileName;
+};
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_IMAGEFORMAT_XBM
+
+#endif // QXBMHANDLER_P_H
diff --git a/src/gui/image/qxpmhandler.cpp b/src/gui/image/qxpmhandler.cpp
new file mode 100644
index 0000000..90bd2ab
--- /dev/null
+++ b/src/gui/image/qxpmhandler.cpp
@@ -0,0 +1,1309 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "private/qxpmhandler_p.h"
+
+#ifndef QT_NO_IMAGEFORMAT_XPM
+
+#include <private/qcolor_p.h>
+#include <qimage.h>
+#include <qmap.h>
+#include <qtextstream.h>
+#include <qvariant.h>
+
+#if defined(Q_CC_BOR)
+// needed for qsort() because of a std namespace problem on Borland
+#include "qplatformdefs.h"
+#endif
+
+#include <stdlib.h>
+
+#if defined(Q_OS_WINCE)
+#include "qguifunctions_wince.h"
+#endif
+
+QT_BEGIN_NAMESPACE
+
+static quint64 xpmHash(const QString &str)
+{
+    unsigned int hashValue = 0;
+    for (int i = 0; i < str.size(); ++i) {
+        hashValue <<= 8;
+        hashValue += (unsigned int)str.at(i).unicode();
+    }
+    return hashValue;
+}
+static quint64 xpmHash(char *str)
+{
+    unsigned int hashValue = 0;
+    while (*str != '\0') {
+        hashValue <<= 8;
+        hashValue += (unsigned int)*str;
+        ++str;
+    }
+    return hashValue;
+}
+
+#ifdef QRGB
+#undef QRGB
+#endif
+#define QRGB(r,g,b) (r*65536 + g*256 + b)
+
+static const int xpmRgbTblSize = 657;
+
+static const struct XPMRGBData {
+    uint  value;
+    const char *name;
+} xpmRgbTbl[] = {
+  { QRGB(240,248,255),  "aliceblue" },
+  { QRGB(250,235,215),  "antiquewhite" },
+  { QRGB(255,239,219),  "antiquewhite1" },
+  { QRGB(238,223,204),  "antiquewhite2" },
+  { QRGB(205,192,176),  "antiquewhite3" },
+  { QRGB(139,131,120),  "antiquewhite4" },
+  { QRGB(127,255,212),  "aquamarine" },
+  { QRGB(127,255,212),  "aquamarine1" },
+  { QRGB(118,238,198),  "aquamarine2" },
+  { QRGB(102,205,170),  "aquamarine3" },
+  { QRGB( 69,139,116),  "aquamarine4" },
+  { QRGB(240,255,255),  "azure" },
+  { QRGB(240,255,255),  "azure1" },
+  { QRGB(224,238,238),  "azure2" },
+  { QRGB(193,205,205),  "azure3" },
+  { QRGB(131,139,139),  "azure4" },
+  { QRGB(245,245,220),  "beige" },
+  { QRGB(255,228,196),  "bisque" },
+  { QRGB(255,228,196),  "bisque1" },
+  { QRGB(238,213,183),  "bisque2" },
+  { QRGB(205,183,158),  "bisque3" },
+  { QRGB(139,125,107),  "bisque4" },
+  { QRGB(  0,  0,  0),  "black" },
+  { QRGB(255,235,205),  "blanchedalmond" },
+  { QRGB(  0,  0,255),  "blue" },
+  { QRGB(  0,  0,255),  "blue1" },
+  { QRGB(  0,  0,238),  "blue2" },
+  { QRGB(  0,  0,205),  "blue3" },
+  { QRGB(  0,  0,139),  "blue4" },
+  { QRGB(138, 43,226),  "blueviolet" },
+  { QRGB(165, 42, 42),  "brown" },
+  { QRGB(255, 64, 64),  "brown1" },
+  { QRGB(238, 59, 59),  "brown2" },
+  { QRGB(205, 51, 51),  "brown3" },
+  { QRGB(139, 35, 35),  "brown4" },
+  { QRGB(222,184,135),  "burlywood" },
+  { QRGB(255,211,155),  "burlywood1" },
+  { QRGB(238,197,145),  "burlywood2" },
+  { QRGB(205,170,125),  "burlywood3" },
+  { QRGB(139,115, 85),  "burlywood4" },
+  { QRGB( 95,158,160),  "cadetblue" },
+  { QRGB(152,245,255),  "cadetblue1" },
+  { QRGB(142,229,238),  "cadetblue2" },
+  { QRGB(122,197,205),  "cadetblue3" },
+  { QRGB( 83,134,139),  "cadetblue4" },
+  { QRGB(127,255,  0),  "chartreuse" },
+  { QRGB(127,255,  0),  "chartreuse1" },
+  { QRGB(118,238,  0),  "chartreuse2" },
+  { QRGB(102,205,  0),  "chartreuse3" },
+  { QRGB( 69,139,  0),  "chartreuse4" },
+  { QRGB(210,105, 30),  "chocolate" },
+  { QRGB(255,127, 36),  "chocolate1" },
+  { QRGB(238,118, 33),  "chocolate2" },
+  { QRGB(205,102, 29),  "chocolate3" },
+  { QRGB(139, 69, 19),  "chocolate4" },
+  { QRGB(255,127, 80),  "coral" },
+  { QRGB(255,114, 86),  "coral1" },
+  { QRGB(238,106, 80),  "coral2" },
+  { QRGB(205, 91, 69),  "coral3" },
+  { QRGB(139, 62, 47),  "coral4" },
+  { QRGB(100,149,237),  "cornflowerblue" },
+  { QRGB(255,248,220),  "cornsilk" },
+  { QRGB(255,248,220),  "cornsilk1" },
+  { QRGB(238,232,205),  "cornsilk2" },
+  { QRGB(205,200,177),  "cornsilk3" },
+  { QRGB(139,136,120),  "cornsilk4" },
+  { QRGB(  0,255,255),  "cyan" },
+  { QRGB(  0,255,255),  "cyan1" },
+  { QRGB(  0,238,238),  "cyan2" },
+  { QRGB(  0,205,205),  "cyan3" },
+  { QRGB(  0,139,139),  "cyan4" },
+  { QRGB(  0,  0,139),  "darkblue" },
+  { QRGB(  0,139,139),  "darkcyan" },
+  { QRGB(184,134, 11),  "darkgoldenrod" },
+  { QRGB(255,185, 15),  "darkgoldenrod1" },
+  { QRGB(238,173, 14),  "darkgoldenrod2" },
+  { QRGB(205,149, 12),  "darkgoldenrod3" },
+  { QRGB(139,101,  8),  "darkgoldenrod4" },
+  { QRGB(169,169,169),  "darkgray" },
+  { QRGB(  0,100,  0),  "darkgreen" },
+  { QRGB(169,169,169),  "darkgrey" },
+  { QRGB(189,183,107),  "darkkhaki" },
+  { QRGB(139,  0,139),  "darkmagenta" },
+  { QRGB( 85,107, 47),  "darkolivegreen" },
+  { QRGB(202,255,112),  "darkolivegreen1" },
+  { QRGB(188,238,104),  "darkolivegreen2" },
+  { QRGB(162,205, 90),  "darkolivegreen3" },
+  { QRGB(110,139, 61),  "darkolivegreen4" },
+  { QRGB(255,140,  0),  "darkorange" },
+  { QRGB(255,127,  0),  "darkorange1" },
+  { QRGB(238,118,  0),  "darkorange2" },
+  { QRGB(205,102,  0),  "darkorange3" },
+  { QRGB(139, 69,  0),  "darkorange4" },
+  { QRGB(153, 50,204),  "darkorchid" },
+  { QRGB(191, 62,255),  "darkorchid1" },
+  { QRGB(178, 58,238),  "darkorchid2" },
+  { QRGB(154, 50,205),  "darkorchid3" },
+  { QRGB(104, 34,139),  "darkorchid4" },
+  { QRGB(139,  0,  0),  "darkred" },
+  { QRGB(233,150,122),  "darksalmon" },
+  { QRGB(143,188,143),  "darkseagreen" },
+  { QRGB(193,255,193),  "darkseagreen1" },
+  { QRGB(180,238,180),  "darkseagreen2" },
+  { QRGB(155,205,155),  "darkseagreen3" },
+  { QRGB(105,139,105),  "darkseagreen4" },
+  { QRGB( 72, 61,139),  "darkslateblue" },
+  { QRGB( 47, 79, 79),  "darkslategray" },
+  { QRGB(151,255,255),  "darkslategray1" },
+  { QRGB(141,238,238),  "darkslategray2" },
+  { QRGB(121,205,205),  "darkslategray3" },
+  { QRGB( 82,139,139),  "darkslategray4" },
+  { QRGB( 47, 79, 79),  "darkslategrey" },
+  { QRGB(  0,206,209),  "darkturquoise" },
+  { QRGB(148,  0,211),  "darkviolet" },
+  { QRGB(255, 20,147),  "deeppink" },
+  { QRGB(255, 20,147),  "deeppink1" },
+  { QRGB(238, 18,137),  "deeppink2" },
+  { QRGB(205, 16,118),  "deeppink3" },
+  { QRGB(139, 10, 80),  "deeppink4" },
+  { QRGB(  0,191,255),  "deepskyblue" },
+  { QRGB(  0,191,255),  "deepskyblue1" },
+  { QRGB(  0,178,238),  "deepskyblue2" },
+  { QRGB(  0,154,205),  "deepskyblue3" },
+  { QRGB(  0,104,139),  "deepskyblue4" },
+  { QRGB(105,105,105),  "dimgray" },
+  { QRGB(105,105,105),  "dimgrey" },
+  { QRGB( 30,144,255),  "dodgerblue" },
+  { QRGB( 30,144,255),  "dodgerblue1" },
+  { QRGB( 28,134,238),  "dodgerblue2" },
+  { QRGB( 24,116,205),  "dodgerblue3" },
+  { QRGB( 16, 78,139),  "dodgerblue4" },
+  { QRGB(178, 34, 34),  "firebrick" },
+  { QRGB(255, 48, 48),  "firebrick1" },
+  { QRGB(238, 44, 44),  "firebrick2" },
+  { QRGB(205, 38, 38),  "firebrick3" },
+  { QRGB(139, 26, 26),  "firebrick4" },
+  { QRGB(255,250,240),  "floralwhite" },
+  { QRGB( 34,139, 34),  "forestgreen" },
+  { QRGB(220,220,220),  "gainsboro" },
+  { QRGB(248,248,255),  "ghostwhite" },
+  { QRGB(255,215,  0),  "gold" },
+  { QRGB(255,215,  0),  "gold1" },
+  { QRGB(238,201,  0),  "gold2" },
+  { QRGB(205,173,  0),  "gold3" },
+  { QRGB(139,117,  0),  "gold4" },
+  { QRGB(218,165, 32),  "goldenrod" },
+  { QRGB(255,193, 37),  "goldenrod1" },
+  { QRGB(238,180, 34),  "goldenrod2" },
+  { QRGB(205,155, 29),  "goldenrod3" },
+  { QRGB(139,105, 20),  "goldenrod4" },
+  { QRGB(190,190,190),  "gray" },
+  { QRGB(  0,  0,  0),  "gray0" },
+  { QRGB(  3,  3,  3),  "gray1" },
+  { QRGB( 26, 26, 26),  "gray10" },
+  { QRGB(255,255,255),  "gray100" },
+  { QRGB( 28, 28, 28),  "gray11" },
+  { QRGB( 31, 31, 31),  "gray12" },
+  { QRGB( 33, 33, 33),  "gray13" },
+  { QRGB( 36, 36, 36),  "gray14" },
+  { QRGB( 38, 38, 38),  "gray15" },
+  { QRGB( 41, 41, 41),  "gray16" },
+  { QRGB( 43, 43, 43),  "gray17" },
+  { QRGB( 46, 46, 46),  "gray18" },
+  { QRGB( 48, 48, 48),  "gray19" },
+  { QRGB(  5,  5,  5),  "gray2" },
+  { QRGB( 51, 51, 51),  "gray20" },
+  { QRGB( 54, 54, 54),  "gray21" },
+  { QRGB( 56, 56, 56),  "gray22" },
+  { QRGB( 59, 59, 59),  "gray23" },
+  { QRGB( 61, 61, 61),  "gray24" },
+  { QRGB( 64, 64, 64),  "gray25" },
+  { QRGB( 66, 66, 66),  "gray26" },
+  { QRGB( 69, 69, 69),  "gray27" },
+  { QRGB( 71, 71, 71),  "gray28" },
+  { QRGB( 74, 74, 74),  "gray29" },
+  { QRGB(  8,  8,  8),  "gray3" },
+  { QRGB( 77, 77, 77),  "gray30" },
+  { QRGB( 79, 79, 79),  "gray31" },
+  { QRGB( 82, 82, 82),  "gray32" },
+  { QRGB( 84, 84, 84),  "gray33" },
+  { QRGB( 87, 87, 87),  "gray34" },
+  { QRGB( 89, 89, 89),  "gray35" },
+  { QRGB( 92, 92, 92),  "gray36" },
+  { QRGB( 94, 94, 94),  "gray37" },
+  { QRGB( 97, 97, 97),  "gray38" },
+  { QRGB( 99, 99, 99),  "gray39" },
+  { QRGB( 10, 10, 10),  "gray4" },
+  { QRGB(102,102,102),  "gray40" },
+  { QRGB(105,105,105),  "gray41" },
+  { QRGB(107,107,107),  "gray42" },
+  { QRGB(110,110,110),  "gray43" },
+  { QRGB(112,112,112),  "gray44" },
+  { QRGB(115,115,115),  "gray45" },
+  { QRGB(117,117,117),  "gray46" },
+  { QRGB(120,120,120),  "gray47" },
+  { QRGB(122,122,122),  "gray48" },
+  { QRGB(125,125,125),  "gray49" },
+  { QRGB( 13, 13, 13),  "gray5" },
+  { QRGB(127,127,127),  "gray50" },
+  { QRGB(130,130,130),  "gray51" },
+  { QRGB(133,133,133),  "gray52" },
+  { QRGB(135,135,135),  "gray53" },
+  { QRGB(138,138,138),  "gray54" },
+  { QRGB(140,140,140),  "gray55" },
+  { QRGB(143,143,143),  "gray56" },
+  { QRGB(145,145,145),  "gray57" },
+  { QRGB(148,148,148),  "gray58" },
+  { QRGB(150,150,150),  "gray59" },
+  { QRGB( 15, 15, 15),  "gray6" },
+  { QRGB(153,153,153),  "gray60" },
+  { QRGB(156,156,156),  "gray61" },
+  { QRGB(158,158,158),  "gray62" },
+  { QRGB(161,161,161),  "gray63" },
+  { QRGB(163,163,163),  "gray64" },
+  { QRGB(166,166,166),  "gray65" },
+  { QRGB(168,168,168),  "gray66" },
+  { QRGB(171,171,171),  "gray67" },
+  { QRGB(173,173,173),  "gray68" },
+  { QRGB(176,176,176),  "gray69" },
+  { QRGB( 18, 18, 18),  "gray7" },
+  { QRGB(179,179,179),  "gray70" },
+  { QRGB(181,181,181),  "gray71" },
+  { QRGB(184,184,184),  "gray72" },
+  { QRGB(186,186,186),  "gray73" },
+  { QRGB(189,189,189),  "gray74" },
+  { QRGB(191,191,191),  "gray75" },
+  { QRGB(194,194,194),  "gray76" },
+  { QRGB(196,196,196),  "gray77" },
+  { QRGB(199,199,199),  "gray78" },
+  { QRGB(201,201,201),  "gray79" },
+  { QRGB( 20, 20, 20),  "gray8" },
+  { QRGB(204,204,204),  "gray80" },
+  { QRGB(207,207,207),  "gray81" },
+  { QRGB(209,209,209),  "gray82" },
+  { QRGB(212,212,212),  "gray83" },
+  { QRGB(214,214,214),  "gray84" },
+  { QRGB(217,217,217),  "gray85" },
+  { QRGB(219,219,219),  "gray86" },
+  { QRGB(222,222,222),  "gray87" },
+  { QRGB(224,224,224),  "gray88" },
+  { QRGB(227,227,227),  "gray89" },
+  { QRGB( 23, 23, 23),  "gray9" },
+  { QRGB(229,229,229),  "gray90" },
+  { QRGB(232,232,232),  "gray91" },
+  { QRGB(235,235,235),  "gray92" },
+  { QRGB(237,237,237),  "gray93" },
+  { QRGB(240,240,240),  "gray94" },
+  { QRGB(242,242,242),  "gray95" },
+  { QRGB(245,245,245),  "gray96" },
+  { QRGB(247,247,247),  "gray97" },
+  { QRGB(250,250,250),  "gray98" },
+  { QRGB(252,252,252),  "gray99" },
+  { QRGB(  0,255,  0),  "green" },
+  { QRGB(  0,255,  0),  "green1" },
+  { QRGB(  0,238,  0),  "green2" },
+  { QRGB(  0,205,  0),  "green3" },
+  { QRGB(  0,139,  0),  "green4" },
+  { QRGB(173,255, 47),  "greenyellow" },
+  { QRGB(190,190,190),  "grey" },
+  { QRGB(  0,  0,  0),  "grey0" },
+  { QRGB(  3,  3,  3),  "grey1" },
+  { QRGB( 26, 26, 26),  "grey10" },
+  { QRGB(255,255,255),  "grey100" },
+  { QRGB( 28, 28, 28),  "grey11" },
+  { QRGB( 31, 31, 31),  "grey12" },
+  { QRGB( 33, 33, 33),  "grey13" },
+  { QRGB( 36, 36, 36),  "grey14" },
+  { QRGB( 38, 38, 38),  "grey15" },
+  { QRGB( 41, 41, 41),  "grey16" },
+  { QRGB( 43, 43, 43),  "grey17" },
+  { QRGB( 46, 46, 46),  "grey18" },
+  { QRGB( 48, 48, 48),  "grey19" },
+  { QRGB(  5,  5,  5),  "grey2" },
+  { QRGB( 51, 51, 51),  "grey20" },
+  { QRGB( 54, 54, 54),  "grey21" },
+  { QRGB( 56, 56, 56),  "grey22" },
+  { QRGB( 59, 59, 59),  "grey23" },
+  { QRGB( 61, 61, 61),  "grey24" },
+  { QRGB( 64, 64, 64),  "grey25" },
+  { QRGB( 66, 66, 66),  "grey26" },
+  { QRGB( 69, 69, 69),  "grey27" },
+  { QRGB( 71, 71, 71),  "grey28" },
+  { QRGB( 74, 74, 74),  "grey29" },
+  { QRGB(  8,  8,  8),  "grey3" },
+  { QRGB( 77, 77, 77),  "grey30" },
+  { QRGB( 79, 79, 79),  "grey31" },
+  { QRGB( 82, 82, 82),  "grey32" },
+  { QRGB( 84, 84, 84),  "grey33" },
+  { QRGB( 87, 87, 87),  "grey34" },
+  { QRGB( 89, 89, 89),  "grey35" },
+  { QRGB( 92, 92, 92),  "grey36" },
+  { QRGB( 94, 94, 94),  "grey37" },
+  { QRGB( 97, 97, 97),  "grey38" },
+  { QRGB( 99, 99, 99),  "grey39" },
+  { QRGB( 10, 10, 10),  "grey4" },
+  { QRGB(102,102,102),  "grey40" },
+  { QRGB(105,105,105),  "grey41" },
+  { QRGB(107,107,107),  "grey42" },
+  { QRGB(110,110,110),  "grey43" },
+  { QRGB(112,112,112),  "grey44" },
+  { QRGB(115,115,115),  "grey45" },
+  { QRGB(117,117,117),  "grey46" },
+  { QRGB(120,120,120),  "grey47" },
+  { QRGB(122,122,122),  "grey48" },
+  { QRGB(125,125,125),  "grey49" },
+  { QRGB( 13, 13, 13),  "grey5" },
+  { QRGB(127,127,127),  "grey50" },
+  { QRGB(130,130,130),  "grey51" },
+  { QRGB(133,133,133),  "grey52" },
+  { QRGB(135,135,135),  "grey53" },
+  { QRGB(138,138,138),  "grey54" },
+  { QRGB(140,140,140),  "grey55" },
+  { QRGB(143,143,143),  "grey56" },
+  { QRGB(145,145,145),  "grey57" },
+  { QRGB(148,148,148),  "grey58" },
+  { QRGB(150,150,150),  "grey59" },
+  { QRGB( 15, 15, 15),  "grey6" },
+  { QRGB(153,153,153),  "grey60" },
+  { QRGB(156,156,156),  "grey61" },
+  { QRGB(158,158,158),  "grey62" },
+  { QRGB(161,161,161),  "grey63" },
+  { QRGB(163,163,163),  "grey64" },
+  { QRGB(166,166,166),  "grey65" },
+  { QRGB(168,168,168),  "grey66" },
+  { QRGB(171,171,171),  "grey67" },
+  { QRGB(173,173,173),  "grey68" },
+  { QRGB(176,176,176),  "grey69" },
+  { QRGB( 18, 18, 18),  "grey7" },
+  { QRGB(179,179,179),  "grey70" },
+  { QRGB(181,181,181),  "grey71" },
+  { QRGB(184,184,184),  "grey72" },
+  { QRGB(186,186,186),  "grey73" },
+  { QRGB(189,189,189),  "grey74" },
+  { QRGB(191,191,191),  "grey75" },
+  { QRGB(194,194,194),  "grey76" },
+  { QRGB(196,196,196),  "grey77" },
+  { QRGB(199,199,199),  "grey78" },
+  { QRGB(201,201,201),  "grey79" },
+  { QRGB( 20, 20, 20),  "grey8" },
+  { QRGB(204,204,204),  "grey80" },
+  { QRGB(207,207,207),  "grey81" },
+  { QRGB(209,209,209),  "grey82" },
+  { QRGB(212,212,212),  "grey83" },
+  { QRGB(214,214,214),  "grey84" },
+  { QRGB(217,217,217),  "grey85" },
+  { QRGB(219,219,219),  "grey86" },
+  { QRGB(222,222,222),  "grey87" },
+  { QRGB(224,224,224),  "grey88" },
+  { QRGB(227,227,227),  "grey89" },
+  { QRGB( 23, 23, 23),  "grey9" },
+  { QRGB(229,229,229),  "grey90" },
+  { QRGB(232,232,232),  "grey91" },
+  { QRGB(235,235,235),  "grey92" },
+  { QRGB(237,237,237),  "grey93" },
+  { QRGB(240,240,240),  "grey94" },
+  { QRGB(242,242,242),  "grey95" },
+  { QRGB(245,245,245),  "grey96" },
+  { QRGB(247,247,247),  "grey97" },
+  { QRGB(250,250,250),  "grey98" },
+  { QRGB(252,252,252),  "grey99" },
+  { QRGB(240,255,240),  "honeydew" },
+  { QRGB(240,255,240),  "honeydew1" },
+  { QRGB(224,238,224),  "honeydew2" },
+  { QRGB(193,205,193),  "honeydew3" },
+  { QRGB(131,139,131),  "honeydew4" },
+  { QRGB(255,105,180),  "hotpink" },
+  { QRGB(255,110,180),  "hotpink1" },
+  { QRGB(238,106,167),  "hotpink2" },
+  { QRGB(205, 96,144),  "hotpink3" },
+  { QRGB(139, 58, 98),  "hotpink4" },
+  { QRGB(205, 92, 92),  "indianred" },
+  { QRGB(255,106,106),  "indianred1" },
+  { QRGB(238, 99, 99),  "indianred2" },
+  { QRGB(205, 85, 85),  "indianred3" },
+  { QRGB(139, 58, 58),  "indianred4" },
+  { QRGB(255,255,240),  "ivory" },
+  { QRGB(255,255,240),  "ivory1" },
+  { QRGB(238,238,224),  "ivory2" },
+  { QRGB(205,205,193),  "ivory3" },
+  { QRGB(139,139,131),  "ivory4" },
+  { QRGB(240,230,140),  "khaki" },
+  { QRGB(255,246,143),  "khaki1" },
+  { QRGB(238,230,133),  "khaki2" },
+  { QRGB(205,198,115),  "khaki3" },
+  { QRGB(139,134, 78),  "khaki4" },
+  { QRGB(230,230,250),  "lavender" },
+  { QRGB(255,240,245),  "lavenderblush" },
+  { QRGB(255,240,245),  "lavenderblush1" },
+  { QRGB(238,224,229),  "lavenderblush2" },
+  { QRGB(205,193,197),  "lavenderblush3" },
+  { QRGB(139,131,134),  "lavenderblush4" },
+  { QRGB(124,252,  0),  "lawngreen" },
+  { QRGB(255,250,205),  "lemonchiffon" },
+  { QRGB(255,250,205),  "lemonchiffon1" },
+  { QRGB(238,233,191),  "lemonchiffon2" },
+  { QRGB(205,201,165),  "lemonchiffon3" },
+  { QRGB(139,137,112),  "lemonchiffon4" },
+  { QRGB(173,216,230),  "lightblue" },
+  { QRGB(191,239,255),  "lightblue1" },
+  { QRGB(178,223,238),  "lightblue2" },
+  { QRGB(154,192,205),  "lightblue3" },
+  { QRGB(104,131,139),  "lightblue4" },
+  { QRGB(240,128,128),  "lightcoral" },
+  { QRGB(224,255,255),  "lightcyan" },
+  { QRGB(224,255,255),  "lightcyan1" },
+  { QRGB(209,238,238),  "lightcyan2" },
+  { QRGB(180,205,205),  "lightcyan3" },
+  { QRGB(122,139,139),  "lightcyan4" },
+  { QRGB(238,221,130),  "lightgoldenrod" },
+  { QRGB(255,236,139),  "lightgoldenrod1" },
+  { QRGB(238,220,130),  "lightgoldenrod2" },
+  { QRGB(205,190,112),  "lightgoldenrod3" },
+  { QRGB(139,129, 76),  "lightgoldenrod4" },
+  { QRGB(250,250,210),  "lightgoldenrodyellow" },
+  { QRGB(211,211,211),  "lightgray" },
+  { QRGB(144,238,144),  "lightgreen" },
+  { QRGB(211,211,211),  "lightgrey" },
+  { QRGB(255,182,193),  "lightpink" },
+  { QRGB(255,174,185),  "lightpink1" },
+  { QRGB(238,162,173),  "lightpink2" },
+  { QRGB(205,140,149),  "lightpink3" },
+  { QRGB(139, 95,101),  "lightpink4" },
+  { QRGB(255,160,122),  "lightsalmon" },
+  { QRGB(255,160,122),  "lightsalmon1" },
+  { QRGB(238,149,114),  "lightsalmon2" },
+  { QRGB(205,129, 98),  "lightsalmon3" },
+  { QRGB(139, 87, 66),  "lightsalmon4" },
+  { QRGB( 32,178,170),  "lightseagreen" },
+  { QRGB(135,206,250),  "lightskyblue" },
+  { QRGB(176,226,255),  "lightskyblue1" },
+  { QRGB(164,211,238),  "lightskyblue2" },
+  { QRGB(141,182,205),  "lightskyblue3" },
+  { QRGB( 96,123,139),  "lightskyblue4" },
+  { QRGB(132,112,255),  "lightslateblue" },
+  { QRGB(119,136,153),  "lightslategray" },
+  { QRGB(119,136,153),  "lightslategrey" },
+  { QRGB(176,196,222),  "lightsteelblue" },
+  { QRGB(202,225,255),  "lightsteelblue1" },
+  { QRGB(188,210,238),  "lightsteelblue2" },
+  { QRGB(162,181,205),  "lightsteelblue3" },
+  { QRGB(110,123,139),  "lightsteelblue4" },
+  { QRGB(255,255,224),  "lightyellow" },
+  { QRGB(255,255,224),  "lightyellow1" },
+  { QRGB(238,238,209),  "lightyellow2" },
+  { QRGB(205,205,180),  "lightyellow3" },
+  { QRGB(139,139,122),  "lightyellow4" },
+  { QRGB( 50,205, 50),  "limegreen" },
+  { QRGB(250,240,230),  "linen" },
+  { QRGB(255,  0,255),  "magenta" },
+  { QRGB(255,  0,255),  "magenta1" },
+  { QRGB(238,  0,238),  "magenta2" },
+  { QRGB(205,  0,205),  "magenta3" },
+  { QRGB(139,  0,139),  "magenta4" },
+  { QRGB(176, 48, 96),  "maroon" },
+  { QRGB(255, 52,179),  "maroon1" },
+  { QRGB(238, 48,167),  "maroon2" },
+  { QRGB(205, 41,144),  "maroon3" },
+  { QRGB(139, 28, 98),  "maroon4" },
+  { QRGB(102,205,170),  "mediumaquamarine" },
+  { QRGB(  0,  0,205),  "mediumblue" },
+  { QRGB(186, 85,211),  "mediumorchid" },
+  { QRGB(224,102,255),  "mediumorchid1" },
+  { QRGB(209, 95,238),  "mediumorchid2" },
+  { QRGB(180, 82,205),  "mediumorchid3" },
+  { QRGB(122, 55,139),  "mediumorchid4" },
+  { QRGB(147,112,219),  "mediumpurple" },
+  { QRGB(171,130,255),  "mediumpurple1" },
+  { QRGB(159,121,238),  "mediumpurple2" },
+  { QRGB(137,104,205),  "mediumpurple3" },
+  { QRGB( 93, 71,139),  "mediumpurple4" },
+  { QRGB( 60,179,113),  "mediumseagreen" },
+  { QRGB(123,104,238),  "mediumslateblue" },
+  { QRGB(  0,250,154),  "mediumspringgreen" },
+  { QRGB( 72,209,204),  "mediumturquoise" },
+  { QRGB(199, 21,133),  "mediumvioletred" },
+  { QRGB( 25, 25,112),  "midnightblue" },
+  { QRGB(245,255,250),  "mintcream" },
+  { QRGB(255,228,225),  "mistyrose" },
+  { QRGB(255,228,225),  "mistyrose1" },
+  { QRGB(238,213,210),  "mistyrose2" },
+  { QRGB(205,183,181),  "mistyrose3" },
+  { QRGB(139,125,123),  "mistyrose4" },
+  { QRGB(255,228,181),  "moccasin" },
+  { QRGB(255,222,173),  "navajowhite" },
+  { QRGB(255,222,173),  "navajowhite1" },
+  { QRGB(238,207,161),  "navajowhite2" },
+  { QRGB(205,179,139),  "navajowhite3" },
+  { QRGB(139,121, 94),  "navajowhite4" },
+  { QRGB(  0,  0,128),  "navy" },
+  { QRGB(  0,  0,128),  "navyblue" },
+  { QRGB(253,245,230),  "oldlace" },
+  { QRGB(107,142, 35),  "olivedrab" },
+  { QRGB(192,255, 62),  "olivedrab1" },
+  { QRGB(179,238, 58),  "olivedrab2" },
+  { QRGB(154,205, 50),  "olivedrab3" },
+  { QRGB(105,139, 34),  "olivedrab4" },
+  { QRGB(255,165,  0),  "orange" },
+  { QRGB(255,165,  0),  "orange1" },
+  { QRGB(238,154,  0),  "orange2" },
+  { QRGB(205,133,  0),  "orange3" },
+  { QRGB(139, 90,  0),  "orange4" },
+  { QRGB(255, 69,  0),  "orangered" },
+  { QRGB(255, 69,  0),  "orangered1" },
+  { QRGB(238, 64,  0),  "orangered2" },
+  { QRGB(205, 55,  0),  "orangered3" },
+  { QRGB(139, 37,  0),  "orangered4" },
+  { QRGB(218,112,214),  "orchid" },
+  { QRGB(255,131,250),  "orchid1" },
+  { QRGB(238,122,233),  "orchid2" },
+  { QRGB(205,105,201),  "orchid3" },
+  { QRGB(139, 71,137),  "orchid4" },
+  { QRGB(238,232,170),  "palegoldenrod" },
+  { QRGB(152,251,152),  "palegreen" },
+  { QRGB(154,255,154),  "palegreen1" },
+  { QRGB(144,238,144),  "palegreen2" },
+  { QRGB(124,205,124),  "palegreen3" },
+  { QRGB( 84,139, 84),  "palegreen4" },
+  { QRGB(175,238,238),  "paleturquoise" },
+  { QRGB(187,255,255),  "paleturquoise1" },
+  { QRGB(174,238,238),  "paleturquoise2" },
+  { QRGB(150,205,205),  "paleturquoise3" },
+  { QRGB(102,139,139),  "paleturquoise4" },
+  { QRGB(219,112,147),  "palevioletred" },
+  { QRGB(255,130,171),  "palevioletred1" },
+  { QRGB(238,121,159),  "palevioletred2" },
+  { QRGB(205,104,137),  "palevioletred3" },
+  { QRGB(139, 71, 93),  "palevioletred4" },
+  { QRGB(255,239,213),  "papayawhip" },
+  { QRGB(255,218,185),  "peachpuff" },
+  { QRGB(255,218,185),  "peachpuff1" },
+  { QRGB(238,203,173),  "peachpuff2" },
+  { QRGB(205,175,149),  "peachpuff3" },
+  { QRGB(139,119,101),  "peachpuff4" },
+  { QRGB(205,133, 63),  "peru" },
+  { QRGB(255,192,203),  "pink" },
+  { QRGB(255,181,197),  "pink1" },
+  { QRGB(238,169,184),  "pink2" },
+  { QRGB(205,145,158),  "pink3" },
+  { QRGB(139, 99,108),  "pink4" },
+  { QRGB(221,160,221),  "plum" },
+  { QRGB(255,187,255),  "plum1" },
+  { QRGB(238,174,238),  "plum2" },
+  { QRGB(205,150,205),  "plum3" },
+  { QRGB(139,102,139),  "plum4" },
+  { QRGB(176,224,230),  "powderblue" },
+  { QRGB(160, 32,240),  "purple" },
+  { QRGB(155, 48,255),  "purple1" },
+  { QRGB(145, 44,238),  "purple2" },
+  { QRGB(125, 38,205),  "purple3" },
+  { QRGB( 85, 26,139),  "purple4" },
+  { QRGB(255,  0,  0),  "red" },
+  { QRGB(255,  0,  0),  "red1" },
+  { QRGB(238,  0,  0),  "red2" },
+  { QRGB(205,  0,  0),  "red3" },
+  { QRGB(139,  0,  0),  "red4" },
+  { QRGB(188,143,143),  "rosybrown" },
+  { QRGB(255,193,193),  "rosybrown1" },
+  { QRGB(238,180,180),  "rosybrown2" },
+  { QRGB(205,155,155),  "rosybrown3" },
+  { QRGB(139,105,105),  "rosybrown4" },
+  { QRGB( 65,105,225),  "royalblue" },
+  { QRGB( 72,118,255),  "royalblue1" },
+  { QRGB( 67,110,238),  "royalblue2" },
+  { QRGB( 58, 95,205),  "royalblue3" },
+  { QRGB( 39, 64,139),  "royalblue4" },
+  { QRGB(139, 69, 19),  "saddlebrown" },
+  { QRGB(250,128,114),  "salmon" },
+  { QRGB(255,140,105),  "salmon1" },
+  { QRGB(238,130, 98),  "salmon2" },
+  { QRGB(205,112, 84),  "salmon3" },
+  { QRGB(139, 76, 57),  "salmon4" },
+  { QRGB(244,164, 96),  "sandybrown" },
+  { QRGB( 46,139, 87),  "seagreen" },
+  { QRGB( 84,255,159),  "seagreen1" },
+  { QRGB( 78,238,148),  "seagreen2" },
+  { QRGB( 67,205,128),  "seagreen3" },
+  { QRGB( 46,139, 87),  "seagreen4" },
+  { QRGB(255,245,238),  "seashell" },
+  { QRGB(255,245,238),  "seashell1" },
+  { QRGB(238,229,222),  "seashell2" },
+  { QRGB(205,197,191),  "seashell3" },
+  { QRGB(139,134,130),  "seashell4" },
+  { QRGB(160, 82, 45),  "sienna" },
+  { QRGB(255,130, 71),  "sienna1" },
+  { QRGB(238,121, 66),  "sienna2" },
+  { QRGB(205,104, 57),  "sienna3" },
+  { QRGB(139, 71, 38),  "sienna4" },
+  { QRGB(135,206,235),  "skyblue" },
+  { QRGB(135,206,255),  "skyblue1" },
+  { QRGB(126,192,238),  "skyblue2" },
+  { QRGB(108,166,205),  "skyblue3" },
+  { QRGB( 74,112,139),  "skyblue4" },
+  { QRGB(106, 90,205),  "slateblue" },
+  { QRGB(131,111,255),  "slateblue1" },
+  { QRGB(122,103,238),  "slateblue2" },
+  { QRGB(105, 89,205),  "slateblue3" },
+  { QRGB( 71, 60,139),  "slateblue4" },
+  { QRGB(112,128,144),  "slategray" },
+  { QRGB(198,226,255),  "slategray1" },
+  { QRGB(185,211,238),  "slategray2" },
+  { QRGB(159,182,205),  "slategray3" },
+  { QRGB(108,123,139),  "slategray4" },
+  { QRGB(112,128,144),  "slategrey" },
+  { QRGB(255,250,250),  "snow" },
+  { QRGB(255,250,250),  "snow1" },
+  { QRGB(238,233,233),  "snow2" },
+  { QRGB(205,201,201),  "snow3" },
+  { QRGB(139,137,137),  "snow4" },
+  { QRGB(  0,255,127),  "springgreen" },
+  { QRGB(  0,255,127),  "springgreen1" },
+  { QRGB(  0,238,118),  "springgreen2" },
+  { QRGB(  0,205,102),  "springgreen3" },
+  { QRGB(  0,139, 69),  "springgreen4" },
+  { QRGB( 70,130,180),  "steelblue" },
+  { QRGB( 99,184,255),  "steelblue1" },
+  { QRGB( 92,172,238),  "steelblue2" },
+  { QRGB( 79,148,205),  "steelblue3" },
+  { QRGB( 54,100,139),  "steelblue4" },
+  { QRGB(210,180,140),  "tan" },
+  { QRGB(255,165, 79),  "tan1" },
+  { QRGB(238,154, 73),  "tan2" },
+  { QRGB(205,133, 63),  "tan3" },
+  { QRGB(139, 90, 43),  "tan4" },
+  { QRGB(216,191,216),  "thistle" },
+  { QRGB(255,225,255),  "thistle1" },
+  { QRGB(238,210,238),  "thistle2" },
+  { QRGB(205,181,205),  "thistle3" },
+  { QRGB(139,123,139),  "thistle4" },
+  { QRGB(255, 99, 71),  "tomato" },
+  { QRGB(255, 99, 71),  "tomato1" },
+  { QRGB(238, 92, 66),  "tomato2" },
+  { QRGB(205, 79, 57),  "tomato3" },
+  { QRGB(139, 54, 38),  "tomato4" },
+  { QRGB( 64,224,208),  "turquoise" },
+  { QRGB(  0,245,255),  "turquoise1" },
+  { QRGB(  0,229,238),  "turquoise2" },
+  { QRGB(  0,197,205),  "turquoise3" },
+  { QRGB(  0,134,139),  "turquoise4" },
+  { QRGB(238,130,238),  "violet" },
+  { QRGB(208, 32,144),  "violetred" },
+  { QRGB(255, 62,150),  "violetred1" },
+  { QRGB(238, 58,140),  "violetred2" },
+  { QRGB(205, 50,120),  "violetred3" },
+  { QRGB(139, 34, 82),  "violetred4" },
+  { QRGB(245,222,179),  "wheat" },
+  { QRGB(255,231,186),  "wheat1" },
+  { QRGB(238,216,174),  "wheat2" },
+  { QRGB(205,186,150),  "wheat3" },
+  { QRGB(139,126,102),  "wheat4" },
+  { QRGB(255,255,255),  "white" },
+  { QRGB(245,245,245),  "whitesmoke" },
+  { QRGB(255,255,  0),  "yellow" },
+  { QRGB(255,255,  0),  "yellow1" },
+  { QRGB(238,238,  0),  "yellow2" },
+  { QRGB(205,205,  0),  "yellow3" },
+  { QRGB(139,139,  0),  "yellow4" },
+  { QRGB(154,205, 50),  "yellowgreen" } };
+
+#if defined(Q_C_CALLBACKS)
+extern "C" {
+#endif
+static int rgb_cmp(const void *d1, const void *d2)
+{
+    return qstricmp(((XPMRGBData *)d1)->name, ((XPMRGBData *)d2)->name);
+}
+#if defined(Q_C_CALLBACKS)
+}
+#endif
+
+static bool qt_get_named_xpm_rgb(const char *name_no_space, QRgb *rgb)
+{
+    XPMRGBData x;
+    x.name = name_no_space;
+    // Funtion bsearch() is supposed to be
+    // void *bsearch(const void *key, const void *base, ...
+    // So why (char*)? Are there broken bsearch() declarations out there?
+    XPMRGBData *r = (XPMRGBData *)bsearch((char *)&x, (char *)xpmRgbTbl, xpmRgbTblSize,
+                                          sizeof(XPMRGBData), rgb_cmp);
+    if (r) {
+        *rgb = r->value;
+        return true;
+    } else {
+        return false;
+    }
+}
+
+/*****************************************************************************
+  Misc. utility functions
+ *****************************************************************************/
+static QString fbname(const QString &fileName) // get file basename (sort of)
+{
+    QString s = fileName;
+    if (!s.isEmpty()) {
+        int i;
+        if ((i = s.lastIndexOf(QLatin1Char('/'))) >= 0)
+            s = s.mid(i);
+        if ((i = s.lastIndexOf(QLatin1Char('\\'))) >= 0)
+            s = s.mid(i);
+        QRegExp r(QLatin1String("[a-zA-Z][a-zA-Z0-9_]*"));
+        int p = r.indexIn(s);
+        if (p == -1)
+            s.clear();
+        else
+            s = s.mid(p, r.matchedLength());
+    }
+    if (s.isEmpty())
+        s = QString::fromLatin1("dummy");
+    return s;
+}
+
+// Skip until ", read until the next ", return the rest in *buf
+// Returns false on error, true on success
+
+static bool read_xpm_string(QByteArray &buf, QIODevice *d, const char * const *source, int &index,
+                            QByteArray &state)
+{
+    if (source) {
+        buf = source[index++];
+        return true;
+    }
+
+    buf = "";
+    bool gotQuote = false;
+    int offset = 0;
+    forever {
+        if (offset == state.size() || state.isEmpty()) {
+            char buf[2048];
+            qint64 bytesRead = d->read(buf, sizeof(buf));
+            if (bytesRead <= 0)
+                return false;
+            state = QByteArray(buf, int(bytesRead));
+            offset = 0;
+        }
+
+        if (!gotQuote) {
+            if (state.at(offset++) == '"')
+                gotQuote = true;
+        } else {
+            char c = state.at(offset++);
+            if (c == '"')
+                break;
+            buf += c;
+        }
+    }
+    state.remove(0, offset);
+    return true;
+}
+
+// Tests if the given prefix can be the start of an XPM color specification
+
+static bool is_xpm_color_spec_prefix(const QByteArray& prefix)
+{
+    return prefix == "c" ||
+           prefix == "g" ||
+           prefix == "g4" ||
+           prefix == "m" ||
+           prefix == "s";
+}
+
+// Reads XPM header.
+
+static bool read_xpm_header(
+    QIODevice *device, const char * const * source, int& index, QByteArray &state,
+    int *cpp, int *ncols, int *w, int *h)
+{
+    QByteArray buf(200, 0);
+
+    if (!read_xpm_string(buf, device, source, index, state))
+        return false;
+
+#if defined(_MSC_VER) && _MSC_VER >= 1400 && !defined(Q_OS_WINCE)
+        if (sscanf_s(buf, "%d %d %d %d", w, h, ncols, cpp) < 4)
+#else
+    if (sscanf(buf, "%d %d %d %d", w, h, ncols, cpp) < 4)
+#endif
+        return false;                                        // < 4 numbers parsed
+
+    return true;
+}
+
+// Reads XPM body (color information & pixels).
+
+static bool read_xpm_body(
+    QIODevice *device, const char * const * source, int& index, QByteArray& state,
+    int cpp, int ncols, int w, int h, QImage& image)
+{
+    QByteArray buf(200, 0);
+    int i;
+
+    if (cpp > 15)
+        return false;
+
+    // For > 256 colors, we delay creation of the image until
+    // after we have read the color specifications, so that we can
+    // create it in correct format (Format_RGB32 vs Format_ARGB32,
+    // depending on absence or presence of "c none", respectively)
+    if (ncols <= 256) {
+        if (image.size() != QSize(w, h) || image.format() != QImage::Format_Indexed8) {
+            image = QImage(w, h, QImage::Format_Indexed8);
+            if (image.isNull())
+                return false;
+        }
+        image.setNumColors(ncols);
+    }
+
+    QMap<quint64, int> colorMap;
+    int currentColor;
+    bool hasTransparency = false;
+
+    for(currentColor=0; currentColor < ncols; ++currentColor) {
+        if (!read_xpm_string(buf, device, source, index, state)) {
+            qWarning("QImage: XPM color specification missing");
+            return false;
+        }
+        QByteArray index;
+        index = buf.left(cpp);
+        buf = buf.mid(cpp).simplified().trimmed().toLower();
+        QList<QByteArray> tokens = buf.split(' ');
+        i = tokens.indexOf("c");
+        if (i < 0)
+            i = tokens.indexOf("g");
+        if (i < 0)
+            i = tokens.indexOf("g4");
+        if (i < 0)
+            i = tokens.indexOf("m");
+        if (i < 0) {
+            qWarning("QImage: XPM color specification is missing: %s", buf.constData());
+            return false;        // no c/g/g4/m specification at all
+        }
+        QByteArray color;
+        while ((++i < tokens.size()) && !is_xpm_color_spec_prefix(tokens.at(i))) {
+            color.append(tokens.at(i));
+        }
+        if (color.isEmpty()) {
+            qWarning("QImage: XPM color value is missing from specification: %s", buf.constData());
+            return false;        // no color value
+        }
+        buf = color;
+        if (buf == "none") {
+            hasTransparency = true;
+            int transparentColor = currentColor;
+            if (ncols <= 256) {
+                image.setColor(transparentColor, 0);
+                colorMap.insert(xpmHash(QLatin1String(index.constData())), transparentColor);
+            } else {
+                colorMap.insert(xpmHash(QLatin1String(index.constData())), 0);
+            }
+        } else {
+            QRgb c_rgb;
+            if (((buf.length()-1) % 3) && (buf[0] == '#')) {
+                buf.truncate(((buf.length()-1) / 4 * 3) + 1); // remove alpha channel left by imagemagick
+            }
+            if (buf[0] == '#') {
+                qt_get_hex_rgb(buf, &c_rgb);
+            } else {
+                qt_get_named_xpm_rgb(buf, &c_rgb);
+            }
+            if (ncols <= 256) {
+                image.setColor(currentColor, 0xff000000 | c_rgb);
+                colorMap.insert(xpmHash(QLatin1String(index.constData())), currentColor);
+            } else {
+                colorMap.insert(xpmHash(QLatin1String(index.constData())), 0xff000000 | c_rgb);
+            }
+        }
+    }
+
+    if (ncols > 256) {
+        // Now we can create 32-bit image of appropriate format
+        QImage::Format format = hasTransparency ?
+                                QImage::Format_ARGB32 : QImage::Format_RGB32;
+        if (image.size() != QSize(w, h) || image.format() != format) {
+            image = QImage(w, h, format);
+            if (image.isNull())
+                return false;
+        }
+    }
+
+    // Read pixels
+    for(int y=0; y<h; y++) {
+        if (!read_xpm_string(buf, device, source, index, state)) {
+            qWarning("QImage: XPM pixels missing on image line %d", y);
+            return false;
+        }
+        if (image.depth() == 8) {
+            uchar *p = image.scanLine(y);
+            uchar *d = (uchar *)buf.data();
+            uchar *end = d + buf.length();
+            int x;
+            if (cpp == 1) {
+                char b[2];
+                b[1] = '\0';
+                for (x=0; x<w && d<end; x++) {
+                    b[0] = *d++;
+                    *p++ = (uchar)colorMap[xpmHash(b)];
+                }
+            } else {
+                char b[16];
+                b[cpp] = '\0';
+                for (x=0; x<w && d<end; x++) {
+                    memcpy(b, (char *)d, cpp);
+                    *p++ = (uchar)colorMap[xpmHash(b)];
+                    d += cpp;
+                }
+            }
+            // avoid uninitialized memory for malformed xpms
+            if (x < w) {
+                qWarning("QImage: XPM pixels missing on image line %d (possibly a C++ trigraph).", y);
+                memset(p, 0, w - x);
+            }
+        } else {
+            QRgb *p = (QRgb*)image.scanLine(y);
+            uchar *d = (uchar *)buf.data();
+            uchar *end = d + buf.length();
+            int x;
+            char b[16];
+            b[cpp] = '\0';
+            for (x=0; x<w && d<end; x++) {
+                memcpy(b, (char *)d, cpp);
+                *p++ = (QRgb)colorMap[xpmHash(b)];
+                d += cpp;
+            }
+            // avoid uninitialized memory for malformed xpms
+            if (x < w) {
+                qWarning("QImage: XPM pixels missing on image line %d (possibly a C++ trigraph).", y);
+                memset(p, 0, (w - x)*4);
+            }
+        }
+    }
+
+    if (device) {
+        // Rewind unused characters, and skip to the end of the XPM struct.
+        for (int i = state.size() - 1; i >= 0; --i)
+            device->ungetChar(state[i]);
+        char c;
+        while (device->getChar(&c) && c != ';') {}
+        while (device->getChar(&c) && c != '\n') {}
+    }
+    return true;
+}
+
+//
+// INTERNAL
+//
+// Reads an .xpm from either the QImageIO or from the QString *.
+// One of the two HAS to be 0, the other one is used.
+//
+
+bool qt_read_xpm_image_or_array(QIODevice *device, const char * const * source, QImage &image)
+{
+    if (!source)
+        return true;
+
+    QByteArray buf(200, 0);
+    QByteArray state;
+
+    int cpp, ncols, w, h, index = 0;
+
+    if (device) {
+        // "/* XPM */"
+        int readBytes;
+        if ((readBytes = device->readLine(buf.data(), buf.size())) < 0)
+            return false;
+
+        if (buf.indexOf("/* XPM") != 0) {
+            while (readBytes > 0) {
+                device->ungetChar(buf.at(readBytes - 1));
+                --readBytes;
+            }
+            return false;
+        }// bad magic
+    }
+
+    if (!read_xpm_header(device, source, index, state, &cpp, &ncols, &w, &h))
+        return false;
+
+    return read_xpm_body(device, source, index, state, cpp, ncols, w, h, image);
+}
+
+static const char* xpm_color_name(int cpp, int index)
+{
+    static char returnable[5];
+    static const char code[] = ".#abcdefghijklmnopqrstuvwxyzABCD"
+                               "EFGHIJKLMNOPQRSTUVWXYZ0123456789";
+    // cpp is limited to 4 and index is limited to 64^cpp
+    if (cpp > 1) {
+        if (cpp > 2) {
+            if (cpp > 3) {
+                returnable[3] = code[index % 64];
+                index /= 64;
+            } else
+                returnable[3] = '\0';
+            returnable[2] = code[index % 64];
+            index /= 64;
+        } else
+            returnable[2] = '\0';
+        // the following 4 lines are a joke!
+        if (index == 0)
+            index = 64*44+21;
+        else if (index == 64*44+21)
+            index = 0;
+        returnable[1] = code[index % 64];
+        index /= 64;
+    } else
+        returnable[1] = '\0';
+    returnable[0] = code[index];
+
+    return returnable;
+}
+
+
+// write XPM image data
+static bool write_xpm_image(const QImage &sourceImage, QIODevice *device, const QString &fileName)
+{
+    if (!device->isWritable())
+        return false;
+
+    QImage image;
+    if (sourceImage.depth() != 32)
+        image = sourceImage.convertToFormat(QImage::Format_RGB32);
+    else
+        image = sourceImage;
+
+    QMap<QRgb, int> colorMap;
+
+    int w = image.width(), h = image.height(), ncolors = 0;
+    int x, y;
+
+    // build color table
+    for(y=0; y<h; y++) {
+        QRgb * yp = (QRgb *)image.scanLine(y);
+        for(x=0; x<w; x++) {
+            QRgb color = *(yp + x);
+            if (!colorMap.contains(color))
+                colorMap.insert(color, ncolors++);
+        }
+    }
+
+    // number of 64-bit characters per pixel needed to encode all colors
+    int cpp = 1;
+    for (int k = 64; ncolors > k; k *= 64) {
+        ++cpp;
+        // limit to 4 characters per pixel
+        // 64^4 colors is enough for a 4096x4096 image
+         if (cpp > 4)
+            break;
+    }
+
+    QString line;
+
+    // write header
+    QTextStream s(device);
+    s << "/* XPM */" << endl
+      << "static char *" << fbname(fileName) << "[]={" << endl
+      << "\"" << w << " " << h << " " << ncolors << " " << cpp << "\"";
+
+    // write palette
+    QMap<QRgb, int>::Iterator c = colorMap.begin();
+    while (c != colorMap.end()) {
+        QRgb color = c.key();
+        if (image.format() != QImage::Format_RGB32 && !qAlpha(color))
+            line.sprintf("\"%s c None\"",
+                          xpm_color_name(cpp, *c));
+        else
+            line.sprintf("\"%s c #%02x%02x%02x\"",
+                          xpm_color_name(cpp, *c),
+                          qRed(color),
+                          qGreen(color),
+                          qBlue(color));
+        ++c;
+        s << "," << endl << line;
+    }
+
+    // write pixels, limit to 4 characters per pixel
+    line.truncate(cpp*w);
+    for(y=0; y<h; y++) {
+        QRgb * yp = (QRgb *) image.scanLine(y);
+        int cc = 0;
+        for(x=0; x<w; x++) {
+            int color = (int)(*(yp + x));
+            QByteArray chars(xpm_color_name(cpp, colorMap[color]));
+            line[cc++] = QLatin1Char(chars[0]);
+            if (cpp > 1) {
+                line[cc++] = QLatin1Char(chars[1]);
+                if (cpp > 2) {
+                    line[cc++] = QLatin1Char(chars[2]);
+                    if (cpp > 3) {
+                        line[cc++] = QLatin1Char(chars[3]);
+                    }
+                }
+            }
+        }
+        s << "," << endl << "\"" << line << "\"";
+    }
+    s << "};" << endl;
+    return (s.status() == QTextStream::Ok);
+}
+
+QXpmHandler::QXpmHandler()
+    : state(Ready), index(0)
+{
+}
+
+bool QXpmHandler::readHeader()
+{
+    state = Error;
+    if (!read_xpm_header(device(), 0, index, buffer, &cpp, &ncols, &width, &height))
+        return false;
+    state = ReadHeader;
+    return true;
+}
+
+bool QXpmHandler::readImage(QImage *image)
+{
+    if (state == Error)
+        return false;
+
+    if (state == Ready && !readHeader()) {
+        state = Error;
+        return false;
+    }
+
+    if (!read_xpm_body(device(), 0, index, buffer, cpp, ncols, width, height, *image)) {
+        state = Error;
+        return false;
+    }
+
+    state = Ready;
+    return true;
+}
+
+bool QXpmHandler::canRead() const
+{
+    if (state == Ready && canRead(device())) {
+        setFormat("xpm");
+        return true;
+    }
+    return state != Error;
+}
+
+bool QXpmHandler::canRead(QIODevice *device)
+{
+    if (!device) {
+        qWarning("QXpmHandler::canRead() called with no device");
+        return false;
+    }
+
+    char head[6];
+    if (device->peek(head, sizeof(head)) != sizeof(head))
+        return false;
+
+    return qstrncmp(head, "/* XPM", 6) == 0;
+}
+
+bool QXpmHandler::read(QImage *image)
+{
+    if (!canRead())
+        return false;
+    return readImage(image);
+}
+
+bool QXpmHandler::write(const QImage &image)
+{
+    return write_xpm_image(image, device(), fileName);
+}
+
+bool QXpmHandler::supportsOption(ImageOption option) const
+{
+    return option == Name
+        || option == Size
+        || option == ImageFormat;
+}
+
+QVariant QXpmHandler::option(ImageOption option) const
+{
+    if (option == Name) {
+        return fileName;
+    } else if (option == Size) {
+        if (state == Error)
+            return QVariant();
+        if (state == Ready && !const_cast<QXpmHandler*>(this)->readHeader())
+            return QVariant();
+        return QSize(width, height);
+    } else if (option == ImageFormat) {
+        if (state == Error)
+            return QVariant();
+        if (state == Ready && !const_cast<QXpmHandler*>(this)->readHeader())
+            return QVariant();
+        // If we have more than 256 colors in the table, we need to
+        // figure out, if it contains transparency. That means reading
+        // the whole color table, which is too much work work pre-checking
+        // the image format
+        if (ncols <= 256)
+            return QImage::Format_Indexed8;
+        else
+            return QImage::Format_Invalid;
+    }
+
+    return QVariant();
+}
+
+void QXpmHandler::setOption(ImageOption option, const QVariant &value)
+{
+    if (option == Name)
+        fileName = value.toString();
+}
+
+QByteArray QXpmHandler::name() const
+{
+    return "xpm";
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_IMAGEFORMAT_XPM
diff --git a/src/gui/image/qxpmhandler_p.h b/src/gui/image/qxpmhandler_p.h
new file mode 100644
index 0000000..5c2f809
--- /dev/null
+++ b/src/gui/image/qxpmhandler_p.h
@@ -0,0 +1,100 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QXPMHANDLER_P_H
+#define QXPMHANDLER_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of the QLibrary class.  This header file may change from
+// version to version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "QtGui/qimageiohandler.h"
+
+#ifndef QT_NO_IMAGEFORMAT_XPM
+
+QT_BEGIN_NAMESPACE
+
+class QXpmHandler : public QImageIOHandler
+{
+public:
+    QXpmHandler();
+    bool canRead() const;
+    bool read(QImage *image);
+    bool write(const QImage &image);
+
+    static bool canRead(QIODevice *device);
+
+    QByteArray name() const;
+
+    QVariant option(ImageOption option) const;
+    void setOption(ImageOption option, const QVariant &value);
+    bool supportsOption(ImageOption option) const;
+
+private:
+    bool readHeader();
+    bool readImage(QImage *image);
+    enum State {
+        Ready,
+        ReadHeader,
+        Error
+    };
+    State state;
+    int width;
+    int height;
+    int ncols;
+    int cpp;
+    QByteArray buffer;
+    int index;
+    QString fileName;
+};
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_IMAGEFORMAT_XPM
+
+#endif // QXPMHANDLER_P_H