Merge branch 'master' of scm.dev.troll.no:qt/oslo-staging-2 into qstatictext-4.7

Conflicts:
	src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp
	tests/auto/qlineedit/tst_qlineedit.cpp

Merge branch 'master' of scm.dev.troll.no:qt/oslo-staging-2 into qstatictext-4.7

Conflicts:
	src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp
	tests/auto/qlineedit/tst_qlineedit.cpp

Merge branch 'master' of scm.dev.troll.no:qt/oslo-staging-2 into qstatictext-4.7

Conflicts:
	src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp
	tests/auto/qlineedit/tst_qlineedit.cpp

8 files changed, 156 insertions, 132 deletions

diff --git a/src/gui/image/qimage.cpp b/src/gui/image/qimage.cpp
index 4f5efa1c46..6bcf72b64d 100644
--- a/src/gui/image/qimage.cpp
+++ b/src/gui/image/qimage.cpp
@@ -1835,7 +1835,7 @@ void QImage::setColor(int i, QRgb c)
     qAlpha() to access the pixels.
 
     \sa bytesPerLine(), bits(), {QImage#Pixel Manipulation}{Pixel
-    Manipulation}
+    Manipulation}, constScanLine()
 */
 uchar *QImage::scanLine(int i)
 {
@@ -1865,6 +1865,28 @@ const uchar *QImage::scanLine(int i) const
 
 
 /*!
+    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.
+
+    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.
+
+    \sa scanLine(), constBits()
+    \since 4.7
+*/
+const uchar *QImage::constScanLine(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).
 
@@ -1873,7 +1895,7 @@ const uchar *QImage::scanLine(int i) const
     data, thus ensuring that this QImage is the only one using the
     current return value.
 
-    \sa scanLine(), byteCount()
+    \sa scanLine(), byteCount(), constBits()
 */
 uchar *QImage::bits()
 {
@@ -1901,6 +1923,20 @@ const uchar *QImage::bits() const
 }
 
 
+/*!
+    Returns a pointer to the first pixel data.
+
+    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.
+
+    \sa bits(), constScanLine()
+    \since 4.7
+*/
+const uchar *QImage::constBits() const
+{
+    return d ? d->data : 0;
+}
 
 /*!
     \fn void QImage::reset()
diff --git a/src/gui/image/qimage.h b/src/gui/image/qimage.h
index ac973a1de9..dd13782304 100644
--- a/src/gui/image/qimage.h
+++ b/src/gui/image/qimage.h
@@ -182,6 +182,7 @@ public:
 
     uchar *bits();
     const uchar *bits() const;
+    const uchar *constBits() const;
 #ifdef QT_DEPRECATED
     QT_DEPRECATED int numBytes() const;
 #endif
@@ -189,6 +190,7 @@ public:
 
     uchar *scanLine(int);
     const uchar *scanLine(int) const;
+    const uchar *constScanLine(int) const;
     int bytesPerLine() const;
 
     bool valid(int x, int y) const;
diff --git a/src/gui/image/qpicture.cpp b/src/gui/image/qpicture.cpp
index fb70e36e76..3220a67332 100644
--- a/src/gui/image/qpicture.cpp
+++ b/src/gui/image/qpicture.cpp
@@ -440,36 +440,6 @@ bool QPicture::play(QPainter *painter)
     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
@@ -679,30 +649,29 @@ bool QPicture::exec(QPainter *painter, QDataStream &s, int nrecords)
 
             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);
-                }
+                QFont fnt(font, painter->device());
+
+                qreal scale = painter->device()->logicalDpiY() / (dbl*qt_defaultDpiY());
+                painter->save();
+                painter->scale(1/scale, 1/scale);
 
                 qreal justificationWidth;
                 s >> justificationWidth;
 
                 int flags = Qt::TextSingleLine | Qt::TextDontClip | Qt::TextForceLeftToRight;
 
-                QSizeF size(1, 1);
+                QSizeF size(scale, scale);
                 if (justificationWidth > 0) {
-                    size.setWidth(justificationWidth);
+                    size.setWidth(justificationWidth*scale);
                     flags |= Qt::TextJustificationForced;
                     flags |= Qt::AlignJustify;
                 }
 
                 QFontMetrics fm(fnt);
-                QPointF pt(p.x(), p.y() - fm.ascent());
+                QPointF pt(p.x()*scale, p.y()*scale - fm.ascent());
                 qt_format_text(fnt, QRectF(pt, size), flags, /*opt*/0,
                                str, /*brect=*/0, /*tabstops=*/0, /*...*/0, /*tabarraylen=*/0, painter);
