Changeset 561 for trunk/src/gui/image/qpixmap.cpp

Timestamp:

Feb 11, 2010, 11:19:06 PM (15 years ago)

Author:

Dmitry A. Kuminov

Message:

trunk: Merged in qt 4.6.1 sources.

Location:

trunk

Files:

• . (modified) (1 prop)
• src/gui/image/qpixmap.cpp (modified) (61 diffs)

trunk/src/gui/image/qpixmap.cpp

@@ -2 +2 @@
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
@@ -21 +22 @@
 ** 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.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
@@ -34 +34 @@
 ** 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.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
@@ -44 +44 @@
 #include "qpixmap.h"
 #include "qpixmapdata_p.h"
+#include "qimagepixmapcleanuphooks_p.h"
 
 #include "qbitmap.h"
@@ -77 +78 @@
 #endif
 
+#if defined(Q_OS_SYMBIAN)
+# include <private/qt_s60_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
@@ -117 +114 @@
 void QPixmap::init(int w, int h, int type)
 {
-    QGraphicsSystem* gs = QApplicationPrivate::graphicsSystem();
-    if (gs)
-        data = gs->createPixmapData(static_cast<QPixmapData::PixelType>(type));
+    if ((w > 0 && h > 0) || type == QPixmapData::BitmapType)
+        data = QPixmapData::create(w, h, (QPixmapData::PixelType) type);
     else
-        data = QGraphicsSystem::createDefaultPixmapData(static_cast<QPixmapData::PixelType>(type));
-
-    data->resize(w, h);
-    data->ref.ref();
+        data = 0;
 }
 
@@ -226 +219 @@
     : QPaintDevice(), data(d)
 {
-    data->ref.ref();
 }
 
@@ -282 +274 @@
     }
     if (pixmap.paintingActive()) {                // make a deep copy
-        data = 0;
         operator=(pixmap.copy());
     } else {
         data = pixmap.data;
-        data->ref.ref();
     }
 }
@@ -315 +305 @@
     QImage image(xpm);
     if (!image.isNull()) {
-        if (data->pixelType() == QPixmapData::BitmapType)
+        if (data && data->pixelType() == QPixmapData::BitmapType)
             *this = QBitmap::fromImage(image);
         else
@@ -330 +320 @@
 QPixmap::~QPixmap()
 {
-    deref();
+    Q_ASSERT(!data || data->ref >= 1); // Catch if ref-counting changes again
+    if (data && data->is_cached && data->ref == 1) // ref will be decrememnted after destructor returns
+        QImagePixmapCleanupHooks::executePixmapDestructionHooks(this);
 }
 
@@ -366 +358 @@
         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);
+    QRect r(0, 0, width(), height());
+    if (!rect.isEmpty())
+        r = r.intersected(rect);
+
+    QPixmapData *d = data->createCompatiblePixmapData();
+    d->copy(data.data(), r);
     return QPixmap(d);
