Merge branch 'kinetic-graphicseffect' of git@scm.dev.nokia.troll.no:qt/kinetic into graphicseffects

Conflicts:
	src/gui/graphicsview/qgraphicseffect.cpp
	src/gui/graphicsview/qgraphicseffect_p.h

40 files changed, 988 insertions, 531 deletions

diff --git a/src/gui/accessible/qaccessible.h b/src/gui/accessible/qaccessible.h
index 19080de..8dc8159 100644
--- a/src/gui/accessible/qaccessible.h
+++ b/src/gui/accessible/qaccessible.h
@@ -210,6 +210,7 @@ public:
         PageTabList    = 0x0000003C,
         Clock          = 0x0000003D,
         Splitter       = 0x0000003E,
+        // Additional Qt roles where enum value does not map directly to MSAA:
         LayeredPane    = 0x0000003F,
         UserRole       = 0x0000ffff
     };
diff --git a/src/gui/accessible/qaccessible_win.cpp b/src/gui/accessible/qaccessible_win.cpp
index bfacb94..85f1a8d 100644
--- a/src/gui/accessible/qaccessible_win.cpp
+++ b/src/gui/accessible/qaccessible_win.cpp
@@ -1051,6 +1051,8 @@ HRESULT STDMETHODCALLTYPE QWindowsAccessible::get_accRole(VARIANT varID, VARIANT
 
     Role role = accessible->role(varID.lVal);
     if (role != NoRole) {
+        if (role == LayeredPane)
+            role = QAccessible::Pane;
         (*pvarRole).vt = VT_I4;
         (*pvarRole).lVal = role;
     } else {
diff --git a/src/gui/dialogs/qmessagebox.cpp b/src/gui/dialogs/qmessagebox.cpp
index b7fa420..31f73b9 100644
--- a/src/gui/dialogs/qmessagebox.cpp
+++ b/src/gui/dialogs/qmessagebox.cpp
@@ -1362,8 +1362,10 @@ void QMessageBox::setVisible(bool visible)
 /*!
     \overload
 
-    Opens the dialog and connects its accepted() signal to the slot specified
-    by \a receiver and \a member.
+    Opens the dialog and connects its finished() or buttonClicked() signal to
+    the slot specified by \a receiver and \a member. If the slot in \a member
+    has a pointer for its first parameter the connection is to buttonClicked(),
+    otherwise the connection is to finished().
 
     The signal will be disconnected from the slot when the dialog is closed.
 */
diff --git a/src/gui/embedded/qscreenproxy_qws.cpp b/src/gui/embedded/qscreenproxy_qws.cpp
index ade16ca..3d7451b 100644
--- a/src/gui/embedded/qscreenproxy_qws.cpp
+++ b/src/gui/embedded/qscreenproxy_qws.cpp
@@ -537,7 +537,7 @@ int QProxyScreen::transformOrientation() const
 }
 
 /*!
-\reimp
+\internal
 */
 int QProxyScreen::memoryNeeded(const QString &str)
 {
@@ -548,7 +548,7 @@ int QProxyScreen::memoryNeeded(const QString &str)
 }
 
 /*!
-\reimp
+\internal
 */
 int QProxyScreen::sharedRamSize(void *ptr)
 {
@@ -559,7 +559,7 @@ int QProxyScreen::sharedRamSize(void *ptr)
 }
 
 /*!
-\reimp
+\internal
 */
 void QProxyScreen::haltUpdates()
 {
@@ -568,7 +568,7 @@ void QProxyScreen::haltUpdates()
 }
 
 /*!
-\reimp
+\internal
 */
 void QProxyScreen::resumeUpdates()
 {
diff --git a/src/gui/graphicsview/qgraphicseffect.cpp b/src/gui/graphicsview/qgraphicseffect.cpp
index ef7341a..1f9f944 100644
--- a/src/gui/graphicsview/qgraphicseffect.cpp
+++ b/src/gui/graphicsview/qgraphicseffect.cpp
@@ -418,7 +418,7 @@ static QImage blurred(const QImage& image, const QRect& rect, int radius)
 int QGraphicsBlurEffect::blurRadius() const
 {
     Q_D(const QGraphicsBlurEffect);
-    return int(d->filter->blurRadius());
+    return int(d->filter->radius());
 }
 
 void QGraphicsBlurEffect::setBlurRadius(int radius)
diff --git a/src/gui/graphicsview/qgraphicseffect_p.h b/src/gui/graphicsview/qgraphicseffect_p.h
index 2d4a5ee..5348ae9 100644
--- a/src/gui/graphicsview/qgraphicseffect_p.h
+++ b/src/gui/graphicsview/qgraphicseffect_p.h
@@ -66,8 +66,6 @@
 
 QT_BEGIN_NAMESPACE
 
-class QPainter;
-
 class QGraphicsEffectSourcePrivate : public QObjectPrivate
 {
     Q_DECLARE_PUBLIC(QGraphicsEffectSource)
@@ -87,7 +85,7 @@ public:
     friend class QGraphicsItemPrivate;
 };
 
-class QGraphicsEffectPrivate : public QObjectPrivate
+class Q_GUI_EXPORT QGraphicsEffectPrivate : public QObjectPrivate
 {
     Q_DECLARE_PUBLIC(QGraphicsEffect)
 public:
diff --git a/src/gui/graphicsview/qgraphicsitem.cpp b/src/gui/graphicsview/qgraphicsitem.cpp
index 223c747..5178d80 100644
--- a/src/gui/graphicsview/qgraphicsitem.cpp
+++ b/src/gui/graphicsview/qgraphicsitem.cpp
@@ -2553,6 +2553,8 @@ void QGraphicsItem::setHandlesChildEvents(bool enabled)
 */
 bool QGraphicsItem::hasFocus() const
 {
+    if (d_ptr->focusProxy)
+        return d_ptr->focusProxy->hasFocus();
     return (d_ptr->scene && d_ptr->scene->focusItem() == this);
 }
 
@@ -2578,12 +2580,16 @@ void QGraphicsItem::setFocus(Qt::FocusReason focusReason)
 {
     if (!d_ptr->scene || !isEnabled() || hasFocus() || !(d_ptr->flags & ItemIsFocusable))
         return;
-    if (isVisible()) {
+    QGraphicsItem *item = this;
+    QGraphicsItem *f;
+    while ((f = item->d_ptr->focusProxy))
+        item = f;
+    if (item->isVisible()) {
         // Visible items immediately gain focus from scene.
-        d_ptr->scene->setFocusItem(this, focusReason);
-    } else if (d_ptr->isWidget) {
+        d_ptr->scene->d_func()->setFocusItemHelper(item, focusReason);
+    } else if (item->d_ptr->isWidget) {
         // Just set up subfocus.
-        static_cast<QGraphicsWidget *>(this)->d_func()->setFocusWidget();
+        static_cast<QGraphicsWidget *>(item)->d_func()->setFocusWidget();
     }
 }
 
@@ -2606,13 +2612,73 @@ void QGraphicsItem::clearFocus()
         // Invisible widget items with focus must explicitly clear subfocus.
         static_cast<QGraphicsWidget *>(this)->d_func()->clearFocusWidget();
     }
-    if (d_ptr->scene->focusItem() == this) {
+    if (hasFocus()) {
         // If this item has the scene's input focus, clear it.
         d_ptr->scene->setFocusItem(0);
     }
 }
 
 /*!
+    \since 4.6
+
+    Returns this item's focus proxy, or 0 if the item
+    does not have any focus proxy.
+
+    \sa setFocusProxy()
+*/
+QGraphicsItem *QGraphicsItem::focusProxy() const
+{
+    return d_ptr->focusProxy;
+}
+
+/*!
+    \since 4.6
+
+    Sets the item's focus proxy to \a item.
+
+    If an item has a focus proxy, the focus proxy will receive
+    input focus when the item gains input focus. The item itself
+    will still have focus (i.e., hasFocus() will return true),
+    but only the focus proxy will receive the keyboard input.
+
+    A focus proxy can itself have a focus proxy, and so on. In
+    such case, keyboard input will be handled by the outermost
+    focus proxy.
+
+    \sa focusProxy()
+*/
+void QGraphicsItem::setFocusProxy(QGraphicsItem *item)
+{
+    if (item == d_ptr->focusProxy)
+        return;
+    if (item == this) {
+        qWarning("QGraphicsItem::setFocusProxy: cannot assign self as focus proxy");
+        return;
+    }
+    if (item) {
+        if (item->d_ptr->scene != d_ptr->scene) {
+            qWarning("QGraphicsItem::setFocusProxy: focus proxy must be in same scene");
+            return;
+        }
+        for (QGraphicsItem *f = item->focusProxy(); f != 0; f = f->focusProxy()) {
+            if (f == this) {
+                qWarning("QGraphicsItem::setFocusProxy: %p is already in the focus proxy chain", item);
+                return;
+            }
+        }
+    }
+
+    QGraphicsItem *lastFocusProxy = d_ptr->focusProxy;
+    d_ptr->focusProxy = item;
+    if (d_ptr->scene) {
+        if (lastFocusProxy)
+            d_ptr->scene->d_func()->focusProxyReverseMap.remove(lastFocusProxy, this);
+        if (item)
+            d_ptr->scene->d_func()->focusProxyReverseMap.insert(item, this);
+    }
+}
+
+/*!
     \since 4.4
     Grabs the mouse input.
 
diff --git a/src/gui/graphicsview/qgraphicsitem.h b/src/gui/graphicsview/qgraphicsitem.h
index 0c20829..afbaf24 100644
--- a/src/gui/graphicsview/qgraphicsitem.h
+++ b/src/gui/graphicsview/qgraphicsitem.h
@@ -233,6 +233,9 @@ public:
     void setFocus(Qt::FocusReason focusReason = Qt::OtherFocusReason);
     void clearFocus();
 
+    QGraphicsItem *focusProxy() const;
+    void setFocusProxy(QGraphicsItem *item);
+
     void grabMouse();
     void ungrabMouse();
     void grabKeyboard();
diff --git a/src/gui/graphicsview/qgraphicsitem_p.h b/src/gui/graphicsview/qgraphicsitem_p.h
index ff1ca09..69d8b5f 100644
--- a/src/gui/graphicsview/qgraphicsitem_p.h
+++ b/src/gui/graphicsview/qgraphicsitem_p.h
@@ -125,6 +125,7 @@ public:
         index(-1),
         siblingIndex(-1),
         depth(0),
+        focusProxy(0),
         acceptedMouseButtons(0x1f),
         visible(1),
         explicitlyHidden(0),
@@ -413,6 +414,7 @@ public:
     int index;
     int siblingIndex;
     int depth;
+    QGraphicsItem *focusProxy;
 
     // Packed 32 bytes
     quint32 acceptedMouseButtons : 5;
@@ -455,7 +457,7 @@ public:
     quint32 acceptedTouchBeginEvent : 1;
     quint32 filtersDescendantEvents : 1;
     quint32 sceneTransformTranslateOnly : 1;
-    quint32 unused : 7; // feel free to use
+    quint32 unused : 6; // feel free to use
 
     // Optional stacking order
     int globalStackingOrder;
diff --git a/src/gui/graphicsview/qgraphicsscene.cpp b/src/gui/graphicsview/qgraphicsscene.cpp
index 7b02883..5cd0ab2 100644
--- a/src/gui/graphicsview/qgraphicsscene.cpp
+++ b/src/gui/graphicsview/qgraphicsscene.cpp
@@ -492,6 +492,13 @@ void QGraphicsScenePrivate::removeItemHelper(QGraphicsItem *item)
 
     item->d_func()->scene = 0;
 
+    // Unregister focus proxy.
+    QMultiHash<QGraphicsItem *, QGraphicsItem *>::iterator it = focusProxyReverseMap.find(item);
+    while (it != focusProxyReverseMap.end() && it.key() == item) {
+        it.value()->d_ptr->focusProxy = 0;
+        it = focusProxyReverseMap.erase(it);
+    }
+
     // Remove from parent, or unregister from toplevels.
     if (QGraphicsItem *parentItem = item->parentItem()) {
         if (parentItem->scene()) {
@@ -560,6 +567,58 @@ void QGraphicsScenePrivate::removeItemHelper(QGraphicsItem *item)
 /*!
     \internal
 */
+void QGraphicsScenePrivate::setFocusItemHelper(QGraphicsItem *item,
+                                               Qt::FocusReason focusReason)
+{
+    Q_Q(QGraphicsScene);
+    if (item == focusItem)
+        return;
+    if (item && (!(item->flags() & QGraphicsItem::ItemIsFocusable)
+                 || !item->isVisible() || !item->isEnabled())) {
+        item = 0;
+    }
+
+    if (item) {
+        q->setFocus(focusReason);
+        if (item == focusItem)
+            return;
+    }
+
+    if (focusItem) {
+        QFocusEvent event(QEvent::FocusOut, focusReason);
+        lastFocusItem = focusItem;
+        focusItem = 0;
+        sendEvent(lastFocusItem, &event);
+
+        if (lastFocusItem
+            && (lastFocusItem->flags() & QGraphicsItem::ItemAcceptsInputMethod)) {
+            // Reset any visible preedit text
+            QInputMethodEvent imEvent;
+            sendEvent(lastFocusItem, &imEvent);
+
+            // Close any external input method panel
+            for (int i = 0; i < views.size(); ++i)
+                views.at(i)->inputContext()->reset();
+        }
+    }
+
+    if (item) {
+        if (item->isWidget()) {
+            // Update focus child chain.
+            static_cast<QGraphicsWidget *>(item)->d_func()->setFocusWidget();
+        }
+
+        focusItem = item;
+        QFocusEvent event(QEvent::FocusIn, focusReason);
+        sendEvent(item, &event);
+    }
+
+    updateInputMethodSensitivityInViews();
+}
+
+/*!
+    \internal
+*/
 void QGraphicsScenePrivate::addPopup(QGraphicsWidget *widget)
 {
     Q_ASSERT(widget);
@@ -1927,21 +1986,42 @@ QPainterPath QGraphicsScene::selectionArea() const
 }
 
 /*!
+    \since 4.6
+
     Sets the selection area to \a path. All items within this area are
     immediately selected, and all items outside are unselected. You can get
     the list of all selected items by calling selectedItems().
 
+    \a deviceTransform is the transformation that applies to the view, and needs to
+    be provided if the scene contains items that ignore transformations.
+
     For an item to be selected, it must be marked as \e selectable
     (QGraphicsItem::ItemIsSelectable).
 
     \sa clearSelection(), selectionArea()
 */
+void QGraphicsScene::setSelectionArea(const QPainterPath &path, const QTransform &deviceTransform)
+{
+    setSelectionArea(path, Qt::IntersectsItemShape, deviceTransform);
+}
+
+/*!
+    \obsolete
+    \overload
+
+    Sets the selection area to \a path.
+
+    This function is deprecated and leads to incorrect results if the scene
+    contains items that ignore transformations. Use the overload that takes
+    a QTransform instead.
+*/
 void QGraphicsScene::setSelectionArea(const QPainterPath &path)
 {
-    setSelectionArea(path, Qt::IntersectsItemShape);
+    setSelectionArea(path, Qt::IntersectsItemShape, QTransform());
 }
 
 /*!
+    \obsolete
     \overload
     \since 4.3
 
@@ -2577,49 +2657,10 @@ QGraphicsItem *QGraphicsScene::focusItem() const
 void QGraphicsScene::setFocusItem(QGraphicsItem *item, Qt::FocusReason focusReason)
 {
     Q_D(QGraphicsScene);
-    if (item == d->focusItem)
-        return;
-    if (item && (!(item->flags() & QGraphicsItem::ItemIsFocusable)
-                 || !item->isVisible() || !item->isEnabled())) {
-        item = 0;
-    }
-
-    if (item) {
-        setFocus(focusReason);
-        if (item == d->focusItem)
-            return;
-    }
-
-    if (d->focusItem) {
-        QFocusEvent event(QEvent::FocusOut, focusReason);
-        d->lastFocusItem = d->focusItem;
-        d->focusItem = 0;
-        d->sendEvent(d->lastFocusItem, &event);
-
-        if (d->lastFocusItem
-            && (d->lastFocusItem->flags() & QGraphicsItem::ItemAcceptsInputMethod)) {
-            // Reset any visible preedit text
-            QInputMethodEvent imEvent;
-            d->sendEvent(d->lastFocusItem, &imEvent);
-
-            // Close any external input method panel
-            for (int i = 0; i < d->views.size(); ++i)
-                d->views.at(i)->inputContext()->reset();
-        }
-    }
-
-    if (item) {
-        if (item->isWidget()) {
-            // Update focus child chain.
-            static_cast<QGraphicsWidget *>(item)->d_func()->setFocusWidget();
-        }
-
-        d->focusItem = item;
-        QFocusEvent event(QEvent::FocusIn, focusReason);
-        d->sendEvent(item, &event);
-    }
-
-    d->updateInputMethodSensitivityInViews();
+    if (item)
+        item->setFocus(focusReason);
+    else
+        d->setFocusItemHelper(item, focusReason);
 }
 
 /*!
@@ -2674,15 +2715,17 @@ void QGraphicsScene::clearFocus()
 
 /*!
     \property QGraphicsScene::stickyFocus
-    \brief whether or not clicking the scene will clear focus
+    \brief whether clicking into the scene background will clear focus
 
     \since 4.6
 
-    If this property is false (the default), then clicking on the scene
-    background or on an item that does not accept focus, will clear
-    focus. Otherwise, focus will remain unchanged.
+    In a QGraphicsScene with stickyFocus set to true, focus will remain
+    unchanged when the user clicks into the scene background or on an item
+    that does not accept focus. Otherwise, focus will be cleared.
+
+    By default, this property is false.
 
-    The focus change happens in response to a mouse press. You can reimplement
+    Focus changes in response to a mouse press. You can reimplement
     mousePressEvent() in a subclass of QGraphicsScene to toggle this property
     based on where the user has clicked.
 
diff --git a/src/gui/graphicsview/qgraphicsscene.h b/src/gui/graphicsview/qgraphicsscene.h
index 813e000..67a2983 100644
--- a/src/gui/graphicsview/qgraphicsscene.h
+++ b/src/gui/graphicsview/qgraphicsscene.h
@@ -182,8 +182,9 @@ public:
 
     QList<QGraphicsItem *> selectedItems() const;
     QPainterPath selectionArea() const;
-    void setSelectionArea(const QPainterPath &path);
-    void setSelectionArea(const QPainterPath &path, Qt::ItemSelectionMode mode);
+    void setSelectionArea(const QPainterPath &path); // ### obsolete
+    void setSelectionArea(const QPainterPath &path, const QTransform &deviceTransform);
+    void setSelectionArea(const QPainterPath &path, Qt::ItemSelectionMode mode); // ### obsolete
     void setSelectionArea(const QPainterPath &path, Qt::ItemSelectionMode mode, const QTransform &deviceTransform);
 
     QGraphicsItemGroup *createItemGroup(const QList<QGraphicsItem *> &items);
diff --git a/src/gui/graphicsview/qgraphicsscene_p.h b/src/gui/graphicsview/qgraphicsscene_p.h
index f380ced..56e6224 100644
--- a/src/gui/graphicsview/qgraphicsscene_p.h
+++ b/src/gui/graphicsview/qgraphicsscene_p.h
@@ -130,6 +130,8 @@ public:
     QGraphicsWidget *tabFocusFirst;
     QGraphicsWidget *activeWindow;
     int activationRefCount;
+    void setFocusItemHelper(QGraphicsItem *item, Qt::FocusReason focusReason);
+    QMultiHash<QGraphicsItem *, QGraphicsItem *> focusProxyReverseMap;
 
     QList<QGraphicsWidget *> popupWidgets;
     void addPopup(QGraphicsWidget *widget);
diff --git a/src/gui/image/qimage.cpp b/src/gui/image/qimage.cpp
index ad55dcd..7d7dde1 100644
--- a/src/gui/image/qimage.cpp
+++ b/src/gui/image/qimage.cpp
@@ -612,9 +612,6 @@ bool QImageData::checkForAlphaPixels() const
     \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.
@@ -5587,7 +5584,7 @@ bool QImage::isDetached() const
     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.
+    Use one of the composition modes in QPainter::CompositionMode instead.
 
     \warning This function is expensive.
 
@@ -5665,6 +5662,8 @@ void QImage::setAlphaChannel(const QImage &alphaChannel)
 
 
 /*!
+    \obsolete
+
     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.
@@ -5744,7 +5743,7 @@ QImage QImage::alphaChannel() const
     Returns true if the image has a format that respects the alpha
     channel, otherwise returns false.
 
-    \sa alphaChannel(), {QImage#Image Information}{Image Information}
+    \sa {QImage#Image Information}{Image Information}
 */
 bool QImage::hasAlphaChannel() const
 {
diff --git a/src/gui/image/qpixmap.cpp b/src/gui/image/qpixmap.cpp
index 72fdec0..3e5c9b7 100644
--- a/src/gui/image/qpixmap.cpp
+++ b/src/gui/image/qpixmap.cpp
@@ -1572,24 +1572,24 @@ QPixmap QPixmap::transformed(const QMatrix &matrix, Qt::TransformationMode mode)
     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.
+    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.
+    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.
 
-    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.
@@ -1600,6 +1600,13 @@ QPixmap QPixmap::transformed(const QMatrix &matrix, Qt::TransformationMode mode)
     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
     QPixmap. Typically, the QImage class is used to load an image
     file, optionally manipulating the image data, before the QImage
@@ -1614,11 +1621,6 @@ QPixmap QPixmap::transformed(const QMatrix &matrix, Qt::TransformationMode mode)
     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
@@ -1675,12 +1677,15 @@ QPixmap QPixmap::transformed(const QMatrix &matrix, Qt::TransformationMode mode)
     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).
+    channel \e or a mask (otherwise false). The mask() function returns
+    the mask as a QBitmap object, which can be set using setMask().
 
-    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.
+    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.
 
     \row
     \o Low-level information
@@ -1718,14 +1723,7 @@ QPixmap QPixmap::transformed(const QMatrix &matrix, Qt::TransformationMode mode)
     \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.
-
+    that is a transformed version of the original:
 
     The scaled(), scaledToWidth() and scaledToHeight() functions
     return scaled copies of the pixmap, while the copy() function
@@ -1740,11 +1738,6 @@ QPixmap QPixmap::transformed(const QMatrix &matrix, Qt::TransformationMode mode)
     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
 */
 
@@ -1763,7 +1756,7 @@ QPixmap QPixmap::transformed(const QMatrix &matrix, Qt::TransformationMode mode)
     Returns true if this pixmap has an alpha channel, \e or has a
     mask, otherwise returns false.
 
-    \sa hasAlphaChannel(), alphaChannel(), mask()
+    \sa hasAlphaChannel(), mask()
 */
 bool QPixmap::hasAlpha() const
 {
@@ -1774,7 +1767,7 @@ bool QPixmap::hasAlpha() const
     Returns true if the pixmap has a format that respects the alpha
     channel, otherwise returns false.
 
-    \sa alphaChannel(), hasAlpha()
+    \sa hasAlpha()
 */
 bool QPixmap::hasAlphaChannel() const
 {
@@ -1791,6 +1784,7 @@ int QPixmap::metric(PaintDeviceMetric metric) const
 
 /*!
     \fn void QPixmap::setAlphaChannel(const QPixmap &alphaChannel)
+    \obsolete
 
     Sets the alpha channel of this pixmap to the given \a alphaChannel
     by converting the \a alphaChannel into 32 bit and using the
@@ -1828,6 +1822,8 @@ void QPixmap::setAlphaChannel(const QPixmap &alphaChannel)
 }
 
 /*!
+    \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
     original pixmap. The color depth of the returned pixmap is the system depth
@@ -1846,7 +1842,9 @@ void QPixmap::setAlphaChannel(const QPixmap &alphaChannel)
     \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.
+    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}
@@ -1867,7 +1865,7 @@ QPaintEngine *QPixmap::paintEngine() const
 /*!
     \fn QBitmap QPixmap::mask() const
 
-    Extracts a bitmap mask from the pixmap's alphachannel.
+    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.
diff --git a/src/gui/image/qpixmapcache.cpp b/src/gui/image/qpixmapcache.cpp
index 82069d0..ecdcd8c 100644
--- a/src/gui/image/qpixmapcache.cpp
+++ b/src/gui/image/qpixmapcache.cpp
@@ -64,7 +64,8 @@ QT_BEGIN_NAMESPACE
     access the global pixmap cache. It creates an internal QCache
     object for caching the pixmaps.
 
-    The cache associates a pixmap with a string as a key or with a QPixmapCache::Key.
+    The cache associates a pixmap with a user-provided string as a key,
+    or with a QPixmapCache::Key that the cache generates.
     Using QPixmapCache::Key for keys is faster than using strings. The string API is
     very convenient for complex keys but the QPixmapCache::Key API will be very
     efficient and convenient for a one-to-one object-to-pixmap mapping \mdash in
@@ -92,6 +93,17 @@ static int cache_limit = 10240; // 10 MB cache limit for desktop
 #endif
 
 /*!
+    \class QPixmapCache::Key
+    \brief The QPixmapCache::Key class can be used for efficient access
+    to the QPixmapCache.
+    \since 4.6
+
+    Use QPixmapCache::insert() to receive an instance of Key generated
+    by the pixmap cache. You can store the key in your own objects for
+    a very efficient one-to-one object-to-pixmap mapping.
+*/
+
+/*!
     Constructs an empty Key object.
 */
 QPixmapCache::Key::Key() : d(0)
diff --git a/src/gui/image/qpixmapfilter.cpp b/src/gui/image/qpixmapfilter.cpp
index 2b275a3..b7b3733 100644
--- a/src/gui/image/qpixmapfilter.cpp
+++ b/src/gui/image/qpixmapfilter.cpp
@@ -478,6 +478,225 @@ void QPixmapConvolutionFilter::draw(QPainter *painter, const QPointF &p, const Q
     }
 }
 
+/*!
+    \class QPixmapBlurFilter
+    \since 4.6
+    \ingroup multimedia
+
+    \brief The QPixmapBlurFilter class provides blur filtering
+    for pixmaps.
+
+    QPixmapBlurFilter implements a blur pixmap filter,
+    which is applied when \l{QPixmapFilter::}{draw()} is called.
+
+    The filter lets you specialize the radius of the blur as well
+    as the quality.
+
+    By default, the blur effect is produced by applying an exponential
+    filter generated from the specified blurRadius().  Paint engines
+    may override this with a custom blur that is faster on the
+    underlying hardware.
+
+    \sa {Pixmap Filters Example}, QPixmapConvolutionFilter, QPixmapDropShadowFilter
+
+    \internal
+*/
+
+class QPixmapBlurFilterPrivate : public QPixmapFilterPrivate
+{
+public:
+    QPixmapBlurFilterPrivate() : radius(5), quality(Qt::FastTransformation) {}
+
+    int radius;
+    Qt::TransformationMode quality;
+};
+
+
+/*!
+    Constructs a pixmap blur filter.
+
+    \internal
+*/
+QPixmapBlurFilter::QPixmapBlurFilter(QObject *parent)
+    : QPixmapFilter(*new QPixmapBlurFilterPrivate, BlurFilter, parent)
+{
+}
+
+/*!
+    Destructor of pixmap blur filter.
+
+    \internal
+*/
+QPixmapBlurFilter::~QPixmapBlurFilter()
+{
+}
+
+/*!
+    Sets the radius of the blur filter. Higher radius produces increased blurriness.
+
+    \internal
+*/
+void QPixmapBlurFilter::setRadius(int radius)
+{
+    Q_D(QPixmapBlurFilter);
+    d->radius = radius;
+}
+
+/*!
+    Gets the radius of the blur filter.
+
+    \internal
+*/
+int QPixmapBlurFilter::radius() const
+{
+    Q_D(const QPixmapBlurFilter);
+    return d->radius;
+}
+
+/*!
+    Setting the quality to FastTransformation causes the implementation
+    to trade off visual quality to blur the image faster.  Setting the
+    quality to SmoothTransformation causes the implementation to improve
+    visual quality at the expense of speed.  The implementation is free
+    to ignore this value if it only has a single blur algorithm.
+
+    \internal
+*/
+void QPixmapBlurFilter::setQuality(Qt::TransformationMode quality)
+{
+    Q_D(QPixmapBlurFilter);
+    d->quality = quality;
+}
+
+/*!
+    Gets the quality of the blur filter.
+
+    \internal
+*/
+Qt::TransformationMode QPixmapBlurFilter::quality() const
+{
+    Q_D(const QPixmapBlurFilter);
+    return d->quality;
+}
+
+/*!
+    \reimp
+
+    \internal
+*/
+QRectF QPixmapBlurFilter::boundingRectFor(const QRectF &rect) const
+{
+    return rect;
+}
+
+// Blur the image according to the blur radius
+// Based on exponential blur algorithm by Jani Huhtanen
+// (maximum radius is set to 16)
+static QImage blurred(const QImage& image, const QRect& rect, int radius)
+{
+    int tab[] = { 14, 10, 8, 6, 5, 5, 4, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2 };
+    int alpha = (radius < 1)  ? 16 : (radius > 17) ? 1 : tab[radius-1];
+
+    QImage result = image.convertToFormat(QImage::Format_ARGB32_Premultiplied);
+    int r1 = rect.top();
+    int r2 = rect.bottom();
+    int c1 = rect.left();
+    int c2 = rect.right();
+
+    int bpl = result.bytesPerLine();
+    int rgba[4];
+    unsigned char* p;
+
+    for (int col = c1; col <= c2; col++) {
+        p = result.scanLine(r1) + col * 4;
+        for (int i = 0; i < 4; i++)
+            rgba[i] = p[i] << 4;
+
+        p += bpl;
+        for (int j = r1; j < r2; j++, p += bpl)
+            for (int i = 0; i < 4; i++)
+                p[i] = (rgba[i] += ((p[i] << 4) - rgba[i]) * alpha / 16) >> 4;
+    }
+
+    for (int row = r1; row <= r2; row++) {
+        p = result.scanLine(row) + c1 * 4;
+        for (int i = 0; i < 4; i++)
+            rgba[i] = p[i] << 4;
+
+        p += 4;
+        for (int j = c1; j < c2; j++, p += 4)
+            for (int i = 0; i < 4; i++)
+                p[i] = (rgba[i] += ((p[i] << 4) - rgba[i]) * alpha / 16) >> 4;
+    }
+
+    for (int col = c1; col <= c2; col++) {
+        p = result.scanLine(r2) + col * 4;
+        for (int i = 0; i < 4; i++)
+            rgba[i] = p[i] << 4;
+
+        p -= bpl;
+        for (int j = r1; j < r2; j++, p -= bpl)
+            for (int i = 0; i < 4; i++)
+                p[i] = (rgba[i] += ((p[i] << 4) - rgba[i]) * alpha / 16) >> 4;
+    }
+
+    for (int row = r1; row <= r2; row++) {
+        p = result.scanLine(row) + c2 * 4;
+        for (int i = 0; i < 4; i++)
+            rgba[i] = p[i] << 4;
+
+        p -= 4;
+        for (int j = c1; j < c2; j++, p -= 4)
+            for (int i = 0; i < 4; i++)
+                p[i] = (rgba[i] += ((p[i] << 4) - rgba[i]) * alpha / 16) >> 4;
+    }
+
+    return result;
+}
+
+/*!
+    \reimp
+
+    \internal
+*/
+void QPixmapBlurFilter::draw(QPainter *painter, const QPointF &p, const QPixmap &src, const QRectF &srcRect) const
+{
+    Q_D(const QPixmapBlurFilter);
+    if (!painter->isActive())
+        return;
+
+    if (d->radius == 0) {
+        painter->drawPixmap(srcRect.translated(p), src, srcRect);
+        return;
+    }
+
+    QPixmapFilter *filter = painter->paintEngine() && painter->paintEngine()->isExtended() ?
+        static_cast<QPaintEngineEx *>(painter->paintEngine())->createPixmapFilter(type()) : 0;
+    QPixmapBlurFilter *blurFilter = static_cast<QPixmapBlurFilter*>(filter);
+    if (blurFilter) {
+        blurFilter->setRadius(d->radius);
+        blurFilter->setQuality(d->quality);
+        blurFilter->draw(painter, p, src, srcRect);
+        delete blurFilter;
+        return;
+    }
+
+    QImage srcImage;
+    QImage destImage;
+
+    if (srcRect.isNull()) {
+        srcImage = src.toImage();
+        destImage = blurred(srcImage, srcImage.rect(), d->radius);
+    } else {
+        QRect rect = srcRect.toAlignedRect().intersected(src.rect());
+
+        srcImage = src.copy(rect).toImage();
+        destImage = blurred(srcImage, srcImage.rect(), d->radius);
+    }
+
+    painter->drawImage(p, destImage);
+}
+
 // 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.
@@ -841,235 +1060,4 @@ void QPixmapDropShadowFilter::draw(QPainter *p,
     p->drawPixmap(pos, px, src);
 }
 
-/*!
-    \class QPixmapBlurFilter
-    \since 4.6
-    \ingroup multimedia
-
-    \brief The QPixmapBlurFilter class is a convenience class
-    for drawing pixmaps with blur effects.
-
-    By default, the blur effect is produced by applying an exponential
-    filter generated from the specified blurRadius().  Paint engines
-    may override this with a custom blur that is faster on the
-    underlying hardware.
-
-    \sa QPixmapConvolutionFilter
-
-    \internal
- */
-
-class QPixmapBlurFilterPrivate : public QPixmapFilterPrivate
-{
-public:
-    QPixmapBlurFilterPrivate()
-        : quality(QPixmapBlurFilter::High), radius(1) {}
-
-    QPixmapBlurFilter::BlurQuality quality;
-    qreal radius;
-};
-
-/*!
-    Constructs blur filter and attaches it to \a parent.
-
-    \internal
-*/
-QPixmapBlurFilter::QPixmapBlurFilter(QObject *parent)
-    : QPixmapFilter(*new QPixmapBlurFilterPrivate, BlurFilter, parent)
-{
-    Q_D(QPixmapBlurFilter);
-    setBlurRadius(4);
-}
-
-/*!
-    Destroys blur filter.
-
-    \internal
-*/
-QPixmapBlurFilter::~QPixmapBlurFilter()
-{
-}
-
-/*!
-    \enum QPixmapFilter::BlurQuality
-    \since 4.6
-    \ingroup multimedia
-    This enum describes the quality of blur to apply to pixmaps.
-
-    \value Fast Blur faster, potentially losing some quality.
-    \value High Produce the best high-quality blur possible, even if slower.
-
-    \internal
-*/
-
-/*!
-    Returns the quality of the blur.  The default value is High.
-
-    \sa blurRadius()
-    \internal
-*/
-QPixmapBlurFilter::BlurQuality QPixmapBlurFilter::blurQuality() const
-{
-    Q_D(const QPixmapBlurFilter);
-    return d->quality;
-}
-
-/*!
-    Sets the quality of the blur to the \a blurQuality specified.
-
-    Setting the quality to Faster causes the implementation to trade
-    off visual quality to blur the image faster.  Setting the quality
-    to High causes the implementation to improve visual quality
-    at the expense of speed.  The implementation is free to ignore
-    this value if it only has a single blur algorithm.
-
-    \sa setBlurRadius()
-    \internal
-*/
-void QPixmapBlurFilter::setBlurQuality(BlurQuality blurQuality)
-{
-    Q_D(QPixmapBlurFilter);
-    d->quality = blurQuality;
-}
-
-/*!
-    Returns the radius in pixels of the blur.  The default value is 4.
-
-    A smaller radius results in a sharper image.
-
-    \sa blurQuality()
-    \internal
-*/
-qreal QPixmapBlurFilter::blurRadius() const
-{
-    Q_D(const QPixmapBlurFilter);
-    return d->radius;
-}
-
-/*!
-    Sets the radius in pixels of the blur to the \a radius specified.
-
-    Using a smaller radius results in a sharper image.
-
-    \sa setBlurQuality()
-    \internal
-*/
-void QPixmapBlurFilter::setBlurRadius(qreal blurRadius)
-{
-    Q_D(QPixmapBlurFilter);
-    d->radius = blurRadius;
-}
-
-/*!
-    \internal
- */
-QRectF QPixmapBlurFilter::boundingRectFor(const QRectF &rect) const
-{
-    Q_D(const QPixmapBlurFilter);
-    qreal delta = d->radius * 3;
-    QRectF blurRect(rect);
-    blurRect.adjust(-delta, -delta, delta, delta);
-    return blurRect;
-}
-
-// Blur the image according to the blur radius
-// Based on exponential blur algorithm by Jani Huhtanen
-// (maximum radius is set to 16)
-static QImage blurred(const QImage& image, const QRect& rect, int radius)
-{
-    int tab[] = { 14, 10, 8, 6, 5, 5, 4, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2 };
-    int alpha = (radius < 1)  ? 16 : (radius > 17) ? 1 : tab[radius-1];
-
-    QImage result = image.convertToFormat(QImage::Format_ARGB32_Premultiplied);
-    int r1 = rect.top();
-    int r2 = rect.bottom();
-    int c1 = rect.left();
-    int c2 = rect.right();
-
-    int bpl = result.bytesPerLine();
-    int rgba[4];
-    unsigned char* p;
-
-    for (int col = c1; col <= c2; col++) {
-        p = result.scanLine(r1) + col * 4;
-        for (int i = 0; i < 4; i++)
-            rgba[i] = p[i] << 4;
-
-        p += bpl;
-        for (int j = r1; j < r2; j++, p += bpl)
-            for (int i = 0; i < 4; i++)
-                p[i] = (rgba[i] += ((p[i] << 4) - rgba[i]) * alpha / 16) >> 4;
-    }
-
-    for (int row = r1; row <= r2; row++) {
-        p = result.scanLine(row) + c1 * 4;
-        for (int i = 0; i < 4; i++)
-            rgba[i] = p[i] << 4;
-
-        p += 4;
-        for (int j = c1; j < c2; j++, p += 4)
-            for (int i = 0; i < 4; i++)
-                p[i] = (rgba[i] += ((p[i] << 4) - rgba[i]) * alpha / 16) >> 4;
-    }
-
-    for (int col = c1; col <= c2; col++) {
-        p = result.scanLine(r2) + col * 4;
-        for (int i = 0; i < 4; i++)
-            rgba[i] = p[i] << 4;
-
-        p -= bpl;
-        for (int j = r1; j < r2; j++, p -= bpl)
-            for (int i = 0; i < 4; i++)
-                p[i] = (rgba[i] += ((p[i] << 4) - rgba[i]) * alpha / 16) >> 4;
-    }
-
-    for (int row = r1; row <= r2; row++) {
-        p = result.scanLine(row) + c2 * 4;
-        for (int i = 0; i < 4; i++)
-            rgba[i] = p[i] << 4;
-
-        p -= 4;
-        for (int j = c1; j < c2; j++, p -= 4)
-            for (int i = 0; i < 4; i++)
-                p[i] = (rgba[i] += ((p[i] << 4) - rgba[i]) * alpha / 16) >> 4;
-    }
-
-    return result;
-}
-
-/*!
-    \internal
- */
-void QPixmapBlurFilter::draw(QPainter *painter, const QPointF &dest, const QPixmap &src, const QRectF &srcRect) const
-{
-    Q_D(const QPixmapBlurFilter);
-
-    QPixmapFilter *filter = painter->paintEngine() && painter->paintEngine()->isExtended() ?
-        static_cast<QPaintEngineEx *>(painter->paintEngine())->createPixmapFilter(type()) : 0;
-    QPixmapBlurFilter *blurFilter = static_cast<QPixmapBlurFilter*>(filter);
-    if (blurFilter) {
-        blurFilter->setBlurQuality(d->quality);
-        blurFilter->setBlurRadius(d->radius);
-        blurFilter->draw(painter, dest, src, srcRect);
-        delete blurFilter;
-        return;
-    }
-
-    QImage srcImage;
-    QImage destImage;
-
-    if (srcRect.isNull()) {
-        srcImage = src.toImage();
-        destImage = blurred(srcImage, srcImage.rect(), int(d->radius + 0.5));
-    } else {
-        QRect rect = srcRect.toAlignedRect().intersected(src.rect());
-
-        srcImage = src.copy(rect).toImage();
-        destImage = blurred(srcImage, srcImage.rect(), int(d->radius + 0.5));
-    }
-
-    qreal delta = d->radius * 3;
-    painter->drawImage(dest - QPointF(delta, delta), destImage);
-}
-
 QT_END_NAMESPACE
diff --git a/src/gui/image/qpixmapfilter_p.h b/src/gui/image/qpixmapfilter_p.h
index ca27cbf..ac393a1 100644
--- a/src/gui/image/qpixmapfilter_p.h
+++ b/src/gui/image/qpixmapfilter_p.h
@@ -118,6 +118,30 @@ private:
     int columns() const;
 };
 
+class QPixmapBlurFilterPrivate;
+
+class Q_GUI_EXPORT QPixmapBlurFilter : public QPixmapFilter
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(QPixmapBlurFilter)
+
+public:
+    QPixmapBlurFilter(QObject *parent = 0);
+    ~QPixmapBlurFilter();
+
+    void setRadius(int radius);
+    void setQuality(Qt::TransformationMode mode);
+
+    int radius() const;
+    Qt::TransformationMode quality() const;
+
+    QRectF boundingRectFor(const QRectF &rect) const;
+    void draw(QPainter *painter, const QPointF &dest, const QPixmap &src, const QRectF &srcRect = QRectF()) const;
+
+private:
+    friend class QGLPixmapBlurFilter;
+};
+
 class QPixmapColorizeFilterPrivate;
 
 class Q_GUI_EXPORT QPixmapColorizeFilter : public QPixmapFilter
@@ -159,33 +183,6 @@ public:
     inline void setOffset(qreal dx, qreal dy) { setOffset(QPointF(dx, dy)); }
 };
 
-class QPixmapBlurFilterPrivate;
-
-class Q_GUI_EXPORT QPixmapBlurFilter : public QPixmapFilter
-{
-    Q_OBJECT
-    Q_DECLARE_PRIVATE(QPixmapBlurFilter)
-
-public:
-    QPixmapBlurFilter(QObject *parent = 0);
-    ~QPixmapBlurFilter();
-
-    enum BlurQuality
-    {
-        Fast,
-        High
-    };
-
-    BlurQuality blurQuality() const;
-    void setBlurQuality(BlurQuality blurQuality);
-
-    qreal blurRadius() const;
-    void setBlurRadius(qreal blurRadius);
-
-    QRectF boundingRectFor(const QRectF &rect) const;
-    void draw(QPainter *painter, const QPointF &dest, const QPixmap &src, const QRectF &srcRect = QRectF()) const;
-};
-
 QT_END_NAMESPACE
 
 QT_END_HEADER
diff --git a/src/gui/kernel/qapplication.cpp b/src/gui/kernel/qapplication.cpp
index b168188..3453408 100644
--- a/src/gui/kernel/qapplication.cpp
+++ b/src/gui/kernel/qapplication.cpp
@@ -819,6 +819,12 @@ QApplication::QApplication(Display *dpy, int &argc, char **argv,
 #endif // Q_WS_X11
 
 extern void qInitDrawhelperAsm();
+extern int qRegisterGuiVariant();
+extern int qUnregisterGuiVariant();
+#ifndef QT_NO_STATEMACHINE
+extern int qRegisterGuiStateMachine();
+extern int qUnregisterGuiStateMachine();
+#endif
 
 /*!
   \fn void QApplicationPrivate::initialize()
@@ -832,11 +838,9 @@ void QApplicationPrivate::initialize()
     if (qt_appType != QApplication::Tty)
         (void) QApplication::style();  // trigger creation of application style
     // trigger registering of QVariant's GUI types
-    extern int qRegisterGuiVariant();
     qRegisterGuiVariant();
 #ifndef QT_NO_STATEMACHINE
     // trigger registering of QStateMachine's GUI types
-    extern int qRegisterGuiStateMachine();
     qRegisterGuiStateMachine();
 #endif
 
@@ -1060,11 +1064,9 @@ QApplication::~QApplication()
 
 #ifndef QT_NO_STATEMACHINE
     // trigger unregistering of QStateMachine's GUI types
-    extern int qUnregisterGuiStateMachine();
     qUnregisterGuiStateMachine();
 #endif
     // trigger unregistering of QVariant's GUI types
-    extern int qUnregisterGuiVariant();
     qUnregisterGuiVariant();
 }
 
diff --git a/src/gui/kernel/qapplication_p.h b/src/gui/kernel/qapplication_p.h
index 3692160..595f220 100644
--- a/src/gui/kernel/qapplication_p.h
+++ b/src/gui/kernel/qapplication_p.h
@@ -192,99 +192,54 @@ extern "C" {
 #endif
 
 #if defined(Q_WS_WIN)
-typedef BOOL (WINAPI *qt_RegisterTouchWindowPtr)(HWND, ULONG);
-typedef BOOL (WINAPI *qt_GetTouchInputInfoPtr)(HANDLE, UINT, PVOID, int);
-typedef BOOL (WINAPI *qt_CloseTouchInputHandlePtr)(HANDLE);
-
-typedef BOOL (WINAPI *PtrGetGestureInfo)(HANDLE hGestureInfo, PVOID pGestureInfo);
-typedef BOOL (WINAPI *PtrGetGestureExtraArgs)(HANDLE hGestureInfo, UINT cbExtraArgs, PBYTE pExtraArgs);
-typedef BOOL (WINAPI *PtrCloseGestureInfoHandle)(HANDLE hGestureInfo);
-typedef BOOL (WINAPI *PtrSetGestureConfig)(HWND hwnd, DWORD dwReserved, UINT cIDs,
-                                    PVOID pGestureConfig,
-                                    UINT cbSize);
-typedef BOOL (WINAPI *PtrGetGestureConfig)(HWND hwnd, DWORD dwReserved,
-                                    DWORD dwFlags, PUINT pcIDs,
-                                    PVOID pGestureConfig,
-                                    UINT cbSize);
-
-typedef BOOL (WINAPI *PtrBeginPanningFeedback)(HWND hwnd);
-typedef BOOL (WINAPI *PtrUpdatePanningFeedback)(HWND hwnd, LONG, LONG, BOOL);
-typedef BOOL (WINAPI *PtrEndPanningFeedback)(HWND hwnd, BOOL);
+typedef BOOL (WINAPI *PtrRegisterTouchWindow)(HWND, ULONG);
+typedef BOOL (WINAPI *PtrGetTouchInputInfo)(HANDLE, UINT, PVOID, int);
+typedef BOOL (WINAPI *PtrCloseTouchInputHandle)(HANDLE);
+
+typedef BOOL (WINAPI *PtrGetGestureInfo)(HANDLE, PVOID);
+typedef BOOL (WINAPI *PtrGetGestureExtraArgs)(HANDLE, UINT, PBYTE);
+typedef BOOL (WINAPI *PtrCloseGestureInfoHandle)(HANDLE);
+typedef BOOL (WINAPI *PtrSetGestureConfig)(HWND, DWORD, UINT, PVOID, UINT);
+typedef BOOL (WINAPI *PtrGetGestureConfig)(HWND, DWORD, DWORD, PUINT, PVOID, UINT);
+
+typedef BOOL (WINAPI *PtrBeginPanningFeedback)(HWND);
+typedef BOOL (WINAPI *PtrUpdatePanningFeedback)(HWND, LONG, LONG, BOOL);
+typedef BOOL (WINAPI *PtrEndPanningFeedback)(HWND, BOOL);
 
 #ifndef WM_GESTURE
+#  define WM_GESTURE 0x0119
+
+#  define GID_BEGIN                       1
+#  define GID_END                         2
+#  define GID_ZOOM                        3
+#  define GID_PAN                         4
+#  define GID_ROTATE                      5
+#  define GID_TWOFINGERTAP                6
+#  define GID_ROLLOVER                    7
 
-#define WM_GESTURE 0x0119
-#define WM_GESTURE_NOTIFY 0x011A
-
-DECLARE_HANDLE(HGESTUREINFO);
-
-#define GF_BEGIN                        0x00000001
-#define GF_INERTIA                      0x00000002
-#define GF_END                          0x00000004
-
-/*
- * Gesture IDs
- */
-#define GID_BEGIN                       1
-#define GID_END                         2
-#define GID_ZOOM                        3
-#define GID_PAN                         4
-#define GID_ROTATE                      5
-#define GID_TWOFINGERTAP                6
-#define GID_ROLLOVER                    7
-
-typedef struct tagGESTUREINFO {
-    UINT cbSize;                    // size, in bytes, of this structure (including variable length Args field)
-    DWORD dwFlags;                  // see GF_* flags
-    DWORD dwID;                     // gesture ID, see GID_* defines
-    HWND hwndTarget;                // handle to window targeted by this gesture
-    POINTS ptsLocation;             // current location of this gesture
-    DWORD dwInstanceID;             // internally used
-    DWORD dwSequenceID;             // internally used
-    ULONGLONG ullArguments;         // arguments for gestures whose arguments fit in 8 BYTES
-    UINT cbExtraArgs;               // size, in bytes, of extra arguments, if any, that accompany this gesture
-} GESTUREINFO, *PGESTUREINFO;
-typedef GESTUREINFO const * PCGESTUREINFO;
-
-typedef struct tagGESTURENOTIFYSTRUCT {
-    UINT cbSize;                    // size, in bytes, of this structure
-    DWORD dwFlags;                  // unused
-    HWND hwndTarget;                // handle to window targeted by the gesture
-    POINTS ptsLocation;             // starting location
-    DWORD dwInstanceID;             // internally used
-} GESTURENOTIFYSTRUCT, *PGESTURENOTIFYSTRUCT;
-
-/*
- * Gesture argument helpers
- *   - Angle should be a double in the range of -2pi to +2pi
- *   - Argument should be an unsigned 16-bit value
- */
-#define GID_ROTATE_ANGLE_TO_ARGUMENT(_arg_)     ((USHORT)((((_arg_) + 2.0 * 3.14159265) / (4.0 * 3.14159265)) * 65535.0))
-#define GID_ROTATE_ANGLE_FROM_ARGUMENT(_arg_)   ((((double)(_arg_) / 65535.0) * 4.0 * 3.14159265) - 2.0 * 3.14159265)
-
-typedef struct tagGESTURECONFIG {
-    DWORD dwID;                     // gesture ID
-    DWORD dwWant;                   // settings related to gesture ID that are to be turned on
-    DWORD dwBlock;                  // settings related to gesture ID that are to be turned off
-} GESTURECONFIG, *PGESTURECONFIG;
-
-#define GC_ALLGESTURES                              0x00000001
-#define GC_ZOOM                                     0x00000001
-#define GC_PAN                                      0x00000001
-#define GC_PAN_WITH_SINGLE_FINGER_VERTICALLY        0x00000002
-#define GC_PAN_WITH_SINGLE_FINGER_HORIZONTALLY      0x00000004
-#define GC_PAN_WITH_GUTTER                          0x00000008
-#define GC_PAN_WITH_INERTIA                         0x00000010
-#define GC_ROTATE                                   0x00000001
-#define GC_TWOFINGERTAP                             0x00000001
-#define GC_ROLLOVER                                 0x00000001
-#define GESTURECONFIGMAXCOUNT           256             // Maximum number of gestures that can be included
-                                                        // in a single call to SetGestureConfig / GetGestureConfig
-
-
-
-#define GCF_INCLUDE_ANCESTORS           0x00000001      // If specified, GetGestureConfig returns consolidated configuration
-                                                        // for the specified window and it's parent window chain
+typedef struct tagGESTUREINFO
+{
+    UINT cbSize;
+    DWORD dwFlags;
+    DWORD dwID;
+    HWND hwndTarget;
+    POINTS ptsLocation;
+    DWORD dwInstanceID;
+    DWORD dwSequenceID;
+    ULONGLONG ullArguments;
+    UINT cbExtraArgs;
+} GESTUREINFO;
+
+#  define GC_PAN                                      0x00000001
+#  define GC_PAN_WITH_SINGLE_FINGER_VERTICALLY        0x00000002
+#  define GC_PAN_WITH_SINGLE_FINGER_HORIZONTALLY      0x00000004
+
+typedef struct tagGESTURECONFIG
+{
+    DWORD dwID;
+    DWORD dwWant;
+    DWORD dwBlock;
+} GESTURECONFIG;
 
 #endif // WM_GESTURE
 
@@ -559,9 +514,9 @@ public:
                                        const QList<QTouchEvent::TouchPoint> &touchPoints);
 
 #if defined(Q_WS_WIN)
-    static qt_RegisterTouchWindowPtr RegisterTouchWindow;
-    static qt_GetTouchInputInfoPtr GetTouchInputInfo;
-    static qt_CloseTouchInputHandlePtr CloseTouchInputHandle;
+    static PtrRegisterTouchWindow RegisterTouchWindow;
+    static PtrGetTouchInputInfo GetTouchInputInfo;
+    static PtrCloseTouchInputHandle CloseTouchInputHandle;
 
     QHash<DWORD, int> touchInputIDToTouchPointID;
     QList<QTouchEvent::TouchPoint> appAllTouchPoints;
diff --git a/src/gui/kernel/qapplication_win.cpp b/src/gui/kernel/qapplication_win.cpp
index cbcac9a..d5c820c 100644
--- a/src/gui/kernel/qapplication_win.cpp
+++ b/src/gui/kernel/qapplication_win.cpp
@@ -3727,7 +3727,7 @@ bool QETWidget::translateGestureEvent(const MSG &msg)
     gi.dwSequenceID  = 0;
 
     QApplicationPrivate *qAppPriv = getQApplicationPrivateInternal();
-    BOOL bResult = qAppPriv->GetGestureInfo((HGESTUREINFO)msg.lParam, &gi);
+    BOOL bResult = qAppPriv->GetGestureInfo((HANDLE)msg.lParam, &gi);
 
     const QPoint widgetPos = QPoint(gi.ptsLocation.x, gi.ptsLocation.y);
     QWidget *alienWidget = !internalWinId() ? this : childAt(widgetPos);
@@ -3765,7 +3765,7 @@ bool QETWidget::translateGestureEvent(const MSG &msg)
         if (dwErr > 0)
             qWarning() << "translateGestureEvent: error = " << dwErr;
     }