+                painter->restore();
             } 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);
diff --git a/src/gui/image/qpixmap.cpp b/src/gui/image/qpixmap.cpp
index d1e5c40540..7cafbd0021 100644
--- a/src/gui/image/qpixmap.cpp
+++ b/src/gui/image/qpixmap.cpp
@@ -1078,6 +1078,9 @@ QPixmap QPixmap::grabWidget(QWidget * widget, const QRect &rect)
     if (widget->testAttribute(Qt::WA_PendingResizeEvent) || !widget->testAttribute(Qt::WA_WState_Created))
         sendResizeEvents(widget);
 
+    widget->d_func()->prepareToRender(QRegion(),
+        QWidget::DrawWindowBackground | QWidget::DrawChildren | QWidget::IgnoreMask);
+
     QRect r(rect);
     if (r.width() < 0)
         r.setWidth(widget->width() - rect.x());
@@ -1088,8 +1091,8 @@ QPixmap QPixmap::grabWidget(QWidget * widget, const QRect &rect)
         return QPixmap();
 
     QPixmap res(r.size());
-    widget->render(&res, QPoint(), r,
-                   QWidget::DrawWindowBackground | QWidget::DrawChildren | QWidget::IgnoreMask);
+    widget->d_func()->render(&res, QPoint(), r, QWidget::DrawWindowBackground
+                             | QWidget::DrawChildren | QWidget::IgnoreMask, true);
     return res;
 }
 
@@ -1370,10 +1373,27 @@ void QPixmap::deref()
 */
 
 /*!
-    \fn bool QPixmap::convertFromImage(const QImage &image, Qt::ImageConversionFlags flags)
+    Replaces this pixmap's data with the given \a image 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. Returns true
+    if the result is that this pixmap is not null.
 
-    Use the static fromImage() function instead.
+    Note: this function was part of Qt 3 support in Qt 4.6 and earlier.
+    It has been promoted to official API status in 4.7 to support updating
+    the pixmap's image without creating a new QPixmap as fromImage() would.
+
+    \sa fromImage()
+    \since 4.7
 */