+}
+
+/*!
+    \fn QPixmap::scroll(int dx, int dy, int x, int y, int width, int height, QRegion *exposed)
+    \since 4.6
+
+    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()
+*/
+
+/*!
+    \since 4.6
+
+    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);
+    }
 }
 
@@ -395 +436 @@
         *this = pixmap.copy();
     } else {
-        pixmap.data->ref.ref();                                // avoid 'x = x'
-        deref();
         data = pixmap.data;
     }
@@ -431 +470 @@
 
     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.
+    bit deep. Images with more bits will be returned in a format
+    closely represents the underlying system. Usually this will be
+    QImage::Format_ARGB32_Premultiplied for pixmaps with an alpha and
+    QImage::Format_RGB32 or QImage::Format_RGB16 for pixmaps without
+    alpha.
 
     Note that for the moment, alpha masks on monochrome images are
@@ -503 +544 @@
 bool QPixmap::isNull() const
 {
-    return data->width() == 0;
+    return !data || data->isNull();
 }
 
@@ -515 +556 @@
 int QPixmap::width() const
 {
-    return data->width();
+    return data ? data->width() : 0;
 }
 
@@ -527 +568 @@
 int QPixmap::height() const
 {
-    return data->height();
+    return data ? data->height() : 0;
 }
 
@@ -540 +581 @@
 QSize QPixmap::size() const
 {
-    return QSize(data->width(), data->height());
+    return data ? QSize(data->width(), data->height()) : QSize();
 }
 
@@ -552 +593 @@
 QRect QPixmap::rect() const
 {
-    return QRect(0, 0, data->width(), data->height());
+    return data ? QRect(0, 0, data->width(), data->height()) : QRect();
 }
 
@@ -568 +609 @@
 int QPixmap::depth() const
 {
-    return data->depth();
+    return data ? data->depth() : 0;
 }
 
@@ -598 +639 @@
 
     // Create new pixmap
-    QPixmap pm(QSize(w, h), data->type);
+    QPixmap pm(QSize(w, h), data ? data->type : QPixmapData::PixmapType);
     bool uninit = false;
 #if defined(Q_WS_X11)
-    QX11PixmapData *x11Data = data->classId() == QPixmapData::X11Class ? static_cast<QX11PixmapData*>(data) : 0;
+    QX11PixmapData *x11Data = data && data->classId() == QPixmapData::X11Class ? static_cast<QX11PixmapData*>(data.data()) : 0;
     if (x11Data) {
         pm.x11SetScreen(x11Data->xinfo.screen());
-        uninit = x11Data->uninit;
+        uninit = x11Data->flags & QX11PixmapData::Uninitialized;
     }
 #elif defined(Q_WS_MAC)
-    QMacPixmapData *macData = data->classId() == QPixmapData::MacClass ? static_cast<QMacPixmapData*>(data) : 0;
+    QMacPixmapData *macData = data && data->classId() == QPixmapData::MacClass ? static_cast<QMacPixmapData*>(data.data()) : 0;
     if (macData)
         uninit = macData->uninit;
@@ -619 +660 @@
     }
 
-#if defined(Q_WS_MAC)
-#ifndef QT_MAC_NO_QUICKDRAW
-    if(macData && macData->qd_alpha)
-        macData->macQDUpdateAlpha();
-#endif
-#elif defined(Q_WS_X11)
+#if defined(Q_WS_X11)
     if (x11Data && x11Data->x11_mask) {
-        QX11PixmapData *pmData = static_cast<QX11PixmapData*>(pm.data);
+        QX11PixmapData *pmData = static_cast<QX11PixmapData*>(pm.data.data());
         pmData->x11_mask = (Qt::HANDLE)XCreatePixmap(X11->display,
                                                      RootWindow(x11Data->xinfo.display(),
@@ -675 +711 @@
     being painted on.
 
-    This is potentially an expensive operation.
+    \warning This is potentially an expensive operation.
 
     \sa mask(), {QPixmap#Pixmap Transformations}{Pixmap Transformations},
@@ -691 +727 @@
         return;
     }
+
+    if (isNull())
+        return;
 
     if (static_cast<const QPixmap &>(mask).data == data) // trying to selfmask
@@ -790 +829 @@
     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());
+        QString::number(info.size()) + QLatin1Char('_') + QString::number(data ? data->pixelType() : QPixmapData::PixmapType);
 
     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;
+    QPixmapData *tmp = QPixmapData::create(0, 0, QPixmapData::PixmapType);
+    if (tmp->fromFile(fileName, format, flags)) {
+        data = tmp;
         QPixmapCache::insert(key, *this);
         return true;
     }
+    delete tmp;
     return false;
 }
@@ -832 +865 @@
 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;
+    if (len == 0 || buf == 0)
+        return false;
+
+    if (!data)
+        data = QPixmapData::create(0, 0, QPixmapData::PixmapType);
+
+    return data->fromData(buf, len, format, flags);
 }
 
@@ -930 +955 @@
     Fills the pixmap with the given \a color.
 
+    The effect of this function is undefined when the pixmap is
+    being painted on.
+
     \sa {QPixmap#Pixmap Transformations}{Pixmap Transformations}
 */