-    qAppPriv->CloseGestureInfoHandle((HGESTUREINFO)msg.lParam);
+    qAppPriv->CloseGestureInfoHandle((HANDLE)msg.lParam);
     return true;
 }
 
@@ -3951,17 +3951,17 @@ void QSessionManager::cancel()
 #endif //QT_NO_SESSIONMANAGER
 
 
-qt_RegisterTouchWindowPtr QApplicationPrivate::RegisterTouchWindow = 0;
-qt_GetTouchInputInfoPtr QApplicationPrivate::GetTouchInputInfo = 0;
-qt_CloseTouchInputHandlePtr QApplicationPrivate::CloseTouchInputHandle = 0;
+PtrRegisterTouchWindow QApplicationPrivate::RegisterTouchWindow = 0;
+PtrGetTouchInputInfo QApplicationPrivate::GetTouchInputInfo = 0;
+PtrCloseTouchInputHandle QApplicationPrivate::CloseTouchInputHandle = 0;
 
 void QApplicationPrivate::initializeMultitouch_sys()
 {
     QLibrary library(QLatin1String("user32"));
     // MinGW (g++ 3.4.5) accepts only C casts.
-    RegisterTouchWindow = (qt_RegisterTouchWindowPtr)(library.resolve("RegisterTouchWindow"));
-    GetTouchInputInfo = (qt_GetTouchInputInfoPtr)(library.resolve("GetTouchInputInfo"));
-    CloseTouchInputHandle = (qt_CloseTouchInputHandlePtr)(library.resolve("CloseTouchInputHandle"));
+    RegisterTouchWindow = (PtrRegisterTouchWindow)(library.resolve("RegisterTouchWindow"));
+    GetTouchInputInfo = (PtrGetTouchInputInfo)(library.resolve("GetTouchInputInfo"));
+    CloseTouchInputHandle = (PtrCloseTouchInputHandle)(library.resolve("CloseTouchInputHandle"));
 
     touchInputIDToTouchPointID.clear();
 }