+bool QPixmap::convertFromImage(const QImage &image, Qt::ImageConversionFlags flags)
+{
+    if (image.isNull() || !data)
+        *this = QPixmap::fromImage(image, flags);
+    else
+        data->fromImage(image, flags);
+    return !isNull();
+}
 
 /*!
     \fn QPixmap QPixmap::xForm(const QMatrix &matrix) const
diff --git a/src/gui/image/qpixmap.h b/src/gui/image/qpixmap.h
index 46363f05a1..180af3be1b 100644
--- a/src/gui/image/qpixmap.h
+++ b/src/gui/image/qpixmap.h
@@ -141,6 +141,8 @@ public:
     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;
 
+    bool convertFromImage(const QImage &img, Qt::ImageConversionFlags flags = Qt::AutoColor);
+
 #if defined(Q_WS_WIN)
     enum HBitmapFormat {
         NoAlpha,
@@ -224,8 +226,6 @@ public:
     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; }
diff --git a/src/gui/image/qpixmap_x11.cpp b/src/gui/image/qpixmap_x11.cpp
index e1e8a0db5e..b9763761ba 100644
--- a/src/gui/image/qpixmap_x11.cpp
+++ b/src/gui/image/qpixmap_x11.cpp
@@ -1142,7 +1142,7 @@ void QX11PixmapData::fromImage(const QImage &img,
     }
 }
 
-void QX11PixmapData::bitmapFromImage(const QImage &image)
+Qt::HANDLE QX11PixmapData::createBitmapFromImage(const QImage &image)
 {
     QImage img = image.convertToFormat(QImage::Format_MonoLSB);
     const QRgb c0 = QColor(Qt::black).rgb();
@@ -1155,10 +1155,8 @@ void QX11PixmapData::bitmapFromImage(const QImage &image)
 
     char  *bits;
     uchar *tmp_bits;
-    w = img.width();
-    h = img.height();
-    d = 1;
-    is_null = (w <= 0 || h <= 0);
+    int w = img.width();
+    int h = img.height();
     int bpl = (w + 7) / 8;
     int ibpl = img.bytesPerLine();
     if (bpl != ibpl) {
@@ -1177,18 +1175,26 @@ void QX11PixmapData::bitmapFromImage(const QImage &image)
         bits = (char *)img.bits();
         tmp_bits = 0;
     }
-    hd = (Qt::HANDLE)XCreateBitmapFromData(xinfo.display(),
-                                           RootWindow(xinfo.display(), xinfo.screen()),
+    Qt::HANDLE hd = (Qt::HANDLE)XCreateBitmapFromData(X11->display,
+                                           QX11Info::appRootWindow(),
                                            bits, w, h);
+    if (tmp_bits)                                // Avoid purify complaint
+        delete [] tmp_bits;
+    return hd;
+}
 
+void QX11PixmapData::bitmapFromImage(const QImage &image)
+{
+    w = image.width();
+    h = image.height();
+    d = 1;
+    is_null = (w <= 0 || h <= 0);
+    hd = createBitmapFromImage(image);
 #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)
diff --git a/src/gui/image/qpixmap_x11_p.h b/src/gui/image/qpixmap_x11_p.h
index 20fb65470e..0c0a9bdd06 100644
--- a/src/gui/image/qpixmap_x11_p.h
+++ b/src/gui/image/qpixmap_x11_p.h
@@ -92,6 +92,8 @@ public:
     Qt::HANDLE handle() const { return hd; }
     Qt::HANDLE x11ConvertToDefaultDepth();
 
+    static Qt::HANDLE createBitmapFromImage(const QImage &image);
+
 protected:
     int metric(QPaintDevice::PaintDeviceMetric metric) const;
 
diff --git a/src/gui/image/qpnghandler.cpp b/src/gui/image/qpnghandler.cpp
index d5406cb847..dd31834cae 100644
--- a/src/gui/image/qpnghandler.cpp
+++ b/src/gui/image/qpnghandler.cpp
@@ -50,8 +50,13 @@
 #include <qvariant.h>
 #include <qvector.h>
 
+#ifdef QT_USE_BUNDLED_LIBPNG
+#include <../../3rdparty/libpng/png.h>
+#include <../../3rdparty/libpng/pngconf.h>
+#else
 #include <png.h>
 #include <pngconf.h>
+#endif
 
 #ifdef Q_OS_WINCE
 #define CALLBACK_CALL_TYPE        __cdecl
@@ -162,11 +167,16 @@ void setup_qt(QImage& image, png_structp png_ptr, png_infop info_ptr, float scre
     png_uint_32 height;
     int bit_depth;
     int color_type;
+    png_bytep trans_alpha = 0;
+    png_color_16p trans_color_p = 0;
+    int num_trans;
+    png_colorp palette = 0;
+    int num_palette;
     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) {
+        if (bit_depth == 1 && png_get_channels(png_ptr, info_ptr) == 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) {
@@ -207,20 +217,16 @@ void setup_qt(QImage& image, png_structp png_ptr, png_infop info_ptr, float scre
                 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)) {
-#if PNG_LIBPNG_VER_MAJOR < 1 || (PNG_LIBPNG_VER_MAJOR == 1 && PNG_LIBPNG_VER_MINOR < 4)
-                const int g = info_ptr->trans_values.gray;
-#else
-                const int g = info_ptr->trans_color.gray;
-#endif
+            if (png_get_tRNS(png_ptr, info_ptr, &trans_alpha, &num_trans, &trans_color_p) && trans_color_p) {
+                const int g = trans_color_p->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)
+               && png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette)
+               && num_palette <= 256)
     {
         // 1-bit and 8-bit color
         if (bit_depth != 1)
@@ -233,29 +239,26 @@ void setup_qt(QImage& image, png_structp png_ptr, png_infop info_ptr, float scre
             if (image.isNull())
                 return;
         }
-        image.setColorCount(info_ptr->num_palette);
+        png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette);
+        image.setColorCount(num_palette);
         int i = 0;
-        if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
-            while (i < info_ptr->num_trans) {
+        if (png_get_tRNS(png_ptr, info_ptr, &trans_alpha, &num_trans, &trans_color_p) && trans_alpha) {
+            while (i < num_trans) {
                 image.setColor(i, qRgba(
-                    info_ptr->palette[i].red,
-                    info_ptr->palette[i].green,
-                    info_ptr->palette[i].blue,
-#if PNG_LIBPNG_VER_MAJOR < 1 || (PNG_LIBPNG_VER_MAJOR == 1 && PNG_LIBPNG_VER_MINOR < 4)
-                    info_ptr->trans[i]
-#else
-                    info_ptr->trans_alpha[i]
-#endif
+                    palette[i].red,
+                    palette[i].green,
+                    palette[i].blue,
+                    trans_alpha[i]
                    )
                );
                 i++;
             }
         }
-        while (i < info_ptr->num_palette) {
+        while (i < num_palette) {
             image.setColor(i, qRgba(
-                info_ptr->palette[i].red,
-                info_ptr->palette[i].green,
-                info_ptr->palette[i].blue,
+                palette[i].red,
+                palette[i].green,
+                palette[i].blue,
                 0xff
                )
            );
@@ -531,33 +534,36 @@ 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) {
+        png_colorp palette;
+        int num_palette;
+        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 (info_ptr->bit_depth == 1 && info_ptr->channels == 1) {
+            if (bit_depth == 1 && png_get_channels(png_ptr, info_ptr) == 1) {
                 format = QImage::Format_Mono;
-            } else if (info_ptr->bit_depth == 16 && png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
+            } else if (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)
+        } else if (color_type == PNG_COLOR_TYPE_PALETTE
+                   && png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette)
+                   && num_palette <= 256)
         {
             // 1-bit and 8-bit color
-            if (info_ptr->bit_depth != 1)
+            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);
             format = bit_depth == 1 ? QImage::Format_Mono : QImage::Format_Indexed8;
         } else {
             // 32-bit
-            if (info_ptr->bit_depth == 16)
+            if (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)
+            if (!(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;
@@ -648,7 +654,7 @@ static void set_text(const QImage &image, png_structp png_ptr, png_infop info_pt
         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 = const_cast<char*>("UTF-8");
         text_ptr[i].lang_key = qstrdup(it.key().toUtf8().constData());
 #endif
         ++i;
@@ -735,64 +741,51 @@ bool Q_INTERNAL_WIN_NO_THROW QPNGImageWriter::writeImage(const QImage& image_in,
         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_COLOR_TYPE_PALETTE, 0, 0, 0);  // also sets #channels
 
+    if (gamma != 0.0) {
+        png_set_gAMA(png_ptr, info_ptr, 1.0/gamma);
+    }
 
-    //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;
+    png_color_8 sig_bit;
+    sig_bit.red = 8;
+    sig_bit.green = 8;
+    sig_bit.blue = 8;
+    sig_bit.alpha = image.hasAlphaChannel() ? 8 : 0;
+    png_set_sBIT(png_ptr, info_ptr, &sig_bit);
 
     if (image.format() == QImage::Format_MonoLSB)
        png_set_packswap(png_ptr);
 
-    png_colorp palette = 0;
-    png_bytep copy_trans = 0;
     if (image.colorCount()) {
         // Paletted
-        int num_palette = image.colorCount();
-        palette = new png_color[num_palette];
-        png_set_PLTE(png_ptr, info_ptr, palette, num_palette);
-        int* trans = new int[num_palette];
+        int num_palette = qMin(256, image.colorCount());
+        png_color palette[256];
+        png_byte trans[256];
         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;
+            QRgb rgba=image.color(i);
+            palette[i].red = qRed(rgba);
+            palette[i].green = qGreen(rgba);
+            palette[i].blue = qBlue(rgba);
+            trans[i] = qAlpha(rgba);
             if (trans[i] < 255) {
                 num_trans = i+1;
             }
         }
+        png_set_PLTE(png_ptr, info_ptr, palette, num_palette);
+
         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);
+            png_set_tRNS(png_ptr, info_ptr, 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
@@ -868,11 +861,6 @@ bool Q_INTERNAL_WIN_NO_THROW QPNGImageWriter::writeImage(const QImage& image_in,
     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;
@@ -958,7 +946,8 @@ QVariant QPngHandler::option(ImageOption option) const
     else if (option == Description)
         return d->description;
     else if (option == Size)
-        return QSize(d->info_ptr->width, d->info_ptr->height);
+        return QSize(png_get_image_width(d->png_ptr, d->info_ptr),
+                     png_get_image_height(d->png_ptr, d->info_ptr));
     else if (option == ImageFormat)
         return d->readImageFormat();
     return 0;