@@ -938 +966 @@
         return;
 
-    detach();
+    // Some people are probably already calling fill while a painter is active, so to not break
+    // their programs, only print a warning and return when the fill operation could cause a crash.
+    if (paintingActive() && (color.alpha() != 255) && !hasAlphaChannel()) {
+        qWarning("QPixmap::fill: Cannot fill while pixmap is being painted on");
+        return;
+    }
+
+    if (data->ref == 1) {
+        // detach() will also remove this pixmap from caches, so
+        // it has to be called even when ref == 1.
+        detach();
+    } else {
+        // Don't bother to make a copy of the data object, since
+        // it will be filled with new pixel data anyway.
+        QPixmapData *d = data->createCompatiblePixmapData();
+        d->resize(data->width(), data->height());
+        data = d;
+    }
     data->fill(color);
 }
@@ -971 +1016 @@
 qint64 QPixmap::cacheKey() const
 {
+    if (isNull())
+        return 0;
+
     int classKey = data->classId();
     if (classKey >= 1024)
@@ -1119 +1167 @@
 {
 #if defined(Q_WS_X11)
-    if (data->classId() == QPixmapData::X11Class)
-        return static_cast<QX11PixmapData*>(data)->handle();
+    if (data && data->classId() == QPixmapData::X11Class)
+        return static_cast<const QX11PixmapData*>(data.constData())->handle();
 #endif
     return 0;
@@ -1170 +1218 @@
         return;
 
-    if (data->pixelType() == QPixmapData::BitmapType)
+    if (data && data->pixelType() == QPixmapData::BitmapType)
         *this = QBitmap::fromImage(image);
     else
@@ -1187 +1235 @@
 QPixmap &QPixmap::operator=(const QImage &image)
 {
-    if (data->pixelType() == QPixmapData::BitmapType)
+    if (data && data->pixelType() == QPixmapData::BitmapType)
         *this = QBitmap::fromImage(image);
     else
@@ -1217 +1265 @@
 bool QPixmap::convertFromImage(const QImage &image, ColorMode mode)
 {
-    if (data->pixelType() == QPixmapData::BitmapType)
+    if (data && data->pixelType() == QPixmapData::BitmapType)
         *this = QBitmap::fromImage(image, colorModeToFlags(mode));
     else
@@ -1233 +1281 @@
     \relates QPixmap
 
-    Writes the given \a pixmap to the the given \a stream as a PNG
+    Writes the given \a pixmap to the given \a stream as a PNG
     image. Note that writing the stream to a file will not produce a
     valid image file.
@@ -1268 +1316 @@
 }
 
-#endif //QT_NO_DATASTREAM
+#endif // QT_NO_DATASTREAM
 
 #ifdef QT3_SUPPORT
@@ -1304 +1352 @@
 bool QPixmap::isDetached() const
 {
-    return data->ref == 1;
-}
-
+    return data && data->ref == 1;
+}
+
+/*! \internal
+  ### Qt5 - remove me.
+*/
 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;
-    }
+    Q_ASSERT_X(false, "QPixmap::deref()", "Do not call this function anymore!");
 }
 
@@ -1381 +1419 @@
     pixmap.
 
+
+    In some cases it can be more beneficial to draw the pixmap to a
+    painter with a scale set rather than scaling the pixmap. This is
+    the case when the painter is for instance based on OpenGL or when
+    the scale factor changes rapidly.
+
     \sa isNull(), {QPixmap#Pixmap Transformations}{Pixmap
     Transformations}
@@ -1399 +1443 @@
         return *this;
 
-    QPixmap pix;
-    QTransform wm;
-    wm.scale((qreal)newSize.width() / width(), (qreal)newSize.height() / height());
-    pix = transformed(wm, mode);
+    QTransform wm = QTransform::fromScale((qreal)newSize.width() / width(),
+                                          (qreal)newSize.height() / height());
+    QPixmap pix = transformed(wm, mode);
     return pix;
 }