diff --git a/src/gui/kernel/qapplication_x11.cpp b/src/gui/kernel/qapplication_x11.cpp
index 76138f8..4016563 100644
--- a/src/gui/kernel/qapplication_x11.cpp
+++ b/src/gui/kernel/qapplication_x11.cpp
@@ -3246,48 +3246,43 @@ int QApplication::x11ProcessEvent(XEvent* event)
 #ifdef ALIEN_DEBUG
     //qDebug() << "QApplication::x11ProcessEvent:" << event->type;
 #endif
-    Time time = 0, userTime = 0;
     switch (event->type) {
     case ButtonPress:
         pressed_window = event->xbutton.window;
-        userTime = event->xbutton.time;
+        X11->userTime = event->xbutton.time;
         // fallthrough intended
     case ButtonRelease:
-        time = event->xbutton.time;
+        X11->time = event->xbutton.time;
         break;
     case MotionNotify:
-        time = event->xmotion.time;
+        X11->time = event->xmotion.time;
         break;
     case XKeyPress:
-        userTime = event->xkey.time;
+        X11->userTime = event->xkey.time;
         // fallthrough intended
     case XKeyRelease:
-        time = event->xkey.time;
+        X11->time = event->xkey.time;
         break;
     case PropertyNotify:
-        time = event->xproperty.time;
+        X11->time = event->xproperty.time;
         break;
     case EnterNotify:
     case LeaveNotify:
-        time = event->xcrossing.time;
+        X11->time = event->xcrossing.time;
         break;
     case SelectionClear:
-        time = event->xselectionclear.time;
+        X11->time = event->xselectionclear.time;
         break;
     default:
-#ifndef QT_NO_XFIXES
-        if (X11->use_xfixes && event->type == (X11->xfixes_eventbase + XFixesSelectionNotify)) {
-            XFixesSelectionNotifyEvent *req =
-                reinterpret_cast<XFixesSelectionNotifyEvent *>(event);
-            time = req->selection_timestamp;
-        }
-#endif
         break;
     }
