Merge branch '4.7' of scm.dev.nokia.troll.no:qt/qt into 4.7

Conflicts fixed:
	src/s60installs/bwins/QtGuiu.def
	src/s60installs/eabi/QtGuiu.def

9 files changed, 232 insertions, 64 deletions

diff --git a/src/gui/image/qimage.cpp b/src/gui/image/qimage.cpp
index bb8a994..79f266d 100644
--- a/src/gui/image/qimage.cpp
+++ b/src/gui/image/qimage.cpp
@@ -2338,6 +2338,12 @@ static bool convert_indexed8_to_ARGB_PM_inplace(QImageData *data, Qt::ImageConve
     const int width = data->width;
     const int src_pad = data->bytes_per_line - width;
     const int dest_pad = (dst_bytes_per_line >> 2) - width;
+    if (data->colortable.size() == 0) {
+        data->colortable.resize(256);
+        for (int i = 0; i < 256; ++i)
+            data->colortable[i] = qRgb(i, i, i);
+    }
+    const int tableSize = data->colortable.size() - 1;
 
     for (int i = 0; i < data->height; ++i) {
         src_data -= src_pad;
@@ -2345,7 +2351,7 @@ static bool convert_indexed8_to_ARGB_PM_inplace(QImageData *data, Qt::ImageConve
         for (int pixI = 0; pixI < width; ++pixI) {
             --src_data;
             --dest_data;
-            const uint pixel = data->colortable[*src_data];
+            const uint pixel = data->colortable[qMin<int>(tableSize, *src_data)];
             *dest_data = (quint32) PREMUL(pixel);
         }
     }
@@ -2377,6 +2383,12 @@ static bool convert_indexed8_to_RGB_inplace(QImageData *data, Qt::ImageConversio
     const int width = data->width;
     const int src_pad = data->bytes_per_line - width;
     const int dest_pad = (dst_bytes_per_line >> 2) - width;
+    if (data->colortable.size() == 0) {
+        data->colortable.resize(256);
+        for (int i = 0; i < 256; ++i)
+            data->colortable[i] = qRgb(i, i, i);
+    }
+    const int tableSize = data->colortable.size() - 1;
 
     for (int i = 0; i < data->height; ++i) {
         src_data -= src_pad;
@@ -2384,7 +2396,7 @@ static bool convert_indexed8_to_RGB_inplace(QImageData *data, Qt::ImageConversio
         for (int pixI = 0; pixI < width; ++pixI) {
             --src_data;
             --dest_data;
-            *dest_data = (quint32) data->colortable[*src_data];
+            *dest_data = (quint32) data->colortable[qMin<int>(tableSize, *src_data)];
         }
     }
 
@@ -2415,6 +2427,12 @@ static bool convert_indexed8_to_RGB16_inplace(QImageData *data, Qt::ImageConvers
     const int width = data->width;
     const int src_pad = data->bytes_per_line - width;
     const int dest_pad = (dst_bytes_per_line >> 1) - width;
+    if (data->colortable.size() == 0) {
+        data->colortable.resize(256);
+        for (int i = 0; i < 256; ++i)
+            data->colortable[i] = qRgb(i, i, i);
+    }
+    const int tableSize = data->colortable.size() - 1;
 
     for (int i = 0; i < data->height; ++i) {
         src_data -= src_pad;
@@ -2422,7 +2440,7 @@ static bool convert_indexed8_to_RGB16_inplace(QImageData *data, Qt::ImageConvers
         for (int pixI = 0; pixI < width; ++pixI) {
             --src_data;
             --dest_data;
-            const uint pixel = data->colortable[*src_data];
+            const uint pixel = data->colortable[qMin<int>(tableSize, *src_data)];
             *dest_data = qt_colorConvert<quint16, quint32>(pixel, 0);
         }
     }
@@ -4061,7 +4079,7 @@ void QImage::setPixel(int x, int y, uint index_or_rgb)
         }
         break;
     case Format_Indexed8:
-        if (index_or_rgb > (uint)d->colortable.size()) {
+        if (index_or_rgb >= (uint)d->colortable.size()) {
             qWarning("QImage::setPixel: Index %d out of range", index_or_rgb);
             return;
         }
diff --git a/src/gui/image/qpixmap.cpp b/src/gui/image/qpixmap.cpp
index fd2c139..ef9be8f 100644
--- a/src/gui/image/qpixmap.cpp
+++ b/src/gui/image/qpixmap.cpp
@@ -2018,7 +2018,7 @@ void QPixmap::detach()
     the color table. If this is too expensive an operation, you can
     use QBitmap::fromImage() instead.
 
-    \sa toImage(), {QPixmap#Pixmap Conversion}{Pixmap Conversion}
+    \sa fromImageReader(), toImage(), {QPixmap#Pixmap Conversion}{Pixmap Conversion}
 */
 QPixmap QPixmap::fromImage(const QImage &image, Qt::ImageConversionFlags flags)
 {
@@ -2033,6 +2033,27 @@ QPixmap QPixmap::fromImage(const QImage &image, Qt::ImageConversionFlags flags)
 }
 
 /*!
+    \fn QPixmap QPixmap::fromImageReader(QImageReader *imageReader, Qt::ImageConversionFlags flags)
+
+    Create a QPixmap from an image read directly from an \a imageReader.
+    The \a flags argument is a bitwise-OR of the \l{Qt::ImageConversionFlags}.
+    Passing 0 for \a flags sets all the default options.
+
+    On some systems, reading an image directly to QPixmap can use less memory than
+    reading a QImage to convert it to QPixmap.
+
+    \sa fromImage(), toImage(), {QPixmap#Pixmap Conversion}{Pixmap Conversion}
+*/
+QPixmap QPixmap::fromImageReader(QImageReader *imageReader, Qt::ImageConversionFlags flags)
+{
+    QGraphicsSystem *gs = QApplicationPrivate::graphicsSystem();
+    QScopedPointer<QPixmapData> data(gs ? gs->createPixmapData(QPixmapData::PixmapType)
+            : QGraphicsSystem::createDefaultPixmapData(QPixmapData::PixmapType));
+    data->fromImageReader(imageReader, flags);
+    return QPixmap(data.take());
+}
+
+/*!
     \fn QPixmap QPixmap::grabWindow(WId window, int x, int y, int
     width, int height)
 
diff --git a/src/gui/image/qpixmap.h b/src/gui/image/qpixmap.h
index 82546da..64ca8a3 100644
--- a/src/gui/image/qpixmap.h
+++ b/src/gui/image/qpixmap.h
@@ -62,6 +62,7 @@ QT_BEGIN_NAMESPACE
 QT_MODULE(Gui)
 
 class QImageWriter;
+class QImageReader;
 class QColor;
 class QVariant;
 class QX11Info;
@@ -134,6 +135,7 @@ public:
 
     QImage toImage() const;
     static QPixmap fromImage(const QImage &image, Qt::ImageConversionFlags flags = Qt::AutoColor);
+    static QPixmap fromImageReader(QImageReader *imageReader, 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);
diff --git a/src/gui/image/qpixmap_raster.cpp b/src/gui/image/qpixmap_raster.cpp
index 13c03a1..53f3559 100644
--- a/src/gui/image/qpixmap_raster.cpp
+++ b/src/gui/image/qpixmap_raster.cpp
@@ -152,9 +152,25 @@ void QRasterPixmapData::fromImage(const QImage &sourceImage,
     createPixmapForImage(image, flags, /* inplace = */false);
 }
 
+void QRasterPixmapData::fromImageReader(QImageReader *imageReader,
+                                        Qt::ImageConversionFlags flags)
+{
+    Q_UNUSED(flags);
+    QImage image = imageReader->read();
+    if (image.isNull())
+        return;
+
+    createPixmapForImage(image, flags, /* inplace = */true);
+}
+
 // from qwindowsurface.cpp
 extern void qt_scrollRectInImage(QImage &img, const QRect &rect, const QPoint &offset);
 
+void QRasterPixmapData::copy(const QPixmapData *data, const QRect &rect)
+{
+    fromImage(data->toImage(rect).copy(), Qt::NoOpaqueDetection);
+}
+
 bool QRasterPixmapData::scroll(int dx, int dy, const QRect &rect)
 {
     if (!image.isNull())
@@ -289,6 +305,20 @@ QImage QRasterPixmapData::toImage() const
     return image;
 }
 
+QImage QRasterPixmapData::toImage(const QRect &rect) const
+{
+    if (rect.isNull())
+        return image;
+
+    QRect clipped = rect.intersected(QRect(0, 0, w, h));
+    if (d % 8 == 0)
+        return QImage(image.scanLine(clipped.y()) + clipped.x() * (d / 8),
+                      clipped.width(), clipped.height(),
+                      image.bytesPerLine(), image.format());
+    else
+        return image.copy(clipped);
+}
+
 void QRasterPixmapData::setAlphaChannel(const QPixmap &alphaChannel)
 {
     image.setAlphaChannel(alphaChannel.toImage());
diff --git a/src/gui/image/qpixmap_raster_p.h b/src/gui/image/qpixmap_raster_p.h
index d7e3f85..36a9b2f 100644
--- a/src/gui/image/qpixmap_raster_p.h
+++ b/src/gui/image/qpixmap_raster_p.h
@@ -74,13 +74,16 @@ public:
     void fromFile(const QString &filename, Qt::ImageConversionFlags flags);
     bool fromData(const uchar *buffer, uint len, const char *format, Qt::ImageConversionFlags flags);
     void fromImage(const QImage &image, Qt::ImageConversionFlags flags);
+    void fromImageReader(QImageReader *imageReader, 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);
     void setMask(const QBitmap &mask);
     bool hasAlphaChannel() const;
     void setAlphaChannel(const QPixmap &alphaChannel);
     QImage toImage() const;
+    QImage toImage(const QRect &rect) const;
     QPaintEngine* paintEngine() const;
     QImage* buffer();
 
diff --git a/src/gui/image/qpixmap_x11.cpp b/src/gui/image/qpixmap_x11.cpp
index e8dc5ae..3d9c363 100644
--- a/src/gui/image/qpixmap_x11.cpp
+++ b/src/gui/image/qpixmap_x11.cpp
@@ -1458,6 +1458,105 @@ int QX11PixmapData::metric(QPaintDevice::PaintDeviceMetric metric) const
     }
 }
 
+struct QXImageWrapper
+{
+    XImage *xi;
+};
+
+bool QX11PixmapData::canTakeQImageFromXImage(const QXImageWrapper &xiWrapper) const
+{
+    XImage *xi = xiWrapper.xi;
+
+    // ARGB32_Premultiplied
+    if (picture && depth() == 32)
+        return true;
+
+    Visual *visual = (Visual *)xinfo.visual();
+
+    // RGB32
+    if (depth() == 24 && xi->bits_per_pixel == 32 && visual->red_mask == 0xff0000
+        && visual->green_mask == 0xff00 && visual->blue_mask == 0xff)
+        return true;
+
+    // RGB16
+    if (depth() == 16 && xi->bits_per_pixel == 16 && visual->red_mask == 0xf800
+        && visual->green_mask == 0x7e0 && visual->blue_mask == 0x1f)
+        return true;
+
+    return false;
+}
+
+QImage QX11PixmapData::takeQImageFromXImage(const QXImageWrapper &xiWrapper) const
+{
+    XImage *xi = xiWrapper.xi;
+
+    QImage::Format format = QImage::Format_ARGB32_Premultiplied;
+    if (depth() == 24)
+        format = QImage::Format_RGB32;
+    else if (depth() == 16)
+        format = QImage::Format_RGB16;
+
+    QImage image((uchar *)xi->data, xi->width, xi->height, xi->bytes_per_line, format);
+    // take ownership
+    image.data_ptr()->own_data = true;
+    xi->data = 0;
+
+    // we may have to swap the byte order
+    if ((QSysInfo::ByteOrder == QSysInfo::LittleEndian && xi->byte_order == MSBFirst)
+        || (QSysInfo::ByteOrder == QSysInfo::BigEndian && xi->byte_order == LSBFirst))
+    {
+        for (int i=0; i < image.height(); i++) {
+            if (depth() == 16) {
+                ushort *p = (ushort*)image.scanLine(i);
+                ushort *end = p + image.width();
+                while (p < end) {
+                    *p = ((*p << 8) & 0xff00) | ((*p >> 8) & 0x00ff);
+                    p++;
+                }
+            } else {
+                uint *p = (uint*)image.scanLine(i);
+                uint *end = p + image.width();
+                while (p < end) {
+                    *p = ((*p << 24) & 0xff000000) | ((*p << 8) & 0x00ff0000)
+                         | ((*p >> 8) & 0x0000ff00) | ((*p >> 24) & 0x000000ff);
+                    p++;
+                }
+            }
+        }
+    }
+
+    // fix-up alpha channel
+    if (format == QImage::Format_RGB32) {
+        QRgb *p = (QRgb *)image.bits();
+        for (int y = 0; y < xi->height; ++y) {
+            for (int x = 0; x < xi->width; ++x)
+                p[x] |= 0xff000000;
+            p += xi->bytes_per_line / 4;
+        }
+    }
+
+    XDestroyImage(xi);
+    return image;
+}
+
+QImage QX11PixmapData::toImage(const QRect &rect) const
+{
+    QXImageWrapper xiWrapper;
+    xiWrapper.xi = XGetImage(X11->display, hd, rect.x(), rect.y(), rect.width(), rect.height(),
+                             AllPlanes, (depth() == 1) ? XYPixmap : ZPixmap);
+
+    Q_CHECK_PTR(xiWrapper.xi);
+    if (!xiWrapper.xi)
+        return QImage();
+
+    if (canTakeQImageFromXImage(xiWrapper))
+        return takeQImageFromXImage(xiWrapper);
+
+    QImage image = toImage(xiWrapper, rect);
+    qSafeXDestroyImage(xiWrapper.xi);
+    return image;
+}
+
 /*!
     Converts the pixmap to a QImage. Returns a null image if the
     conversion fails.
@@ -1475,6 +1574,13 @@ int QX11PixmapData::metric(QPaintDevice::PaintDeviceMetric metric) const
 
 QImage QX11PixmapData::toImage() const
 {
+    return toImage(QRect(0, 0, w, h));
+}
+
+QImage QX11PixmapData::toImage(const QXImageWrapper &xiWrapper, const QRect &rect) const
+{
+    XImage *xi = xiWrapper.xi;
+
     int d = depth();
     Visual *visual = (Visual *)xinfo.visual();
     bool trucol = (visual->c_class >= TrueColor) && d > 1;
@@ -1492,59 +1598,21 @@ QImage QX11PixmapData::toImage() const
         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 && xi->byte_order == LSBFirst))
-        {
-            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);
+    QImage image(xi->width, xi->height, format);
     if (image.isNull())                        // could not create image
         return image;
 
     QImage alpha;
     if (x11_mask) {
-        alpha = mask().toImage();
+        if (rect.contains(QRect(0, 0, w, h)))
+            alpha = mask().toImage();
+        else
+            alpha = mask().toImage().copy(rect);
     }
     bool ale = alpha.format() == QImage::Format_MonoLSB;
 
@@ -1587,11 +1655,11 @@ QImage QX11PixmapData::toImage() const
         if (bppc > 8 && xi->byte_order == LSBFirst)
             bppc++;
 
-        for (int y = 0; y < h; ++y) {
+        for (int y = 0; y < xi->height; ++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++) {
+            for (int x = 0; x < xi->width; x++) {
                 switch (bppc) {
                 case 8:
                     pixel = *src++;
@@ -1621,8 +1689,8 @@ QImage QX11PixmapData::toImage() const
                     src += 4;
                     break;
                 default:                        // should not really happen
-                    x = w;                        // leave loop
-                    y = h;
+                    x = xi->width;                        // leave loop
+                    y = xi->height;
                     pixel = 0;                // eliminate compiler warning
                     qWarning("QPixmap::convertToImage: Invalid depth %d", bppc);
                 }
@@ -1660,7 +1728,7 @@ QImage QX11PixmapData::toImage() const
     } 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++) {
+        for (int y=0; y<xi->height; y++) {
             memcpy(image.scanLine(y), xidata, bpl);
             xidata += xi->bytes_per_line;
         }
@@ -1686,17 +1754,17 @@ QImage QX11PixmapData::toImage() const
         bpl = image.bytesPerLine();
 
         if (x11_mask) {                         // which pixels are used?
-            for (int i = 0; i < h; i++) {
+            for (int i = 0; i < xi->height; i++) {
                 uchar* asrc = alpha.scanLine(i);
                 p = image.scanLine(i);
                 if (ale) {
-                    for (int x = 0; x < w; x++) {
+                    for (int x = 0; x < xi->width; x++) {
                         if (asrc[x >> 3] & (1 << (x & 7)))
                             use[*p] = 1;
                         ++p;
                     }
                 } else {
-                    for (int x = 0; x < w; x++) {
+                    for (int x = 0; x < xi->width; x++) {
                         if (asrc[x >> 3] & (0x80 >> (x & 7)))
                             use[*p] = 1;
                         ++p;
@@ -1704,7 +1772,7 @@ QImage QX11PixmapData::toImage() const
                 }
             }
         } else {
-            for (int i = 0; i < h; i++) {
+            for (int i = 0; i < xi->height; i++) {
                 p = image.scanLine(i);
                 end = p + bpl;
                 while (p < end)
@@ -1716,7 +1784,7 @@ QImage QX11PixmapData::toImage() const
             if (use[i])
                 pix[i] = ncols++;
         }
-        for (int i = 0; i < h; i++) {                        // translate pixels
+        for (int i = 0; i < xi->height; i++) {                        // translate pixels
             p = image.scanLine(i);
             end = p + bpl;
             while (p < end) {
@@ -1736,17 +1804,17 @@ QImage QX11PixmapData::toImage() const
                 // use first pixel in image (as good as any).
                 trans = image.scanLine(0)[0];
             }
-            for (int i = 0; i < h; i++) {
+            for (int i = 0; i < xi->height; i++) {
                 uchar* asrc = alpha.scanLine(i);
                 p = image.scanLine(i);
                 if (ale) {
-                    for (int x = 0; x < w; x++) {
+                    for (int x = 0; x < xi->width; x++) {
                         if (!(asrc[x >> 3] & (1 << (x & 7))))
                             *p = trans;
                         ++p;
                     }
                 } else {
-                    for (int x = 0; x < w; x++) {
+                    for (int x = 0; x < xi->width; x++) {
                         if (!(asrc[x >> 3] & (1 << (7 -(x & 7)))))
                             *p = trans;
                         ++p;
@@ -1764,8 +1832,6 @@ QImage QX11PixmapData::toImage() const
         }
     }
 
-    qSafeXDestroyImage(xi);
-
     return image;
 }
 
diff --git a/src/gui/image/qpixmap_x11_p.h b/src/gui/image/qpixmap_x11_p.h
index 7575838..821fb69 100644
--- a/src/gui/image/qpixmap_x11_p.h
+++ b/src/gui/image/qpixmap_x11_p.h
@@ -62,6 +62,8 @@ QT_BEGIN_NAMESPACE
 
 class QX11PaintEngine;
 
+struct QXImageWrapper;
+
 class Q_GUI_EXPORT QX11PixmapData : public QPixmapData
 {
 public:
@@ -87,6 +89,7 @@ public:
     QPixmap transformed(const QTransform &transform,
                         Qt::TransformationMode mode) const;
     QImage toImage() const;
+    QImage toImage(const QRect &rect) const;
     QPaintEngine* paintEngine() const;
 
     Qt::HANDLE handle() const { return hd; }
@@ -116,10 +119,15 @@ private:
 
     void release();
 
+    QImage toImage(const QXImageWrapper &xi, const QRect &rect) const;
+
     QBitmap mask_to_bitmap(int screen) const;
     static Qt::HANDLE bitmap_to_mask(const QBitmap &, int screen);
     void bitmapFromImage(const QImage &image);
 
+    bool canTakeQImageFromXImage(const QXImageWrapper &xi) const;
+    QImage takeQImageFromXImage(const QXImageWrapper &xi) const;
+
     Qt::HANDLE hd;
 
     enum Flag {
diff --git a/src/gui/image/qpixmapdata.cpp b/src/gui/image/qpixmapdata.cpp
index 31ca909..ef1f6c4 100644
--- a/src/gui/image/qpixmapdata.cpp
+++ b/src/gui/image/qpixmapdata.cpp
@@ -124,6 +124,13 @@ static QImage makeBitmapCompliantIfNeeded(QPixmapData *d, const QImage &image, Q
     return image;
 }
 
+void QPixmapData::fromImageReader(QImageReader *imageReader,
+                                  Qt::ImageConversionFlags flags)
+{
+    const QImage image = imageReader->read();
+    fromImage(image, flags);
+}
+
 bool QPixmapData::fromFile(const QString &fileName, const char *format,
                            Qt::ImageConversionFlags flags)
 {
@@ -146,7 +153,7 @@ bool QPixmapData::fromData(const uchar *buf, uint len, const char *format, Qt::I
 
 void QPixmapData::copy(const QPixmapData *data, const QRect &rect)
 {
-    fromImage(data->toImage().copy(rect), Qt::NoOpaqueDetection);
+    fromImage(data->toImage(rect), Qt::NoOpaqueDetection);
 }
 
 bool QPixmapData::scroll(int dx, int dy, const QRect &rect)
@@ -255,6 +262,14 @@ void QPixmapData::setSerialNumber(int serNo)
     ser_no = serNo;
 }
 
+QImage QPixmapData::toImage(const QRect &rect) const
+{
+    if (rect.contains(QRect(0, 0, w, h)))
+        return toImage();
+    else
+        return toImage().copy(rect);
+}
+
 QImage* QPixmapData::buffer()
 {
     return 0;
diff --git a/src/gui/image/qpixmapdata_p.h b/src/gui/image/qpixmapdata_p.h
index 60ed26a..ec62b0b 100644
--- a/src/gui/image/qpixmapdata_p.h
+++ b/src/gui/image/qpixmapdata_p.h
@@ -58,6 +58,8 @@
 
 QT_BEGIN_NAMESPACE
 
+class QImageReader;
+
 class Q_GUI_EXPORT QPixmapData
 {
 public:
@@ -83,6 +85,8 @@ public:
     virtual void resize(int width, int height) = 0;
     virtual void fromImage(const QImage &image,
                            Qt::ImageConversionFlags flags) = 0;
+    virtual void fromImageReader(QImageReader *imageReader,
+                                 Qt::ImageConversionFlags flags);
 
     virtual bool fromFile(const QString &filename, const char *format,
                           Qt::ImageConversionFlags flags);
@@ -102,6 +106,7 @@ public:
     virtual void setAlphaChannel(const QPixmap &alphaChannel);
     virtual QPixmap alphaChannel() const;
     virtual QImage toImage() const = 0;
+    virtual QImage toImage(const QRect &rect) const;
     virtual QPaintEngine* paintEngine() const = 0;
 
     inline int serialNumber() const { return ser_no; }