@@ -1429 +1472 @@
         return QPixmap();
 
-    QTransform wm;
     qreal factor = (qreal) w / width();
-    wm.scale(factor, factor);
+    QTransform wm = QTransform::fromScale(factor, factor);
     return transformed(wm, mode);
 }
@@ -1458 +1500 @@
         return QPixmap();
 
-    QTransform wm;
     qreal factor = (qreal) h / height();
-    wm.scale(factor, factor);
+    QTransform wm = QTransform::fromScale(factor, factor);
     return transformed(wm, mode);
 }
@@ -1515 +1556 @@
     that can be used as a paint device.
 
-    \ingroup multimedia
+    \ingroup painting
     \ingroup shared
-    \mainclass
+
 
     Qt provides four classes for handling image data: QImage, QPixmap,
@@ -1525 +1566 @@
     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.
+    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.
+    QAbstractButton has an icon property.
 
     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.
+    window, into it.
+
+    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.
+
     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
+    On X11, Mac and Symbian, 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).
+
+    Note that the pixel data in a pixmap is internal and is managed by
+    the underlying window system. Because QPixmap is a QPaintDevice
+    subclass, QPainter can be used to draw directly onto pixmaps.
+    Pixels can only be accessed through QPainter functions or by
+    converting the QPixmap to a QImage. However, the fill() function
+    is available for initializing the entire pixmap with a given color.
 
     There are functions to convert between QImage and
@@ -1560 +1608 @@
     file can be loaded directly into a QPixmap. On Windows, the
     QPixmap class also supports conversion between \c HBITMAP and
-    QPixmap.
+    QPixmap. On Symbian, the QPixmap class also supports conversion
+    between CFbsBitmap and QPixmap.
 
     QPixmap provides a collection of functions that can be used to
@@ -1566 +1615 @@
     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
@@ -1628 +1672 @@
     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
+    channel \e or a mask (otherwise false). The mask() function returns
+    the mask as a QBitmap object, which can be set using setMask().
+
+    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
@@ -1679 +1682 @@
     QBitmap) for the pixmap based on a given color.
 
+    \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 by the screen to which the pixmap currently
+    belongs. 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. The QPixmap class also supports conversion to
+    and from HICON: the toWinHICON() function creates a HICON equivalent
+    to the QPixmap, and returns the HICON handle. The fromWinHICON()
+    function returns a QPixmap that is equivalent to the given icon.
+
+    In addition, on Symbian, the QPixmap class supports conversion to
+    and from CFbsBitmap: the toSymbianCFbsBitmap() function creates
+    CFbsBitmap equivalent to the QPixmap, based on given mode and returns
+    a CFbsBitmap object. The fromSymbianCFbsBitmap() function returns a
+    QPixmap that is equivalent to the given bitmap and given mode.
+
+    \section1 Pixmap Transformations
+
+    QPixmap supports a number of functions for creating a new pixmap
+    that is a transformed version of the original:
 
     The scaled(), scaledToWidth() and scaledToHeight() functions
@@ -1693 +1742 @@
     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
 */
@@ -1716 +1760 @@
     mask, otherwise returns false.
 
-    \sa hasAlphaChannel(), alphaChannel(), mask()
+    \sa hasAlphaChannel(), mask()
 */
 bool QPixmap::hasAlpha() const
 {
-    return (data->hasAlphaChannel() || !data->mask().isNull());
+    return data && (data->hasAlphaChannel() || !data->mask().isNull());
 }
 
@@ -1727 +1771 @@
     channel, otherwise returns false.
 