-    if (time > X11->time)
-        X11->time = time;
-    if (userTime > X11->userTime)
-        X11->userTime = userTime;
+#ifndef QT_NO_XFIXES
+    if (X11->use_xfixes && event->type == (X11->xfixes_eventbase + XFixesSelectionNotify)) {
+        XFixesSelectionNotifyEvent *req =
+            reinterpret_cast<XFixesSelectionNotifyEvent *>(event);
+        X11->time = req->selection_timestamp;
+    }
+#endif
 
     QETWidget *widget = (QETWidget*)QWidget::find((WId)event->xany.window);
 
diff --git a/src/gui/kernel/qguivariant.cpp b/src/gui/kernel/qguivariant.cpp
index 01df47d..ab69cdf 100644
--- a/src/gui/kernel/qguivariant.cpp
+++ b/src/gui/kernel/qguivariant.cpp
@@ -60,6 +60,11 @@
 #include "qregion.h"
 #include "qsizepolicy.h"
 #include "qtextformat.h"
+#include "qmatrix4x4.h"
+#include "qvector2d.h"
+#include "qvector3d.h"
+#include "qvector4d.h"
+#include "qquaternion.h"
 
 #include "private/qvariant_p.h"
 
@@ -148,6 +153,31 @@ static void construct(QVariant::Private *x, const void *copy)
         v_construct<QColor>(x, &color);
         break;
     }