-    \sa alphaChannel(), hasAlpha()
+    \sa hasAlpha()
 */
 bool QPixmap::hasAlphaChannel() const
 {
-    return data->hasAlphaChannel();
-}
-
-/*!
-  \reimp
+    return data && data->hasAlphaChannel();
+}
+
+/*!
+    \internal
 */
 int QPixmap::metric(PaintDeviceMetric metric) const
 {
-    return data->metric(metric);
+    return data ? data->metric(metric) : 0;
 }
 
 /*!
     \fn void QPixmap::setAlphaChannel(const QPixmap &alphaChannel)
+    \obsolete
 
     Sets the alpha channel of this pixmap to the given \a alphaChannel
@@ -1751 +1796 @@
     The effect of this function is undefined when the pixmap is being
     painted on.
+
+    \warning This is potentially an expensive operation. Most usecases
+    for this function are covered by QPainter and compositionModes
+    which will normally execute faster.
 
     \sa alphaChannel(), {QPixmap#Pixmap Transformations}{Pixmap
@@ -1777 +1826 @@
 
 /*!
+    \obsolete
+
     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
@@ -1794 +1845 @@
     \image alphachannelimage.png The pixmap and channelImage QPixmaps
 
+    \warning This is an expensive operation. The alpha channel of the
+    pixmap is extracted dynamically from the pixeldata. Most usecases of this
+    function are covered by QPainter and compositionModes which will normally
+    execute faster.
+
     \sa setAlphaChannel(), {QPixmap#Pixmap Information}{Pixmap
     Information}
@@ -1799 +1855 @@
 QPixmap QPixmap::alphaChannel() const
 {
-    return data->alphaChannel();
-}
-
-/*!
-  \reimp
+    return data ? data->alphaChannel() : QPixmap();
+}
+
+/*!
+    \internal
 */
 QPaintEngine *QPixmap::paintEngine() const
 {
-    return data->paintEngine();
+    return data ? data->paintEngine() : 0;
 }
 
@@ -1813 +1869 @@
     \fn QBitmap QPixmap::mask() const
 
-    Extracts a bitmap mask from the pixmap's alphachannel.
-
-    This is potentially an expensive operation.
+    Extracts a bitmap mask from the pixmap's alpha channel.
+
+    \warning This is potentially an expensive operation. The mask of
+    the pixmap is extracted dynamically from the pixeldata.
 
     \sa setMask(), {QPixmap#Pixmap Information}{Pixmap Information}
@@ -1821 +1878 @@
 QBitmap QPixmap::mask() const
 {
-    return data->mask();
+    return data ? data->mask() : QBitmap();
 }
 
@@ -1840 +1897 @@
 #elif defined(Q_WS_X11)
     return QX11Info::appDepth();
-#elif defined(Q_OS_WINCE)
+#elif defined(Q_WS_WINCE)
     return QColormap::instance().depth();
 #elif defined(Q_WS_WIN)
@@ -1848 +1905 @@
 #elif defined(Q_WS_MAC)
     return 32;
+#elif defined(Q_OS_SYMBIAN)
+    return S60->screenDepth;
 #endif
 }