+#ifndef QT_NO_MATRIX4X4
+    case QVariant::Matrix4x4:
+        v_construct<QMatrix4x4>(x, copy);
+        break;
+#endif
+#ifndef QT_NO_VECTOR2D
+    case QVariant::Vector2D:
+        v_construct<QVector2D>(x, copy);
+        break;
+#endif
+#ifndef QT_NO_VECTOR3D
+    case QVariant::Vector3D:
+        v_construct<QVector3D>(x, copy);
+        break;
+#endif
+#ifndef QT_NO_VECTOR4D
+    case QVariant::Vector4D:
+        v_construct<QVector4D>(x, copy);
+        break;
+#endif
+#ifndef QT_NO_QUATERNION
+    case QVariant::Quaternion:
+        v_construct<QQuaternion>(x, copy);
+        break;
+#endif
     default:
         qcoreVariantHandler()->construct(x, copy);
         return;
@@ -221,6 +251,31 @@ static void clear(QVariant::Private *d)
     case QVariant::Pen:
         v_clear<QPen>(d);
         break;
+#ifndef QT_NO_MATRIX4X4
+    case QVariant::Matrix4x4:
+        v_clear<QMatrix4x4>(d);
+        break;
+#endif
+#ifndef QT_NO_VECTOR2D
+    case QVariant::Vector2D:
+        v_clear<QVector2D>(d);
+        break;
+#endif
+#ifndef QT_NO_VECTOR3D
+    case QVariant::Vector3D:
+        v_clear<QVector3D>(d);
+        break;
+#endif
+#ifndef QT_NO_VECTOR4D
+    case QVariant::Vector4D:
+        v_clear<QVector4D>(d);
+        break;
+#endif
+#ifndef QT_NO_QUATERNION
+    case QVariant::Quaternion:
+        v_clear<QVector4D>(d);
+        break;
+#endif
     default:
         qcoreVariantHandler()->clear(d);
         return;
@@ -266,7 +321,26 @@ static bool isNull(const QVariant::Private *d)
     case QVariant::KeySequence:
 #endif
     case QVariant::Pen:
+#ifndef QT_NO_MATRIX4X4
+    case QVariant::Matrix4x4:
+#endif
         break;
+#ifndef QT_NO_VECTOR2D
+    case QVariant::Vector2D:
+        return v_cast<QVector2D>(d)->isNull();
+#endif
+#ifndef QT_NO_VECTOR3D
+    case QVariant::Vector3D:
+        return v_cast<QVector3D>(d)->isNull();
+#endif
+#ifndef QT_NO_VECTOR4D
+    case QVariant::Vector4D:
+        return v_cast<QVector4D>(d)->isNull();
+#endif
+#ifndef QT_NO_QUATERNION
+    case QVariant::Quaternion:
+        return v_cast<QQuaternion>(d)->isNull();
+#endif
     default:
         return qcoreVariantHandler()->isNull(d);
     }
@@ -326,6 +400,26 @@ static bool compare(const QVariant::Private *a, const QVariant::Private *b)
 #endif
     case QVariant::Pen:
         return *v_cast<QPen>(a) == *v_cast<QPen>(b);
+#ifndef QT_NO_MATRIX4X4
+    case QVariant::Matrix4x4:
+        return *v_cast<QMatrix4x4>(a) == *v_cast<QMatrix4x4>(b);
+#endif
+#ifndef QT_NO_VECTOR2D
+    case QVariant::Vector2D:
+        return *v_cast<QVector2D>(a) == *v_cast<QVector2D>(b);
+#endif
+#ifndef QT_NO_VECTOR3D
+    case QVariant::Vector3D:
+        return *v_cast<QVector3D>(a) == *v_cast<QVector3D>(b);
+#endif
+#ifndef QT_NO_VECTOR4D
+    case QVariant::Vector4D:
+        return *v_cast<QVector4D>(a) == *v_cast<QVector4D>(b);
+#endif
+#ifndef QT_NO_QUATERNION
+    case QVariant::Quaternion:
+        return *v_cast<QQuaternion>(a) == *v_cast<QQuaternion>(b);
+#endif
     default:
         break;
     }
@@ -513,6 +607,31 @@ static void streamDebug(QDebug dbg, const QVariant &v)
     case QVariant::Pen:
         dbg.nospace() << qvariant_cast<QPen>(v);
         break;
+#ifndef QT_NO_MATRIX4X4
+    case QVariant::Matrix4x4:
+        dbg.nospace() << qvariant_cast<QMatrix4x4>(v);
+        break;
+#endif
+#ifndef QT_NO_VECTOR2D
+    case QVariant::Vector2D:
+        dbg.nospace() << qvariant_cast<QVector2D>(v);
+        break;
+#endif
+#ifndef QT_NO_VECTOR3D
+    case QVariant::Vector3D:
+        dbg.nospace() << qvariant_cast<QVector3D>(v);
+        break;
+#endif
+#ifndef QT_NO_VECTOR4D
+    case QVariant::Vector4D:
+        dbg.nospace() << qvariant_cast<QVector4D>(v);
+        break;
+#endif
+#ifndef QT_NO_QUATERNION
+    case QVariant::Quaternion:
+        dbg.nospace() << qvariant_cast<QQuaternion>(v);
+        break;
+#endif
     default:
         qcoreVariantHandler()->debugStream(dbg, v);
         break;
@@ -596,6 +715,21 @@ Q_DECL_METATYPE_HELPER(QTextLength)
 Q_DECL_METATYPE_HELPER(QTextFormat)
 Q_DECL_METATYPE_HELPER(QMatrix)
 Q_DECL_METATYPE_HELPER(QTransform)
+#ifndef QT_NO_MATRIX4X4
+Q_DECL_METATYPE_HELPER(QMatrix4x4)
+#endif
+#ifndef QT_NO_VECTOR2D
+Q_DECL_METATYPE_HELPER(QVector2D)
+#endif
+#ifndef QT_NO_VECTOR3D
+Q_DECL_METATYPE_HELPER(QVector3D)
+#endif
+#ifndef QT_NO_VECTOR4D
+Q_DECL_METATYPE_HELPER(QVector4D)
+#endif
+#ifndef QT_NO_QUATERNION
+Q_DECL_METATYPE_HELPER(QQuaternion)
+#endif
 
 #ifdef QT_NO_DATASTREAM
 #  define Q_IMPL_METATYPE_HELPER(TYPE) \
@@ -645,7 +779,32 @@ static const QMetaTypeGuiHelper qVariantGuiHelper[] = {
     Q_IMPL_METATYPE_HELPER(QTextLength),
     Q_IMPL_METATYPE_HELPER(QTextFormat),
     Q_IMPL_METATYPE_HELPER(QMatrix),
-    Q_IMPL_METATYPE_HELPER(QTransform)
+    Q_IMPL_METATYPE_HELPER(QTransform),
+#ifndef QT_NO_MATRIX4X4
+    Q_IMPL_METATYPE_HELPER(QMatrix4x4),
+#else
+    {0, 0, 0, 0},
+#endif
+#ifndef QT_NO_VECTOR2D
+    Q_IMPL_METATYPE_HELPER(QVector2D),
+#else
+    {0, 0, 0, 0},
+#endif
+#ifndef QT_NO_VECTOR3D
+    Q_IMPL_METATYPE_HELPER(QVector3D),
+#else
+    {0, 0, 0, 0},
+#endif
+#ifndef QT_NO_VECTOR4D
+    Q_IMPL_METATYPE_HELPER(QVector4D),
+#else
+    {0, 0, 0, 0},
+#endif
+#ifndef QT_NO_QUATERNION
+    Q_IMPL_METATYPE_HELPER(QQuaternion)
+#else
+    {0, 0, 0, 0}
+#endif
 };
 
 static const QVariant::Handler *qt_guivariant_last_handler = 0;