-
-typedef void (*_qt_pixmap_cleanup_hook_64)(qint64);
-extern _qt_pixmap_cleanup_hook_64 qt_pixmap_cleanup_hook_64;
 
 /*!
@@ -1873 +1929 @@
 void QPixmap::detach()
 {
+    if (!data)
+        return;
+
     QPixmapData::ClassId id = data->classId();
     if (id == QPixmapData::RasterClass) {
-        QRasterPixmapData *rasterData = static_cast<QRasterPixmapData*>(data);
+        QRasterPixmapData *rasterData = static_cast<QRasterPixmapData*>(data.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 (data->is_cached && data->ref == 1)
+        QImagePixmapCleanupHooks::executePixmapModificationHooks(this);
 
 #if defined(Q_WS_MAC)
-    QMacPixmapData *macData = id == QPixmapData::MacClass ? static_cast<QMacPixmapData*>(data) : 0;
+    QMacPixmapData *macData = id == QPixmapData::MacClass ? static_cast<QMacPixmapData*>(data.data()) : 0;
     if (macData) {
         if (macData->cg_mask) {
@@ -1900 +1953 @@
     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;
@@ -1910 +1958 @@
 #if defined(Q_WS_X11)
     if (data->classId() == QPixmapData::X11Class) {
-        QX11PixmapData *d = static_cast<QX11PixmapData*>(data);
-        d->uninit = false;
+        QX11PixmapData *d = static_cast<QX11PixmapData*>(data.data());
+        d->flags &= ~QX11PixmapData::Uninitialized;
 
         // reset the cache data
@@ -1947 +1995 @@
         return QPixmap();
 
-    QPixmapData *data;
     QGraphicsSystem* gs = QApplicationPrivate::graphicsSystem();
-    if (gs)
-        data = gs->createPixmapData(QPixmapData::PixmapType);
-    else
-        data = QGraphicsSystem::createDefaultPixmapData(QPixmapData::PixmapType);
-
+    QScopedPointer<QPixmapData> data(gs ? gs->createPixmapData(QPixmapData::PixmapType)
+            : QGraphicsSystem::createDefaultPixmapData(QPixmapData::PixmapType));
     data->fromImage(image, flags);
-    return QPixmap(data);
+    return QPixmap(data.take());
 }
 
@@ -2000 +2044 @@
 QPixmapData* QPixmap::pixmapData() const
 {
-    return data;
-}
+    return data.data();
+}
+
+/*!
+    \enum QPixmap::HBitmapFormat
+
+    \bold{Win32 only:} 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()
+*/
+
+/*! \fn HBITMAP QPixmap::toWinHBITMAP(HBitmapFormat format) const
+    \bold{Win32 only:} 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(), {QPixmap#Pixmap Conversion}{Pixmap Conversion}
+*/
+
+/*! \fn QPixmap QPixmap::fromWinHBITMAP(HBITMAP bitmap, HBitmapFormat format)
+    \bold{Win32 only:} 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}
+
+*/
+
+/*! \fn HICON QPixmap::toWinHICON() const
+    \since 4.6
+
+    \bold{Win32 only:} Creates a \c HICON equivalent to the QPixmap.
+    Returns the \c HICON handle.
+
+    It is the caller's responsibility to free the \c HICON data after use.
+
+    \warning This function is only available on Windows.
+
+    \sa fromWinHICON(), {QPixmap#Pixmap Conversion}{Pixmap Conversion}
+*/
+
+/*! \fn QPixmap QPixmap::fromWinHICON(HICON icon)
+    \since 4.6
+
+    \bold{Win32 only:} Returns a QPixmap that is equivalent to the given
+    \a icon.
+
+    \warning This function is only available on Windows.
+
+    \sa toWinHICON(), {QPixmap#Pixmap Conversion}{Pixmap Conversion}
+
+*/
+
+/*! \fn const QX11Info &QPixmap::x11Info() const
+    \bold{X11 only:} Returns information about the configuration of
+    the X display used by the screen to which the pixmap currently belongs.
+
+    \warning This function is only available on X11.
+
+    \sa {QPixmap#Pixmap Information}{Pixmap Information}
+*/
+
+/*! \fn Qt::HANDLE QPixmap::x11PictureHandle() const
+    \bold{X11 only:} 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}
+*/
+
+/*! \fn int QPixmap::x11SetDefaultScreen(int screen)
+  \internal
+*/
+
+/*! \fn void QPixmap::x11SetScreen(int screen)
+  \internal
+*/
+
+/*! \fn QRgb* QPixmap::clut() const
+    \internal
+*/
+
+/*! \fn int QPixmap::numCols() const
+    \obsolete
+    \internal
+    \sa colorCount()
+*/
+
+/*! \fn int QPixmap::colorCount() const
+    \since 4.6
+    \internal
+*/
+
+/*! \fn const uchar* QPixmap::qwsBits() const
+    \internal
+    \since 4.1
+*/
+
+/*! \fn int QPixmap::qwsBytesPerLine() const
+    \internal
+    \since 4.1
+*/
 
 QT_END_NAMESPACE