diff --git a/src/gui/kernel/qt_cocoa_helpers_mac_p.h b/src/gui/kernel/qt_cocoa_helpers_mac_p.h
index 99f058b..af3b4cb 100644
--- a/src/gui/kernel/qt_cocoa_helpers_mac_p.h
+++ b/src/gui/kernel/qt_cocoa_helpers_mac_p.h
@@ -105,6 +105,8 @@
 #include <qpoint.h>
 #include "private/qt_mac_p.h"
 
+struct HIContentBorderMetrics;
+
 #ifdef Q_WS_MAC32
 typedef struct _NSPoint NSPoint; // Just redefine here so I don't have to pull in all of Cocoa.
 #else
@@ -122,7 +124,6 @@ bool macWindowToolbarIsVisible( void * /*OSWindowRef*/ window );
 void macWindowSetHasShadow( void * /*OSWindowRef*/ window, bool hasShadow );
 void macWindowFlush(void * /*OSWindowRef*/ window);
 void macSendToolbarChangeEvent(QWidget *widget);
-struct HIContentBorderMetrics;
 void qt_mac_updateContentBorderMetricts(void * /*OSWindowRef */window, const ::HIContentBorderMetrics &metrics);
 void * /*NSImage */qt_mac_create_nsimage(const QPixmap &pm);
 void qt_mac_update_mouseTracking(QWidget *widget);
diff --git a/src/gui/math3d/qmatrix4x4.cpp b/src/gui/math3d/qmatrix4x4.cpp
index 88f58c8..b4c54a0 100644
--- a/src/gui/math3d/qmatrix4x4.cpp
+++ b/src/gui/math3d/qmatrix4x4.cpp
@@ -1794,6 +1794,51 @@ QDebug operator<<(QDebug dbg, const QMatrix4x4 &m)
 
 #endif
 
-#endif
+#ifndef QT_NO_DATASTREAM
+
+/*!
+    \fn QDataStream &operator<<(QDataStream &stream, const QMatrix4x4 &matrix)
+    \relates QMatrix4x4
+
+    Writes the given \a matrix to the given \a stream and returns a
+    reference to the stream.
+
+    \sa {Format of the QDataStream Operators}
+*/
+
+QDataStream &operator<<(QDataStream &stream, const QMatrix4x4 &matrix)
+{
+    for (int row = 0; row < 4; ++row)
+        for (int col = 0; col < 4; ++col)
+            stream << double(matrix(row, col));
+    return stream;
+}
+
+/*!
+    \fn QDataStream &operator>>(QDataStream &stream, QMatrix4x4 &matrix)
+    \relates QMatrix4x4
+
+    Reads a 4x4 matrix from the given \a stream into the given \a matrix
+    and returns a reference to the stream.
+
+    \sa {Format of the QDataStream Operators}
+*/
+
+QDataStream &operator>>(QDataStream &stream, QMatrix4x4 &matrix)
+{
+    double x;
+    for (int row = 0; row < 4; ++row) {
+        for (int col = 0; col < 4; ++col) {
+            stream >> x;
+            matrix(row, col) = float(x);
+        }
+    }
+    matrix.inferSpecialType();
+    return stream;
+}
+
+#endif // QT_NO_DATASTREAM
+
+#endif // QT_NO_MATRIX4X4
 
 QT_END_NAMESPACE
diff --git a/src/gui/math3d/qmatrix4x4.h b/src/gui/math3d/qmatrix4x4.h
index d63de70..f7246bb 100644
--- a/src/gui/math3d/qmatrix4x4.h
+++ b/src/gui/math3d/qmatrix4x4.h
@@ -960,6 +960,11 @@ inline float *QMatrix4x4::data()
 Q_GUI_EXPORT QDebug operator<<(QDebug dbg, const QMatrix4x4 &m);
 #endif
 
+#ifndef QT_NO_DATASTREAM
+Q_GUI_EXPORT QDataStream &operator<<(QDataStream &, const QMatrix4x4 &);
+Q_GUI_EXPORT QDataStream &operator>>(QDataStream &, QMatrix4x4 &);
+#endif
+
 template <int N, int M>
 QMatrix4x4 qGenericMatrixToMatrix4x4(const QGenericMatrix<N, M, qreal, float>& matrix)
 {
@@ -989,10 +994,6 @@ QGenericMatrix<N, M, qreal, float> qGenericMatrixFromMatrix4x4(const QMatrix4x4&
 
 QT_END_NAMESPACE
 
-#ifndef QT_NO_MATRIX4X4
-Q_DECLARE_METATYPE(QMatrix4x4)
-#endif
-
 QT_END_HEADER
 
 #endif
diff --git a/src/gui/math3d/qquaternion.cpp b/src/gui/math3d/qquaternion.cpp
index d9d4160..841a4c0 100644
--- a/src/gui/math3d/qquaternion.cpp
+++ b/src/gui/math3d/qquaternion.cpp
@@ -571,6 +571,51 @@ QDebug operator<<(QDebug dbg, const QQuaternion &q)
 
 #endif
 
+#ifndef QT_NO_DATASTREAM
+
+/*!
+    \fn QDataStream &operator<<(QDataStream &stream, const QQuaternion &quaternion)
+    \relates QQuaternion
+
+    Writes the given \a quaternion to the given \a stream and returns a
+    reference to the stream.
+
+    \sa {Format of the QDataStream Operators}
+*/
+
+QDataStream &operator<<(QDataStream &stream, const QQuaternion &quaternion)
+{
+    stream << double(quaternion.scalar()) << double(quaternion.x())
+           << double(quaternion.y()) << double(quaternion.z());
+    return stream;
+}
+
+/*!
+    \fn QDataStream &operator>>(QDataStream &stream, QQuaternion &quaternion)
+    \relates QQuaternion
+
+    Reads a quaternion from the given \a stream into the given \a quaternion
+    and returns a reference to the stream.
+
+    \sa {Format of the QDataStream Operators}
+*/
+
+QDataStream &operator>>(QDataStream &stream, QQuaternion &quaternion)
+{
+    double scalar, x, y, z;
+    stream >> scalar;
+    stream >> x;
+    stream >> y;
+    stream >> z;
+    quaternion.setScalar(qreal(scalar));
+    quaternion.setX(qreal(x));
+    quaternion.setY(qreal(y));
+    quaternion.setZ(qreal(z));
+    return stream;
+}
+
+#endif // QT_NO_DATASTREAM
+
 #endif
 
 QT_END_NAMESPACE
diff --git a/src/gui/math3d/qquaternion.h b/src/gui/math3d/qquaternion.h
index 6b24a04..55c871d 100644
--- a/src/gui/math3d/qquaternion.h
+++ b/src/gui/math3d/qquaternion.h
@@ -324,14 +324,15 @@ inline QVector4D QQuaternion::toVector4D() const
 Q_GUI_EXPORT QDebug operator<<(QDebug dbg, const QQuaternion &q);
 #endif
 
+#ifndef QT_NO_DATASTREAM
+Q_GUI_EXPORT QDataStream &operator<<(QDataStream &, const QQuaternion &);
+Q_GUI_EXPORT QDataStream &operator>>(QDataStream &, QQuaternion &);
 #endif
 
-QT_END_NAMESPACE
-
-#ifndef QT_NO_QUATERNION
-Q_DECLARE_METATYPE(QQuaternion)
 #endif
 
+QT_END_NAMESPACE
+
 QT_END_HEADER
 
 #endif
diff --git a/src/gui/math3d/qvector2d.cpp b/src/gui/math3d/qvector2d.cpp
index b492aa8..28f6b7a 100644
--- a/src/gui/math3d/qvector2d.cpp
+++ b/src/gui/math3d/qvector2d.cpp
@@ -410,6 +410,46 @@ QDebug operator<<(QDebug dbg, const QVector2D &vector)
 
 #endif
 
-#endif
+#ifndef QT_NO_DATASTREAM
+
+/*!
+    \fn QDataStream &operator<<(QDataStream &stream, const QVector2D &vector)
+    \relates QVector2D
+
+    Writes the given \a vector to the given \a stream and returns a
+    reference to the stream.
+
+    \sa {Format of the QDataStream Operators}
+*/
+
+QDataStream &operator<<(QDataStream &stream, const QVector2D &vector)
+{
+    stream << double(vector.x()) << double(vector.y());
+    return stream;
+}
+
+/*!
+    \fn QDataStream &operator>>(QDataStream &stream, QVector2D &vector)
+    \relates QVector2D
+
+    Reads a 2D vector from the given \a stream into the given \a vector
+    and returns a reference to the stream.
+
+    \sa {Format of the QDataStream Operators}
+*/
+
+QDataStream &operator>>(QDataStream &stream, QVector2D &vector)
+{
+    double x, y;
+    stream >> x;
+    stream >> y;
+    vector.setX(qreal(x));
+    vector.setY(qreal(y));
+    return stream;
+}
+
+#endif // QT_NO_DATASTREAM
+
+#endif // QT_NO_VECTOR2D
 
 QT_END_NAMESPACE
diff --git a/src/gui/math3d/qvector2d.h b/src/gui/math3d/qvector2d.h
index bb62afe..d473c2f 100644
--- a/src/gui/math3d/qvector2d.h
+++ b/src/gui/math3d/qvector2d.h
@@ -243,14 +243,15 @@ inline QPointF QVector2D::toPointF() const
 Q_GUI_EXPORT QDebug operator<<(QDebug dbg, const QVector2D &vector);
 #endif
 
+#ifndef QT_NO_DATASTREAM
+Q_GUI_EXPORT QDataStream &operator<<(QDataStream &, const QVector2D &);
+Q_GUI_EXPORT QDataStream &operator>>(QDataStream &, QVector2D &);
 #endif
 
-QT_END_NAMESPACE
-
-#ifndef QT_NO_VECTOR2D
-Q_DECLARE_METATYPE(QVector2D)
 #endif
 
+QT_END_NAMESPACE
+
 QT_END_HEADER
 
 #endif
diff --git a/src/gui/math3d/qvector3d.cpp b/src/gui/math3d/qvector3d.cpp
index 95550cd..881f47c 100644
--- a/src/gui/math3d/qvector3d.cpp
+++ b/src/gui/math3d/qvector3d.cpp
@@ -558,6 +558,49 @@ QDebug operator<<(QDebug dbg, const QVector3D &vector)
 
 #endif
 
-#endif
+#ifndef QT_NO_DATASTREAM
+
+/*!
+    \fn QDataStream &operator<<(QDataStream &stream, const QVector3D &vector)
+    \relates QVector3D
+
+    Writes the given \a vector to the given \a stream and returns a
+    reference to the stream.
+
+    \sa {Format of the QDataStream Operators}
+*/
+
+QDataStream &operator<<(QDataStream &stream, const QVector3D &vector)
+{
+    stream << double(vector.x()) << double(vector.y())
+           << double(vector.z());
+    return stream;
+}
+
+/*!
+    \fn QDataStream &operator>>(QDataStream &stream, QVector3D &vector)
+    \relates QVector3D
+
+    Reads a 3D vector from the given \a stream into the given \a vector
+    and returns a reference to the stream.
+
+    \sa {Format of the QDataStream Operators}
+*/
+
+QDataStream &operator>>(QDataStream &stream, QVector3D &vector)
+{
+    double x, y, z;
+    stream >> x;
+    stream >> y;
+    stream >> z;
+    vector.setX(qreal(x));
+    vector.setY(qreal(y));
+    vector.setZ(qreal(z));
+    return stream;
+}
+
+#endif // QT_NO_DATASTREAM
+
+#endif // QT_NO_VECTOR3D
 
 QT_END_NAMESPACE
diff --git a/src/gui/math3d/qvector3d.h b/src/gui/math3d/qvector3d.h
index 873b388..7494dcf 100644
--- a/src/gui/math3d/qvector3d.h
+++ b/src/gui/math3d/qvector3d.h
@@ -271,14 +271,15 @@ inline QPointF QVector3D::toPointF() const
 Q_GUI_EXPORT QDebug operator<<(QDebug dbg, const QVector3D &vector);
 #endif
 
+#ifndef QT_NO_DATASTREAM
+Q_GUI_EXPORT QDataStream &operator<<(QDataStream &, const QVector3D &);
+Q_GUI_EXPORT QDataStream &operator>>(QDataStream &, QVector3D &);
 #endif
 
-QT_END_NAMESPACE
-
-#ifndef QT_NO_VECTOR3D
-Q_DECLARE_METATYPE(QVector3D)
 #endif
 
+QT_END_NAMESPACE
+
 QT_END_HEADER
 
 #endif
diff --git a/src/gui/math3d/qvector4d.cpp b/src/gui/math3d/qvector4d.cpp
index 1f7d921..1a84db6 100644
--- a/src/gui/math3d/qvector4d.cpp
+++ b/src/gui/math3d/qvector4d.cpp
@@ -509,6 +509,51 @@ QDebug operator<<(QDebug dbg, const QVector4D &vector)
 
 #endif
 
-#endif
+#ifndef QT_NO_DATASTREAM
+
+/*!
+    \fn QDataStream &operator<<(QDataStream &stream, const QVector4D &vector)
+    \relates QVector4D
+
+    Writes the given \a vector to the given \a stream and returns a
+    reference to the stream.
+
+    \sa {Format of the QDataStream Operators}
+*/
+
+QDataStream &operator<<(QDataStream &stream, const QVector4D &vector)
+{
+    stream << double(vector.x()) << double(vector.y())
+           << double(vector.z()) << double(vector.w());
+    return stream;
+}
+
+/*!
+    \fn QDataStream &operator>>(QDataStream &stream, QVector4D &vector)
+    \relates QVector4D
+
+    Reads a 4D vector from the given \a stream into the given \a vector
+    and returns a reference to the stream.
+
+    \sa {Format of the QDataStream Operators}
+*/
+
+QDataStream &operator>>(QDataStream &stream, QVector4D &vector)
+{
+    double x, y, z, w;
+    stream >> x;
+    stream >> y;
+    stream >> z;
+    stream >> w;
+    vector.setX(qreal(x));
+    vector.setY(qreal(y));
+    vector.setZ(qreal(z));
+    vector.setW(qreal(w));
+    return stream;
+}
+
+#endif // QT_NO_DATASTREAM
+
+#endif // QT_NO_VECTOR4D
 
 QT_END_NAMESPACE
diff --git a/src/gui/math3d/qvector4d.h b/src/gui/math3d/qvector4d.h
index dcfd87a..cd61496 100644
--- a/src/gui/math3d/qvector4d.h
+++ b/src/gui/math3d/qvector4d.h
@@ -276,14 +276,15 @@ inline QPointF QVector4D::toPointF() const
 Q_GUI_EXPORT QDebug operator<<(QDebug dbg, const QVector4D &vector);
 #endif
 
+#ifndef QT_NO_DATASTREAM
+Q_GUI_EXPORT QDataStream &operator<<(QDataStream &, const QVector4D &);
+Q_GUI_EXPORT QDataStream &operator>>(QDataStream &, QVector4D &);
 #endif
 
-QT_END_NAMESPACE
-
-#ifndef QT_NO_VECTOR4D
-Q_DECLARE_METATYPE(QVector4D)
 #endif
 
+QT_END_NAMESPACE
+
 QT_END_HEADER
 
 #endif
diff --git a/src/gui/painting/qgraphicssystemfactory.cpp b/src/gui/painting/qgraphicssystemfactory.cpp
index b618d8b..ddc66f3 100644
--- a/src/gui/painting/qgraphicssystemfactory.cpp
+++ b/src/gui/painting/qgraphicssystemfactory.cpp
@@ -64,6 +64,10 @@ QGraphicsSystem *QGraphicsSystemFactory::create(const QString& key)
     if (system.isEmpty()) {
         system = QLatin1String("opengl");
     }
+#elif defined (QT_GRAPHICSSYSTEM_OPENVG)
+    if (system.isEmpty()) {
+        system = QLatin1String("openvg");
+    }
 #elif defined (QT_GRAPHICSSYSTEM_RASTER) && !defined(Q_WS_WIN)
     if (system.isEmpty()) {
         system = QLatin1String("raster");
diff --git a/src/gui/painting/qpaintengine.h b/src/gui/painting/qpaintengine.h
index 57c9e2d..5298b6a 100644
--- a/src/gui/painting/qpaintengine.h
+++ b/src/gui/painting/qpaintengine.h
@@ -210,6 +210,7 @@ public:
         Direct3D,
         Pdf,
         OpenVG,
+        OpenGL2,
 
         User = 50,    // first user type id
         MaxUser = 100 // last user type id
diff --git a/src/gui/painting/qpdf.cpp b/src/gui/painting/qpdf.cpp
index 178d519..6735ee6 100644
--- a/src/gui/painting/qpdf.cpp
+++ b/src/gui/painting/qpdf.cpp
@@ -968,8 +968,7 @@ QPdfBaseEngine::QPdfBaseEngine(QPdfBaseEnginePrivate &dd, PaintEngineFeatures f)
 
 void QPdfBaseEngine::drawPoints (const QPointF *points, int pointCount)
 {
-    Q_D(QPdfBaseEngine);
-    if (!points || !d->hasPen)
+    if (!points)
         return;
 
     QPainterPath p;
@@ -999,6 +998,12 @@ void QPdfBaseEngine::drawRects (const QRectF *rects, int rectCount)
         return;
 
     Q_D(QPdfBaseEngine);
+    if (d->useAlphaEngine) {
+        QAlphaPaintEngine::drawRects(rects, rectCount);
+        if (!continueCall())
+            return;
+    }
+
     if (d->clipEnabled && d->allClipped)
         return;
     if (!d->hasPen && !d->hasBrush)
diff --git a/src/gui/styles/qcleanlooksstyle.cpp b/src/gui/styles/qcleanlooksstyle.cpp
index 01f19c6..8f88781 100644
--- a/src/gui/styles/qcleanlooksstyle.cpp
+++ b/src/gui/styles/qcleanlooksstyle.cpp
@@ -1745,10 +1745,9 @@ void QCleanlooksStyle::drawControl(ControlElement element, const QStyleOption *o
 
             int maxWidth = rect.width() - 4;
             int minWidth = 4;
-			qint64 progress = (qint64)qMax(bar->progress, bar->minimum); // workaround for bug in QProgressBar
-			double vc6_workaround = ((progress - qint64(bar->minimum)) / qMax(double(1.0), double(qint64(bar->maximum) - qint64(bar->minimum))) * maxWidth);
-			int progressBarWidth = (int(vc6_workaround) > minWidth ) ? int(vc6_workaround) : minWidth;
-			int width = indeterminate ? maxWidth : progressBarWidth;
+            qreal progress = qMax(bar->progress, bar->minimum); // workaround for bug in QProgressBar
+            int progressBarWidth = (progress - bar->minimum) * qreal(maxWidth) / qMax(qreal(1.0), qreal(bar->maximum) - bar->minimum);
+            int width = indeterminate ? maxWidth : qMax(minWidth, progressBarWidth);
 
             bool reverse = (!vertical && (bar->direction == Qt::RightToLeft)) || vertical;
             if (inverted)
diff --git a/src/gui/styles/qgtkstyle.cpp b/src/gui/styles/qgtkstyle.cpp
index b6ef4c9..660b4c3 100644
--- a/src/gui/styles/qgtkstyle.cpp
+++ b/src/gui/styles/qgtkstyle.cpp
@@ -2075,8 +2075,8 @@ void QGtkStyle::drawControl(ControlElement element,
             }
             if (vertical)
                 rect = QRect(rect.left(), rect.top(), rect.height(), rect.width()); // flip width and height
-            const int progressIndicatorPos = static_cast<int>((bar->progress - qint64(bar->minimum)) /
-                                       qMax(double(1.0), double(qint64(bar->maximum) - qint64(bar->minimum))) * rect.width());
+            const int progressIndicatorPos = (bar->progress - qreal(bar->minimum)) * rect.width() /
+                                              qMax(qreal(1.0), qreal(bar->maximum) - bar->minimum);
             if (progressIndicatorPos >= 0 && progressIndicatorPos <= rect.width())
                 leftRect = QRect(rect.left(), rect.top(), progressIndicatorPos, rect.height());
             if (vertical)
diff --git a/src/gui/styles/qplastiquestyle.cpp b/src/gui/styles/qplastiquestyle.cpp
index cd0bd0a..80c9881 100644
--- a/src/gui/styles/qplastiquestyle.cpp
+++ b/src/gui/styles/qplastiquestyle.cpp
@@ -2571,8 +2571,7 @@ void QPlastiqueStyle::drawControl(ControlElement element, const QStyleOption *op
                 painter->setTransform(m, true);
             }
 
-            double vc6_workaround = ((bar->progress - qint64(bar->minimum)) / qMax(double(1.0), double(qint64(bar->maximum) - qint64(bar->minimum))) * rect.width());
-            int progressIndicatorPos = int(vc6_workaround);
+            int progressIndicatorPos = (bar->progress - qreal(bar->minimum)) / qMax(qreal(1.0), qreal(bar->maximum) - bar->minimum) * rect.width();
 
             bool flip = (!vertical && (((bar->direction == Qt::RightToLeft) && !inverted)
                                        || ((bar->direction == Qt::LeftToRight) && inverted))) || (vertical && ((!inverted && !bottomToTop) || (inverted && bottomToTop)));
diff --git a/src/gui/widgets/qprogressbar.cpp b/src/gui/widgets/qprogressbar.cpp
index d168028..6593cd6 100644
--- a/src/gui/widgets/qprogressbar.cpp
+++ b/src/gui/widgets/qprogressbar.cpp
@@ -443,11 +443,11 @@ QSize QProgressBar::minimumSizeHint() const
 QString QProgressBar::text() const
 {
     Q_D(const QProgressBar);
-    if (d->maximum == 0 || d->value < d->minimum
+    if ((d->maximum == 0 && d->minimum == 0) || d->value < d->minimum
             || (d->value == INT_MIN && d->minimum == INT_MIN))
         return QString();
 
-    qint64 totalSteps = qint64(d->maximum) - qint64(d->minimum);
+    qint64 totalSteps = qint64(d->maximum) - d->minimum;
 
     QString result = d->format;
     result.replace(QLatin1String("%m"), QString::number(totalSteps));
@@ -461,7 +461,7 @@ QString QProgressBar::text() const
         return result;
     }
 
-    int progress = int(((qreal(d->value) - qreal(d->minimum)) * 100.0) / totalSteps);
+    int progress = (qreal(d->value) - d->minimum) * 100.0 / totalSteps;
     result.replace(QLatin1String("%p"), QString::number(progress));
     return result;
 }